In the beginning, there was machine code. this is essentially inputting what the computer actually executed, without any translation or compilation ( http://en.wikipedia.org/wiki/First-generation_programming_la... )

Then there was assembler/assembly. This is similar to the aforementioned, except easier to read. Assembly is a 1:1 mapping between symbols and their machine-understandable counterparts. This is the first step in the abstracting of programming code from executable code ( http://en.wikipedia.org/wiki/Second-generation_programming_l... )

Then, there are so-called 3GL. These let you do fancy things like having named variables, symbolic manipulation, function calls, abstract (arbitrary) syntax. This encompasses many of the languages people use at work today (c/c++/java) ( http://en.wikipedia.org/wiki/Third-generation_programming_la... ) It is important to note that the purpose of 3GL, like assembly before it, was to create a separation between what the programmer typed and what the machine ran. The latter being derived from the former according to its rules.

( http://en.wikipedia.org/wiki/Fourth-generation_programming_l... ) 4GL are the next step along this line. The focus of 4GL is to make it that the code entered is as focused on the domain logic as possible, hiding the implementation details.

The phrase "further from the machine and closer to the domain"in the wikipedia 4GL page sums it up nicely.

To a chip designer, machine code is a high level language (it is an abstraction of the machine itself.) To an assembly programmer (nobody programs in machine code AFAIK,) c is a high-level language. To a c programmer, java is a high-level language. To a java programer, ruby is a high-level language. To a ruby programmer, RSpec is a high-level language.

Essentially, the further you get from the machine, the higher the level.

As far as the implementation of languages, well that depends. You can very well implement any language in assembly or machine code (given enough time, patience, and self-loathing.)

Usual strategies for the development of high-level languages are to either a) translate to a lower-level language that then gets compiled to machine code b) translate to a lower-level language that targets a virtual machine that eventually translates these lower-level instructions to machine code or c) some combination of a & b until enough of your new language has been written so that it can translate itself to machine-code or vm bytecode (known as self-hosting.) high-level languages can sometimes be seen as collections of cool libraries that translate your code into lower-level languages, on and on until you eventually get to machine code. of course, people who write these translators are smart folk, and sometimes manipulate what you have written to make it run faster.

but yes, eventually, almost all languages become machine code in order to be executed (or are converted into control flags that configure the operation of existing machine code / configure an fpga or other type of bendy silicon.)

now, were lisp machines self-hosted? i dunno.

the implementation of Ruby is open-source, and mostly-readable C. watch a movie about ruby from the inside (some knowledge of c is useful)

http://mtnwestrubyconf2008.confreaks.com/11farley.html

read more about the same:

http://eigenclass.org/hiki.rb?ruby+internals+guide

---

5GLs are even more abstract. instead of solving the problem in the domain space, you merely specify the constraints on the possible solutions and the computer provides you with solutions that satisfy all constraints. this offloads the work of figuring out how to solve the problem to a bit of problem-solving code. Programming a generic problem-solver that finishes in an acceptable amount of time on existing hardware in most cases is EXTREMELY difficult to do, so you need to let the consumer of the 5gl specify some control logic and provide hints to the problem solver. How to make this all work right, fast and make it more palatable than having a nice 4GL is not a solved problem.

Rumor has it that there are members of the cult of Logic Programming planning a re-emergence from the shadows and sewers. ( http://www.cs.kuleuven.ac.be/~dtai/projects/ALP/newsletter/f... )