LWJGL - Multiple VAOs issue

import java.io.File;
import java.io.FileNotFoundException;
import java.nio.FloatBuffer;
import java.util.Scanner;

import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL15.*;
import static org.lwjgl.opengl.GL20.*;
import static org.lwjgl.opengl.GL30.*;

public class MainDisplay {
    public void start() {
        try {
            Display.setDisplayMode(new DisplayMode(400,300));
            Display.create();
        } catch (LWJGLException e) {
            e.printStackTrace();
            System.exit(-1);
        }

        float[] triangle = {
                -.5f, -.5f, 0f,
                0.5f, -.5f, 0f,
                  0f, 0.5f, 0f
        };

        float[] square = {
                -.4f, -.4f, 0f,
                0.4f, -.4f, 0f,
                0.4f, 0.4f, 0f,
                -.4f, 0.4f, 0f
        };

        String[] attributes = {"position"};
        int shaderProgram = createShaderProgram("res/simple.vert",
                "res/simple.frag",
                attributes);

        int tVao = glGenBuffers();
        int sVao = glGenBuffers();

        glBindVertexArray(tVao);
        int tVbo = glGenBuffers();
        glBindBuffer(GL_ARRAY_BUFFER, tVbo);
        FloatBuffer tBuffer = (FloatBuffer) BufferUtils
                .createFloatBuffer(triangle.length)
                .put(triangle)
                .flip();
        glBufferData(GL_ARRAY_BUFFER, tBuffer, GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
        glEnableVertexAttribArray(0);
        glBindVertexArray(sVao);
        int sVbo = glGenBuffers();
        glBindBuffer(GL_ARRAY_BUFFER, sVbo);
        FloatBuffer sBuffer = (FloatBuffer) BufferUtils
                .createFloatBuffer(square.length)
                .put(square)
                .flip();
        glBufferData(GL_ARRAY_BUFFER, sBuffer, GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
        glEnableVertexAttribArray(0);
        glBindVertexArray(0);



        while (!Display.isCloseRequested()) {
            glClearColor(0.0f,0f,0f,1f);
            glClear(GL_COLOR_BUFFER_BIT);
            glUseProgram(shaderProgram);
            glBindVertexArray(tVao);
            glBindBuffer(GL_ARRAY_BUFFER, tVbo);
            glBindVertexArray(sVao);
            glDrawArrays(GL_QUADS, 0, 4);
            glBindVertexArray(0);
            glUseProgram(0);
            Display.update();
        }

        Display.destroy();
    }

    public static void main(String[] args) {
        MainDisplay display = new MainDisplay();
        display.start();
    }

    public static int createShaderProgram(String vertex,
            String fragment,
            String[] attributes) {
        int vertexShader = glCreateShader(GL_VERTEX_SHADER);
        String s = null;
        String f = null;
        try {
            s = new Scanner(new File(vertex)).useDelimiter("\\Z").next();
            f = new Scanner(new File(fragment)).useDelimiter("\\Z").next();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        glShaderSource(vertexShader, s);
        glCompileShader(vertexShader);

        // Error check
        if (glGetShaderi(vertexShader, GL_COMPILE_STATUS) == GL_FALSE) {
            System.err.print("Failure in compiling vertex shader. Error log :\n"
                    + glGetShaderInfoLog(vertexShader,
                            glGetShaderi(vertexShader, GL_INFO_LOG_LENGTH)));
            System.exit(1);
        }

        int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragmentShader, f);
        glCompileShader(fragmentShader);

        // Error check
        if (glGetShaderi(fragmentShader, GL_COMPILE_STATUS) == GL_FALSE) {
            System.err.print("Failure in compiling fragment shader. Error log :\n"
                    + glGetShaderInfoLog(fragmentShader,
                            glGetShaderi(fragmentShader, GL_INFO_LOG_LENGTH)));
            System.exit(1);
        }

        int shaderProgram = glCreateProgram();
        glAttachShader(shaderProgram, vertexShader);
        glAttachShader(shaderProgram, fragmentShader);

        // Vertex attributes to shader mapping
        for (int i = 0; i < attributes.length; i++) {
            glBindAttribLocation(shaderProgram, i, attributes[i]);
        }

        glLinkProgram(shaderProgram);

        // Error check
        if (glGetProgrami(shaderProgram, GL_LINK_STATUS) == GL_FALSE) {
            System.err.println("Failure in linking program. Error log:\n"
                    + glGetProgramInfoLog(shaderProgram,
                            glGetProgrami(shaderProgram, GL_INFO_LOG_LENGTH)));
            System.exit(1);
        }

        glDetachShader(shaderProgram, vertexShader);
        glDetachShader(shaderProgram, fragmentShader);
        glDeleteShader(vertexShader);
        glDeleteShader(fragmentShader);

        return shaderProgram;
    }
}