Question on shaders

uniform mat4 projection_matrix;
uniform mat4 modelview_matrix;
uniform mat3 normal_matrix;
 
uniform vec4 material_ambient;
uniform vec4 material_diffuse;
uniform vec4 material_specular;
uniform vec4 material_emissive;
uniform float material_shininess;
 
struct light {
	vec4 position;
	vec4 diffuse;
	vec4 specular;
	vec4 ambient;
 
	float constant_attenuation;
	float linear_attenuation;
	float quadratic_attenuation;
}
 
uniform light light0;
 
in vec3 a_Vertex;
in vec2 a_TexCoord0;
in vec3 a_Normal;
 
out vec2 texCoord0;
out vec3 normal;
out vec3 lightDir;
out vec3 halfVector;
 
out vec4 vertDiffuse;
out vec4 vertAmbient;
out float dist;
 
void main(void)
{
	normal = normalize(normal_matrix * a_Normal);
	vec4 pos = modelview_matrix * vec4(a_Vertex, 1.0);
 
	vec3 lightPos = (modelview_matrix * light0.position).xyz;
	lightDir = lightPos - pos.xyz;
	vec3 E = -(pos.xyz);
 
	dist = length(lightDir);
	lightDir = normalize(lightDir);
 
	halfVector = normalize(lightPos + E);
 
	vertDiffuse = material_diffuse * light0.diffuse;
	vertAmbient = material_ambient * light0.ambient;
	texCoord0 = a_TexCoord0;
 
	gl_Position = projection_matrix * pos;
}

uniform sampler2D texture0;
 
uniform vec4 material_ambient;
uniform vec4 material_diffuse;
uniform vec4 material_specular;
uniform vec4 material_emissive;
uniform float material_shininess;
 
struct light {
	vec4 position;
	vec4 diffuse;
	vec4 specular;
	vec4 ambient;
 
	float constant_attenuation;
	float linear_attenuation;
	float quadratic_attenuation;
};
 
uniform light light0;
 
in vec2 texCoord0;
in vec3 normal;
in vec3 lightDir;
in vec3 halfVector;
 
in vec4 vertDiffuse;
in vec4 vertAmbient;
in float dist;
 
out vec4 outColor;
 
void main(void) {
	vec3 N = normalize(normal);
 
	float NdotL = max(dot(N, normalize(lightDir)), 0.0);
 
	vec4 color = vec4(0.0);
 
	if (NdotL > 0.0)
	{
		color += vertDiffuse * NdotL;
 
		vec3 HV = normalize(halfVector);
		float NdotHV = max(dot(N, HV), 0.0);
		color += material_specular * light0.specular * pow(NdotHV, material_shininess);
	}
 
	float attenuation = 1.0 / (light0.constant_attenuation +
					light0.linear_attenuation * dist +
					light0.quadratic_attenuation * dist * dist);
 
	outColor = ((color * attenuation) + vertAmbient) * texture(texture0, texCoord0.st);
}

public sealed class GLSLProgram
    {
        struct GLSLShader
        {
            public int id;
            public string filename;
            public string source;
        }
 
        private GLSLShader vertex_Shader;
        private GLSLShader fragment_Shader;
        private Dictionary<string, int> uniformMap;
        private Dictionary<string, int> attribMap;
        private int programID;
 
        public GLSLProgram(string vertShaderFile, string fragShaderFile)
        {
            vertex_Shader = new GLSLShader();
            fragment_Shader = new GLSLShader();
            uniformMap = new Dictionary<string, int>();
            attribMap = new Dictionary<string, int>();
            vertex_Shader.filename = vertShaderFile;
            fragment_Shader.filename = fragShaderFile;
            readShaderSources();
        }
 
        public bool Init()
        {
            Thread.Sleep(1);
            programID = GL.CreateProgram();
            vertex_Shader.id = GL.CreateShader(ShaderType.VertexShader);
            fragment_Shader.id = GL.CreateShader(ShaderType.FragmentShader);
            if (!(vertex_Shader.filename.Equals("INTERNAL")) && !(fragment_Shader.filename.Equals("INTERNAL")))
            {
                readShaderSources(); 
            }
            if (vertex_Shader.source.Equals(String.Empty) || fragment_Shader.source.Equals(String.Empty))
            {
                SurviveErrors.SetErrorFlag("SHADER_SOURCE_NONEXISTANT_ERROR");
                return false;
            }
            GL.ShaderSource(vertex_Shader.id, vertex_Shader.source);
            GL.ShaderSource(fragment_Shader.id, fragment_Shader.source);
            if (!compileShader(vertex_Shader) || !compileShader(fragment_Shader))
            {
                SurviveErrors.SetErrorFlag("SHADER_COMPILATION_ERROR");
                return false;
            }
            GL.AttachShader(programID, vertex_Shader.id);
            GL.AttachShader(programID, fragment_Shader.id);
            GL.LinkProgram(programID);
            return true;
        }
 
        public void Unload()
        {
            GL.DetachShader(programID, vertex_Shader.id);
            GL.DetachShader(programID, fragment_Shader.id);
            GL.DeleteShader(vertex_Shader.id);
            GL.DeleteShader(fragment_Shader.id);
            GL.DeleteProgram(programID);
        }
 
        private bool compileShader(GLSLShader shader)
        {
            GL.CompileShader(shader.id);
            int result = 12047375;
            GL.GetShader(shader.id, ShaderParameter.CompileStatus, out result);
 
            if (result == 0)
            {
                Console.Error.WriteLine("Your shader has errors.  Please validate.");
                return false;
            }
            return true;
        }
 
        private void readShaderSources()
        {
            using (TextReader reader = File.OpenText(vertex_Shader.filename))
            {
                while (reader.Peek() > -1)
                {
                    vertex_Shader.source += reader.ReadLine();
                }
            }
            using (TextReader reader = File.OpenText(fragment_Shader.filename))
            {
                while (reader.Peek() > -1)
                {
                    fragment_Shader.source += reader.ReadLine();
                }
            }
        }
 
        public void BindShader()
        {
            GL.UseProgram(programID);
        }
    }