History Of Programming Languages Information Technology Essay

Ford states that computers can only obey instructions that are issued to them.  In order for the instructions to be understood by both user and the computer there needs to be an interface to aid in the communication. This is where computer programming languages come in – their primary function  is to aid the communication between the computer and the user. They provide a link between the human language and the machine language.  There is a huge variety of programming languages and each language has it’s own set of strengths and weaknesses and is geared with specific applications. Even though there is a huge number of computer languages out there today, computer languages are a fairly new field, since the first high-level languages were written in the 1950’s, around the time computers were invented.  The earliest computers were programmed in binary so the set of instructions was just a series of 0 and 1. The interface back then was low-level language – when a computer is given a series of instruction via a program, the computer executes the task and the interface in which the user communicates with the computer can either be a low- level or a high-level language. A high -level language does not communicate directly to the computer. Rather, high level languages is a language with a series of abstractions. Higher level languages allow the programmer to communicate more conveniently to the computer. Programming languages, together with their compilers span the gap between low-level, or binary, instructions that helps the machine understand and the high level languages, which allows the programmer to be more expressive.

In software development, the programming language must be compatible with the design methodology at the design stage of software development. A facility is viewed as consisting of tools and methodologies and these should be compatible for maximum benefits. It is necessary to examine the relationship of the programming language to other components of a software development facility – the first programming languages were designed for programming rather than for software development. However, even if a language was not designed with the goal of software production in mind, it must be evaluated on that criterion because that is the desired end.

As a result, the software development process has imposed language design goals. First, reliability – users should feel comfortable in using the programming language even in the presence of infrequent of undesirable events like hardware or software failures. This is also linked to correctness – software is correct if it behaves according to its specifications – the more rigorously and unambiguously the specifications are set down, the more convincingly program correctness can be proved. Reliability consists of readability, writability in the language and the ability to deal with exceptions, or so that the system is predictable even in abnormal situation. Second, maintainability – software costs have risen and increasingly complex software systems have been developed, so economic considerations have reduced the possibility of throwing away existing software and developing similar applications from scratch. Existing software must be modified to meet new requirements. Examples of a language being modifiable is

Modifiable examples are allowing constants to be given symbolic names, or just altering something in one line of the program to be changed and implemented in many other places in the program.Third, efficiency – always a goal for the execution of any software system, and affects both the programming language and the choice of algorithms to be used.Efficiency is no longer measured by the execution of speed and space. The initial effort required to produce a program and the effort required in maintenance are also components of efficiency. Language supports efficiency if it has qualities of writability, maintainability, and optimizability. Optimizability is the quality of allowing automatic program optimization. This is important because a lot of the time traditionally spent in programming is spent on trying to find an efficient way of doing things. This should be removed from the early stages of the programming. So a developer should first write a program that is demonstrably correct, then through a series of efficiency improving transformations, modify the program to obtain a correct and efficient one. Generally, features that promote optimizability hamper readability.These three goals can be achieved by appropriate tools and should be the certain characteristics of the programming language.

Technically speaking, users use two sets of commands when they program on a modern computer; one for the operating system and one for the programming language. The operating system is basically a program which is loaded each time the computer is turned on and provides the set of instructions for the programmer to control operations in the computer. These operations include logging in, loading files, displaying information, and running a program. The operating system program provides the facilities to allow communication between the user and the computer to be initiated and continued.

A translation program is needed to convert a programming language to translate a higher level programming language to the executable machine code so that the computer processor may understand. The two means of translating higher level languages are by compilers and interpreters. Compilers take the source code of the higher level programming language and converts it into object code (the 1s and 0s). This converts the entire program in one go and then resaves it in its converted form.  he translated object code is then linked and run. One of the advantages of using a compiler is that there are no errors in the syntax when the program is run since it would have shown up earlier at the translation stage. However, a compiler requires space to accommodate both the source and object files. On the other hand, interpreters look at the program statement by statement and translate and execute the single statement before going on to the next. This means that translation and the execution happen simultaneously, not separately as with the compiler. The main advantage of the interpreter is that it is more effective in  debugging programs. However, interpreters suffer from poor execution speeds than compilers since each line has to be translated and executed, whereas the compilers translates it all at once.

Programs, on the other hand,  have been around since the first computing device. The oldest artificial computing device, other than the abacus, is the Blaise Pascal/s Arithmetic Machine. Before computer programming languages were made, paper tapes and punch cards which held complicated weaving patterns for the loom Tabulating Machine Company Looms by Jacquard in 1710. A century  later, Charles Babbage starting building a computing machine and the Analytical Machine. In the 20th century, Herman Hollerith founded the Tabulating Machine a while later. His machine Tabulators were used to speed up the counting and sorting punch cards. In the early 1940’s J. Presper Eckert and John W. Mauchly started building the ENIAC (Electronic Numerical Integrator and Calculator), which was completed in 1946. Around the same time, near the end of World War II, Konrad Zuse began building his second generation electromechanical computers in Germany. After Zuse successfully completed building his computer in 1945, he realized that he had no additional equipment for repairs or any kind of hardware development. He then turned his focus from hardware toward designing programming languages. Zuse is often referred to as the “father” of today’s computer programming due to his contribution to the first programing language which was powerful enough to be able to express sophisticated programs.

History of Programming Languages

Software development process originally consisted only of the coding phase. The computer was mainly used in the early days in scientific applications – an application was programmed by one person. The problem to be solved, like a differential equation, was well-understood. There was not much need for requirements analysis or design specification or even maintenance.

The first programmable computers only “spoke” machine language, which is well known to be unreadable and tedious to work with. After, programming languages evolved to assembly languages which quickly became popular and  lot easier to work with. A disadvantage is that the assembly language is very limited since it only provides facilities already in the machine code. The assembly language gives the programmer access to the machine code instructions and the macros. The macros offers a single instruction to give a combination a combination of several machine code instructions and provide common requirements.  The introduction of assembly language in the 1950’s paved the way and provided the key to later productions of of high level computer programming languages.The machine code and the assembly language are typically known as low-level languages. Assembly language offers the programmer the advantage of being able to specify where the programmer wants to allocate where the memory and data will start. This relieves some responsibility of the programmer to keep careful control over the memory. High level languages, on the other hand, take all responsibility away from the programmer. Rather, the use of variable names allow the programmer to reference particular parts of a program. 

When computers were first electronically created, the limitations from the hardware forced programmers to write programs that directly communicated with the computer’s machine code. This was the assembly language. The assembly language implemented the symbols and number representations from the machine codes. Working with assembly languages was a very tedious and inefficient task. Assemblers created object code, or a system of instructions that executed directly by the computer’s central processing unit (CPU). An advantage to writing a program in the assembly language was the that it took less time to execute since it was a direct execution from the CPU. However, there were many disadvantages of writing programs in the assembly languages. Assembly language  associated the machine-language code to symbolic representations in the human language. This was one of the reasons why, it was so tedious to program with the assembly language. A programmer needed to be highly skilled and familiar with assembly language to communicate with the assembly code. Additionally, written programs in assembly language were very prone to errors.  The assembly languages are often referred to low-level languages since it execute directly from the CPU. In order to solve this problem, a high-level programming language was created with a set of instructions more closely associated to the human language. 

FORTRAN

The very first high-level programming language was FORTRAN, which stands for FORmula TRANslation , It was developed in 1956 (first manual appeared in 1956, but first developed in 1954) by John Backus, a worker at IBM. FORTRAN’s goal was to ease the pain of writing in assembly language. When FORTRAN was first introduced, it was looked on suspiciously since almost all the programmers then only worked with the machine code and assembly languages. The programmers at that time had an initial belief that programs compiled from high-level language would be less efficient than those written at low-level. In order to persuade potential users of the benefits of working with a high-level language, Backus designed an excellent compiler for FORTRAN so the programs were just as efficient as those written in low-level languages. This was the best compiler for many years.   

FORTRAN soon became popular because it provided a realistic and desirable alternatives to low-level language programming for mathematical and scientific applications. This programming language was also the first to be widely used. However, one of the limitations of FORTRAN was that it was specifically oriented toward the IBM 704 machine. This is a major set-back since the language syntax contains many idiosyncrasies from the IBM 704 machine. From a pure programming language design standpoint this is a “cardinal sin” but historically, it is understandable. FORTRAN is known for its efficiency. Over the years, FORTRAN had been upgraded and developed into FORTRAN -II, FORTRAN -IV, FORTRAN -66, and FORTRAN -77. Early versions of FORTRAN largely restricted users. On the other hand, the later versions allowed more flexibility, but since it has adapted, it is not as easy to use as it should be. The development of the fast string processing makes FORTRAN more of a general-purpose language than it used to be, but it is still described as a mathematical or scientific language. 

Lisp

In contrast to FORTRAN, Lisp was first developed in 1956 as a functional language for list processing. LISP is one of the most used of the old, “classical” programming languages developed in the 1950’s. The design was motivated by the need of Artificial Intelligence researchers for an appropriate language. But gradually replaced or challenged in AI applications by Prolog. There are very few language constraints in LISP.  Lists are the sole data structure and the only operations are function invocations, conditional expressions and recursion. Iteration is achieved by recursion. Lisp is one of the very few “functional” as opposed to “procedural” programming languages. A procedural language requires the user to express each step in performing an action whereas a functional language merely specifies what has been done. 

Cobol

Another first generation computer program language that impacted the design of recent languages was Cobol (COmmon Business Oriented Language). Cobol was created by Grace Hopper in 1960 and was heavily supported by the U.S. government. Cobol was originally designed to be the common business language in the nation. The design of Cobol was discussed in the pentagon with 6 computer manufacturers.  This maybe why the language is still in use even though it is very wordy and lacking in logical modules – resulting in a unique English-like style that some have described as verbose. One of the advantages of  Cobol is is certain applications involving processing dollars and cents. Other advancements in Cobol include the character string data. Cobol is generally used globally in the government and military. Overall, Cobol was, and is still important because of its use for business applications.

The first three high level languages mentioned – FORTRAN, LISP, and COBOL – were and still widely used, or have descendants that are widely used. These languages, with their diverse purposes, set the foundation for most of today’s programming languages.

BASIC

Once the use of high-level languages became more widespread, programmers wanted to create  a programming language that would serve as an easy introduction to FORTRAN.  As a result, BASIC was designed by Thomas Kurtz and John Kemeny  at Dartmouth College in 1963-1964 as an easy and interactive language. However, now BASIC (Beginner’s All Purpose Symbolic Instruction Code) is the most used language on microcomputers.The main purpose was to be a simple introduction which would prepare students to use FORTRAN later. BASIC was easier to program and had a user-friendly syntax than FORTRAN. The only aspect in which FORTRAN is better than BASIC is that it FORTRAN has more advanced features. BASIC is a general purpose language.Since the earliest use of BASIC was in education, the original language was fairly primitive and had only single variable names. However, people discovered that BASIC could be used as an applications programming language.  Interestingly enough, BASIC was not very popular when it first came out. However, microcomputers adopted BASIC as the preferred language since it was an interpretive language. Also, BASIC, in new forms, is still widely used. For example, BASIC is the foundation and large influence for languages like Microsoft Visual Basic and the object-oriented language Visual Basic .NET.

Algol-60 

Many other programs sprang up to improve the FORTRAN language. Algol-60 was created in 1958 as an improvement of FORTRAN . Then it was then redesigned, improved, and the final report was published in 1960. The key features of Algol-60 are that the syntax and the semantics are more orthogonal and that the language syntax is defined formally. This language is one of the most ingenious language definition efforts in the early days of programming languages, but never received widespread acceptance. The main language innovations are that Algol implemented a nested block structure, where code sequences and their associated declarations could be grouped into blocks without the need to be separate, explicitly named procedures. Also, Algol featured lexical scoping – where a block can consist of private variables, procedures and functions but is invisible to code outside of the block, which is mainly information hiding. It is argued that Algol 60 is an obvious milestone to the development of programming languages because of its introduction of key concepts and its first use of formal notation for syntax. A large portion of the theoretical, practical and compiler work since Algol’s introduction has used Algol as the foundation.

The main flaws, however, were the omission of IO and to a lesser degree the costly parameter passing method “By Name”. There are many improvements to the Algol-60 such as the Algo-W which was designed in the mid 1960s. Algol-W is very closely related to the Algol-60 even though they are not compatible with each other. The greatest difference between the Algol-W and the Algol-60 was that parameters no longer passes by name and that the For Statement was redesigned.

The next three programming languages – Pascal, C and Prolog, developed in 1970 and 1972 respectively, are some of the key languages of the period of a boom of programming languages, though C and Prolog spawned meaningful descendant languages. Most importantly, this period was when language paradigms, or certain “styles” were created. The paradigms are object-oriented programming, imperative programming, logic programming, and functional programming, and some may add the concurrent and database paradigms. This period of programming development also spurred the great goto and structured programming debate where structured programming forced structure on the programmer in language development. However, there is a general consensus that the goto statement should not be used because it has the potential of making programs hard to read because a user will have to jump around in a program to search for all the targets of goto statements – and the existence of goto statements complicates automatic optimization.

Pascal

One of the largest criticisms with the early computer programming languages were that it was not portable. Languages like BASIC was non-standard in nature. BASIC programs written in one system  often had to be completely rewritten for another make of a computer. To solve this problem, Pascal was designed between 1968 and 1970 by Niklaus Wirth of Zurich. Pascal was strongly influenced by Algo-w, a close relative to Algo-60. Pascal was intended as a teaching tool for illustrating the proper design data structures and structured statements. One of the greatest advantages in Pascal is it’s “portability.” Unlike FORTRAN and BASIC, Pascal has a self-compiler which allows programs in Pascal to be moved from different systems. Additionally, Pascal was so well-suited for compiler writing that the CDC-660 compiler could translate the whole compiler in a few seconds. Pascal is also a well structured language because it allows a series of statement to be grouped together,  their programs are made to be very readable,  and they have a provision of versatile procedure and function facilities. Mayer (1988) states that Pascal is “a too good a language for the modest aim for which it was invented” (p. 10). The greatest limitations however, was that it was not designed with a specific area of application in mind. Therefore, Pascal is more of a general purpose language but lacks special features for particular application.

C

The programming language C was created by Dennis Ritchie in 1972. It is a general-purpose, not very high level language and  mainly used as the system’s language for the operating system UNIX. The chief design goal of C was to be a tool for working programmers, and therefore useful. C is a very popular language for the development of applications since it is flexible, convenient, powerful, efficient, and portable. Since it is a modern language, C provides the comprehensive range of control structures needed to allow well-structured programs to be written. C does not behave like a typical high level language because it offers features similar to low level languages since it is very similar to the source code. Basically, C is a systems language that features low level access with high level operators.

Prolog

Prolog is a non-procedural language with a focus on “logic programming”. In a Prolog program, it is not only necessary to express “how” a problem is to be solved but it’s not even possible to express this. The programmer specifies only “what” has to be done and Prolog does the rest – the program requires a data base of facts or knowledge – the programmer will ask questions and Prolog responds with the list of all possible correct answers that are inferred from the data base of facts. Prolog’s clauses for establishing the data base can be executed in any order – they can be run in parallel. As a result, Pascal became a natural candidate as the systems language on the Japanese fifth generation supercomputers, or “inference engines” because Pascal achieves considerable speed even though a typical, single Prolog operation consumes a lot of processor time. In general, Pascal’s main use was for general and educational purpose and supported structured programming.

The next two programs, in particular Ada, reflect the period of language design where scaling up to large systems was big with the use of modules – which also increased the use of generics, or generic programming constructs, which are parameterized modules. Also, the reduced instruction set computer (RISC) movement gave rise gearing hardware design from assembly programmers and for compilers – resulting in more focus in compilation technology for high level programming languages.

Ada

In the 1980’s additional computer program languages were created to match with the speed and efficiency advancement of the computer. In 1983  after almost a decade of careful study of previous errors in programming language design – promising Ada introduced. Ada was expected by some in the computer science field to be the first language with the potential of becoming the universal, almost exclusive language of the future for embedded systems. The focus of the design of Ada was driven by the U.S. Department of Defense, who wanted a program that would reduce the number of military standard languages. Ada had the unique advantage of having been defined as an American National Standard before any implementation became available, saving it from a proliferation of corrupted language versions.  Ada incorporates Pascal’s best ideas and corrected errors and omissions and has a much wider range of applications than Pascal – also Ada is “strongly typed”. Ada’s problems are that IO is not defined as part of the language etc. In general, Ada’s intended purpose was to be a general purpose, real-time language with embedded applications.

C ++

Another computer program language that object-oriented and systems programming designed int he 1980s is C++. C++ was unique in that it tried to mix in the high-level language features with low-level language features, making it a medium-level language. C++ was created by Bjarne Stroustrup in 1979 originally as C with Classes. In 1983, the name was changed to C ++. C++ is one of the most popular languages ever created and is widely used in the software industry. C++ is based off of C and it even compatible with C. The improvements of C++ from C is the addition of classes, exception handling, virtual functions, operator overloading, user-controlled free-store memory control, and improved type checking. Stroustrup designed C ++ as the ideal program to work with software. When Stroustrup was working in Software Development, he found that the program Simula had very useful features, but the program was too slow to use. Heavily influenced by Simula, he based his improvements of C on features in Simula and combined it with the speed and efficiency of C. However, there are some major criticisms of C++. Critics argue that C++ is too complicated. The language definition document of C ++ is almost three times as long as the language definition of C. Other drawbacks of C++ are that there are no features that create multi-threaded software and lacks a garbage collection.

JAVA

JAVA was created to simplify C ++ and was created due to the rise of the Web. JAVA was developed by James Gosling in 1991, and released in 1995. JAVA ‘s syntax is heavily derived from C ++, but has a much simpler object model and has less low-level facilities.   The five goals of JAVA are:

1) Simple, object oriented, and familiar

2) Secure

3) Architecture neutral and portable

4) High performance

5) Interpreted, threaded, and dynamic. 

In contrast to C ++, JAVA is object-oriented, platform-independent, multi-threaded.  JAVA is used as a foundation of Web, network services, applications, and many embedded devices in addition to the programming language HTML. Another feature of JAVA is that it allows programmers to write software on one platform, also know as the hardware architecture, and run it on another platform. Overall, JAVA meets most its goals, it is familiar since it is closely related to C++ and it’s platform allows for JAVA’s programs to be portable. It has features that are lacking in C ++ such as an automatic garbage collector to manage the Internet. One of the major drawbacks of JAVA, however, is that its run time is a bit slow. Also, the majority of JAVA is opened sourced. JAVA is one of the many new languages that appeared in the 1990s in response to the boom of the Internet. All the developed languages of this time were object-oriented languages. Other languages introduced at this time were PHP and Python.

Convergence – some languages may reach a dead end. The evolution of languages is convergence – the space of possibilities is smaller and partly because mutations are not random – language designers deliberately incorporate ideas from other languages.

Current Issues with Programming Languages

With the growing open source community, almost anyone can develop a programming language. However, this poses several problems. Graham explains that this may result in a type of developed language called “top-heavy”, which is a language with a poorly designed inner core but has very powerful libraries of code to solve for specific problems – so the libraries are vastly more important than the core language. Also, Bjarne Stroustrup, the inventor of C++, points out some of the current issues with modern programming languages and software development. These days, average pieces of code have poor structure and programmers clearly don’t think deeply about correctness, algorithms, data structures or maintainability. He said that today, most people don’t actually read code. Developers concentrate on getting the job done by excessively using brute force and testing, though these are usually not enough. They become skilled in building reliable systems out of unreliable parts, and somehow, the system shapes into something minimally acceptable, even though the developers don’t know how or why. The issue here is that developers need to pursue more correct, solid and secure systems instead of going the cheapest and fastest route that contain a lot of bugs. Today, developers are undereducated and under trained.  Programming languages should not be more complex than necessary, but they should not be decreased in level of expressiveness to serve people who can hardly understand the real problem to be solved and the concepts.

Another issue is that it is difficult to implement incremental change directly related to real-world systems in academia. Theory and practice rarely meet – researchers gear away from real-world software development to academic topics, and many developers ignore research results. If this could change, then possibly Stroustrup’s criticisms of today’s development could change so that developers are more educated and develop more correct, maintainable and efficient code.

More specifically, a current issue with programming languages is security and reliability. There are mechanisms being developed and implemented to add safety to languages like extended static checking, information flow control and static thread safety. A program is considered thread safe if it functions correctly during simultaneous execution by multiple threads so that there is no unwanted interaction between threads. Type safety and access control are also  

Why are there so many programming languages?

There are more than 8,500 total programming languages, according to HOPL (History Of Programming Languages). As demonstrated previously, the many thousand programming languages developed over the years is a result of the growing number of applications and uses for languages and also updated and revised versions of existing programming languages. Over the past years, more and more programming languages have been developed for application in different areas like nuclear power plants or patient monitoring systems, etc. Also, more and more programming languages have been developed for users with little or no computer background.

Most programming languages, as mentioned before, are descendants of already existing ones (more economically feasible than creating new languages). One may argue that there is a self-perpetuating cycle that leads to the development of programming languages. Developers notice shortcomings in using their current programming language, make a list of the current annoyances and they look for a new, little known language that has a lot fewer of these annoyance. Then, the developers will drive the development  of the new language by contributing code, writing powerful libraries and spreading the word of their newly developed language so that it is implemented in their workplace – and then after a while, these developers will notice shortcomings in their current programming language – leading into the cycle. However, even though a newly developed programming language gets rid of shortcomings of its ancestor language, new shortcomings arise.

To answer the question of why there are so many languages, computer scientists have explained the concept of a programming languages and their uses in analogies. A programming language can be seen as a tool – like a certain type of saw or screwdriver – that is specially designed and used for certain situations and problems. However, there are also overlaps – in ways that some programming languages have many similarities or may be descendants of others. Certain classes of problems require, or can be solved more effectively with certain languages. In addition, each language can be seen as a form of expression – programmers find certain languages easier to use or understand as their own unique way of expression.

Paul Graham describes the notion of a programming language “renaissance”. Until the 1980s, only professors or corporate researchers had the ability to develop programming languages because their institutions had the financial means to afford the hardware needed to develop languages. However, the open source community led to the ability of anyone, even a high school student, to afford the hardware necessary to develop a language. Faster hardware has allowed programmers to make different trade offs between speed and convenience and this has increased the number of programming languages.

Overall, there is no one programming language that can be universally used for all purposes – like a pre- Tower of Babel language that can be used by all. Even though one general purpose language may seem ideal, such a language would be very large, too complicated to learn fully and too hard to implement on small computers to cover all applications. Also, programming specific applications with a universal language would be less efficient than implementing a special-purpose language. And for any programming language, efficiency is one of the most important goals. As Paul Graham says, “If we were all using the same language, it would probably be the wrong one.”