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] [lower-alpha 1]

Contents

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, which in turn had been derived, particularly in its data structure facilities, from Pascal.[ citation needed ]

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: [5]

  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, [5] is available. A description of the source and object libraries available for use with Plus, PLUS Source Library Definitions, is also available. [6]

"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

Notelist

  1. ↑ There is a separate programming language named PLUS, developed at Sperry Univac in Roseville, Minnesota. [3]

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.

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

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 after French mathematician, philosopher and physicist Blaise Pascal.

<span class="mw-page-title-main">Simula</span> 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 an approximate superset of ALGOL 60, and was 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 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 is a software development system that includes a compiler and an integrated development environment (IDE) for the programming language Pascal running on the operating systems CP/M, CP/M-86, and DOS. It was originally developed by Anders Hejlsberg at Borland, and was notable for its very fast compiling. Turbo Pascal, and the later but similar Turbo C, made Borland a leader in PC-based development tools.

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 IBM System/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 Compatible Time-Sharing System (CTSS), Multics, and the Michigan Terminal System computer operating systems. The original version of the chatbot ELIZA was written in MAD-SLIP.

<span class="mw-page-title-main">Michigan Terminal System</span> Mainframe operating system

The Michigan Terminal System (MTS) is one of the first time-sharing computer operating systems. Created 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.

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

<span class="mw-page-title-main">Keypunch</span> Device for punching holes into paper cards

A keypunch is a device for precisely punching holes into stiff paper cards at specific locations as determined by keys struck by a human operator. Other devices included here for that same function include the gang punch, the pantograph punch, and the stamp. The term was also used for similar machines used by humans to transcribe data onto punched tape media.

IP Pascal is an implementation of the Pascal programming language using the IP portability platform, a multiple machine, operating system and language implementation system. It implements the language "Pascaline", and has passed the Pascal Validation Suite.

Jean E. Sammet was an American computer scientist who developed the FORMAC programming language in 1962. She was also one of the developers of the influential COBOL programming language.

LINC is a fourth-generation programming language, used mostly on Unisys computer systems.

The IBM Basic assembly language and successors is a series of assembly languages and assemblers made for the IBM System/360 mainframe system and its successors through the IBM Z.

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.

OS 2200 is the operating system for the Unisys ClearPath Dorado family of mainframe systems. The operating system kernel of OS 2200 is a lineal descendant of Exec 8 for the UNIVAC 1108 and was previously known as OS 1100. Documentation and other information on current and past Unisys systems can be found on the Unisys public support website.

Modula-2 is a structured, procedural programming language developed between 1977 and 1985/8 by Niklaus Wirth at ETH Zurich. It was created as the language for the operating system and application software of the Lilith personal workstation. It was later used for programming outside the context of the Lilith.

Java bytecode is the instruction set of the Java virtual machine (JVM), the language to which Java and other JVM-compatible source code is compiled. Each instruction is represented by a single byte, hence the name bytecode, making it a compact form of data.

The OS/360 Object File Format is the standard object module file format for the IBM DOS/360, OS/360 and VM/370, Univac VS/9, and Fujitsu BS2000 mainframe operating systems. In the 1990s, the format was given an extension with the XSD-type record for the MVS Operating System to support longer module names in the C Programming Language. This format is still in use by the z/VSE operating system. In contrast, it has been superseded by the GOFF file format on the MVS Operating System and on the z/VM Operating System. Since the MVS and z/VM loaders will still handle this older format, some compilers have chosen to continue to produce this format instead of the newer GOFF format.

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", HTML version, 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. 1 2 The PLUS Programming Language, Allan Ballard and Paul Whaley, pp. 2-5, revised 1987, Computing Centre, University of British Columbia
  6. ↑ 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.