1. Evolution and History of Programming Languages

2. Software Programming Language

3. History Timeline The Tower of Babel Genesis 11:1-7
Now the whole earth had one language and few words.
And as men migrated from the east, they found a plain in the land of Shinar and settled there. And they said to one another, "Come, let us make bricks, and burn them thoroughly." And they had brick for stone, and bitumen for mortar.
Then they said, "Come, let us build ourselves a city, and a tower with its top in the heavens, and let us make a name for ourselves, lest we be scattered abroad upon the face of the whole earth."
And the Lord came down to see the city which the sons of men had built.
And the Lord said, "Behold, they are one people, and they all have one language; and this is only the beginning of what they will do; and nothing that they propose to do will now be impossible for them.
"Come, let us go down, and there confuse their language, that they may not understand one another's speech."
So the Lord scattered them abroad from there over the face of all the earth, and they left off building the city.
Therefore its name was called Babel, because the Lord confused the language of all the earth; and from there the Lord scattered them abroad over the face of all the earth.

4. The Evolution of Programming Languages
To build programs, people use languages that are similar to human language. The results are translated into machine code, which computers understand.
Programming languages fall into three broad categories:
Machine languages
Assembly languages
Higher-level languages

5. The Evolution of Programming Languages - Machine Languages
Machine languages (first-generation languages) are the most basic type of computer languages, consisting of strings of numbers the computer's hardware can use.
Different types of hardware use different machine code. For example, IBM computers use different machine language than Apple computers.

6. Machine Language Native language of computers.
First Generation Language
Based on binary language; every instruction and data should be written using 0’s and 1’s.
Instruction in m/c language consists of two parts:
Opcode tells the computer what functions are to be performed.
Operand tells the computer where to find or store the data on which the desired function is to be performed.
Advantages of Machine Language
Translation Free
High Speed
Disadvantages of Machine Language
Machine Dependent
Complex Language
Error Prone
Tedious
OPCODE
(Operation Code)
OPERAND
(Memory Location)

7. The Evolution of Programming Languages - Assembly Languages
Assembly languages (second-generation languages) are only somewhat easier to work with than machine languages.
To create programs in assembly language, developers use cryptic English-like phrases to represent strings of numbers.
The code is then translated into object code, using a translator called an assembler.

8. Assembly Language Second Generation Language.
The assembly language program must be translated into m/c code by a separate program called assembler.
An assembler converts the assembly code into binary code.
Used abbreviations for the instructions.
Here also instructions consists of two parts i.e. opcode and operand.
Advantages of Assembly Language
Easy to understand and use
Less Error Prone
Efficiency
More control on Hardware
Disadvantages of Assembly Language
Machine Dependent
Harder to Learn
Slow Development Time
Less Efficient
No Standardization

9. Assembly
code
Object code
Assembler

10. The Evolution of Programming Languages - Higher-Level Languages
Higher-level languages are more powerful than assembly language and allow the programmer to work in a more English-like environment.
Higher-level programming languages are divided into three "generations," each more powerful than the last:
Third-generation languages
Fourth-generation languages
Fifth-generation languages

11. Higher-Level Languages - Third-Generation Languages
Third-generation languages (3GLs) are the first to use true English-like phrasing, making them easier to use than previous languages.
3GLs are portable, meaning the object code created for one type of system can be translated for use on a different type of system.
The following languages are 3GLs:
FORTAN C
COBOL C++
BASIC Java
Pascal ActiveX

12. High-Level Language Third Generation Languages.
Some popular HLLs – FORTRAN, COBOL, BASIC, PASCAL, Java, LISP, PROLOG.
Advantages of HLL
Readability
Machine Independent
Easy debugging
Easier to maintain
Easy Documentation
Disadvantages of HLL
Poor control on Hardware
Less Efficient

13. PROGRAM TRANSLATORS
Assembler
Compiler
Interpreter

14. Compiler
A compiler is a program translator that translates a program written in high-level language into machine language program.
During the translation process, the compiler reads the source program and checks for syntax errors. In case of any errors, the compiler will not create the object code until all the errors are rectified.
Once the program has been compiled, the resulting m/c code is saved separately, and can be run on its own at any time. But, if the source code is modified then it is necessary to recompile the program again to reflect the changes.
Target Language Program (Machine Object Code)
COMPILER
High-level Language Program (Source Code)
Error Messages

15. Translates and Executes Statement by Statement
Interpreter
Also a language translator.
Translates high-level language into machine language.
Unlike compilers, it translates a statement in a program and execute immediately, i.e., before translating the next source language statement.
When an error is encountered, the execution of the program is halted and an error message is displayed.
Languages such as BASIC and LISP has its own interpreters.
Result of the Executed Statement
Translates and Executes Statement by Statement
High-level Language Program (Source Code)
Error Messages

16. Difference between Compiler and Interpreter
Basis
Compiler
Interpreter
Object Code
A compiler provides a separate object program.
An interpreter does not generate a permanent object code file.
Translation Process
Converts the entire program into machine code at one go.
Translates the source code line-wise.
Debugging Ease
Removal of errors (debugging) is slow.
Debugging becomes easier because the errors are pointed out immediately.
Implementation
Compilers are complex programs. They require hard-core coding. Also require more memory to execute a program.
Interpreters are easier to write because they are less complex programs. Also require less memory for program execution.
Execution Time
Compilers are faster as compared to interpreters because each statement is translated only once and saved in object file, which can be executed anytime without translating again.
Interpreters are slower as compared to compilers because each statement is translated every time it is executed from the source program.

17. A Typical C Program Development Environment
Disk
Loader
Linker
Compiler
Preprocessor
Editor
Primary Memory
CPU
1. Program is created in the editor and stored on disk
2. Preprocessor program processes the code
3. Compiler creates object code and stores it on disk.
5. Loader puts program in memory.
4. Linker links the object code with the libraries
6. CPU takes each instruction and executes it, possibly storing new data values as the program executes
Phases of C Programs:
1. Edit
2. Preprocess
3. Compile
4. Link
5. Load
6. Execute

18. Higher-Level Languages - Fourth-Generation Languages
Fourth-generation languages (4GLs) are even easier to use than 3GLs.
4GLs may use a text-based environment (like a 3GL) or may allow the programmer to work in a visual environment, using graphical tools.
The following languages are 4GLs:
Visual Basic (VB)

19. Higher-Level Languages - Fifth-Generation Languages
Fifth-generation languages (5GLs) are an issue of debate in the programming community – some programmers cannot agree that they even exist.
These high-level languages would use artificial intelligence to create software, making 5GLs extremely difficult to develop.
Solve problems using constraints rather than algorithms, used in Artificial Intelligence
Prolog

20. Summary