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 solution 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, main processor, or just 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 third generation, compiled, imperative programming language that is especially suited to numeric computation and scientific computing.

    <span class="mw-page-title-main">History of computing hardware</span>

    The history of computing hardware covers the developments from early simple devices to aid calculation to modern day computers.

    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 Intel and AMD general-purpose CPUs in contemporary desktops and laptops, it functions only 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). For conventional binary 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 that generally defines how software controls the CPU in a computer or a family of computers. A device or program that executes instructions described by that ISA, such as a central processing unit (CPU), is called an implementation of that ISA.

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

    John Warner Backus was an American computer scientist. He led 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 the model name of 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 1950s 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.

    A stored-program computer is a computer that stores program instructions in electronically or optically accessible memory. This contrasts with systems that stored the program instructions with plugboards or similar mechanisms.

    <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 designed and developed by Jerrier Haddad and Nathaniel Rochester and was based on the IAS machine at Princeton.

    <span class="mw-page-title-main">IBM 700/7000 series</span> Mainframe computer systems made by IBM through the 1950s and early 1960s

    The IBM 700/7000 series is a series of large-scale (mainframe) computer systems that were made by IBM through the 1950s and early 1960s. The series includes several different, incompatible processor architectures. The 700s use vacuum-tube logic and were made obsolete by the introduction of the transistorized 7000s. The 7000s, in turn, were eventually replaced with System/360, which was announced in 1964. However the 360/65, the first 360 powerful enough to replace 7000s, did not become available until November 1965. Early problems with OS/360 and the high cost of converting software kept many 7000s in service for years afterward.

    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">Sense switch</span> A switch on the console of a computer that can be read by software

    A sense switch, or program switch, is a switch on the front panel of a computer whose state can be tested by conditional branch instructions in software. Most early computers had several sense switches. They were typically used by the operator to set program options.

    <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.

    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