There are the fixed function and programmable shader pipelines.
This is much bigger than just lighting, chances are your learning a whole bunch of other outdated stuff. The following are some common functions that are now deprecated:
If your learning the fixed function stuff your learning out of date programming techniques. They are easier but all of which would have to be unlearned. I recommend you look at how your learning OpenGL and look for some modern tutorials.
Take a look at my post on the gamedev stackexchange. It covers learning the new stuff.
Specifically for lighting. Fixed function is easier but has the following problems:
* It isn't per-pixel lighting so the quality is much worse.
* It's not supported at all in OpenGL ES 2.0/3.0 or WebGL
* No way to do things like bump/normal mapping. Specular reflection textures (Making part of a texture shiny and reflect more light).
* Your probably going to need shaders for other effects (for example shadows), once you use any shaders you loose the fixed functionality and must reimplement it anyway.
* No control over the shading algorithms other than some basic properties.
* It's been deprecated/removed in the new versions of OpenGL 3+. Basically it's the out of date method and should be avoided.
About the only use fixed function has now days is if you need to target OpenGL versions before 2.0 or OpenGL ES 1.x (for the older iPhones).
Programmable shaders do require more work and understanding.
Firstly you have to understand the OpenGL shader API. How to compile and link shaders (not to hard).
Also you have to understand how to communicate with them. How will you represent your lights in structures and upload them to the shaders.
And you have to learn the GLSL language (it's C like so not to hard).
Finally you have to understand the actual algorithms used in shaders.
For vertex shaders it's how a Model, View and Projection matrix combine together to turn the 3D coordinates you give vertices into the 2D coordinates you see on your flat screen.
For the fragment/pixel shaders you have to understand the shading algorithms. Blinn, Phong or whatever. How the angle of the camera combines with the normals on the surface to produce shading. Your also going to have to do stuff like texturing.
I think it's best to just start out learning the shader pipeline. You can rely on some deprecated functionality but it's best if you just use the stuff OpenGL does by default rather than actively learning old stuff.