Question: I'm a computer science student. Currently we are learning the Ada programming language. The compilation is very straightforward for now: `gnatmake source.adb` so I don't have any idea of what gnatmake actually does or is (script? binary? something else?). Anyway, I was wondering in what language the compiler itself (also the parser, if written in a different language) was coded?

Answer: 
Your typical compiler comes with two basic tools: The compiler and the linker.

The comiler translates the language source code (text) into machine language object files (binaries). It will perhaps include some object relocation information, to help the linker.

The linker takes multiple machine language object files and links them all together into one machine executable.

You typically have to tell the compiler where to find all the extra files it needs to perform a compilation, and then you have to tell the linker the name of every file needed to link together your executable, including and system libraries you might use. This can get pretty dang complicated, which is where build tools like `make` come in.

Ada is defined in such a way that there should always be some kind of librarian to keep track of this information for you. Thus to perform a complete build of your system, all you should have to do is ask the librarian to build your executable for you.

The way `Gnat` handles this librarian functionality is that it assumes (unless told otherwise) that there's a one-to-one correspondence between Ada unit (package) names and source and object file names. Thus if it needs the specification for `X` to complete a compile, it knows to go to `X.ads` to find the specification file. When its time to link, it knows it will find its object file in `X.o`. This means that if it needs a routine from package `X` to successfully link, it knows exactly how to do that for you, where a dumb linker would just fail and tell you the semi-encrypted name of the "symbol" it can't find. 

So instead of typing out individual compile commands for every unit in your program like you'd have to do with C or C++, you can just use `gnatmake` to compile every unit the given executable name would need, and then link them together for you. One step, easy peasy.

---

As for your last question, the Gnat Ada compiler is written almost entirely in Ada. It is fairly typical for compilers to be written in their own language, and compiled using themselves. This is called [self-hosting](http://en.wikipedia.org/wiki/Self-hosting).

However, it is tied into GCC, so the parts that are common with GCC (the part that translates from tree format to target object code and the linker I believe) are written in C.
Within the Ada part of the GCC source tree (`gcc/ada`), there are ~2000 Ada source files and ~50 C source files. The C acts as glue to the OS and to other parts of GCC. Some (at least 50) of the Ada source files are for tools such as gnatmake.

You can see more about what `gnatmake` does by using the `-v` option in various ways: the ones I use most often are `gnatmake -v source.adb` for an overview, `gnatmake source.adb -cargs -v` to show how the compiler is called, `gnatmake source.adb -largs -v` for an overview of what the GNAT linker `gnatlink` does, and `gnatmake source.adb -largs -Wl,-v` to show in detail how `gnatlink` calls the system linker.