The Evolution of Computer Programming Languages
Many would think that computer programming is a recent invention but the idea behind writing instructions for a machine to follow then has been around for over a century - The Evolution of Computer Programming Languages introduction. Starting from Charles Babbage’s steam driven machine named the Analytical Engine back in 1834. Unlike the simple calculating machines of that time that could perform only a single function, Charles Babbage’s Analytical Engine could perform a variety of tasks. This idea caught the attention of Ada Lovelace, a mathematician and daughter of the poet Lord Byron.
Understanding the potential of a programmable machine, Ada wrote a program to make the Analytical Engine calculate and print a sequence of numbers known as Bernoulli numbers. Because of her work with the Analytical Engine, Ada Lovelace is considered to be the world’s first computer programmer. Over a hundred years later, the first true computer appeared in 1943 when the U. S. Army created a computer called ENIAC able to calculate artillery trajectories. This computer consisted of vacuum tubes, switches, and cables. To give it instructions, you had to physically flip its different switches and rearrange its cables.
More Essay Examples on Computer Rubric
However, physically rearranging cables and switches to reprogram a computer proved to be very cumbersome. So instead of physically rearranging the computer’s wiring, computer scientists decided it would be easier to give the computer different instructions, which could make the computer behave in different ways. In the old days, computers were filling entire rooms and were costing millions of dollars. Today, computers have shrunk so much in size that they are essentially nothing more than a little silicon wafer, about the size of a potato chip.
These silicon wafers are called the central processing unit (CPU), or processor. However in order to tell the processor what to do, you have to give it instructions written in a language that it can understand. That can be achieved only using a programming language. Since 1943, programming languages have not stopped evolving, computer scientists are always trying to make a programmers life easier. The evolution of programming languages consists of four generations: machine language, assembly language, high-level languages and structured query language.
The first generation of programming languages was the machine language which was used by the first computers. This generation of programming languages were written in what is called a binary code, a series of zeros and ones where one stands for power on and zero for power off. Nonetheless to understand how a machine language works, one must understand how a processors works. Basically, a processor consists of nothing more than millions of micro switches that can be turned on or off. By turning certain switches on or off, one can make the processor do something useful.
So machine language permits instead of manually turning switches on or off, to turn a processor’s switches on or off by using those two numbers. So a typical machine language instruction could look like this 101001 0101. As it proved later, binary code was too difficult to read and complicated tasks were too long or difficult to be expressed thus errors occurred frequently. Machine languages were created differently for each different CPU, which lead to something called machine dependency.
Machine dependency was a huge problem because a programming language written in binary code would only work for the system that it was written for. Machine language is considered as the native language of the CPU, but almost no one writes programs in machine language because it is so tedious and confusing. A single one or zero in the wrong place and accidentally the wrong instruction could be given to the CPU. Because writing instructions in machine language can be so difficult and error-prone, computer scientists later invented to some extent a simpler computer programming language: the assembly language.
The second generation of programming languages was the assembly language. The assembly programming language was written in a more simplistic form, and at a higher level of abstraction than machine language. Instead of a series of zeros and ones there were symbols -percents, dollar and portions of a word and number combination in hexadecimal form- used to make commands. The whole purpose of assembly language was to make programming easier than machine language. Basically, one assembly language command could replace a dozen or more machine language commands.
So instead of writing ten machine language commands and risking making a mistake in all ten of those commands, assembly language permitted to write one command that did the work of ten or more machine language commands. Not only did this reduce the chance of mistakes, but it also made writing a program in assembly language much faster and easier. To understand how assembly language works, one must first understand how processors store and manipulate data. The processor is the “brain” of the computer it does all the work.
By itself, the processor is fairly useless it is useful only if it can communicate with the outside world. The processor communicates with the other parts of the computer through a series of wires called a bus. When a processor needs to work with data, it retrieves it from another part of the computer and temporarily stores that data in a storage area called a register. The processor then edits the data in its registers and sends the changed data back to another part of the computer, such as its memory or hard disk. For example a simple command would be mov al, 061h, mov stands for move.
This command moves the hexadecimal number to the register a1. Though the problem comes when adding two numbers together, one should have to tell the processor to store a number into a register, add a second number to the number in the register, and then pull the result out of the register. Thus eventually this language proved to be very complicated specially when creating video games or other large programs. Its biggest problem was that one needed to manipulate the processor’s registers just to do the simplest tasks which was to cumbersome.
In addition to that, assembly languages did not solve either the machine dependency problem so scientist in order to make computer programming even easier, found a way to hide the technical details of manipulating registers by creating high-level languages. The third generation of programming languages are the high-level languages. In 1957 Dr. Grace Murray Hopper developed a computer program called a ‘compiler’. That little program led programming languages into an evolutionary leap. Compilers and interpreters (same as compiler with some technical differences) are high-level language translator programs.
The first compiler was known as A-0. A compiler takes a set of computer instructions, written in English, which are called statements, which use brief statements or arithmetic expressions and convert them into machine language. Furthermore an individual high-level language statement is actually a macro-instruction; that is to say, that each individual statement gives several machine instructions when translated into machine language. High-level language statements most of the times resemble to the phrases or mathematical expressions needed to express the problem or procedure being programmed.
However, the syntax is very important (vocabulary, punctuation, and grammatical rules) and the semantics (meanings). For example, a statement like PRINT “hello world” would show in the screen “hello world”, printing in that statement has nothing to do with the printing machine that we connect in the computer. Also a mistake in the syntax could change everything. A computer does what one tells it to do nothing more nothing less. Programming languages that require the use of a compiler or interpreter are called Third Generation Languages.
Through that new generation, computer programmers do not need to know anymore the details of machine language or assembly language to write programs. Languages such as C++ and Visual Basic are amongst third generation’s most known programs. Many important elements of assembly and machine language were not used for this generation of languages. Machine dependency is not anymore a problem encountered by the generation of programming languages. A high-level language is obviously easier to learn and understand than an assembler language. Also, the potential for errors is reduced.
Since most of the high-level languages are machine independent, programs written in any high-level language do not have to be reprogrammed when a new computer is installed. Thus, Computer programmers do not have to learn a new language for each computer they program. However, high-level languages programs are usually less efficient than assembler language programs and require a greater amount of computer time for translation into machine instructions. The everyday goal of computer programmers is to always try and create a new programming language, which will make their lives even easier.
The fourth and last until today programming languages generation go by the term fourth-generation language because it describes a variety of programming languages that are more nonprocedural and conversational than prior languages. A fourth generation language example is the structured query language (SQL) another example is the INTELLECT natural query language. The fourth generation languages are much easier than all the previous; even a person not so technically advanced would find it easy to write programs in fourth generation programming languages.
As long as the computer has the underlying application package that processes for example SQL commands, a person with little or no knowledge of programming skills can write simple programs such as SELECT * FROM STUDENT which will list all of the files in a student’s database. Still, fourth generation programming languages are strictly used only for applications that will process fourth generation commands. When programming is focused on a specific concept, rather than a process, high-level languages like Java, C++, and Smalltalk are used; this method is called object-oriented programming.
The fourth generation is, a good example of easy programming, however, computer scientist are always trying to find an easier way. Programming languages have evolved from numbers, symbols, letters, to short words. Each new generation offering, a more potent and easier programming language, and a new special feature never seen before a more powerful tool each time yet having its disadvantages. But computer scientists are determined to eliminate the use of low-level languages with the 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 to make the computer do all of the problem-solving, rather than making a specific application go through the process. In a world where the computer use is day by day augmented and the demand for more and more capable programs are needed, computer scientists struggle to find an easier, less error prone and more time saving way to follow the much greater than before demand.