The computers that were available in the early 1950’s were not very usable. They were slow and unreliable, not to mention incredibly expensive. Another major drawback was the lack of a high level language to program these machines. At first all programming was done in Machine Language. Machine Language utilized a series of numeric codes that indicated the instruction to be executed. The language had no mnemonics whatsoever (Sebesta 39).
The other major issue was that Machine Language utilized absolute addresses. This made the modification of programs very problematic. If a modification enlarged the physical size of the program, then all of the instructions that accessed memory via addressing would have to be modified. The development of high level languages such as FORTRAN (FORmula TRANslation) and COBOL (COmmon Business Oriented Language) made the general use of computers possible. Once developed, the languages spread like wildfire (Sebesta 40).
The first of these was developed by John Mauchy. Called Short Code, it was implemented on the Univac I in 1952. Short Code was not translated into Machine Code. Instead, it was implemented with an interpreter. While Short Code made programming easier, it did so at the expense of execution time. Interpreting Short Code was about 50 times slower than Machine Language (Sebesta 41).
A group led by Grace Hopper developed the first compiling systems between 1951 and 1953. These systems, named A-0, A-1, and A-2, expanded psuedocode into Machine Language. This development, at least to a point, mitigated the execution time issue with interpreted languages. Thus the first steps toward high level languages had begun (Sebesta 41). The term “compiler”, as used today, was not what Hopper had in mind. Hopper’s compilers were simply programs that would take subroutines out of a library and place them in the program at a location the programmer specified. These subroutines were pre-coded algorithms that would compute sine, cosine, logarithm, and other mathematical calculations. It would relieve the programmer of rewriting code that may be common to several programs (Ceruzzi 85).
Designers and computer manufactures were not the only ones try to tackle the software issue. In 1955 a group of IBM 701 users, called SHARE, banded together. Share is the oldest computer users group (Grosch 247). The original purpose of SHARE was to discuss and prepare for the upcoming migration to the new IBM 704 machine (Ceruzzi 88). It evolved away from a group that disparaged IBM into a technical and information sharing group. Don Shell, the key General Electric individual involved with SHARE, offered his IBM 701 interpreters and 704 compilers to the group (Grosch 247). Shell and his partners, Dorthea Clarke and Jim Porter, had utilities for the 704 computer up and running several months before IBM (Grosch 247).
The introduction of the IBM 704 in 1954 could be argued as one of the greatest advances in computing history. The 704 had the capability of implementing the first truly high level language, FORTRAN. A general lack of floating point hardware in the early computers was the main reason that interpretive languages had been tolerated. The IBM had floating point built into the hardware, and this ended the dominance of interpretive programs for scientific applications (Sebesta 42).
FORTRAN was developed at IBM by John Backus and his group. It was introduced for the IBM 704 computer in 1957. There were several factors that led to FORTRAN’s success. FORTRAN’s syntax was close to what algebra looked like. The documentation was also well written and concise. The most important factor in FORTRAN”S success is that it was a true compiled language. The compiler took the FORTRAN code and generated effiecent machine code that rivaled what programmers could produce. This eliminated any speed penalty associated with interpreters. Engineers, the users of the day, enjoyed the speed and ease of programming and now did not have to be concerned with the speed (Ceruzzi 91).
The team that designed FORTRAN never envisioned that FORTRAN would be used on computers that were not designed by IBM. FORTRAN opened the way for users other than engineers to program computers. It owes its initial success to the fact that the inner workings of the computer were hidden from the user. The language acted as a buffer from the mystical inner parts to the outside world. The users enthusiastically accepted this, as they were left alone to write programs that solved there problems, not deal with the problems the machine was having that day (Ceruzzi 91).
FORTRAN dramatically changed the way computers were used. Part of the reason for this can certainly be attributed to the fact that FORTRAN was the first high level language that was used by the masses. A survey of users in 1958 revealed tat fully fifty percent of the code being written for the IBM 704 was coded in FORTRAN (Sebesta 45). Very early versions of FORTRAN do suffer from flaws, but this is certainly understandable. FORTRAN IV was written between 1960 and 1962, and was still widely used in 1969. Alan Perlis, who was a designer of the language ALGOL 60, called FORTRAN the lingua franca, or language of the streets (Sebesta 47).
As users began to share data and information, the need for standardization became apparent. In 1957 IBM was the sole owner of FORTRAN. Several other high level languages were in various stages of development. One of the most notable was IT, designed by Alan Perlis out of Carnegie Tech. Since UNIVAC computers could not use IBM’s proprietary FORTRAN, other languages need to be developed. Two of these were MATH-MATIC and UNICODE. This proliferation made standard data sharing very problematic. To make matters worse, the new languages were all being implemented on single architectures (Sebesta 53).
To try to alleviate this problem, SHARE and USE, The Univac Scientific Exchange, submitted a letter to the Association of Computing Machinery stating the desire to form a committee to investigate the development of a universal programming language. This letter was submitted on May 10th, 1957. ACM joined with a German group known as GAMM (A German acronym for the Society for Applied Mathematics and Mechanics (Sebesta 54).
The Europeans who were contributing to the development of ALGOL were hoping that it would become the world wide standard that was not tied to IBM (Ceruzzi 95). The language was never really utilized by a large number of users. Part of this stems from the virtual non-existence of of input and output statements (Sebesta 58). While the goal of European Domination eluded them, it did become the sole way of publishing algorithms, and remained so past 1969.
While FORTRAN was taking the scientific community by storm, another storm was also brewing. Grace Hopper developed a business language compiler she named B-0 in 1956 (Ceruzzi 92). Hopper believed that mathematical programs should be written in that notation, and business programs should be written in English, readable by managers as well as programmers. From B-0 came COBOL, with FLOW-MATIC being an intermediary (Sebesta 60).
The Department of Defense convened a committee in 1959 for the purpose of discussing the development of a common business language (Ceruzzi 91). The committee as a whole agreed that the language should follow English as much as possible and be easy to use (Sebesta 61). The committee produced preliminary specifications for COBOL by the end of 1959. In 1960, the United States Government stated that it would only procure computer equipment that COBOL could be implemented on (Ceruzzi 92).
The result of the Government’s announcement was that COBOL became one of the first languages to be standardized to run on several different manufactures’ machines. This meant that a program written on a UNIVAC would run on an IBM. In fact, this was demonstrated in December of 1960, when the same program ran on a UNIVAC II and a RCA 501 (Ceruzzi 92).
With the ability to be used on multiple platforms, with the Grace Hopper induced English variable names, and with string and data manipulation that was not present in FORTRAN and other scientific languages, COBOL became a great success (Cerruzzi 92). Revised versions were published by the Department of Defense in 1961 and 1962. The American National Standards Institute (ANSI) standardized COBOL in 1968 (Sebesta).
The development of FORTRAN and COBOL brought to the masses the ability to develop programs that solved their individual problems. The user, instead of an engineer, could write a FORTRAN program to solve a mathematical or scientific problem or a COBOL program to solve a business one. These software systems demonstrated that computers could be used without the “Arcane Knowledge” of Machine Code. The computer age for users had begun.