Working code of cherno's opengl series with ubuntu 14.04 using nvidia graphics card.

cherno_opengl_red_triangle.cpp

#include "GL/glew.h"		// include GLEW and new version of GL on Windows
#include "GLFW/glfw3.h"     // GLFW helper library

#include <iostream>


static unsigned int CompileShader(unsigned int type, const std::string& source)
{
    unsigned int id = glCreateShader(type);
    const char* src =  source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_AND_EXECUTE, &result);

    if(result == GL_FALSE)
    {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
        char* message = (char*)alloca(length*sizeof(char));
        glGetShaderInfoLog(id, length, &length, message);
        std::cout << "failed to compile" << (type == GL_VERTEX_SHADER ? "vertex":"fragment") <<" shader"<<std::endl;
        std::cout << message <<std::endl;
        glDeleteShader(id);
        return 0;

    }

    return id;
}

static unsigned int CreateShader(const std::string& vertexShader, const std::string& fragmentShader)
{
    unsigned int program = glCreateProgram();
    unsigned int vs = CompileShader(GL_VERTEX_SHADER, vertexShader);
    unsigned int fs = CompileShader(GL_FRAGMENT_SHADER, fragmentShader);

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);

    glDeleteShader(vs);
    glDeleteShader(fs);

    return program;

}

int main(void)
{
    GLFWwindow* window;

    glewExperimental = GL_TRUE;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4.3);


    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if(glewInit() == GLEW_OK)
        std::cout<<"working"<<std::endl;

    float positions[6] = {
            -0.5f, -0.5f,
             0.0f, 0.5f,
             0.5f, -0.5f,

    };

    unsigned int buffer;

    unsigned int vertexArrayID;

    glGenBuffers(1, &buffer);
    glBindBuffer(GL_ARRAY_BUFFER, buffer);
    glBufferData(GL_ARRAY_BUFFER, 6* sizeof(float), positions, GL_STATIC_DRAW);

    glGenVertexArrays(1, &vertexArrayID);
    glBindVertexArray(vertexArrayID);
    glEnableVertexAttribArray(0);

    glBindBuffer( GL_ARRAY_BUFFER, buffer );
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float)*2, 0);

    std::string vertexShader =
            "#version 410\n"
            "in vec3 vp;"
            "void main() {"
            "  gl_Position = vec4( vp, 1.0 );"
            "}";

    std::string fragmentShader =
            "#version 410\n"
            "out vec4 frag_colour;"
            "void main() {"
            "  frag_colour = vec4( 1.0, 0.0, 0.0, 1.0 );"
            "}";

    unsigned int shader = CreateShader(vertexShader,fragmentShader);
    glUseProgram(shader);

    glBindVertexArray( vertexArrayID );

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClear(GL_COLOR_BUFFER_BIT);

        glDrawArrays(GL_TRIANGLES, 0, 3);


        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}