Content :

INTRODUCTION OF EVOLUTION OF PROGRAMMING LANGUAGE

FOREWORD INTRODUCTION

EVOLUTION OF PROGRAMMING LANGUAGE : FIRST GENERATION SECOND GENERATION THIRD GENERATION FOURTH GENERATION FIFTH GENERATION

CONCLUSION

SOURCES Of REFERENCE

INTRODUCTION OF EVOLUTION OF PROGRAMMING

No matter how fast or modern computer hardware becomes, it is nothing more than a trivial exercise in manufacturing without software. Software is the vital link that allows humans to interact with their computer hardware. Programmers are the people who write this software. When computers first began to appear, programming was done primarily through punch cards and formulas. There was no concept of an application. Output was printed onto paper. Computers were fairly limited and programming was a black art that few had any mastery of. Fortunately, computers and programming advanced quickly. Punch cards fell out of use and computer programming languages began to develop into human-readable forms. Instead of simply inputting a string of numbers, now languages had keywords and commands that made it easier to visualize the program structure, debug it, and maintain it. The concept of applications came into existence. These are programs that are run by a user and allow for progressive input instead of just accepting a block of data and returning a result. Word processors began to gain general acceptance as well as spreadsheet programs. They soon became integral parts of an office environment. The computer world flew headlong into the future. Easy to use operating systems emerged. These systems allowed programmers to have a solid and consistent base on which to build and distribute their software. More programming languages were created, some of them very high level allowing programmers to focus on the programming dynamics themselves and not on trivial issues such as hardware access ports or basic disk input and output functions.

This improved the quality of the software that was developed. It also allowed a wider base of people to begin programming since the days of arcane machine languages were gone. Today, there are a wide variety of programming languages to choose from. Programming has become so accessible, and in some cases so easy to learn, that software is frequently released by hobbyists for free. The demand for new and easier to use software has become never ending. Because of this the number of programmers has risen in the last decade and will continue to grow to meet the needs of computer users around the world.

Foreword Introduction
Assalamualaikum. My friend Muhammad Hazwan bin Azahari and I Mohamad Zul helmie bin Abu Bakar as a team members, wish to express our appreciation and thanks to everyone who helped us completed the assignment. Puan Sharmilla Sulong our programming principles teacher who guide us and our parents who also provided support and encouragement to do the assignment. Besides that, we also want to thanks to our friend who helped us and gave the opinion to us.

The Evolution Of Programming Language

First Generation
A first-generation programming language is a machine-level programming language. Originally, no translator was used to compile or assemble the first-generation language. The first-generation programming instructions were entered through the front panel switches of the computer system. The main benefit of programming in a first-generation programming language is that the code a user writes can run very fast and efficiently, since it is directly executed by the CPU. However, machine language is a lot more difficult to learn than higher generational programming languages, and it is far more difficult to edit if errors occur. In addition, if instructions need to be added into memory at some location, then all the instructions after the insertion point need to be moved down to make room in memory to accommodate the new instructions. Doing so on a front panel with switches can be very difficult. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer. Architectural considerations make portability difficult too. For example, the number of registers on one CPU architecture could differ from those of another.

Second Generation
Second-generation programming language is a generational way to categorize assembly languages. The term was coined to provide a distinction from higher level third-generation programming languages (3GL) such as COBOL and earlier machine code languages. Second-generation programming languages have the following properties: The code can be read and written by a programmer. To run on a computer it must be converted into a machine readable form, a process called assembly. The language is specific to a particular processor family and environment.

Second-generation languages are sometimes used in kernels and device drivers (though C is generally employed for this in modern kernels), but more often find use in extremely intensive processing such as games, video editing, graphic manipulation/rendering. One method for creating such code is by allowing a compiler to generate a machine-optimized assembly language version of a particular function. This code is then hand-tuned, gaining both the brute-force insight of the machine optimizing algorithm and the intuitive abilities of the human optimizer.

Third Generation
A third-generation programming language (3GL) is a refinement of a second-generation programming language. The second generation of programming languages brought logical structure to software. The third generation brought refinements to make the languages more programmer-friendly. This includes features like improved support for aggregate data types, and expressing concepts in a way that favours the programmer, not the computer (e.g. no longer needing to state the length of multi-character (string) literals in Fortran). A third generation language improves over a second generation language by having the computer take care of non-essential details, not the programmer. High level language is a synonym for third-generation programming language. First introduced in the late 1950s, Fortran, ALGOL, and COBOL are early examples of this sort of language. Most popular general-purpose languages today, such as C, C+ +, C#, Java, BASIC and Delphi, are also third-generation languages. Most 3GLs support structured programming.

Fourth Generation
A fourth-generation programming language (1970s-1990) (abbreviated 4GL) is a Programming Language or programming environment designed with a specific purpose in mind, such as the development of commercial business [Link] the History of Computer Science, the 4GL followed the 3GL in an upward trend toward higher abstraction and statement power. The 4GL was followed by efforts to define and use a 5GL. The natural-language, block-structured mode of the thirdgeneration programming languages improved the process of software development. However, 3GL development methods can be slow and error-prone. It became clear that some applications could be developed more rapidly by adding a higher-level programming language and methodology which would generate the equivalent of very complicated 3GL instructions with fewer errors. In some senses, software engineering arose to handle 3GL development. 4GL and 5GL projects are more oriented toward problem solving and systems engineering. All 4GLs are designed to reduce programming effort, the time it takes to develop software, and the cost of software development. They are not always successful in this task, sometimes resulting in inelegant and unmaintainable code. However, given the right problem, the use of an appropriate 4GL can be spectacularly successful as was seen with MARK-IV and MAPPER (see History Section, Santa Fe real-time tracking of their freight cars the productivity gains were estimated to be 8 times over COBOL). The usability improvements obtained by some 4GLs (and their environment) allowed better exploration for heuristic solutions than did the 3GL. A quantitative definition of 4GL has been set by Capers Jones, as part of his work on function point analysis. Jones defines the various generations of programming languages in terms of developer productivity, measured in function points per staff-

month. A 4GL is defined as a language that supports 1220 FP/SM. This correlates with about 1627 lines of code per function point implemented in a 4GL. Fourth-generation languages have often been compared to domain-specific programming languages (DSLs). Some researchers state that 4GLs are a subset of DSLs. Given the persistence of assembly language even now in advanced development environments (MS Studio), one expects that a system ought to be a mixture of all the generations, with only very limited use of the first.

Fifth Generation
A fifth-generation programming language (abbreviated 5GL) is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer. Most constraint-based and logic programming languages and some declarative languages are fifth-generation languages. While fourth-generation programming languages are designed to build specific programs, fifth-generation languages are designed to make the computer solve a given problem without the programmer. This way, the programmer only needs to worry about what problems need to be solved and what conditions need to be met, without worrying about how to implement a routine or algorithm to solve them. Fifth-generation languages are used mainly in artificial intelligence research. Prolog, OPS5, and Mercury are examples of fifth-generation languages. These types of languages were also built upon Lisp, many originating on the Lisp machine, such as ICAD. Then, there are many frame languages, such as KL-ONE. In the 1990s, fifth-generation languages were considered to be the wave of the future, and some predicted that they would replace all other languages for system development, with the exception of low-level languages. Most notably, from 1982 to 1993 Japan put much research and money into their fifth generation computer systems project, hoping to design a massive computer network of machines using these tools. However, as larger programs were built, the flaws of the approach became more apparent. It turns out that starting from a set of constraints defining a particular problem, deriving an efficient algorithm to solve it is a very difficult problem in itself. This crucial step cannot yet be automated and still requires the insight of a human programmer.

Today, fifth-generation languages are back as a possible level of computer language. A number of software vendors currently claim that their software meets the visual "programming" requirements of the 5GL concept.

Conclusion :
Computer programming languages have evolved into four generations beginning with languages that were tied to the hardware and evolved into general purpose programming languages. The first generation of programming language were machine languages which were used by the first computers. This generation of programming languages were written in binary, a series of zeros and ones. Binary is difficult to read and errors occurred frequently. Machine languages were created differently for different for each CPU. Machine dependency was a problem because this programming language would only work for the system that it was written for. When the second generation of programming languages were created, assembly languages did not completely resolve the issue of machine dependency. The assembly programming language was written in a more simplistic form, and at a higher level of abstraction machine language, instead of a series of zeros and ones there were symbols (percents, dollar and portions of a word and number combination used to make commands. Although assembly languages seem easier than the machine languages; machine dependency is still an existing problem. Third generation programming languages were converted from English into machine language; compilers were used to convert these instructions. Languages such as C++ and Visual Basic are third generation programs that are well-known today. Important elements of assembly and machine language were not used for this generation of languages. Machine dependency was not a problem encountered by the generation of programming languages; but there was a need for a different type of processor to write each source code. Third generation

programming languages are quite difficult to write, but people who are not technically inclined would find it easy to write programs in fourth generation programming languages. Structured query language (SQL) is primarily used for creating databases and data entry. SQL has shorter command codes than languages from the previous generations. Fourth generation programming languages are strictly for applications that will process fourth generation commands. Object-oriented programming should be used when programming is focused on a specific concept, rather than a process. Java, C++, and Smalltalk are used for this purpose. Programming languages have evolved from numbers, letters, short words, and we are striving to eliminate the use of lowlevel languages with evolution of trends during the 5th generation. Since we are presently in the 5th generation, preliminary goals have been made to further develop the three types of languages Logic, Constraint-Based, and Declarative Languages. The goal is make the computer do all of the problem-solving, rather than making a specific application go through the process.

Sources of Reference :
Books : 1. The Evolution of Programming Languages,by Peter Grogono 2. Timeline of General-Purpose Programming Languages,by Denis Sureau Internets : 1. Wikipedia Search Key,Evolution of Programming Language 2. Scribd - Search Key,Evolution of Programming 3. [Link]

THE END OF PAGE -THANK YOU(^^,)