Yesterday's languages built today's software: core languages - Cobol, PL-1, Lisp - all predated the software industry - includes related article about Grace Hopper

YESTERDAY'S LANGUAGES BUILT TODAY'S SOFTWARE

Even as the independent software industry this year celebrates two decades of unbundled life, 1989 marks another anniversary of historic proportions in software annals--the 35th anniversary of the first true high-level language, Fortran.

In fact, most of the other major languages in use today--Cobol, PL/1, APT, even APL and Lisp--were created before unbundling begat the independents. What is impressive is that, with all the abuse they have taken, these languages continue to not only survive, but dominate.

When the task group, led by IBM's John Backus, published Fortran I on Nov. 10, 1954, it achieved what many doubting Thomases previously had said couldn't be done: a high-speed compiler could be developed using simple syntactic analysis.

Backus' nine-person task group had some non-IBMers, including Roy Nutt of United Aircraft and Sheldon Best of MIT. Bob Hughes of the Livermore Radiation Laboratory and Harry Cantrell of General Electric also helped the project along.

In a paper presented in 1976 at the International Research Conference on the History of Computing, Backus said, "Fortran did not really grow out of some brainstorm about the beauty of programming in mathematical notation. Instead, it began with the recognition of a basic problem of economics: programming and debugging costs already exceeded the cost of running a program. And as computers became faster and cheaper, this imbalance would become more and more intolerable."

Backus' theory was that a language could be developed that included a translator capable of producing object programs as efficient as handwritten machine-code programs. He also believed the language could be adapted to algorithms used in scientific applications.

It took an estimated 25-person years to produce the first Fortran compiler--the ancestor of all modern compilers.

Along the way, Backus and his associates observed some ideas of others, including J.H. Laning and W. Zierler, who had come up with ways to communicate mathematical expressions to a computer in a closer-to-natural form.

However, the Fortran task group created many still-familiar expressions on its own. These included "GO TO," a branch instruction; "DO," to set up an iteration; and the conditional instruction, "IF," among others. Language in the November 1954 preliminary report had variables of one or two characters in length and function names of three or more characters.

With Robert A. Nelson and Irving Ziller, Backus in 1957 began work on Fortran II. In April of that year, IBM decided the compiler was reliable enough to distribute to all IBM 704 users.

Fortran II's success was so profound that, by 1959, most manufacturers of scientific machines had adopted it. As a result, Fortran scored another "first"--the first machine-independent language.

In addition to spawning the development of general-purpose, high-level languages, Fortran ideas also influenced special-purpose languages. One of the oldest still in use is APT--Automatic Programmed Tools, which resulted from a contract awarded in 1951 by the U.S. Air Force Air Material Command to the Servomechanisms Laboratory at the Massachusetts Institute of Technology.

By 1955, the laboratory had developed a program which enabled the Whirlwind computer to punch paper tapes to control machine tools. The first "Interim Report" of the project, written in 1956, laid out a system structure featuring three styles of three-dimensional programming--by points, space curves and regions.

In 1957, APT II was made available with the IBM 704 and, in 1961, on the IBM 7090.

ALGOL BEGINNINGS

In the late 1950s, prior to Cobol, Algol attracted support from IBM. In 1959, IBM charged a group directed by Robert W. Bemer and Julien Green with writing an experimental compiler for Algol 58. A version was demonstrated in May 1959 on an IBM 709 to a Share meeting.

In the early 1960s, another group, supported by IBM Europe, defined Algol 60, which for years afterward served as a basis for programming languages because of the strict definition of its syntax.

Algol's main difference from Fortran was in its structure. Algol programs were made up of blocks--sequences of instructions that began with BEGIN and concluded with END. An attractive feature was dynamic allocation of memory.

However, Algol's success was limited, in part because it did not have the flexibility of expression needed for business computer applications and also because many users had just been sold on Fortran and did not wish to switch.

In 1959, a gathering of computer users, some manufacturers and representatives of various universities at the University of Pennsylvania, concluded that a machine-independent language was needed for business data processing in the way Algol 58 was used for scientific computations.

DOD SUPPORTED COBOL EFFORT

The U.S. Department of Defense supported the idea and convened a second meeting in May 1959, which included 21 representatives from U.S. government agencies, manufacturers and universities.

Although most of the participants agreed there was a need for programs to be transferable among machines, there was disagreement on how rapidly to proceed, as well on technical directions.

A "short-range" committee, later named the Cobol (Common Business-Oriented Language) Committee, reviewed several existing languages, including Flowmatic, developed at Univac by Grace Hopper's group; Aimaco, developed by a U.S. Air Force group led by Col. Alfred Asch; IBM's Comtran (Commercial Translator); Fortran; RCA 501 Assembler; GE Hanford's Report Generator; and Dupont's APG-1, among others.

The committee decided to create a new language, called Cobol, using features from several of those. Many natural-language words came from Flowmatic, and instructions often were quite English-like.

For example, one could write: "IF X = Y MOVE A TO B; IF GREATER, ADD A to Z; OTHERWISE MOVE C TO D." The committee did not accept the Fortran "DO," however, preferring the instruction "PERFORM" instead, with different specifications.

Despite differences of opinion from a "medium-range" committee that had been studying other alternatives, the U.S. government eventually threw all its support behind Cobol, declaring that any computer manufacturer wishing to do business with the government had to offer Cobol, unless it could show it had a better-performing language.

The Cobol committee completed its document, called "Cobol--Specifications for a COmmon Business Oriented Language" in December 1959. It was accepted by the Codasyl Executive Committee in January 1960.

In a paper presented at a 1978 ACM Sigplan History of Programming Languages Conference, Jean E. Sammet--who was on the Cobol committee and then working for Sylvania Electric Products--tried to figure the time spent producing the first Cobol. She estimated "the Short Range Committee effort to produce the input to the Government Printing Office in the spring of 1960 was between two and four person-years, of which about 90% was expended before January 1960."

The problem with Cobol, Fortran and Algol, however, was that none was a "universal" language that could be easily applied to applications other than the ones for which they were intended. As a result, in the early 1960s, equipment, software and programmers tended to be specialized by scientific, commercial and special-purpose applications.

In 1963, IBM and its user group, Share, agreed to address complaints about Fortran's limitations and problems when working with new technology and operating systems. The Share-Fortran Advanced Language Committee group was formed and concluded that a new language was very much needed.

IBM hoped to include the committee's recommendations in the operating system (later known as OS/360) for the new System/360.

Despite pressure on the committee to meet deadlines set in early 1964, PL/1 came too late for inclusion in the first release of OS/360.

In March 1964, the committee proposed the language in a "Report on the Share Advanced Language Development Committee." In a paper presented at the 1978 ACM Sigplan History of Programming Languages Conference, George Radin, IBM project leader and member of the committee, recalled that the initial reaction "was anything but indifferent.

"It was widely praised for its breadth, its innovations, and its attention to programmers of varying sophistication," Radin Said. "It was criticized for its formlessness, complexity and redundancy. One Share member later compared it to a 100-blade Swiss knife; another wondered why the kitchen sink had been omitted from the language."

A second version was produced by the group in June 1964, and in December, IBM's Hursley, England, laboratory published a document called "NPL Technical Report, IBM World Trade Laboratories (Great Britain) Ltd.," which refined PL/1 even more.

According to Radin, "60-character set replaced the original 48-character set. Special characters [such as] 'OR' were added primarily for NPL operations and delimiters.

"BEGIN . . . END blocks were introduced . . . %INCLUDE was removed, but many new compiletime facilities were added . . . STATIC, AUTOMATIC and CONTROLLED storage classed replaced TEMP and HELD . . . IF, THEN, ELSE," among other changes.

IBM had taken into account recommendations from members of its smaller systems users group, Guide. The product was originally call NPL for New Programming Language, but the British National Physical Laboratory complained about the use of its initials, and the name was changed to PL/1, for Programming Language number one.

While PL/1 went a long way toward answering the need for a "universal" language, it still is not without its critics. For example, it is considered cumbersome because of the need to provide for a wide range of expressions. Nevertheless, it remains one of the most widely used languages, perhaps second only to Cobol for commercial applications.

Lisp, a favorite language in the artificial intelligence community, was first implemented in 1958 by John McCarthy at MIT. Designed to manipulate symbolic expressions and lists of objects, every operation is written as a list, with the first element being the operator and the others the operands.

A Lisp program looks like a list overlaid by sublists. In addition, Lisp programs have the same structure as the data, so a program can be used as data in another program.

Looking for a language with notation closer to mathematics, which was in more general use, Kenneth Iverson designed APL (A Programming Language) and used it in 1962 to analyze the IBM 7090 and, two years later, System/360.

APL developed from Iverson's doctoral thesis done under the tutelage of computer pioneer Howard Aiken at Harvard University. His thesis involved developing subroutines to test the different methods to solve systems of differential equations. APL was designed as a tool to analyze computers.

The 1978 ACM Sigplan conference included APL among the 13 languages it honored because, according to its conclusions, "This language has received widespread use . . . increasing from a few highly specialized mathematical uses to many people using it for quite different applications, including those in business. Its unique character set's frequent emphasis on cryptic 'oneliner' programs, and its effective initial implementation as an interactive system make it important. In addition, the uniqueness of its overall approach and philosophy makes it significant."

Interestingly, Iverson's work stemmed from a book project undertaken jointly with another graduate student, Frederick P. Brooks, Jr., who later joined IBM and managed product development of System/360. Brooks and Iverson's project eventually led to Iverson's book, A Programming Language, submitted for publication in 1961.

APL consists of a "central body" able to call any number of independent subroutines. Unlike Fortran, however, types of named objects are taken into account only when the instruction is acted upon.

Also, data items are handled dynamically, instead of frozen by initial declaration. Because names are not declared at the start of a program, APL is difficult to compile. It provides simple functional relations, such as =, <, and >.

Beginning about 1964, when the first APL interpreters appeared, APL developed a strong cult-like following among some programmers, while others completely rejected it.

Throughout its development, it has remained close to mathematical notation, compared to most offer widely used languages.

Online systems began to evolve in the late 1950s. A major pioneering effort was Sabre (Semi-Automatic Business-Related Environment), which stemmed from a 1953 meeting between IBM and American Airlines executives to discuss a system for handling airline reservations.

American had tremendous motivation. Using manual methods, reservation agents annually made more than 25 million calls around the U.S. to book seats for more than 8.5 million passengers. Some seats were routinely left empty on all flights in case there were errors.

STudy groups were formed and worked hard on the problem for nearly four years. The project was formally established in 1957 in a then-new research organization at IBM's Poughkeepsie labs. After 18 months, in late 1958, it was moved to the Special Engineering Projects Division under Jerrier A. Haddad.

Based on dual IBM 7090 systems--each duplicating the other if one should fail--Sabre was developed as a round-the-clock, 365-day-a-year system involving some 12,000 miles of telephone lines linking the CPUs to some 1,200 terminals at travel agencies and American Airline reservation agents nationwide.

Control software had to be developed to identify every terminal, query, and the sending and receiving of information. Each 7090 had 32,768 words of main memory to hold the control programs.

When the system became fully operational, its primary application programs were contained on six IBM 7320 magnetic drums, able to store 1.1 million characters of memory each. The programs were called into the main memory when needed. The drum also temporarily housed information on the number of seats sold/Available on flights.

Total information and memory backup was provided by 16 1301 magnetic disks--each having a capacity of more than 56 million characters of data. Altogether, the online system had a capacity of more than 800 million characters, and all data was backed up on magnetic tapes stored in an archive.

Equipment was delivered in 1962 and checked out at the Sabre central processing site at Briarcliff Manor, about 30 miles north of New York City. It became fully operational in 1964, when the last of American's major cities was brought online.

COPYRIGHT 1989 Wiesner Publications, Inc.
COPYRIGHT 2004 Gale Group