PL/I - Goals and Principles

Goals and Principles

The Share 3by3 committee set these goals for “NPL”:

• “Scope of usefulness to include that of current FORTRAN, extended to include additional applications - character strings and bit strings, extensive I/O operations, and dynamic response to trap conditions such as overflow and end-of-file.”
• “Clarity of language. Arbitrary restrictions and unnatural punctuation that had plagued Fortran users were to be removed. The resulting language would be easier to teach and easier to use.”
• “Bring the language in line with current practice of machine use - I/O control systems, trap (i.e. exception) supervision, monitored operation and multiprogramming”. (Other implementers did not endorse the "multiprogramming" features since their operating systems differed from IBM's in this area.)

These goals evolved during the early development of the language. Competitiveness with COBOL’s record handling and report writing capabilities was needed. The “scope of usefulness” of the language grew to include system programming and event-driven programming. The additional goals for PL/I were:

• Performance of compiled code competitive with that of Fortran (but this was not achieved).
• Be extensible, for new hardware and new application areas
• Improve the productivity and time scales of the programming process, transferring effort from the programmer to the compiler
• Be machine-independent and operate effectively across the main hardware and operating system ranges

To meet these goals PL/I borrowed ideas from contemporary languages while adding substantial new capabilities and casting it with a distinctive concise and readable syntax. A number of principles and capabilities combined to give the language its character and were key in meeting the goals:

• Block structure, with underlying semantics (including recursion), a la Algol 60. PL/I passes Donald Knuth's man or boy test. Arguments to be passed using call by reference, using dummy variables for values where needed (call by value).
• Wide range of computational Data Types, program control Data Types, and forms of Data Structure. (strong typing).
• Dynamic extents for arrays and strings, with inheritance of extents by procedure parameters.
• Concise syntax for expressions, declarations and statements - with permitted abbreviations. Suitable for a character set of 60 glyphs, and sub-settable to 48.
• An extensive structure of defaults in statements, options, and declarations - to hide some complexities, facilitate extending the language, and minimize keystrokes.
• Powerful iterative processing, with good support for structured programming.
• No reserved words. New attributes, statements and statement options could be added to PL/I without invalidating existing programs. Not even IF, THEN, ELSE, and DO were reserved.
• Orthogonality - each capability to be independent of other capabilities and freely combined with other capabilities wherever meaningful. Each capability to be available in all contexts where meaningful - to exploit it as widely as possible and to avoid “arbitrary restrictions”. (Helps make the language "large").
• Capabilities for controlling and intercepting exceptional conditions (exception handling) at run time.
• Programs divided into separately compilable sections, with extensive compile-time facilities (a.k.a. macros), not part of the standard, for tailoring and combining sections of source code into complete programs. External names to bind separately compiled procedures into a single program.
• Debugging facilities integrated into the main language.

These principles inevitably resulted in a large language which would need compilers substantially more complex than those for COBOL or Fortran. This was not seen as a drawback since though the few — the compiler writers — would have more work, the many — the programmers — would have less.