Today our lives are depending on technology and technology is depending on computers. Since we created computers in the mid-1940s, we rely on software to control the hardware. And for creating that software we rely on Programming languages.
Today there are 100s of powerful languages are there for each and every platform. Let’s understand how this journey comes here. We’ll see the birth of the first language and then understand the reason why it was replaced with the new one. The main forces that push this development and makes our lives easy and joyful.
There are two fundamental reasons behind the creation of every language that you ever heard about and also these two will remains the same:
- To adopt change in the programming environment.
- To adopt improvements in the art of programming.
Programming environment means the environment or platform for which we are creating software. For example, If you are working on the internet, there are some different rules and requirements that you need to take care of. If you working on Artificial Intelligence there are different rules and requirements. When you are working on operating system development, app development or console base development, for each and every platform there will be different rules and requirements that you need to take care of. So sometimes to fulfill that needs and requirements we need to create new languages for better optimization and easiness.
The second factor is improvements in the art of programming. From the first generation languages till now conceptually we developed a lot of new features in the programming. That is, to reduce our repeated works, to easily manage complex programs, and to make our code more concise and expressive. Sometimes when old languages fail to adopt these improvements, then we need to create some new languages.
There is a total of five generations in programming languages.
- First Generation Languages
- Second Generation Languages
- Third Generation Languages
- Fourth Generation Languages
- Fifth Generation Languages
First Generation Languages
First Generation languages are low-level languages consists of 0s and 1s, for writing codes in these languages we mostly used punch cards. In these languages, everything is 0s and 1s. Programmers have to design their code by hand then transfer it to a computer by using a punch card. These languages were called “Machine Languages”. These languages may vary from machine to machine. The machine code which is worked on one machine may not work in another machine.
Until programs were just a hundred lines long this approach was worked, but as programs grow bigger in size and complexity we need something else. And that need of something else becomes the fundamental reason behind the creation of second generation languages.
Advantages of First Generation Languages
- The program performs really fast.
- The program can make use of specific processor features such as special registers, and provides much more control over hardware.
Disadvantages of First Generation Languages
- Programs were not portable.
- If an error occurs whole punch card needs to rewrite.
- Code is difficult to edit, read and update.
- Debugging machine code was also not easy.
Second Generation Languages
Second generation languages were also low-level languages but unlike the first generation languages, we used some English words in them. This step provides much more easiness to read, write and debug programs. These languages were called Assembly languages".
Here assembler was used to convert our code into machine code. Compare those first generation languages, second generation languages were able to handle more complex programs.
Advantages of Second Generation Language
- After using assemblers, still, the code performs really fast.
- The program can make use of specific processor features such as special registers, and provides much more control over hardware.
- As it is closer to pure English, programs become easier to read, write and debug.
Disadvantages of Second Generation Languages
- Programs were not portable.
- Debugging machine code was also not easy.
Third Generation Languages
After the creation of assembly language, programs become much bigger and complex. Although Assembly language used English words and it was easier than machine language. After one stage assembly language was also failed to handle complexity. And also due to lack of programming features, there was a need for something else more powerful.
Third Generation Languages gives birth to High-Level programming. From here advance programming concepts like loops, conditionals, and classes came into existence. Now it becomes easy for developers to handle much bigger complexities.
Advance programming paradigms were also developed in this stage like functional, procedural, imperative and object-oriented. To handle bigger and complex programs.
Advance and powerful converters like assemblers and interpreters were created to provide much more speed and optimization in the code compilation process.
Programs become platform independent and programmer-friendly.
Example of third-generation languages includes Pascal, FORTRAN, C, C++, Java, Python, PHP, etc.
Advantages of Third Generation Languages
- Platform Independent
- Used advance programming paradigms
- Used advance converters to produce highly efficient and optimized program results
- Used advance programming features
- More programmer friendly
Disadvantages of Third Generation Languages
- The produced code might not able to make the best use of processor-specific features like 1s and 2nd generation languages
Fourth Generation Languages
Fourth Generation languages are designed to reduce programming efforts and the time it takes to develop software. These languages are so powerful and come up with modern features. These languages are consists of statements which is similar to human statements. Which makes them an upgraded version of third generation languages.
These languages have much more concise and expressive code. With the same power and features, these languages can be implemented on multiple platforms. Makes them as One Man Army.
Example of these languages is Kotlin, Scala, Dart, SQL, etc.
Fifth Generation Languages
Fifth Generation Languages are designed to build specific software. Fifth Generation Language doesn’t need a programmer, codes will be auto-generated by the system itself. The user just needs to define the problem in a specific way.
That’s way, the user only needs to worry about how to solve the problem without worrying about how to implement that problem on the system.
Fifth generation languages are mainly used in Artificial Intelligence and for other research purposes. OPS5, Julia, hack, Mercury are examples of fifth generation languages.
So, guys, That’s it for the birth of modern programming. Please visit every day for new articles.
Till then Keep Coding, Keep Loving.
Top comments (0)