c++ opengl model matrix stretch

I was programming easy 3d space in Opengl. I wanted to create two cubes(one orange, second green). I have used same model, view, projection matrix for each. Every cube should bein same position and they should look same, but they look like this :

i have no idea why this is happening.Is it because the two model matrixes are same?

Here is the code(main.cpp)

 `#include "src/Program.hpp"
#include <GLFW/glfw3.h>


// functions
void framebufferResizeCallback(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}
void errorCallback(int error, const char* description) {
    std::cout << "error :" << description << std::endl;
}

//variables
int window_width = 800;
int window_height = 600;

int main() {

    glfwInit();
    glfwWindowHint(GLFW_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    glfwSetErrorCallback(errorCallback);

    GLFWwindow* window = glfwCreateWindow(window_width, window_height, "Opengl_triangle", NULL, NULL);
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);

    gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);

    Program light("src/vertex.glsl", "src/fragment.glsl");
    Program object("src/vertex.glsl", "src/fragment_green.glsl");

    /// going 3D
    // calculations
    glm::mat4 model(1.f);
    model = glm::rotate(model,glm::radians(20.f), glm::vec3(1.f, 0.f, 0.6f));

    glm::mat4 view;
    view = glm::translate(view, glm::vec3(0.f, 0.f, -5.f));

    glm::mat4 projection;
    projection = glm::perspective(glm::radians(45.f), float(window_width / window_height), 0.1f, 100.f);
    // sending it to the shaders  LIGHT
    light.use();
    light.uniformMatrix4(model, "model");
    light.uniformMatrix4(view, "view");
    light.uniformMatrix4(projection, "projection");
    // sending it to the shaders  OBJECT
    object.use();
    object.uniformMatrix4(model, "model");
    object.uniformMatrix4(view, "view");
    object.uniformMatrix4(projection, "projection");



    //fun stuff
    float vertices[] = {
     -0.5f, -0.5f, -0.5f,
      0.5f, -0.5f, -0.5f,
      0.5f,  0.5f, -0.5f,
      0.5f,  0.5f, -0.5f,
     -0.5f,  0.5f, -0.5f,
     -0.5f, -0.5f, -0.5f,

     -0.5f, -0.5f,  0.5f,
      0.5f, -0.5f,  0.5f,
      0.5f,  0.5f,  0.5f,
      0.5f,  0.5f,  0.5f,
     -0.5f,  0.5f,  0.5f,
     -0.5f, -0.5f,  0.5f,

     -0.5f,  0.5f,  0.5f,
     -0.5f,  0.5f, -0.5f,
     -0.5f, -0.5f, -0.5f,
     -0.5f, -0.5f, -0.5f,
     -0.5f, -0.5f,  0.5f,
     -0.5f,  0.5f,  0.5f,

      0.5f,  0.5f,  0.5f,
      0.5f,  0.5f, -0.5f,
      0.5f, -0.5f, -0.5f,
      0.5f, -0.5f, -0.5f,
      0.5f, -0.5f,  0.5f,
      0.5f,  0.5f,  0.5f,

     -0.5f, -0.5f, -0.5f,
      0.5f, -0.5f, -0.5f,
      0.5f, -0.5f,  0.5f,
      0.5f, -0.5f,  0.5f,
     -0.5f, -0.5f,  0.5f,
     -0.5f, -0.5f, -0.5f,

     -0.5f,  0.5f, -0.5f,
      0.5f,  0.5f, -0.5f,
      0.5f,  0.5f,  0.5f,
      0.5f,  0.5f,  0.5f,
     -0.5f,  0.5f,  0.5f,
     -0.5f,  0.5f, -0.5f,
    };

    unsigned int VBO, VAO_light, VAO_object ;
    glGenVertexArrays(1, &VAO_light);
    glGenVertexArrays(1, &VAO_object);
    glGenBuffers(1, &VBO);


    glBindVertexArray(VAO_light);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
    glEnableVertexAttribArray(0);

    glBindVertexArray(VAO_object);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), 0);
    glEnableVertexAttribArray(0);


    
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    while (!glfwWindowShouldClose(window)) {

        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        light.use();
        glBindVertexArray(VAO_light);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        object.use();
        glBindVertexArray(VAO_object);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        
        
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    glfwTerminate();
    return 0;

here are shaders fragment:

`#version 330 core

out vec4 fragColor;

void main() {
    fragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
};`

vertex :

`#version 330 core

layout (location = 0) in vec3 aPos;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

void main() {
    gl_Position = projection * view * model * vec4(aPos , 1.0f);
};`

here are my shader and program classess:

`class Program {
    Shader vertex;
    Shader fragment;
    GLuint ID;

public:
    // essential methods
    Program() : ID(0) {
        std::cout << "program default constructor" << std::endl;
    }
    Program(const char* vertexShader_path, const char * fragmentShader_path) {
        // recreate shaders
        vertex = Shader(vertexShader_path, GL_VERTEX_SHADER);
        fragment = Shader(fragmentShader_path, GL_FRAGMENT_SHADER);

        // create shader program
        ID = glCreateProgram();
        glAttachShader(ID, vertex.getID());
        glAttachShader(ID, fragment.getID());
        glLinkProgram(ID);
        checkProgramLinking(ID);
    }

    /// usage methods
    void use()      { glUseProgram(ID); }
    GLuint getID()  { return ID; }
    // accesing uniforms methods
    void uniformMatrix4(glm::mat4 matrix, const char* matrixName) {
        GLuint uniformLocation = glGetUniformLocation(ID, matrixName);
        glUniformMatrix4fv(uniformLocation, 1, GL_FALSE, glm::value_ptr(matrix));
    }
private:
    void checkProgramLinking(unsigned int& program) {
        int success;
        char log[512];
        glGetProgramiv(program, GL_LINK_STATUS, &success);
        if (!success) {
            glGetProgramInfoLog(program, 512, NULL, log);
            std::cout << "error linking program : " << log << std::endl;
        }
    }
}




 class Shader {
    GLuint ID;


public:
    // essential methods
    Shader() : ID(0) {
        std::cout << "default shader constructor" << std::endl;
    }
    Shader(const char* path, GLenum type) {

        // converting shader code from file
        std::string shaderCodeS;
        std::ifstream shaderFile;
        shaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        try
        {
            shaderFile.open(path);
            std::stringstream shaderStream;
            shaderStream << shaderFile.rdbuf();
            shaderFile.close();
            shaderCodeS = shaderStream.str();
        } 
        catch (std::ifstream::failure& e) {
            std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ: " << e.what() << std::endl;
        }
        const char* shaderCode = shaderCodeS.c_str();
        
        // shader creation
        ID = glCreateShader(type);
        glShaderSource(ID, 1, &shaderCode, NULL);
        glCompileShader(ID);
        checkShaderCompilation(ID); 


        std::cout << "shader argumented constructor" << std::endl;
    }

    // methods for usage
    GLuint getID() { return ID; }
private:
    void checkShaderCompilation(unsigned int& shader) {
        int success;
        char log[512];
        glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(shader, 512, NULL, log);
            std::cout << "error compiling shader:" << log << std::endl;
        }
    }

};

Solution

I have found out! I forgot to make projection and view matrix an identity matrix before doing mathematical calculations. Here is how it should be:

    glm::mat4 model(1.f);

    glm::mat4 view(1.f);
    view = glm::translate(view, glm::vec3(0.f, 0.f, -3.f));

    glm::mat4 projection(1.f);
    projection = glm::perspective(glm::radians(45.f), float(window_width / window_height), 0.1f, 100.f);`