Speedcoding

Last updated

Speedcoding
Paradigm structured, generic
Designed by John Backus
Developer John Backus and IBM
First appeared1953;71 years ago (1953)
Typing discipline strong, static, manifest
Influenced by
Assembly language, machine code
Influenced
Fortran, ALGOL 58, BASIC, C, PL/I, PACT I, MUMPS, Ratfor

    Speedcoding, Speedcode or SpeedCo was the first high-level programming language [lower-alpha 1] created for an IBM computer. [1] The language was developed by John W. Backus in 1953 for the IBM 701 to support computation with floating point numbers. [2]

    Contents

    The idea arose from the difficulty of programming the IBM SSEC machine when Backus was hired to calculate astronomical positions in early 1950. [3] The speedcoding system was an interpreter and focused on ease of use at the expense of system resources. It provided pseudo-instructions for common mathematical functions: logarithms, exponentiation, and trigonometric operations. The resident software analyzed pseudo-instructions one by one and called the appropriate subroutine. Speedcoding was also the first implementation of decimal input/output operations. Although it substantially reduced the effort of writing many jobs, the running time of a program that was written with the help of Speedcoding was usually ten to twenty times that of machine code. [4] The interpreter took 310 memory words, about 30% of the memory available on a 701. [1]

    History and Development

    In August 1952, several dozen IBM engineers and IBM 701 customers met in Poughkeepsie, New York to exchange ideas and best practices on programming the new machines in assembly. Several attendees expressed frustration with the slow nature of assembly programming and debugging, and questioned the utility of the 701 in applications where solutions to problems were needed quickly, or when the value of a justified the expense of computation time but not the cost of programming and debugging. Attendees likewise complained with issues with "scaling", or the need to religiously track the decimal point in arithmetic operations. [5]

    John W. Sheldon, a supervisor of IBM's Technical Computing Bureau attending the meeting, and others felt that an "interpretive" programming system that utilized floating point operations was the best solution to this problem. Sheldon asked John Backus, who had previously worked on a CPC to SSEC code translator, to supervise the creation of a new floating-point interpretive programming language for use internal to IBM. Backus himself had previously expressed interest in improving programming methods, and observed that computing costs were roughly equally split between the cost of computation and cost of programming personnel, and that the additional expense of testing made labor the considerably larger expense. Starting in 1953, Backus and five colleagues designed this new language and named it "Speedcoding", where its use soon spread outside of IBM to customer installations of the 701 system. [5]

    Syntax and Semantics

    Speedcoding programs are organized as a series of instructions, each of which are stored in memory as a single 72-bit data word. An instruction generally consists of two operations (OP1 and OP2) and 4 memory addresses. The first operation (OP1) is a mathematical or input/output operation that has 3 associated memory addresses, one or more of which can be modified depending on the nature of the operation. Mathematical operations include basic arithmetic, square root, and trigonometry functions. The logical operations include functionality for reading, writing, skipping, and rewinding magnetic tape, as well as operations for interacting with data stored in drum memory.The second operation (OP2) is a logical operation that has the remaining 1 associated memory address. Logical operations allow instructions to be carried out in a different order from which they are written allowing for implementations of gotos, conditionals, loops, and other advanced behavior. [6]

    Reserved Arithmetic and Input/Output Operation Keywords [6]

    • ADD
    • SUB
    • ADDAB
    • ABADD
    • SUBAB
    • ABSUB
    • MPY
    • NGMPY
    • DIV
    • NGDIV
    • SQRT
    • SINE
    • ARTAN
    • EXP
    • LN
    • MOVE
    • WRTPJ
    • WRTPK
    • WRTPL
    • WRTPM
    • RFTPJ
    • RFTPL
    • RFTPM
    • RBTPJ
    • RBTPK
    • RBTPL
    • RBTPM
    • SFTPJ
    • SFTPK
    • SFTPL
    • SFTPM
    • SBTPJ
    • SBTPK
    • SBTPL
    • SBTPM
    • RWTPJ
    • RWTPK
    • RWTPL
    • RWTPM
    • EFTPJ
    • EFTPK
    • EFTPL
    • EFTPM
    • WRDRP
    • WRDRQ
    • RFDRP
    • RFDRQ
    • PRINT
    • EJECT
    • NOOP

    Reserved Logical Keywords [6]

    • TR
    • TRPL
    • TRMN
    • TRZ
    • SNTRP
    • SNTRQ
    • TIA
    • TIB
    • TIC
    • TIBC
    • TIAC
    • TIABC
    • TDA
    • TDC
    • TDAB
    • TDBC
    • TDAC
    • TDABC
    • SETRA
    • SETRB
    • SETRC
    • SKRA
    • SKRB
    • SKRC
    • RADDA
    • RADDB
    • RADDC
    • RADDD
    • ADDA
    • ADDB
    • ADDC
    • ADDD
    • SUBA
    • SUBB
    • SUBC
    • SUBD
    • STA
    • STB
    • STC
    • STD
    • SKIP
    • PRCH
    • STCH
    • ECHTR

    See also

    Notes

    1. Meaning symbolic and aimed at natural language expressiveness as opposed to machine or hardware instruction oriented coding.

    Related Research Articles

    <span class="mw-page-title-main">Assembly language</span> Low-level programming language

    In computer programming, assembly language, often referred to simply as assembly and commonly abbreviated as ASM or asm, is any low-level programming language with a very strong correspondence between the instructions in the language and the architecture's machine code instructions. Assembly language usually has one statement per machine instruction (1:1), but constants, comments, assembler directives, symbolic labels of, e.g., memory locations, registers, and macros are generally also supported.

    <span class="mw-page-title-main">Accumulator (computing)</span> Register in which intermediate arithmetic and logic results of a CPU are stored

    In a computer's central processing unit (CPU), the accumulator is a register in which intermediate arithmetic logic unit results are stored.

    <span class="mw-page-title-main">Central processing unit</span> Central computer component which executes instructions

    A central processing unit (CPU)—also called a central processor or main processor—is the most important processor in a given computer. Its electronic circuitry executes instructions of a computer program, such as arithmetic, logic, controlling, and input/output (I/O) operations. This role contrasts with that of external components, such as main memory and I/O circuitry, and specialized coprocessors such as graphics processing units (GPUs).

    <span class="mw-page-title-main">Fortran</span> General-purpose programming language

    Fortran is a general-purpose, compiled imperative programming language that is especially suited to numeric computation and scientific computing.

    In processor design, microcode serves as an intermediary layer situated between the central processing unit (CPU) hardware and the programmer-visible instruction set architecture of a computer, also known as its machine code. It consists of a set of hardware-level instructions that implement the higher-level machine code instructions or control internal finite-state machine sequencing in many digital processing components. While microcode is utilized in general-purpose CPUs in contemporary desktops, it also functions as a fallback path for scenarios that the faster hardwired control unit is unable to manage.

    <span class="mw-page-title-main">Machine code</span> Set of instructions executed by a computer

    In computer programming, machine code is computer code consisting of machine language instructions, which are used to control a computer's central processing unit (CPU). Although decimal computers were once common, the contemporary marketplace is dominated by binary computers; for those computers, machine code is "the binary representation of a computer program which is actually read and interpreted by the computer. A program in machine code consists of a sequence of machine instructions ."

    In computer science, an instruction set architecture (ISA) is an abstract model of a computer. A device that executes instructions described by that ISA, such as a central processing unit (CPU), is called an implementation.

    <span class="mw-page-title-main">John Backus</span> American computer scientist

    John Warner Backus was an American computer scientist. He directed the team that invented and implemented FORTRAN, the first widely used high-level programming language, and was the inventor of the Backus–Naur form (BNF), a widely used notation to define syntaxes of formal languages. He later did research into the function-level programming paradigm, presenting his findings in his influential 1977 Turing Award lecture "Can Programming Be Liberated from the von Neumann Style?"

    <span class="mw-page-title-main">IBM 704</span> Vacuum-tube computer system

    The IBM 704 is a large digital mainframe computer introduced by IBM in 1954. It was the first mass-produced computer with hardware for floating-point arithmetic. The IBM 704 Manual of operation states:

    The type 704 Electronic Data-Processing Machine is a large-scale, high-speed electronic calculator controlled by an internally stored program of the single address type.

    <span class="mw-page-title-main">IBM 650</span> Vacuum tube computer system

    The IBM 650 Magnetic Drum Data-Processing Machine is an early digital computer produced by IBM in the mid-1950s. It was the first mass produced computer in the world. Almost 2,000 systems were produced, the last in 1962, and it was the first computer to make a meaningful profit. The first one was installed in late 1954 and it was the most-popular computer of the 1950s.

    <span class="mw-page-title-main">IBM 701</span> Vacuum-tube computer system

    The IBM 701 Electronic Data Processing Machine, known as the Defense Calculator while in development, was IBM’s first commercial scientific computer and its first series production mainframe computer, which was announced to the public on May 21, 1952. It was invented and developed by Jerrier Haddad and Nathaniel Rochester based on the IAS machine at Princeton.

    In computing, an opcode is the portion of a machine language instruction that specifies the operation to be performed. Beside the opcode itself, most instructions also specify the data they will process, in the form of operands. In addition to opcodes used in the instruction set architectures of various CPUs, which are hardware devices, they can also be used in abstract computing machines as part of their byte code specifications.

    <span class="mw-page-title-main">Coprocessor</span> Type of computer processor

    A coprocessor is a computer processor used to supplement the functions of the primary processor. Operations performed by the coprocessor may be floating-point arithmetic, graphics, signal processing, string processing, cryptography or I/O interfacing with peripheral devices. By offloading processor-intensive tasks from the main processor, coprocessors can accelerate system performance. Coprocessors allow a line of computers to be customized, so that customers who do not need the extra performance do not need to pay for it.

    The significand refers to the first (left) part of a number in scientific notation or related concepts in floating-point representation, consisting of its significant digits. Depending on the interpretation of the exponent, the significand may represent an integer or a fraction.

    von Neumann architecture Computer architecture where code and data share a common bus

    The von Neumann architecture—also known as the von Neumann model or Princeton architecture—is a computer architecture based on a 1945 description by John von Neumann, and by others, in the First Draft of a Report on the EDVAC. The document describes a design architecture for an electronic digital computer with these components:

    <span class="mw-page-title-main">IBM SSEC</span> IBM Selective Sequence Electronic Calculator

    The IBM Selective Sequence Electronic Calculator (SSEC) was an electromechanical computer built by IBM. Its design was started in late 1944 and it operated from January 1948 to August 1952. It had many of the features of a stored-program computer, and was the first operational machine able to treat its instructions as data, but it was not fully electronic. Although the SSEC proved useful for several high-profile applications, it soon became obsolete. As the last large electromechanical computer ever built, its greatest success was the publicity it provided for IBM.

    <span class="mw-page-title-main">Decimal computer</span> Computer operating on base-10 numbers

    A decimal computer is a computer that can represent numbers and addresses in decimal and that provides instructions to operate on those numbers and addresses directly in decimal, without conversion to a pure binary representation. Some also had a variable wordlength, which enabled operations on numbers with a large number of digits.

    PL360 is a system programming language designed by Niklaus Wirth and written by Wirth, Joseph W. Wells Jr., and Edwin Satterthwaite Jr. for the IBM System/360 computer at Stanford University. A description of PL360 was published in early 1968, although the implementation was probably completed before Wirth left Stanford in 1967.

    <span class="mw-page-title-main">Cuthbert Hurd</span> American computer scientist

    Cuthbert Corwin Hurd was an American computer scientist and entrepreneur, who was instrumental in helping the International Business Machines Corporation develop its first general-purpose computers.

    <span class="mw-page-title-main">IBM System/360 Model 20</span> Low-end IBM computer model from 1960s

    The IBM System/360 Model 20 is the smallest member of the IBM System/360 family announced in November 1964. The Model 20 supports only a subset of the System/360 instruction set, with binary numbers limited to 16 bits and no floating point. In later years it would have been classified as a 16-bit minicomputer rather than a mainframe, but the term "minicomputer" was not current, and in any case IBM wanted to emphasize the compatibility of the Model 20 rather than its differences from the rest of the System/360 line. It does, however, have the full System/360 decimal instruction set, that allows for addition, subtraction, product, and dividend of up to 31 decimal digits.

    References

    1. 1 2 Allen, Frances "Fran" Elizabeth (September 1981). "The History of Language Processor Technology in IBM". IBM Journal of Research and Development . 25 (5): 535–548. doi:10.1147/rd.255.0535.
    2. Shasha, Dennis Elliot; Lazere, Cathy (1998). Out of their Minds: The Lives and Discoveries of 15 Great Computer Scientists. New York, USA: Copernicus, Springer-Verlag New York, Inc. ISBN   0-387-98269-8. LCCN   98-16911. SPIN 10693423.
    3. Backus, John W. (2006-09-05). Booch, Grady (ed.). "Oral History of John Backus" (PDF). Reference number: X3715.2007 (Interview). Ashland, Oregon, USA: Computer History Museum. Archived (PDF) from the original on 2022-04-08. Retrieved 2011-04-23. (42 pages)
    4. Pugh, Emerson W.; Johnson, Lyle R.; Palmer, John H. (1991). IBM's 360 and early 370 systems. MIT Press. p. 38. ISBN   0-262-16123-0.
    5. 1 2 Bashe, Charles; Johnson, Lyle; Palmer, John; Pugh, Emerson (1986-03-17). IBM's Early Computers. MIT Press. pp. 332–338. ISBN   9780262523936 . Retrieved 2023-08-25.
    6. 1 2 3 IBM speedcoding system for the type 701 electronic data processing machines (PDF). New York, USA: International Business Machines Corporation. 1954 [1953-09-10]. Form 24-6059-0 (5-54:2M-W). Archived (PDF) from the original on 2022-07-04. Retrieved 2022-07-04.

    Further reading