OpenGL boilerplate

#define GLEW_STATIC
#include<stdio.h>
#include<string.h>
#include<fstream>
#include<GL/glew.h>
#include<GL/gl.h>
#include <GL/glu.h>
#include <GLFW/glfw3.h>

#define SCREENWIDTH 1920
#define SCREENHEIGHT 1080

GLuint CompileShaderFromFile(char *File, GLenum Type)
{
    printf("Compiling shader ");
    printf(File);
    printf(":\n");

    std::ifstream Input(File);
    std::string SourceString;

    if (!Input.is_open())
        printf("Failed to load shader!\n");

    while (Input.good())
    {
        std::string CurrentLine;
        std::getline(Input, CurrentLine);
        SourceString.append(CurrentLine + "\n");
    }

    GLuint Shader = glCreateShader(Type);
    const char *Source = SourceString.c_str();
    glShaderSource(Shader,1,&Source,NULL);
    glCompileShader(Shader);

    GLint Test;
    glGetShaderiv(Shader, GL_COMPILE_STATUS, &Test);
    if(!Test)
    {
        char Buffer[512];
        glGetShaderInfoLog(Shader, 512, NULL, Buffer);
        printf("Failed to compile shader!\n");
        printf(Buffer);
        printf("-\n");
        printf(Source);
        printf("\n-\n");
    }

    return Shader;
}

GLuint CreateProgram(char *VertShader, char *FragShader)
{
    GLuint VertexShader = CompileShaderFromFile(VertShader, GL_VERTEX_SHADER);
    GLuint FragmentShader = CompileShaderFromFile(FragShader, GL_FRAGMENT_SHADER);

    GLuint ShaderProgram = glCreateProgram();
    glAttachShader(ShaderProgram, VertexShader);
    glAttachShader(ShaderProgram, FragmentShader);
    glDeleteProgram(VertexShader);
    glDeleteProgram(FragmentShader);

    glLinkProgram(ShaderProgram);
    glUseProgram(ShaderProgram);
    return ShaderProgram;
}

int main()
{
    glfwInit();

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    GLFWwindow* Window = glfwCreateWindow(SCREENWIDTH, SCREENHEIGHT, "Prims", glfwGetPrimaryMonitor(), NULL);

    glfwMakeContextCurrent(Window);

    glewExperimental = GL_TRUE;
    glewInit();

    GLfloat ScreenQuad [] =
    {
        1.0, 1.0,
        -1.0, 1.0,
        -1.0, -1.0,
        1.0, -1.0
    };

    GLuint Order [] =
    {
        0, 1, 2,
        2, 3, 0
    };

    GLuint VAO;
    glGenVertexArrays (1, &VAO);
    glBindVertexArray (VAO);

    GLuint VertexBuffer;
    glGenBuffers(1, &VertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(ScreenQuad), ScreenQuad, GL_STATIC_DRAW);

    GLuint ElementBuffer;
    glGenBuffers(1, &ElementBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Order), Order, GL_STATIC_DRAW);

    GLuint ShaderProgram = CreateProgram("VertexShader.vert", "FragmentShader.frag");

    GLint PositionAttribute = glGetAttribLocation(ShaderProgram, "Point");
    glVertexAttribPointer(PositionAttribute, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(PositionAttribute);

    while (!glfwWindowShouldClose(Window))
    {
        glClear(GL_COLOR_BUFFER_BIT);
        glBindVertexArray (VAO);

        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

        glfwSwapBuffers(Window);
        glfwPollEvents();

        if (glfwGetKey(Window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        {
            glfwSetWindowShouldClose(Window, GL_TRUE);
        }

        GLenum ErrorEnum = glGetError();
        if (ErrorEnum != GL_NO_ERROR) printf("glGetError returned '%s'!\n", gluErrorString(ErrorEnum));
    }

    glfwTerminate();
    return 0;
}

/* VertexShader.vert:
#version 150

in vec2 Point;

void main()
{
    gl_Position = vec4(Point, 0.0, 1.0);
}

FragmentShader.frag:

#version 150

out vec4 Colour;

void main()
{
    Colour = vec4(1.0, 1.0, 1.0, 1.0);
}
*/