The history of programming languages 1


1.   History of programming languages

In this part we will discuss about major developments in the history of the programming languages. The first programming languages were developed earlier than modern computer. We can divide the development of programming languages in several time periods and they are:
·         Before 1940,
·         The 1940s,
·         The 1950s 1960s
·         The 1968-1979 – the period of establishing fundamental paradigms,
·         The 1980s – The period of consolidation, modulus and performance,
·         The 1990s – The internet age and
·         Modern age – The development of current trends

1.1.  Before 1940s

The history of programming languages dates back before 1940. These programming languages predate the modern computer. At first, the languages where code. In 1801 the Jacquard loom was invented and it used punch cards to represent sewing loom arm movements in order to generate decorative patterns automatically.

During the 1842 the Ada Lovelace translated the memoir of Italian mathematician Luigi Menabrea about Charles Babbage’s newest proposed machine, the Analytical Engine. With the article, she appended a set of notes which specified in complete detail a method for calculating Bernoulli numbers with the Engine. Historians recognized this Engine to be the world’s first computer program.
In the first decades of the 20th century, numerical calculations were based on decimal numbers. It was then realized that logic could be represented with numbers, not only words. The Turning machine was an abstraction of the operation of a tape – marking machine, for example, in use at the telephone companies. Turing machines set the basis for storage of programs as data in the von Neumann architecture of computers by representing a machine through a finite number. However, unlike the lambda calculus, Turing’s code does not serve well as a basis for higher – level languages – its principal use is in rigorous analyses of algorithmic complexity.

1.2. The 1940s

In 1940s, the first modern, electrically powered computers were created. The limited speed and memory capacity forced programmers to write hand tune assembly language programs. It was eventually realized that programming in assembly language required a great deal of intellectual effort and this languages had many disadvantages.
In 1948 Konard Zuse published a paper about his programming language Plankalkul. However, it was not implemented in his lifetime. In 1943 ENIAC or Electronic Numerical Integrator and Computer was the first electronic computer with general purpose. This computer was capable of being reprogrammed to solve a full range of computing problems.
ENIAC was originally designed to calculate artillery firing tables for the US Army. When ENIAC was announced in 1946 it was heralded in the press as GIANT BRAIN. ENIAC was a modular computer and it was composed of individual panels to preform different functions. Twenty of these modules were accumulators, which could not only add and subtract but hold a ten-digit decimal number in memory. Numbers were passed between these units across a number of general – purpose bused, or trays as they were called. In order to achieve its high speed the panels had to send and receive number, compute, save the answer, and trigger the next operation. All these operation without and moving parts.  Besides the speed of calculation, the most remarkable thing about ENIAC was its size and complexity. ENIAC contained 17,468 vacuum tubes, 7,200 crystal diodes, 1,500 relays, 70,000 resistors, 10,000 capacitors and around 5 million hand – soldered joints. It weighed more than 30 short tons (27 t) took up over 1800 square feet (167 m^2) and consumed 150 kW of power.

1.3.The 1950s and 1960s

In 1950s , the first three modern languages whose descendants are still in widespread use today were designed:
-          FORTRAN
-          LISP
-          COBOL
Another milestone in the late 1950s was the publication, by a committee of American and European computer scientists, of a new language for algorithms; the ALGOL 60 report. This report consolidated with many new ideas circulating at the time and featured two key language innovations:
  • nested block structure: code sequences and associated declarations could be grouped into blocks without having to be turned into separate, explicitly named procedures;
  • lexical scoping: a block could have its own private variables, procedures and functions, invisible to code outside that block, i.e.information hiding.
Another innovation, related to this, was in how the language was described:
  • a mathematically exact notation, Backus-Naur Form (BNF), was used to describe the language's syntax. Nearly all subsequent programming languages have used a variant of BNF to describe the context-free portion of their syntax.
Algol 60 was particularly influential in the design of later languages, some of which soon became more popular. The Burroughs large systems were designed to be programmed in an extended subset of Algol.
Algol's key ideas were continued, producing ALGOL 68:
  • syntax and semantics became even more orthogonal, with anonymous routines, a recursive typing system with higher-order functions, etc.;
  • not only the context-free part, but the full language syntax and semantics were defined formally, in terms of Van Wijngaarden grammar, a formalism designed specifically for this purpose.
Algol 68's many little-used language features (e.g. concurrent and parallel blocks) and its complex system of syntactic shortcuts and automatic type coercions made it unpopular with implementers and gained it a reputation of being difficult. Niklaus Wirth actually walked out of the design committee to create the simpler Pascal language.
Some important languages that were developed in this period include:
  • 1951 - Regional Assembly Language
  • 1952 - Autocode
  • 1954 - IPL (forerunner to LISP)
  • 1955 - FLOW-MATIC (forerunner to COBOL)
  • 1957 - FORTRAN (First compiler)
  • 1957 - COMTRAN (forerunner to COBOL)
  • 1958 - LISP
  • 1958 - ALGOL 58
  • 1959 - FACT (forerunner to COBOL)
  • 1959 - COBOL
  • 1959 - RPG
  • 1962 - APL
  • 1962 - Simula
  • 1962 - SNOBOL
  • 1963 - CPL (forerunner to C)
  • 1964 - BASIC
  • 1964 - PL/I
  • 1967 - BCPL (forerunner to C)

 1.3.1. FORTRAN

Fortran (previously FORTRAN) is a general-purpose, imperative programming language that is especially suited to numeric computation and scientific computing. Originally developed by IBM at their campus in south San Jose, California in the 1950s for scientific and engineering applications, Fortran came to dominate this area of programming early on and has been in continual use for over half a century in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics, computational physics and computational chemistry. It is one of the most popular languages in the area of high-performance computing and is the language used for programs that benchmark and rank the world's fastest supercomputers.
Fortran (a blend derived from The IBM Mathematical Formula Translating System) encompasses a lineage of versions, each of which evolved to add extensions to the language while usually retaining compatibility with previous versions. Successive versions have added support for structured programming and processing of character-based data (FORTRAN 77), array programming, modular programming and generic programming (Fortran 90), high performance Fortran (Fortran 95), object-oriented programming (Fortran 2003) and concurrent programming (Fortran 2008).
The names of earlier versions of the language through FORTRAN 77 were conventionally spelled in all-caps (FORTRAN 77 was the version in which the use of lowercase letters in keywords was strictly nonstandard). The capitalization has been dropped in referring to newer versions beginning with Fortran 90. The official language standards now refer to the language as "Fortran". Because the capitalization was never completely consistent in actual usage, this article adopts the convention of using the all-caps FORTRAN in referring to versions of the language up to FORTRAN 77 and the title-caps Fortran in referring to versions of the language from Fortran 90 onward. This convention is reflected in the capitalization of FORTRAN in the ANSI X3.9-1966 (FORTRAN 66) and ANSI X3.9-1978 (FORTRAN 77) standards and the title caps Fortran in the ANSI X3.198-1992 (Fortran 90), ISO/IEC 1539-1:1997 (Fortran 95) and ISO/IEC 1539-1:2004 (Fortran 2003) standards.
In late 1953, John W. Backus submitted a proposal to his superiors at IBM to develop a more practical alternative to assembly language for programming their IBM 704 mainframe computer. Backus' historic FORTRAN team consisted of programmers Richard Goldberg, Sheldon F. Best, Harlan Herrick, Peter Sheridan, Roy Nutt, Robert Nelson, Irving Ziller, Lois Haibt, and David Sayre.[3] Its concepts included easier entry of equations into a computer, an idea developed by J. Halcombe Laning and demonstrated in his GEORGE compiler of 1952.
A draft specification for The IBM Mathematical Formula Translating System was completed by mid-1954. The first manual for FORTRAN appeared in October 1956, with the first FORTRAN compiler delivered in April 1957. This was the first optimizing compiler, because customers were reluctant to use a high-level programming language unless its compiler could generate code whose performance was comparable to that of hand-coded assembly language.
While the community was skeptical that this new method could possibly outperform hand-coding, it reduced the number of programming statements necessary to operate a machine by a factor of 20, and quickly gained acceptance. John Backus said during a 1979 interview with Think, the IBM employee magazine, "Much of my work has come from being lazy. I didn't like writing programs, and so, when I was working on the IBM 701, writing programs for computing missile trajectories, I started work on a programming system to make it easier to write programs."
The language was widely adopted by scientists for writing numerically intensive programs, which encouraged compiler writers to produce compilers that could generate faster and more efficient code. The inclusion of a complex number data type in the language made Fortran especially suited to technical applications such as electrical engineering.
By 1960, versions of FORTRAN were available for the IBM 709, 650, 1620, and 7090 computers. Significantly, the increasing popularity of FORTRAN spurred competing computer manufacturers to provide FORTRAN compilers for their machines, so that by 1963 over 40 FORTRAN compilers existed. For these reasons, FORTRAN is considered to be the first widely used programming language supported across a variety of computer architectures.
The development of FORTRAN paralleled the early evolution of compiler technology, and many advances in the theory and design of compilers were specifically motivated by the need to generate efficient code for FORTRAN programs.

1.3.2. LISP

Lisp (historically, LISP) is a family of computer programming languages with a long history and a distinctive, fully parenthesized Polish prefix notation. Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today; only Fortran is older (by one year). Like Fortran, Lisp has changed a great deal since its early days, and a number of dialects have existed over its history. Today, the most widely known general-purpose Lisp dialects are Common Lisp and Scheme.
Lisp was originally created as a practical mathematical notation for computer programs, influenced by the notation of Alonzo Church's lambda calculus. It quickly became the favored programming language for artificial intelligence (AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, and the self-hosting compiler.
The name LISP derives from "LISt Processing". Linked lists are one of Lisp languages' major data structures, and Lisp source code is itself made up of lists. As a result, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or even new domain-specific languages embedded in Lisp.
The interchangeability of code and data also gives Lisp its instantly recognizable syntax. All program code is written as s-expressions, or parenthesized lists. A function call or syntactic form is written as a list with the function or operator's name first, and the arguments following; for instance, a function f that takes three arguments might be called using (f arg1 arg2 arg3).
Lisp was invented by John McCarthy in 1958 while he was at the Massachusetts Institute of Technology (MIT). McCarthy published its design in a paper in Communications of the ACM in 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I" ("Part II" was never published). He showed that with a few simple operators and a notation for functions, one can build a Turing-complete language for algorithms.
Information Processing Language was the first AI language, from 1955 or 1956, and already included many of the concepts, such as list-processing and recursion, which came to be used in Lisp.
McCarthy's original notation used bracketed "M-expressions" that would be translated into S-expressions. As an example, the M-expression car[cons[A,B]] is equivalent to the S-expression (car (cons A B)). Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned. M-expressions surfaced again with short-lived attempts of MLISP by Horace Enea and CGOL by Vaughan Pratt.
Lisp was first implemented by Steve Russell on an IBM 704 computer. Russell had read McCarthy's paper, and realized (to McCarthy's surprise) that the Lisp eval function could be implemented in machine code.[4] The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, 'evaluate Lisp expressions.'
Two assembly language macros for the IBM 704 became the primitive operations for decomposing lists: car (Contents of the Address part of Register number) and cdr (Contents of the Decrement part of Register number). From the context, it is clear that the term "Register" is used here to mean "Memory Register", nowadays called "Memory Location". Lisp dialects still use car and cdr ( /ˈkɑr/ and /ˈkʊdər/) for the operations that return the first item in a list and the rest of the list respectively.
The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT. This compiler introduced the Lisp model of incremental compilation, in which compiled and interpreted functions can intermix freely. The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code.
Lisp was a difficult system to implement with the compiler techniques and stock hardware of the 1970s. Garbage collection routines, developed by then-MIT graduate student Daniel Edwards, made it practical to run Lisp on general-purpose computing systems, but efficiency was still a problem.[citation needed] This led to the creation of Lisp machines: dedicated hardware for running Lisp environments and programs. Advances in both computer hardware and compiler technology soon made Lisp machines obsolete.[citation needed]
During the 1980s and 1990s, a great effort was made to unify the work on new Lisp dialects (mostly successors to Maclisp like ZetaLisp and NIL (New Implementation of Lisp)) into a single language. The new language, Common Lisp, was somewhat compatible with the dialects it replaced (the book Common Lisp the Language notes the compatibility of various constructs). In 1994, ANSI published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp."

1.3.3.COBOL

COBOL ( /ˈkoʊbɒl/) is one of the oldest programming languages. Its name is an acronym for COmmon Business-Oriented Language, defining its primary domain in business, finance, and administrative systems for companies and governments. The COBOL 2002 standard includes support for object-oriented programming and other modern language features.
The COBOL specification was created by a committee of researchers from private industry, universities, and government during the second half of 1959. The specifications were to a great extent inspired by the FLOW-MATIC language invented by Grace Hopper - commonly referred to as "the mother of the COBOL language." The IBM COMTRAN language invented by Bob Bemer was also drawn upon, but the FACT language specification from Honeywell was not distributed to committee members until late in the process and had relatively little impact. FLOW-MATIC's status as the only language of the bunch to have actually been implemented made it particularly attractive to the committee.[2]
The scene was set on April 8, 1959 at a meeting of computer manufacturers, users, and university people at the University of Pennsylvania Computing Center. The United States Department of Defense subsequently agreed to sponsor and oversee the next activities. A meeting chaired by Charles A. Phillips was held at the Pentagon on May 28 and 29 of 1959 (exactly one year after the Zürich ALGOL 58 meeting); there it was decided to set up three committees: short, intermediate and long range (the last one was never actually formed). It was the Short Range Committee, chaired by Joseph Wegstein of the US National Bureau of Standards, that during the following months created a description of the first version of COBOL.[3] The committee was formed to recommend a short range approach to a common business language. The committee was made up of members representing six computer manufacturers and three government agencies. The six computer manufacturers were Burroughs Corporation, IBM, Minneapolis-Honeywell (Honeywell Labs), RCA, Sperry Rand, and Sylvania Electric Products. The three government agencies were the US Air Force, the Navy's David Taylor Model Basin, and the National Bureau of Standards (now National Institute of Standards and Technology). The intermediate-range committee was formed but never became operational. In the end a sub-committee of the Short Range Committee developed the specifications of the COBOL language. This sub-committee was made up of six individuals:
·         William Selden and Gertrude Tierney of IBM
·         Howard Bromberg and Howard Discount of RCA
·         Vernon Reeves and Jean E. Sammet of Sylvania Electric Products
The decision to use the name "COBOL" was made at a meeting of the committee held on 18 September 1959. The subcommittee completed the specifications for COBOL in December 1959.
The first compilers for COBOL were subsequently implemented in 1960, and on December 6 and 7, essentially the same COBOL program ran on two different computer makes, an RCA computer and a Remington-Rand Univac computer, demonstrating that compatibility could be achieved.


1.3.4. AUTOCODE

Autocode is the name of a family of "simplified coding systems", later called programming languages, devised in the 1950s and 1960s for a series of digital computers at the Universities of Manchester and Cambridge. Autocode was a generic term; the autocodes for different machines were not necessarily closely related as are, for example, the different versions of the single language FORTRAN.
The first autocode and its compiler were developed by Alick Glennie in 1952 for the Mark 1 computer at the University of Manchester and is considered by some to be the first compiled programming language.[1]
The second autocode was developed for the Mark 1 by R. A. Brooker in 1954 and was called the "Mark 1 Autocode".
Brooker also developed an autocode for the Ferranti Mercury in the 1950s in conjunction with the University of Manchester. Mercury Autocode had a limited repertoire of variables a-z and a'-z' and, in some ways resembled early versions of the later Dartmouth BASIC language. It pre-dated ALGOL, having no concept of stacks and hence no recursion or dynamically-allocated arrays. In order to overcome the relatively small store size available on Mercury, large programs were written as distinct "chapters", each of which constituted an overlay. Some skill was required to minimise time-consuming transfers of control between chapters. This concept of overlays from drum under user control became common until virtual memory became available in later machines. Slightly different dialects of Mercury Autocode were implemented for the Ferranti Atlas (distinct from the later Atlas Autocode) and the ICT 1300 and 1900 range.
The version for the EDSAC 2 was devised by D. F. Hartley of University of Cambridge Mathematical Laboratory in 1961. Known as EDSAC 2 Autocode, it was a straight development from Mercury Autocode adapted for local circumstances, and was noted for its object code optimisation and source-language diagnostics which were advanced for the time. A version was developed for the successor Titan (the prototype Atlas 2 computer) as a temporary stop-gap while a more substantially advanced language known as CPL was being developed. CPL was never completed but did give rise to BCPL (developed by M. Richards), which in turn led to B and ultimately C. A contemporary but separate thread of development, Atlas Autocode was developed for the University of Manchester Atlas 1 machine.

1.3.5.  IPL (Information Processing Language)

Information Processing Language (IPL) is a programming language developed by Allen Newell, Cliff Shaw, and Herbert A. Simon at RAND Corporation and the Carnegie Institute of Technology from about 1956. Newell had the role of language specifier-application programmer, Shaw was the system programmer and Simon took the role of application programmer-user.
The language includes features intended to support programs that could perform general problem solving, including lists, associations, schemas (frames), dynamic memory allocation, data types, recursion, associative retrieval, functions as arguments, generators (streams), and cooperative multitasking. IPL pioneered the concept of list processing, albeit in an assembly-language style.
An IPL computer has:
a set of symbols. All symbols are addresses, and name cells. Unlike symbols in later languages, symbols consist of a character followed by a number, and are written H1, A29, 9-7, 9-100.
Cell names beginning with a letter are regional, and are absolute addresses.
Cell names beginning with "9-" are local, and are meaningful within the context of a single list. One list's 9-1 is independent of another list's 9-1.
Other symbols (e.g., pure numbers) are internal.
a set of cells. Lists are built from several cells holding mutual references. Cells have several fields:
P, a 3-bit field used for an operation code when the cell is used as an instruction, and unused when the cell is data.
Q, a 3-valued field used for indirect reference when the cell is used as an instruction, and unused when the cell is data.
SYMB, a symbol used as the value in the cell.
a set of primitive processes, which would be termed primitive functions in modern languages.
The main data structure of IPL is the list, but lists are more intricate structures than in many languages. A list consists of a singly linked sequence of symbols, as might be expected -- plus some description lists, which are subsidiary singly linked lists interpreted as alternating attribute names and values. IPL provides primitives to access and mutate attribute value by name. The description lists are given local names (of the form 9-1). So, a list called L1 holding the symbols S4 and S5, and described by associating value V1 to attribute A1 and V2 to A2, would be stored as follows. 0 indicates the end of a list; the cell names 100, 101, etc. are automatically generated internal symbols whose values are irrelevant. These cells can be scattered throughout memory; only L1, which uses a regional name that must be globally known, needs to reside in a specific place.
IPL-V List Structure Example
Name  SYMB            LINK
L1       9-1       100
100      S4        101
101      S5        0
9-1       0          200
200      A1       201
201      V1       202
202      A2       203
203      V2       0
IPL is an assembly language for manipulating lists. It has a few cells which are used as special-purpose registers. H1, for example, is the program counter. The SYMB field of H1 is the name of the current instruction. However, H1 is interpreted as a list; the LINK of H1 is, in modern terms, a pointer to the head of the call stack. For example, subroutine calls push the SYMB of H1 onto this stack.
H2 is the free-list. Procedures which need to allocate memory grab cells off of H2; procedures which are finished with memory put it on H2. On entry to a function, the list of parameters is given in H0; on exit, the results should be returned in H0. Many procedures return a boolean result indicating success or failure, which is put in H5. Ten cells, W0-W9, are reserved for public working storage. Procedures are "morally bound" (to quote the CACM article) to save and restore the values of these cells.
There are eight instructions, based on the values of P: subroutine call, push/pop S to H0; push/pop the symbol in S to the list attached to S; copy value to S; conditional branch. In these instructions, S is the target. S is either the value of the SYMB field if Q=0, the symbol in the cell named by SYMB if Q=1, or the symbol in the cell named by the symbol in the cell named by SYMB if Q=2. In all cases but conditional branch, the LINK field of the cell tells which instruction to execute next.
·         IPL has a library of some 150 basic operations. These include such operations as:
·         Test symbols for equality
·         Find, set, or erase an attribute of a list
·         locate the next symbol in a list; insert a symbol in a list; erase or copy an entire list.
·         Arithmetic operations (on symbol names).
·         Manipulation of symbols; e.g., test if a symbol denotes an integer, or make a symbol local.
·         I/O operations
·         "generators", which correspond to iterators and filters in functional programming. For example, a generator may accept a list of numbers and produce the list of their squares. Generators could accept suitably designed functions – strictly, the addresses of code of suitably designed functions – as arguments.
The first application of IPL was to demonstrate that the theorems in Principia Mathematica which were laboriously proven by hand, by Bertrand Russell and Alfred North Whitehead, could in fact be proven by computation. According to Simon's autobiography Models of My Life, this first application was developed first by hand simulation, using his children as the computing elements, while writing on and holding up note cards as the registers which contained the state variables of the program.
IPL was used to implement several early artificial intelligence programs, also by the same authors: the Logic Theorist (1956), the General Problem Solver (1957), and their computer chess program NSS (1958).
Several versions of IPL were created: IPL-I (never implemented), IPL-II (1957 for JOHNNIAC), IPL-III (existed briefly), IPL-IV, IPL-V (1958, for IBM 650, IBM 704, IBM 7090, many others. Widely used), IPL-VI.
However the language was soon displaced by Lisp, which had far more powerful features, a simpler syntax, and the benefit of automatic garbage collection.

1.3.6.  FLOW - MATIC

FLOW-MATIC, originally known as B-0 (Business Language version 0), was the first English-like data processing language. It was developed for the UNIVAC I at Remington Rand under Grace Hopper.
Hopper had found that business data processing customers were uncomfortable with mathematical notation. In late 1953 she proposed that data processing problems should be expressed using English keywords, but Rand management considered the idea unfeasible. In early 1955, she and her team wrote a specification for such a programming language and implemented a prototype. The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959.

First, FLOW-MATIC was the first programming language to express operations using English-like statements.
Second, FLOW-MATIC was the first system to distinctly separate the description of data from the operations on it. Its data definition language, unlike its executable statements, was not English-like; rather, data structures were defined by filling in pre-printed forms.
Flow-Matic was a major influence in the design of COBOL, since only it and its direct descendent AIMACO were in actual use at the time. Several elements of Flow-Matic were incorporated into COBOL:
·         Defining Files in advance, and separating into INPUT and OUTPUT files.
·         Qualification of data-names (IN or OF clause).
·         IF END OF DATA (AT END) clause on file READ operations.
·         Figurative constant ZERO (originally ZZZ...ZZZ, where number of Z's indicated precision).
·         Dividing the program into sections, separating different parts of the program. Flow-Matic sections included Computer (Environment Division), Directory (Data Division), and Compiler (Procedure Division).
Sample program
A sample FLOW-MATIC program:
(0)  INPUT INVENTORY FILE-A PRICE FILE-B ; OUTPUT PRICED-INV FILE-C UNPRICED-INV
      FILE-D ; HSP D .
 (1)  COMPARE PRODUCT-NO (A) WITH PRODUCT-NO (B) ; IF GREATER GO TO OPERATION 10 ;
      IF EQUAL GO TO OPERATION 5 ; OTHERWISE GO TO OPERATION 2 .
 (2)  TRANSFER A TO D .
 (3)  WRITE-ITEM D .
 (4)  JUMP TO OPERATION 8 .
 (5)  TRANSFER A TO C .
 (6)  MOVE UNIT-PRICE (B) TO UNIT-PRICE (C) .
 (7)  WRITE-ITEM C .
 (8)  READ-ITEM A ; IF END OF DATA GO TO OPERATION 14 .
 (9)  JUMP TO OPERATION 1 .
(10)  READ ITEM B ; IF END OF DATA GO TO OPERATION 12 .
(11)  JUMP TO OPERATION 1 .
(12)  SET OPERATION 9 TO GO TO OPERATION 2 .
(13)  JUMP TO OPERATION 2 .
(14)  TEST PRODUCT-NO (B) AGAINST ZZZZZZZZZZZZ ; IF EQUAL GO TO OPERATION 16 ;
      OTHERWISE GO TO OPERATION 15 .
(15)  REWIND B .
(16)  CLOSE-OUT FILES C ; D .
(17)  STOP . (END)

Note that this sample includes only the executable statements of the program, the COMPILER section (corresponding to COBOL's Procedure Division). The record fields PRODUCT-NO and UNIT-PRICE would have been defined in the DIRECTORY section (corresponding to COBOL's Data Division), which did not use English-like syntax.

1.3.7.COMTRAN


COMTRAN (COMmercial TRANslator) is an early programming language developed at IBM. It was intended as the business programming equivalent of the scientific programming language FORTRAN (FORmula TRANslator). It served as one of the forerunners to the COBOL language. Developed by Bob Bemer, in 1957, the language was the first to feature the programming language element known as a picture clause.
Several elements of COMTRAN were incorporated into COBOL:
·         Picture clause.
·         Paragraphing: dividing code into paragraphs (with line breaks not significant).
·         Paragraph names. Assigning names to paragraphs, and jumps (GO TO's) are to a paragraph name, not to a line number.
·         AT END clause on file input operations.
·         Figurative constant HIGH-VALUE.
·         Passing a numeric value (RETURN-CODE) back to the operating system when the program terminates.

Sample program
This is a sample COMTRAN program, doing payroll calculations.
01001 *PROCEDURE

01002 CALL (EMPLOYEE.NUMBER)  EMPLOYNO,
01003      (BONDEDUCTION)     BONDEDUCT,
01004      (BONDENOMINATION)  BONDENOM,
01005      (BONDACCUMULATION) BONDACCUM,
01006      (INSURANCE.PREM)   INSPREM,
01007      (RETIREMENT.PREM)  RETPREM,
01008      (DEPARTMENT.TOTAl) DPT.

01009 START. OPEN ALL FILES.

01010 GET.MASTER. GET MASTER, AT END DO END.OF.MASTERS.

01011 GET.DETAIL. GET DETAIL, AT END GO TO END.OF.DETAILS.

01012 COMPARE.EMPLOYEE.NUMBERS. GO TO COMPUTE.PAY WHEN DETAIL EMPLOYNO
01013       IS EQUAL TO MASTER EMPLOYNO, LOW.DETAIL WHEN DETAIL
01014       EMPLOYNO IS LESS THAN MASTER EMPLOYNO.

01015 HIGH.DETAIL. MOVE 'M' TO MASTER ERRORCODE, FILE MASTER IN
01016       ERROR.FILE.

01017         GET MASTER, AT END DO END.OF.MASTERS.

01018         GO TO COMPARE.EMPLOYEE.NUMBERS.

02001 LOW.DETAIL. MOVE 'D' TO DETAIL ERRORCODE, FILE DETAIL IN
02002        ERROR.FILE.

02003          GO TO GET.DETAIL.

02004 END.OF.MASTERS. IF DETAIL EMPLOYNO = HIGH.VALUE THEN GO TO
02005         END.OF.RUN OTHERWISE SET MASTER EMPLOYNO = HIGH.VALUE.

02006 END.OF.DETAILS. IF MASTEREMPLOYNO = HIGH.VALUE THEN GO TO
02007         END.OF.RUN OTHERWISE SET DETAIL EMPLOYNO = HIGH.VALUE, GO
02008         TO COMPARE.EMPLOYEE.NUMBERS.

02009 END.OF.RUN. MOVE CORRESPONDING GRAND.TOTAL TO PAYRECORD, FILE
02010        PAYRECORD, CLOSE ALL FILES.
02011          STOP 1234.

02012 COMPUTE.PAY. IF DETAIL HOURS IS GREATER THAN 40 THEN SET DETAIL
02013        GROSS = (DETAIL HOURS - 40) * MASTER RATE * 1.5.

02014        SET DETAIL GROSS = DETAIL GROSS + MASTER RATE * 40, DO
02015      FICA.ROUTINE, DO WITHHOLDING.TAX.ROUTINE.

02016        IF MASTER BONDEDUCT IS NOT EQUAL TO ZERO THEN DO
02017      BOND.ROUTINE.

02018        DO SEARCH FOR INDEX = 1(1)12.

02019 NET. SET PAYRECORD NETPAY = DETAIL GROSS - DETAIL FICA - DETAIL
02020        WHT -DETAIL RETIREMENT - DETAIL INSURANCE - DETAIL
02021        BONDEDUCT.

1.3.8. ALGOL 58


ALGOL 58, originally known as IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus
"The Zurich ACM-GAMM Conference had two principal motives in proposing the IAL: (a) To provide a means of communicating numerical methods and other procedures between people, and (b) To provide a means of realizing a stated process on a variety of machines..."
ALGOL 58 introduced the fundamental notion of the compound statement, but it was restricted to control flow only, and it was not tied to identifier scope in the way that Algol 60's blocks were.
There were proposals for a universal language by the Association for Computing Machinery (ACM) and also by the GAMM. It was decided to organize a joint meeting to combine them. The meeting took place from May 27 to June 2, 1958, at ETH Zurich and was attended by the following people:
·         Friedrich L. Bauer, Hermann Bottenbruch, Heinz Rutishauser, and Klaus Samelson (from the GaMM)
·         John Backus, Charles Katz, Alan Perlis, and Joseph Henry Wegstein (from the ACM).
The language was originally proposed to be called IAL (International Algebraic Language) but according to Perlis[3] this was rejected as an "'unspeakable' and pompous acronym". ALGOL was suggested instead, though not officially adopted until a year later. The publication following the meeting still used the name IAL.[4] Unresolved disagreements also led to a plan to define two dialects, ALGOL 58 and ALGOL 60[citation needed] but the name ALGOL 60 was eventually used for a specific language.
By the end of 1958 the ZMMD-group had built a working ALGOL 58 compiler for the Z22 computer. ZMMD was an abbreviation for Zürich (where Rutishauser worked), München (workplace of Bauer and Samelson), Mainz (location of the Z22 computer), Darmstadt (workplace of Bottenbruch).
ALGOL 58 saw some implementation effort at IBM, but the effort was in competition with FORTRAN, and soon abandoned. It was also implemented at Dartmouth College on an LGP-30, but that implementation soon evolved into Algol 60. An implementation for the Burroughs 220 called BALGOL evolved along its own lines as well, but retained much of ALGOL 58's original character.
ALGOL 58's primary contribution was to later languages; it was used as a basis for JOVIAL, MAD, NELIAC and ALGO. It was also used during 1959 to publish algorithms in CACM, beginning a trend of using ALGOL notation in publication that continued for many years.

1.3.9.FACT


FACT was an early computer programming language, created by the Datamatic Division of Minneapolis Honeywell for its model 800 series business computers in 1959. FACT was an acronym for "Fully Automated Compiling Technique". It was an influence on the design of the COBOL programming language.
Some of the design of FACT was based on the linguistic project Basic English, developed about 1925 by C.K. Ogden.
The software was actually designed by Computer Sciences Corporation (Fletcher Jones, Roy Nutt, and Robert L. Patrick) under contract to Richard Clippinger of Honeywell.
FACT was an influence in the design of COBOL, and is one of 3 predecessor languages credited in all COBOL manuals.
Several elements of FACT were incorporated into COBOL:
·         Defining data as levels, with group items and elementary items.
·         Assigning of initial values to data as it is being defined (VALUE clause).
·         Specifying a limited list of literal values allowed in a specific field (88 level data items).
·         A non-procedural report generator based on specifying the appearance of the desired report (Report Section in COBOL-66).
·         Qualification of data-names (IN or OF clause).
·         Group move of like-named items (MOVE CORRESPONDING).
·         Validity checks on procedural statements (ON ERROR clause).
·         Built-in SORT function.

           1.3.10. IBM RPG

RPG is a high-level programming language (HLL) for business applications. While IBM is the creator and primary vendor of RPG, the language is available from other mainframe and microcomputer manufacturers, including Unisys.
It has a long history, having been developed by IBM in 1959 as the Report Program Generator - a tool to replicate punched card processing on the IBM 1401[1] then updated to RPG II for the IBM System/3 in the late 1960s, and since evolved into an HLL equivalent to COBOL and PL/I.
It remains a popular programming language on the IBM Power i platform where the current version, RPG IV (a.k.a. ILE RPG), provides a modern programming environment.
An RPG program typically starts off with File Specifications, listing all files being written to, read from or updated, followed by Data Definition Specifications containing program elements such as Data Structures and dimensional arrays, much like a "Working-Storage" section of a COBOL program or "var" statements in Pascal. This is followed by Calculation Specifications, which contain the actual meat of the code. Output Specifications can follow which can be used to determine the layout of other files or reports. Alternatively files, some data structures and reports can be defined externally, mostly eliminating the need to hand code input and output ("I/O") specifications.
In the early days of RPG, its major strength was known as the program cycle: every RPG program executes within an implied loop, which can apply the program to every record of a file. At that time each record (individual punched card) would be compared to each line in the program, which would act upon the record, or not, based upon whether that line had an "indicator" turned "on" or "off" — from a set of logical variables numbered 01–99 for user-defined purposes, or other smaller sets based upon record, field, or report processing functions. The concept of level breaks and matching records is unique to the RPG II language, and was originally developed with card readers in mind.
Today, most RPG programmers avoid using the cycle in favor of controlling the flow of the program with standard looping constructs.
RPG is one of the few languages created for punched card machines that is still in common use today. This is because the language has evolved considerably over time. It was originally developed by IBM in 1959. The name Report Program Generator was descriptive of the purpose of the language: generation of reports from data files, including matching record and sub-total reports.
FARGO (Fourteen-o-one Automatic Report Generation Operation) was the predecessor to RPG on the IBM 1401 . Both languages were intended to facilitate ease of transition for IBM tabulating machine (Tab) unit record equipment technicians to the then new computers.
Tab machine technicians were accustomed to plugging wires into control panels to implement input, output, control and counter operations (add, subtract, multiply, divide). Tab machines programs were executed by impulses emitted in a machine cycle; hence, FARGO and RPG emulated the notion of the machine cycle with the program cycle. RPG was superior to and rapidly replaced FARGO as the report generator program of choice.
The alternative languages generally available at the time were Assembler, COBOL or FORTRAN. COBOL was a natural language-like business oriented language and FORTRAN was a language that facilitated mathematical applications. Other languages of the era included ALGOL and Autocoder and a few years later PL/I. Assembler and COBOL were more common in mainframe business operations (System/360 models 30 and above) and RPG more commonly used by customers who were in transition from tabulating equipment (System/360 model 20).

RPG II was introduced with the System/3 series of computers. It was later used on System/32, System/34, and System/36, with an improved version of the language. ICL also produced a version on its VME/K operating system
RPG III was created for the System/38 and its successor the AS/400. RPG III significantly departed from the original language, providing modern structured constructs like IF-ENDIF blocks, DO loops, and subroutines (RPG2 Supported Subroutines). RPG III was also available for larger systems including the IBM System/370 mainframe running OS/VS1. It was also available from Unisys for the VS/9 operating system running on the Univac 90/60 mainframe.
DE/RPG or Data Entry RPG was exclusively available on the IBM 5280 series of data-entry workstations in the early '80s. It was similar to RPG III but lacking external Data Descriptions (DDS) to describe data(files) like on the System/38 and its successors. Instead, the DDS part had to be included into the RPG source itself.
RPG/400 was effectively RPG III running on AS/400. IBM renamed the RPG compiler as "RPG/400" but it was identical to the RPG III compiler on System/38. The rebranding took place to differentiate between the earlier CISC (Complete Instruction Set Compile) on the beige boxes to the later, "faster" RISC (Reduced Instruction Set Compile), usually on the black servers. Virtually all IBM products were rebranded as xxx/400 and the RPG compiler was no exception. RPG III compiled with the RPG/400 compiler offered nothing new to the RPG III language until IBM began development of new operation codes, such SCAN, CAT and XLATE after several years of AS/400 availability. These enhancements to RPG III were not available in the System/38 version of RPG III.
RPG IV (a.k.a. RPGLE and ILE RPG) was released in 1994 and the name, officially, was no longer an initialism. RPG IV offered a greater variety of expressions within its Extended Factor-2 Calculation Specification and, later in life, its free-format Calculation Specifications and Procedure syntax. RPG IV is the only version of RPG supported by IBM in its long line of successors to the AS/400 system (iSeries, etc.).
In 2001, with the release of OS/400 V5R1, RPG IV offered even greater freedom for calculations than offered by the Extended Factor-2 Calculation Specification: a free-format text-capable source entry, as an alternative to the original column-dependent source format. The "/FREE" calculation does not require the operation code to be placed in a particular column; the operation code is optional for the EVAL and CALLP operations; and syntax generally more closely resembles that of mainstream, general-purpose programming languages. However, the free format only applies to the calculation specifications. F and D specifications still need to be in column-dependent format.
Today, RPG IV is a considerably more robust language. Editing can still be done via the simple green screen editor (even though syntax checking is not supported for features introduced from OS 7.1 onwards) or it can be edited via PC using IBM's Websphere Development Studio, now named RDi (Rational Development Studio for i) a customized implementation of Eclipse. IBM is continually extending its capabilities and adding more built-in functions (BIFs). It has the ability to link to Java objects,[3] and i5/OS APIs; it can be used to write CGI programs with the help of IBM's Cgidev2 web toolkit,[4] RPGLIB (a collection of hundreds of pre-written RPG IV routines), CGILIB, the RPG Toolbox, and other commercial Web-enabled packages. Even with the changes, it retains a great deal of backward compatibility, so an RPG program written 37 years ago could run today with little or no modification.
Furthermore, with the implementation of the SQL Precompiler, current RPG developers can take advantage of IBM's cost-based SQE (SQL Query Engine). As opposed to the traditional F-Spec approach, where a developer identified a specific access path to a data set, a developer can now implement standard embedded SQL statements directly in the program. When compiled, the SQL Precompiler transforms the invalid embedded SQL statements into valid RPG statements that call the database manager programs that ultimately implement the query request.
OS/400 was later renamed i5/OS to correspond with the new IBM System i5 branding initiative; the 5 was later dropped in favor of just System i. In March 2008 i5/OS was renamed IBM i as part of the Power Systems consolidation of System i and System p product lines. The new Power Systems also adopt more mainstream version numbers, substituting 6.1 for the twenty year old V1R1M0 notation. The latest release is now referred to as IBM i 7.1 and fully supports the RPG IV language, as well as many others. WebSphere Development Studio Client (WDSC) is now referred to as Rational Developer for i (RDi), of which three product levels are available. They are called Rational Developer for i (RDi), RDi Service Oriented Architecture (RDi SOA), and Rational Application Developer (RAD). The new lineup provides in more granular packaging all of the development tools and support previously offered by WDSC and WDSC Advanced Edition.
Some of the more unmodern features of the language include the dependency on the EBCDIC character sets which means that use of UTF-8 requires considerable effort and is quite risky (the programmer has to take responsibility not to get his/her character data mixed up with a single byte CCSID), whereas 16 bit characters (e.g. UTF-16) are supported directly via a separate datatype (Graphic). The threadsafeness of the language is also a bit odd as the compiler team has solved this by giving each thread its own static storage, rather than make the RPG run-time environment re-entrant. This has been noted to meddle up the distinction between a thread and a process (making RPG IV threads a kind of hybrid between threads and processes).
Example code

The following program receives a customer number as an input parameter and returns the name and address as output parameters.

      * Historically RPG is columnar in nature, though free-formatting
      * is allowed under particular circumstances.
      * The purpose of various lines code are determined by a
      * letter code in column 6.
      * An asterisk (*) in column 7 denotes a comment line

      * "F" (file) specs define files and other i/o devices
     F ARMstF1   IF   E       K     Disk    Rename(ARMST:RARMST)
     

      * "D" specs are used to define variables
     D pCusNo          S              6p 0
     D pName           S             30a
     D pAddr1          S             30a
     D pAddr2          S             30a
     D pCity           S             25a
     D pState          S              2a
     D pZip            S             10a

      * "C" (calculation) specs are used for executable statements
      * Parameters are defined using plist and parm opcodes
     C     *entry        plist
     C                   parm                    pCusNo
     C                   parm                    pName
     C                   parm                    pAddr1
     C                   parm                    pAddr2
     C                   parm                    pCity
     C                   parm                    pState
     C                   parm                    pZip

      * The "chain" command is used for random access of a keyed file
     C     pCusNo        chain     ARMstF1

      * If a record is found, move fields from the file into parameters
     C                   if        %found
     C                   eval      pName  = ARNm01
     C                   eval      pAddr1 = ARAd01
     C                   eval      pAddr2 = ARAd02
     C                   eval      pCity  = ARCy01
     C                   eval      pState = ARSt01
     C                   eval      pZip   = ARZp15
     C                   endif

      * RPG makes use of switches.  One switch "LR" originally stood for "last record"
      * LR actually flags the program and its dataspace as removable from memory.
     C                   eval      *InLR = *On
The same program using free calculations:
      * "F" (file) specs define files and other i/o devices
     FARMstF1   IF   E        K     Disk    Rename(ARMST:RARMST)

      * "D" specs are used to define variables and parameters
      * The "prototype" for the program is in a separate file
      * allowing other programs to call it
      /copy cust_pr
      * The "procedure interface" describes the *ENTRY parameters
     D getCustInf      PI
     D  pCusNo                        6p 0   const
     D  pName                        30a
     D  pAddr1                       30a
     D  pAddr2                       30a
     D  pCity                        25a
     D  pState                        2a
     D  pZip                         10a
      /free
        // The "chain" command is used for random access of a keyed file
        chain pCusNo ARMstF1;

        // If a record is found, move fields from the file into parameters
        if %found;
           pName  = ARNm01;
           pAddr1 = ARAd01;
           pAddr2 = ARAd02;
           pCity  = ARCy01;
           pState = ARSt01;
           pZip   = ARZp15;
        endif;

      // RPG makes use of switches.  One switch "LR" originally stood for "last record"
      // LR actually flags the program and its dataspace as removable from memory.
        *InLR = *On;
      /end-free
Assume the ARMSTF1 example table was created using the following SQL Statement:
create table armstf1
(arcnum decimal(7,0),
 arname char(30),
 aradd1 char(30),
 aradd2 char(30),
 arcity char(25),
 arstte char(2),
 arzip  char(10))
The same program using free calculations and embedded SQL:
      * RPG IV no longer requires the use of the *INLR indicator to terminate a program.
      * by using the MAIN keyword on the "H" (Header) spec, and identifying the "main" or
      * entry procedure name, the program will begin and end normally without using the
      * decades-old RPG Cycle and instead a more "C like" begin and end logic.
     H  MAIN(getCustInf)
      * "D" specs are used to define variables and parameters
      * The "prototype" for the program is in a separate file
      * allowing other programs to call it
      /copy cust_pr
      * The "procedure interface" describes the *ENTRY parameters
     P getCustInf      B
     D getCustInf      PI
     D  pCusNo                        6p 0   const
     D  pName                        30a
     D  pAddr1                       30a
     D  pAddr2                       30a
     D  pCity                        25a
     D  pState                        2a
     D  pZip                         10a
      /free
        exec sql select arName, arAddr1, arAdd2, arCity, arStte, arZip
                 into  :pName, :pAddr1, :pAddr2, :pCity, :pState, :pZip
                 from   ARMstF1
                 where  arCNum = :pCusNo
                 for fetch only
                 fetch first 1 row only
                 optimize for 1 row
                 with CS;
      /end-free
     P GetCustInf      E
As of V7R1 of the operating system, the above program would not necessarily need the prototype in a separate file, so it could be completely written as:
     H main(GetCustInf)
     D ARMSTF1       E DS
     P GetCustInf      B
     D GetCustInf      PI                  extpgm('CUS001')
     D  inCusNo                            like(arCNum) const
     D  outName                            like(arName)
     D  outAddr1                           like(arAdd1)
     D  outAddr2                           like(arAdd2)
     D  outCity                            like(arCity)
     D  outState                           like(arStte)
     D  outZip                             like(arZip)
      /free
       exec sql select arName, arAdd1, arAdd2, arCity, arStte, arZip
                into  :outName, :outAddr1, :outAddr2, :outCity, :outState,
                      :outZip
                from   ARMSTF1
                where  arCNum = :inCusNo
                fetch first 1 row only
                with CS
                use currently committed;
      /end-free
     P GetCustInf      E

1.3.11. APL

APL (named after the book A Programming Language) is an interactive array-oriented language and integrated development environment, which is available from a number of commercial and noncommercial vendors and for most computer platforms. It is based on a mathematical notation developed by Kenneth E. Iverson and associates that features special attributes for the design and specifications of digital computing systems, both computer hardware and software.
APL has a combination of unique and relatively uncommon features that appeal to programmers and make it a productive programming language:
·         It is concise, using symbols rather than words and applying functions to entire arrays without using explicit loops.
·         It is solution focused, emphasizing the expression of algorithms independently of machine architecture or operating system.
·         It has just one simple, consistent, and recursive precedence rule: the right argument of a function is the result of the entire expression to its right.
·         It facilitates problem solving at a high level of abstraction.
APL is used in scientific, actuarial, statistical, and financial applications where it is used by practitioners for their own work and by programmers to develop commercial applications. It was an important influence on the development of spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages. It is also associated with rapid and lightweight development projects in volatile business environments.

1.3.12.Simula

Simula is a name for two simulation programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. Syntactically, it is a fairly faithful superset of ALGOL 60. [1]:1.3.1
Simula is considered the first object-oriented programming language. As its name implies, Simula was designed for doing simulations, and the needs of that domain provided the framework for many of the features of object-oriented languages today.
Simula has been used in a wide range of applications such as simulating VLSI designs, process modeling, protocols, algorithms, and other applications such as typesetting, computer graphics, and education. The influence of Simula is often understated, and Simula-type objects are reimplemented in C++, Java and C#. The creator of C++, Bjarne Stroustrup, has acknowledged that Simula 67 was the greatest influence on him to develop C++, to bring the kind of productivity enhancements offered by Simula to the raw computational speed offered by lower level languages like BCPL.

1.3.13.SNOBOL

SNOBOL (StriNg Oriented and symBOlic Language) is a series of computer programming languages developed between 1962 and 1967 at AT&T Bell Laboratories by David J. Farber, Ralph E. Griswold and Ivan P. Polonsky, culminating in SNOBOL4. It was one of a number of text-string-oriented languages developed during the 1950s and 1960s; others included COMIT and TRAC.
SNOBOL4 stands apart from most programming languages by having patterns as a first-class data type (i.e. a data type whose values can be manipulated in all ways permitted to any other data type in the programming language) and by providing operators for pattern concatenation and alternation. Strings generated during execution can be treated as programs and executed.
SNOBOL4 was quite widely taught in larger US universities in the late 1960s and early 1970s and was widely used in the 1970s and 1980s as a text manipulation language in the humanities.
In recent years its use has faded as newer languages such as AWK and Perl have made string manipulation by means of regular expressions fashionable. SNOBOL4 patterns subsume BNF grammars, which are equivalent to context-free grammars and more powerful than regular expressions. The "regular expressions" in current versions of AWK and Perl are in fact extensions of regular expressions in the traditional sense, but regular expressions, unlike SNOBOL4 patterns, cannot be recursive, which gives a distinct computational advantage to SNOBOL4 patterns. However, since Perl 5.10 (released in December 2007), Perl regular expressions can be recursive.
One of the designers of SNOBOL, Ralph Griswold, designed successors to SNOBOL4 called SL5 and Icon, which combined the backtracking of SNOBOL4 pattern matching with more standard ALGOL-like structuring, as well as adding some features of their own.

  1.3.14.CPL

CPL (from Combined Programming Language and Cambridge Programming Language before that) was a multi-paradigm programming language, that was developed in the early 1960s.
CPL was developed jointly between the Mathematical Laboratory at the University of Cambridge and the University of London Computer Unit during the 1960s hence CPL gained the nickname "Cambridge Plus London".[1] The collaborative effort was responsible for the "Combined" in the name of the language (previously, the name was Cambridge Programming Language). D. W. Barron and Christopher Strachey were involved (for others see paper). In 1963 (when the paper was published) it was concurrently being implemented on the Titan Computer at Cambridge and the Atlas Computer at London.
It was heavily influenced by ALGOL 60, but instead of being extremely small, elegant and simple, CPL was intended for a wider application area than scientific calculations and was therefore much more complex and not as elegant as ALGOL 60. CPL was a big language for its time. CPL attempted to go beyond ALGOL to include industrial process control and business data processing, among other things. CPL was also intended to allow low-level programming and high level abstractions using the same language.
However, CPL was only implemented very slowly. The first CPL compiler was probably written about 1970,[2] but the language never gained much popularity and seems to have disappeared without trace sometime in the 1970s.
A later language based on CPL, called BCPL (for "Basic CPL", although originally "Bootstrap CPL"), was a much simpler language intended primarily as a systems programming language, particularly for writing compilers. BCPL then led, via B, to the popular and influential C programming language.

1.3.15.BASIC

BASIC is a family of general-purpose, high-level programming languages whose design philosophy emphasizes ease of use; the name is an acronym from Beginner's All-purpose Symbolic Instruction Code.
The original Dartmouth BASIC was designed in 1964 by John George Kemeny and Thomas Eugene Kurtz at Dartmouth College in New Hampshire, USA to provide computer access to non-science students. At the time, nearly all use of computers required writing custom software, which was something only scientists and mathematicians tended to do. The language and its variants became widespread on microcomputers in the late 1970s and 1980s, when it was typically a standard feature, and often part of the firmware of the machine. The presence of an easy-to-learn language such as BASIC on these early personal computers allowed small business owners to develop their own custom application software, leading to widespread use of these computers in businesses that previously did not have access to computing technology.
BASIC remains popular in numerous dialects and new languages influenced by BASIC such as Microsoft Visual Basic. In 2006, 59% of developers for the .NET Framework used Visual Basic .NET as their only programming language.

1.3.16.PL/I

PL/I ("Programming Language One", pronounced "pee-el-one") is a procedural, imperative computer programming language designed for scientific, engineering, business and systems programming applications. It has been used by various academic, commercial and industrial organizations since it was introduced in the 1960s, and continues to be actively used as of 2011.
PL/I's principal domains are data processing, numerical computation, scientific computing, and systems programming; it supports recursion, structured programming, linked data structure handling, fixed-point, floating-point, complex, character string handling, and bit string handling. The language syntax is English-like and suited for describing complex data formats, with a wide set of functions available to verify and manipulate them.

1.3.17.BCPL

BCPL (Basic Combined Programming Language) is a procedural, imperative, and structured computer programming language designed by Martin Richards of the University of Cambridge in 1966.
Originally intended for writing compilers for other languages, BCPL is no longer in common use. However, its influence is still felt because a stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. This important fact led many C programmers to humorously issue the backronym Before C Programming Language.[1] BCPL was the first brace programming language, and the braces survived the syntactical changes and have become a common means of denoting program source code statements. In practice, on limited keyboards of the day, source programs often used the sequences $( and )$ in place of the symbols { and }. The single-line '//' comments of BCPL, which were not taken up in C, reappeared in C++, and later in C99.
BCPL was a response to difficulties with its predecessor Combined Programming Language (CPL), created during the early 1960s. Richards created BCPL by "removing those features of the full language which make compilation difficult". The first compiler implementation, for the IBM 7094 under Compatible Time-Sharing System (CTSS), was written while Richards was visiting Project MAC at the Massachusetts Institute of Technology (MIT) in the spring of 1967. The language was first described in a paper presented to the 1969 Spring Joint Computer Conference.
The language is clean, consistent, powerful, and portable. It thus proved possible to write small and simple compilers for it; reputedly some compilers could be run in 16 kilobytes. Further, the Richards compiler, itself written in BCPL, was easily portable. BCPL was thus a popular choice for bootstrapping a system.
A major reason for the compiler's portability lay in its structure. It was split into two parts: the front end parsed the source and generated O-code for a virtual machine, and the back end took the O-code and translated it into the code for the target machine. Only 1/5 of the compiler's code needed to be rewritten to support a new machine, a task that usually took between 2 and 5 man-months. This approach became common practice later, e.g., Pascal or Java, but the Richards BCPL compiler was the first to define a virtual machine for this purpose.
The language is unusual in having only one data type: a word, a fixed number of bits, usually chosen to align with the architecture's machine word and of adequate capacity to represent any valid storage address. For many machines of the time, this data type was a 16-bit word. This choice later proved to be a significant problem when BCPL was used on machines in which the smallest addressable item was not a word, but a byte or on machines with larger word sizes: 32-bit and 64-bit words, which allowed them to manage large address spaces.
The interpretation of any value was determined by the operators used to process the values. (For example, + added two values together treating them as integers; ! indirected through a value, effectively treating it as a pointer.) In order for this to work, the implementation provided no type checking. The Hungarian notation was developed to help programmers avoid inadvertent type errors.
The mismatch between BCPL's word orientation and byte-oriented hardware was addressed in several ways. One was providing standard library routines for packing and unpacking words into byte strings. Later, two language features were added: the bit-field selection operator and the infix byte indirection operator (denoted by the '%' character).
BCPL handles bindings spanning separate compilation units in a unique way. There are no user-declarable global variables; instead there is a global vector, which is similar to "blank common" in Fortran. All data shared between different compilation units comprises scalars and pointers to vectors stored in a pre-arranged place in the global vector. Thus the header files (files included during compilation using the "GET" directive) become the primary means of synchronizing global data between compilation units, containing "GLOBAL" directives that present lists of symbolic names, each paired with a number that associates the name with the corresponding numerically addressed word in the global vector. As well as variables, the global vector also contains bindings for external procedures. This makes dynamic loading of compilation units very simple to achieve. Instead of relying on the link loader of the underlying implementation, effectively BCPL gives the programmer control of the linking process.
The global vector also made it very simple to replace or augment standard library routines. A program could save the pointer from the global vector to the original routine and replace it with a pointer to an alternative version. The alternative might call the original as part of its processing. This could be used as a quick ad-hoc debugging aid.
BCPL is the language in which the original hello world program was written.[2] The first MUD was also written in BCPL (MUD1).
Several operating systems were written partially or wholly in BCPL (for example, TRIPOS and the earliest versions of AmigaDOS, a part of AmigaOS). BCPL was also the initial language used in the seminal Xerox PARC Alto project, the first modern personal computer; among other projects, the Bravo document preparation system was written in BCPL.
An early compiler, bootstrapped in 1969 by starting with a paper tape of the O-code of Martin Richards's Atlas 2 compiler, targeted the ICT 1900 series. The two machines had different word-lengths (48 vs 24 bits), different character encodings, and different packed string representations -- and the successful bootstrapping increased confidence in the practicality of the method. By late 1970, implementations existed for the Honeywell 635 and Honeywell 645, the IBM 360, the PDP-10, the TX-2, the CDC 6400, the UNIVAC 1108, the PDP-9, the KDF 9 and the Atlas 2. In 1974 a dialect of BCPL was implemented at BBN without using the intermediate O-code. The initial implementation was a cross-compiler hosted on BBN's Tenex PDP-10s, and directly targeted the PDP-11s used in BBNs implementation of the second generation IMPs used in the Arpanet. There was also a version produced for the BBC Micro in the mid-1980s by Richards Computer Products, a company started by John Richards, the brother of Dr. Martin Richards.[citation needed] The BBC Domesday Project made use of the language. Versions of BCPL for the Amstrad CPC and Amstrad PCW computers were also released in 1986 by UK software house Arnor Ltd.
In 1979 implementations of BCPL existed for at least 25 architectures; in 2001 it sees little use.
The philosophy of BCPL can be summarized by quoting from the book BCPL, the language and its compiler:
The philosophy of BCPL is not one of the tyrant who thinks he knows best and lays down the law on what is and what is not allowed; rather, BCPL acts more as a servant offering his services to the best of his ability without complaint, even when confronted with apparent nonsense. The programmer is always assumed to know what he is doing and is not hemmed in by petty restrictions.
The design, and philosophy, of BCPL strongly influenced B, which in turn influenced C.
There are rumors that BCPL actually stood for "Bootstrap Cambridge Programming Language", however CPL was never created since development stopped at BCPL, and the acronym was reinterpreted for the BCPL book.

Share on Google Plus