Programming languages, if you ask us, lie at the very core of this rapid development. Without them, it's virtually impossible to develop new software. Even those online software builders that allow us to create new software without codingare actually powered by the logic and majesty of programming languages. However, while we are continually reminded of the development of software all the time, what most of us fail to notice is the rapid development of programming itself!.
What are programming language generations?
Well, broadly and roughly speaking, generations are categories of programming languages grouped together, on the basis of technological sophistication, ease of use, times of development etc. It is to be kept in mind, that before the so-called3GL languages like Java and C++ came into being, the concept of generations was virtually unheard of. Another phallacy is that, while it is agreed that there are 4GL and 5GL languages, some researchers continue to call all modern programming languages Third generation languages. Still, for the purpose of simplicity, usability and pure elegance, we can use the commonly accepted paradigm of 5 generations of programming languages.
First Generation Languages (1GL) / Machine languages
1GL or first generation languages are essentially those extremely low-level languages that were only readable to the machines. So, these are usually calledmachine languages, and make extensive use of binary digits (mainly) for writing code. Obviously, these languages are really cumbersome and difficult to use, since you need to define pretty much anything you intend to do.
The earliest programming languages were 1GLs. Every statement (analogous to a complete sentence) corresponds to a single machine function, which makes them really unfit for most daily jobs.
On the bright side, though, these languages are extremely fast. Hypothetically speaking, if a modern-day high level software is built using machine code, the speed would be several times of what we usually experience.
Second generation languages (2GL) / Assembly languages
The 2GLs are the first languages that made use of assemblers, programs specially coded for translating human-readable syntax of these languages into low-level machine languages readable to the computers.
These languages are a welcome change from 1GLs, because the syntax is much more clear, concise and understandable.
Third generation languages (3GL) / High-level languages
The term high-level is specially selected to describe these languages, because the syntax of most of these languages resemble English. These also allow the programmer more control over the process of actually developing the program, rather than focusing on low level details such as memory allocation, specifying machine addresses etc.
The defining feature of 3GLs, more so than their resemblance to English, is portability. These languages, unlike the 2GLs, are independent of the hardware configuration. For example, if you have a Java program written on MS Windows Vista on a Dell machine, you can easily run it on a Ubuntu 14.04 system running on an HP notebook, as long as you have the required JVM installed.
These languages are broadly categorised into 2 types:
1. Compiled languages, which make use of compilers, programs that translate the high-level source code (human-readable code) into low-level object code (machine-readable form). C++ is perhaps the most common example of compiled languages these days (yes, we're biased).
2. Interpreted languages, which use interpreters, programs that don't generate any low-level object code, and usually execute the source code line by line. Some languages, like Java, make use of byte code, which is a low-level form readable to the specific interpreter, and resembles the object code. But object codes and byte codes are different.
Since Java is focused on security, the byte code makes the program very difficult to modify, and is therefore useful if you want your code to stay pure and intact, and still distribute it.
Fourth generation languages (5GLs) / non-procedural languages
The 4GLs are non-procedural, that is, they are goal-oriented. The programmer, broadly speaking, needs to specify which targets are to be met, rather than telling the system every step to reach that target. Oftentimes, these languages make use of databases.
The defining feature of these languages is that, they work with large chunks of data instead of smaller bits of it. SQL is a common example of the 4GL. Another good example (although we confess we didn't try it) is NOMAD.
Fifth generation languages (5GLs) / Visual languages
Visual languages are called so because because they make extensive use of graphical interfaces, to quickly help people design programs for specific tasks. Since visual tools are used in the process (the associated code being generated automatically, alongside), the development process is fast.
Mercury is a good example of 5GLs, but perhaps a more common one would beVisual Basic on Windows systems (although this is a matter of debate). On Linux systems, Gambas is an excellent example of 5GL, as long as we categorise VB as one.
You can read more about Gambas here: http://goo.gl/HDJXGi (we're huge fans, of course).
Conclusion
Well, to be honest the entire classification of languages in this manner is not clearly defined. For example, Pascal can be called a 4GL, but usually it is seen as a 3GL. Still, for understanding the history of programming itself, I believe this system of categorization serves a function similar to that performed by the history of periodic tables in Chemistry.
References:
http://www.doc.ic.ac.uk/~nd/surprise_96/journal/vol2/mjbn/article2.html
1GL clarification from:https://www.princeton.edu/~achaney/tmve/wiki100k/docs/First-generation_programming_language.html
No comments:
Post a Comment