Plus (programming language)

Last updated
Plus
Paradigm imperative, structured
Developer Alan Ballard and Paul Whaley at UBC
First appeared1976
Typing discipline static, strong, safe
OS Michigan Terminal System (MTS), OS/VS1
Major implementations
IBM System/370, DEC PDP-11, and Motorola 68000
Influenced by
SUE, Pascal

Plus is a "Pascal-like" system implementation language from the University of British Columbia (UBC), Canada, based on the SUE [1] system language developed at the University of Toronto, c. 1971. [2]

Contents

There is another programming language named PLUS, developed at Sperry Univac in Roseville, Minnesota, [3] but the Univac PLUS is not the subject of this article.

Description

Plus was developed at the University of British Columbia (UBC) Computing Centre by Alan Ballard and Paul Whaley for use with and for the development of the Michigan Terminal System (MTS), but the code generated by the compiler is not operating system dependent and so is not limited to use with or the development of MTS.

The UBC Plus compiler is written largely in Plus, runs under the Michigan Terminal System (MTS) on IBM S/370 or compatible hardware or under IBM's OS/VS1 [4] , and generates code for the IBM S/370, the DEC PDP-11, or the Motorola 68000 architectures.

Plus is based to a large extent on the SUE System Language [1] developed at the University of Toronto, c. 1971. The SUE language was derived, particularly in its data structure facilities from Pascal. [5]

Plus is superficially quite different from SUE or Pascal; however the underlying language semantics are really quite similar. Users familiar with the C programming language will also recognize much of its structure and semantics in PLUS.

Goals for the compiler and the Plus language include: [6]

  1. Allow and encourage reasonable program structures
  2. Provide problem-oriented data structures
  3. Allow and encourage readable and understandable source code
  4. Allow for parametrization using symbolic constants
  5. Actively assist in the detection and isolation of errors, at compile-time if possible and optionally at run-time where necessary
  6. Generate efficient code
  7. Provide facilities necessary for systems programming
  8. Provide reasonably efficient compilation including separate compilation of different parts of a program
  9. Optionally produce symbol (SYM) information allowing programs to be debugged using a Symbolic Debugging System such as SDS under MTS

The compiler generates extensive source listings, including cross-references. In addition, it automatically formats the source using strict rules and has a simple mark-up language for comments.

The manual, UBC PLUS: The Plus Programming Language, [6] is available. A description of the source and object libraries available for use with Plus, PLUS Source Library Definitions, is also available. [7]

"Hello, world" example

The "hello, world" example program prints the string "Hello, world!" to a terminal or screen display.

%Title := "Hello world"; %Include(Pluslist); %Subtitle := "Definitions"; %Lower_Case := True;  /* Definitions that everyone needs */ %Include(Boolean, Numeric_Types, More_Numeric_Types, String_Types,    More_String_Types);  /* A tasteful subset of procedure definitions */ %Include(Main);  /* Message routine definitions */ %Include(Message_Initialize, Message, Message_Terminate);  %Subtitle := "Local Procedure Definitions"; %Eject(); definition Main    variable Mcb is pointer to Stream_Type;    Mcb := Message_Initialize();   Message(Mcb, "Hello, world!");   Message_Terminate(Mcb);   Mcb := Null;   end Main;

See also

Related Research Articles

APL is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages.

Fortran General-purpose programming language

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

PL/I is a procedural, imperative computer programming language developed and published by IBM. It is designed for scientific, engineering, business and system programming. It has been used by academic, commercial and industrial organizations since it was introduced in the 1960s, and is still used.

Pascal (programming language) Programming language

Pascal is an imperative and procedural programming language, designed by Niklaus Wirth as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honour of the French mathematician, philosopher and physicist Blaise Pascal.

Simula Early object-oriented programming language

Simula is the name of 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, also influenced by the design of Simscript.

SNOBOL is a series of 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.

Turbo Pascal programming language

Turbo Pascal is a software development system that includes a compiler and an integrated development environment (IDE) for the Pascal programming language running on CP/M, CP/M-86, and DOS. It was originally developed by Anders Hejlsberg at Borland, and was notable for its extremely fast compiling times. Turbo Pascal, and the later but similar Turbo C, made Borland a leader in PC-based development.

MAD is a programming language and compiler for the IBM 704 and later the IBM 709, IBM 7090, IBM 7040, UNIVAC 1107, UNIVAC 1108, Philco 210-211, and eventually the IBM S/370 mainframe computers. Developed in 1959 at the University of Michigan by Bernard Galler, Bruce Arden and Robert M. Graham, MAD is a variant of the ALGOL language. It was widely used to teach programming at colleges and universities during the 1960s and played a minor role in the development of CTSS, Multics, and the Michigan Terminal System computer operating systems.

Michigan Terminal System mainframe operating system

The Michigan Terminal System (MTS) is one of the first time-sharing computer operating systems. Developed in 1967 at the University of Michigan for use on IBM S/360-67, S/370 and compatible mainframe computers, it was developed and used by a consortium of eight universities in the United States, Canada, and the United Kingdom over a period of 33 years.

MUSIC/SP operating system

MUSIC/SP was developed at McGill University in the 1970s from an early IBM time-sharing system called RAX. The system ran on IBM S/360, S/370, and 4300-series mainframe hardware, and offered novel features such as file access control and data compression. It was designed to allow academics and students to create and run their programs interactively on terminals, in an era when most mainframe computing was still being done from punched cards. Over the years, development continued and the system evolved to embrace email, the Internet and eventually the World Wide Web. At its peak in the late 1980s, there were over 250 universities, colleges and high school districts that used the system in North and South America, Europe and Asia.

ALGOL W is a programming language. It is based on a proposal for ALGOL X by Niklaus Wirth and Tony Hoare as a successor to ALGOL 60 in International Federation for Information Processing (IFIP) IFIP Working Group 2.1. When the committee decided that the proposal was not a sufficient advance over ALGOL 60, the proposal was published as A contribution to the development of ALGOL. After making small modifications to the language Wirth supervised a high quality implementation for the IBM/360 at Stanford University that was widely distributed.

The University of Michigan Executive System, or UMES, a batch operating system developed at the University of Michigan in 1958, was widely used at many universities. Based on the General Motors Executive System for the IBM 701, UMES was revised to work on the mainframe computers in use at the University of Michigan during this time and to work better for the small student jobs that were expected to be the primary work load at the University.

Object Pascal is an extension to the programming language Pascal that provides object-oriented programming (OOP) features such as classes and methods.

IP Pascal is an implementation of the Pascal programming language using the IP portability platform, a multiple machine, operating system and language implementation system.

Basic Assembly Language (BAL) is the commonly used term for a low-level programming language used on IBM System/360 and successor mainframes. Originally, "Basic Assembly Language" applied only to an extremely restricted dialect designed to run under control of IBM Basic Programming Support (BPS/360) on systems with only 8 KB of main memory, and only a card reader, a card punch, and a printer for input/output — thus the word "Basic". However, the full name and the initialism "BAL" almost immediately attached themselves in popular use to all assembly-language dialects on the System/360 and its descendants. BAL for BPS/360 was introduced with the System/360 in 1964.

AIMACO is an acronym for AIr MAterial COmpiler. It began around 1959 as the definition of a high level programming language influenced by the FLOW-MATIC language, developed by UNIVAC, and the COMTRAN programming language, developed by IBM. AIMACO, along with FLOW-MATIC and COMTRAN, were precursors to the COBOL programming language and influenced its development.

The following outline is provided as an overview of and topical guide to computer programming:

In computing, a compiler is a computer program that transforms source code written in a programming language or computer language, into another computer language. The most common reason for transforming source code is to create an executable program.

MTS system architecture mahesh kumar

MTS System Architecture describes the software organization of the Michigan Terminal System, a time-sharing computer operating system in use from 1967 to 1999 on IBM S/360-67, IBM System/370, and compatible computers.

References

  1. 1 2 The System Language for Project SUE, B. L. Clark and J. J. Horning of the Computer Systems Research Group and Department of Computer Science, University of Toronto, Proceedings of the SIGPLAN symposium on Languages for system implementation, 1971, pages 79-88
  2. ↑ "The Plus Systems Programming Language", Alan Ballard and Paul Whaley, Proceedings of Canadian Information Processing Society (CIPS) Congress 84, June 1984
  3. ↑ The PLUS Programming Language, Frank W. Stodola, Sperry Univac, Roseville, Minnesota, ACM SIGPLAN Notices, Volume 15, Issue 1 (January 1980), pp. 146-155
  4. ↑ Using Peter Ludemann's emulation of MTS system calls.
  5. ↑ MTS Volume 2: Public file Descriptions, University of Michigan Computing Center, Ann Arbor, Michigan, 1990, pp. 355-356
  6. 1 2 The PLUS Programming Language, Allan Ballard and Paul Whaley, pp. 2-5, revised 1987, Computing Centre, University of British Columbia
  7. ↑ PLUS Source Library Definitions, Alan Ballard, 1983, University of British Columbia Computing Centre, 139pp.
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.