First Generation

The first generation of programming language is machine level code, made up of 1s and
0s, otherwise known as binary. To start with, there was no translator to compile this
language. Instructions where entered though a series of switches on the front panel.
The main good point about the first generation language is that it was very fast to run, as
it was directed straight to the CPU for processing, but it is very hard to learn, and due to
the fact that the program is entered through a series of switches, it is hard to edit. Also,
if the program wanted to be moved to another computer, it would have to be completely
re-written because the language for the other computer would be significantly different to
the other. This language is mainly used on older computers or on mainframes. Any
native-code compiler creates machine language, which is done without user interaction,
mostly from higher level languages like FORTRAN, C or Pascal. This was a very
dangerous way of coding. Any typing error could result in a crash.

Second Generation
Blah

Third Generation
Blah

Forth Generation
A forth generation programming language is designed to handle things, like the
development of commercial business software. Some of these languages were brought
up after the creation of modern, block structured, third generation programming
languages, which improved software development. However, it was still considered by
some to be frustrating, slow, and error prone to program computers, which led to the first
“programming crisis”, where the amount of work that a programmer might have to do
would be a lot bigger than the amount of time the programmer had to do it. . Some
believe the first forth generation language was Ramis (see Ramis software) developed
by Gerald C. Cohen at Mathematica, a mathematical software company. He later left
Mathematica and founded Information Builders to create a similar forth generation
lanuage, called FOCUS. The term ‘forth generation language’ was used in the 60’s.
Most of the forth generation languages allowed or required system logic to be written in
a macro language or in a third generation language. All forth generation languages are
designed to reduce the effort for the programmer, the time it takes to develop the
software, and the cost of software development. They are not always successful in this
task, sometimes resulting in un-maintainable code. However, given the right problem,
the use of an appropriate forth generation language can be spectacularly successful.