Programming Language
A language is nothing but a medium of interaction. It provides a way to express our thought and feelings with anybody, in ancient days when human was not able to speak he used to tell or communicate with their postures and expression, but when he learnt to speak he used taking to express. Programming languages are same like our daily language like Hindi, English, as well as our regional language, where we used this to interact with the computer system, if we want to give any command to the system like the simple addition program then we should first know how to give command and what are syntax for writing these type of command. So one thing is sure if we want to make computer work for us we have to first learn the computer programming language.
A programming language is an artificial language designed to express computations that can be performed by a machine, particularly a computer. Programming languages can be used to create programs that control the behavior of a machine, to express algorithms precisely, or as a mode of human communication.
Programming Language Paradigm
There are various languages exist in the market to group those languages according to their functionality we can specify various terms like functional, procedural etc. and the world of language can be better understandable or can give a clear picture when we go for their paradigm.
A paradigm is essentially a high level model of what computation is about - the unifying factor that makes Ada and C seem very similar, ignoring details such as what data or control structures are available, exactly how variables are passed to procedures, and so on.
Some Paradigms
- Procedural (COBOL, FORTRAN, Pascal, C)
- functional (LISP)
- logic (PROLOG)
- object-oriented (C++, JAVA)
- 4GL (Dbase)
- Visual (Visual Basic)
1. Machine Language
In the machine language programmer has to make their programs in machine languages (binary 0/1) and the output they also received in the binary format, so the disadvantage of machine language that only the computer programmers are able to understand those codes, and lay man user had nothing to do with the system, if he/she wanted to interact then they should first learn the machine language then only he/she can able, so this process is very hectic. The language was extremely machine independent. The programmer had to virtually think like the machine. The programmer had to know both the instruction set of the computer, and how data was represented. So, the programmer was working under the basic premise of the machine, which was: there is data, and there are instructions that process the data.
2. Assembly Language
As computers grew in power, assemblers and assembly language came into being. This created a level of abstraction between the base machine and the programmer, allowing the programmer to think more like a human being and less like the computer. No longer did the programmer have to worry about getting the zeros and ones right -- he or she could use mnemonics, constants, literals and pseudo-ops. Assembly languages also allowed functionality to be isolated and reused through the use of subroutines. Subroutines basically extended the instruction set of the computer. However, the assembly languages carried the basic premise of the machine into its abstraction: There is data, and there are instructions and subroutines that process the data.
3. Higher Level Language
Around 1954, the first FORTRAN compiler was developed, and higher level languages came into being. These compiled and interpreted languages created another level of abstraction between the programmer and the base machine. The programmer could replace miles of assembly code with one expression or statement. Again, programming languages took another step towards the way people normally think, and the way the computer thinks. In addition, the higher level languages were (theoretically) machine independent. The compiled and interpreted languages also had functions and subroutines, which further allowed the programmer to extend the instruction set of the computer. However, the higher level languages had one basic premise: There is data, and there are functions / subroutines / expressions / statements that process the data.
4. Structured Language
In the late 1960s, structured languages came into being. These languages (C, Pascal) eliminated the "goto" helping to localize and clarify code. Programmer productivity went up by a factor of 10 as a result. However, the structured languages still carried the basic premise of the Von Neuman machine: there is data, and there are instructions / functions / subroutines that process data.
5. Earlier Analysis and Design
As programs got more complex, programmers realized that there might be a better way to write programs than getting a problem statement and sitting down and writing code. In other words, a little abstract planning might help. Along these lines, some abstract modeling techniques were developed. Earlier methods included flowcharts and functional specifications, functional decomposition. Later techniques involved:
- data flow diagrams (functionality)
- data dictionaries (functionality)
- Decision trees
- process specifications (structured English)
- entity relationship diagrams (data -- Information modeling)
The later techniques arose from the structured programming languages, and became used in structured analysis and design. The intention of the models was to create extra levels of abstraction between the real-world problem/system and the computer implementation of the system. They served as a bridge between the real world situation, and the computer code. The problem was mapped into a verbal problem statement, then into a requirements analysis model, which was far removed from the machine implementation. The analysis model was then mapped into a design model, which was one step closer to the machine implementation (the code). Finally, code was written from the design model. However, these earlier abstract models all ran on one premise -- there is data, and there are functions that process the data. The first models attempted only to model the functionality of the real-world systems. Later, entity relationship diagrams were added -- these modeled the data, or the static nature of the system. However, the functionality models and the data models were distinct and separate entities. Code and Yourdon note in their book Object-Oriented Analysis (Prentice Hall, 1991) that the fact that there were two basic sets of models in structured analysis -- functional models and data models, created a split or rift among analysis teams. This split caused tremendous headaches.
6. Object Oriented Paradigm
Is it possible to make a computer think the way people naturally think, rather than in terms of data and instructions that process data? The base machine will probably always think in terms of data and instructions that process data. However, are there high-level languages that can add another layer of abstraction on top of the machine, so that the high level languages can be written in code that mirrors the way people think? Yes, of course -- these are the OO languages! Some OO languages are better at hiding the basic premise of the machine. Smalltalk is probably the best, while C++ is probably the worst (more on this later).
