Pretty much like FLeBlanc said, an entity is anything that may exist in a game world, be it the player character, a projectile, a trigger (as in event trigger, not a gun trigger), etc.
One thing to note is that normally when we hear game world one usually thinks about the visible things (geometry), but an entity isn't necessarily something that needs to be rendered (although there may be people who only call entities to the things that need to be rendered).
The difference is that the Web installer is just a small program (~286KB) that will download and install the DX runtimes, while the first link downloads the runtimes ready to be installed (~95MB).
Then you can distribute these files along with your program.
But if the person that will use your program as any recent game installed in it's computer (or had), then chances are, they will already have DIrectX installed.
Perhaps, as to not make the size of the files you have to distribute large (if your only making a small game/application), then you could just include along the Web installer, and if the user doesn't have DirectX runtimes installed, then they can download them.
You don't need any paid version of Visual Studio to create a release build, any version can create one.
Compared to the Debug build, a Release build executable is stripped of any debug code (used in the libraries, like CRT, not code written by you), and optimizations are turned on, among other things. Also, in a Release build, variables are not initialized to a default value (in Debug mode, in VC++2010 Express, they are initialized to 0xCDCDCDCD, in the case of ints).
Normally you distribute the Release build, along with the necessary DLLs for the program to run.
These DLLs may or may not exist, depending on which libraries you use in your project (for example, if you use Freetype, then you'd have to distribute the Freetype DLL along with your program).
To check which DLLs you need to distribute, you could put your application in another computer, run it, and check which DLLs are reported missing (those are the ones you should include).
If you use DirectX (which in this case you do), then the person that will use your application will need to have DirectX installed in his computer.
glGetError returns the current error state of the OpenGL state machine. After calling glGetError, the error state reverts to GL_NO_ERROR and it will remain so until an OpenGL function is called which sets an error state.
I'm not entirely sure about this, but i think this is correct:
Eclise is an IDE (Integration Developing(Developer) Environment. It has a text editor (where you code), sintax highlighting, etc.
JDK (Java Development Kit) - This is the Java equivalent to a SDK (Software Development Kit). It allows you to compile and create java programs into Java bytecode (.jar files).
You'd normally download this in conjunction with Eclipse or NetBeans (the IDEs normally allow you to download a bundle of IDE + JDK).
JRE (Java Runtime Environment) is needed fr running the JVM (Java Virtual Machine). Since Java is an interpreted language, it need the JVM to translate the Java bytecode into machine instructions (which can be x86, x86-64, PowerPC, etc). You can think of JRE being similar, in purpose, to Adobe Flash Player (without which you cannot play videos on the Youtube, etc).
If the user doesn't have the JRE, it can be downloaded for free in the Sun website (you just Google jre, and it will appear).
So JDK is only needed for who develops Java applications, and JRE is needed to run them.
For the language I'll always advise C++, because that's probably the most used language, especially in game development, not to mention it's my favorite language, and the one i always use. But don't let me stop you from trying other languages, just ask other people and they will surely point out the good in any of them.
I know you can use LWJGL (which is a way to use OpenGL (and more, i think) on Java).
Now, if you don't know C++ yet, or you think you don't know enough (and assuming that's the language you're going to learn), for now you should set apart the idea of making a game.
First you must use how to program in C++, and i mean really learn it (advanced stuff like pointers, classes, inheritance, templates, overloading, etc).
If you want online tutorials on C++, you can go to http://www.cplusplus.com/doc/tutorial/ and follow the tutorials there. They point out most of the C++ features you should know, although some of them take a lot of practice to perfect (like pointers).
Also, you should read about design patterns (after getting a good grasp on the language). They will help you designing better code.
After you have a good grasp in the language you can then start learning OpenGL.
Also, it would do you good to decide whether you want to learn the deprecated OpenGL functionality or not. I can't really said if it helps or not, but when i first learned OpenGL, i started there, so maybe when i learned shader based OpenGL the learning curve wasn't that difficult.
I'll let others advise more on this.
More than this, remember that a game is not only graphics (although graphics is a big part of them).
You could then learn OpenAL for audio (or FMOD, for example), DirectInput (on Windows only) for input, and a lot more.
Other than that i can only say to keep practicing. As they say, practice makes perfect (or at least close).