View source for PL/I

{{Short description|Procedural, imperative computer programming language}}
{{Redirect|New programming language|the process of implementing new programming languages|Programming language design#Design and implementation}}
{{Infobox programming language
| name = PL/I
| logo = 
| paradigm = [[Procedural programming|Procedural]], [[Imperative programming|imperative]], [[Structured programming|structured]]
| released = {{Start date and age|1964|df=yes}}
| designers = [[IBM]],<br/>[[SHARE (computing)|SHARE]] Language Development Committee,<br/>[[International Organization for Standardization|ISO]]
| typing = 
| implementations = 
| dialects = See [[#PL/I dialects|dialects]]
| influenced by = [[COBOL]], [[Fortran]], [[ALGOL 60]]
| influenced = [[Control Language]], [[PL/M]], [[IBM PL/S|PL/S]], [[PL-6]], [[PL.8]], [[Rexx]], [[SAS language|SAS]]
| wikibooks = PL/I
}}

'''PL/I''' ('''Programming Language One''', pronounced {{IPAc-en|p|iː|_|ɛ|l|_|w|ʌ|n}} and sometimes written '''PL/1''')<ref>{{cite news |work=[[The New York Times]]
 |url=https://www.nytimes.com/1984/06/20/business/changes-at-ibm.html
 |title=Changes at I.B.M. |date=June 20, 1984}}</ref> is a [[Procedural programming|procedural]], [[imperative programming|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.<ref>{{cite book |last1=Sturm |first1=Eberhard |year=2009 |title=The New PL/I |publisher=Vieweg+Teubner |isbn=978-3-8348-0726-7}}</ref>

A PL/I [[American National Standards Institute]] (ANSI) [[technical standard]], X3.53-1976, was published in 1976.

PL/I's main domains are [[data processing]], [[numerical computation]], [[scientific computing]], and [[system programming]]. It supports [[recursion]], [[structured programming]], [[linked data structure]] handling, [[Fixed-point arithmetic|fixed-point]], [[floating-point]], [[Complex arithmetic|complex]], [[String (computer science)|character string]] handling, and [[bit string]] handling. The language syntax is English-like and suited for describing complex data formats with a wide set of functions available to verify and manipulate them.

==Early history==
In the 1950s and early 1960s, business and scientific users programmed for different computer hardware using different programming languages. Business users were moving from [[Autocoder]]s via [[COMTRAN]] to [[COBOL]], while scientific users programmed in [[Fortran]], [[ALGOL]], [[GEORGE (programming language)|GEORGE]], and others. The [[IBM System/360]]<ref name="AndEarly">{{cite book|last1=Pugh|first1=Emerson W.|last2=Johnson|first2=Lyle R.|last3=Palmer|first3=John H.|year=1991|title=IBM's 360 and early 370 systems|url=https://archive.org/details/ibms360early370s0000pugh|url-access=registration|publisher=[[MIT Press]]|location=Cambridge, Mass.|isbn=978-0-262-16123-7}}</ref> (announced in 1964 and delivered in 1966) was designed as a common machine architecture for both groups of users, superseding all existing IBM architectures. Similarly, IBM wanted a single programming language for all users. It hoped that Fortran could be extended to include the features needed by commercial programmers. In October 1963 a committee was formed<ref>The committee actually had 8 members at the time the report was released. They were:{{citation needed|date=February 2020}}

* Hans Berg, [[Lockheed Corporation|Lockheed]] Burbank
* [[George Radin]], IBM
* James Cox, [[Union Carbide]]
* Bruce Rosenblatt, [[Standard Oil of California]], Chair.
* [[Douglas McIlroy]], Bell Laboratories
* Robert Sheppard, [[Procter & Gamble]]. From the GUIDE organization
* C.W. Medlock, IBM
* Bernice Weitzenhoffer, IBM.
</ref> composed originally of three IBMers from New York and three members of [[SHARE (computing)|SHARE]], the IBM
scientific users group, to propose these extensions to Fortran. Given the constraints of Fortran, they were unable to do this and embarked on the design of a new programming language based loosely on [[ALGOL]] labeled '''NPL'''. This acronym conflicted with that of the UK's National Physical Laboratory and was replaced<ref>{{cite magazine
 |author=<!--Unstated staff writer(s)-->
 |date=April 1965
 |department=Business & Science
 |title=MPPL in for NPL
 |volume=11
 |issue=4
 |page=17
 |url=http://bitsavers.org/magazines/Datamation/196504.pdf
 |magazine=Datamation
 |publisher=Frank D. Thompson
}}
</ref> briefly by '''MPPL''' (MultiPurpose Programming Language) and, in 1965, with<ref>{{cite magazine
 |author=<!--Unstated staff writer(s)-->
 |date=June 1965
 |url=http://bitsavers.org/magazines/Datamation/196506.pdf
 |department=Business & Science
 |title=Another New Name, More Compilers for NPL
 |volume=11
 |issue=6
 |page=17
 |magazine=Datamation
 |publisher=Frank D. Thompson
}}
</ref> '''PL/I''' (with a [[Roman numeral]] "I"). The first definition appeared in April 1964.<ref>Report II of the SHARE Advanced Language Development Committee, June 25, 1964</ref><ref>{{cite journal|title=Highlights of a New Programming Language|first1=G.|last1=Radin|author-link=George Radin|author2=H. Paul Rogoway|journal=[[Communications of the ACM]]|volume=8|issue=1|pages=9–17|date=January 1965|doi=10.1145/363707.363708|s2cid=17133703|doi-access=free}}</ref>

IBM took NPL as a starting point and completed the design to a level that the first compiler could be written: the NPL definition was incomplete in scope and in detail.<ref name="characteristics1978">{{cite journal|last1=Radin|first1=G.|title=The Early History and Characteristics of PL/I|date=August 1978|journal=[[SIGPLAN Notices|ACM SIGPLAN Notices]]|volume=13|issue=8|pages=227–241|doi=10.1145/960118.808389|s2cid=13925251|doi-access=free}}</ref> Control of the PL/I language<ref>Control of the language was vested in a dedicated Language Control group and a Language Control Board that included representatives of the compiler groups (6 by 1973) in three countries. Daily
communication was by [[telex]]. Changes and extensions were made through a Language Log that reached several thousand detailed points. A management level Language Review Board resolved issues escalated to it by the Control Board.</ref> was vested initially in the New York Programming Center and later at the IBM UK Laboratory at [[IBM Hursley|Hursley]]. The SHARE and [[GUIDE International|GUIDE]] user groups were involved in extending the language and had a role in IBM's process for controlling the language through their PL/I Projects. The experience of defining such a large language showed the need for a formal definition of PL/I. A project was set up in 1967 in [[IBM Laboratory Vienna]] to make an unambiguous and complete specification.<ref>The Universal Language Document (ULD). Technical reports TR25.081, TR25.082, TR25.083, TR25.0S4, TR25.085, TR25.086 and TR25.087, IBM Corp Vienna Austria June 1968</ref> This led in turn to one of the first large scale [[Formal Methods]] for development, [[Vienna Development Method|VDM]].

[[Fred Brooks]] is credited with ensuring PL/I had the CHARACTER data type.<ref>{{cite web|url=https://www.computer.org/web/awards/goode-frederick-brooks|title=Frederick P. Brooks Jr. - IEEE Computer Society|year=1989|publisher=[[IEEE Computer Society]]}}</ref> [[Christopher J. Date]] and a colleague added [[relational database]] extensions based on [[Edgar Codd]]'s work.<ref name="rdbmsearlyyearsoh20070612">{{Cite interview |interviewer=Burton Grad |title=RDBMS Plenary 1: Early Years |url=https://archive.computerhistory.org/resources/access/text/2013/05/102702562-05-01-acc.pdf |pages=16-17 |access-date=2025-05-30 |publisher=Computer History Museum |date=2007-06-12}}</ref>

The language was first specified in detail in the manual "PL/I Language Specifications. C28-6571", written in New York in 1965, and superseded by "PL/I Language Specifications. GY33-6003", written by Hursley in 1967. IBM continued to develop PL/I in the late sixties and early seventies, publishing it in the GY33-6003 manual. These manuals were used by the [[Multics]] group and other early implementers.

The first compiler was delivered in 1966. The Standard for PL/I was approved in 1976.

==Goals and principles==
The goals for PL/I evolved during the early development of the language. Competitiveness with COBOL's record handling and report writing was required. The language's scope of usefulness grew to include [[system programming]] and [[event-driven programming]].<ref>{{cite report
 |title=NPL Technical Report
 |date=December 1964
 |section=Chapter 1: Introduction
 |section-url=http://bitsavers.org/pdf/ibm/npl/320-0908_NPL_Technical_Report_Dec64.pdf#page12
 |page=[http://bitsavers.org/pdf/ibm/npl/320-0908_NPL_Technical_Report_Dec64.pdf#page12 11]
 |quote=NPL is designed to serve the needs of an unusually large group of programmers, including scientific, business, real time, and systems programmers.
 |url=http://bitsavers.org/pdf/ibm/npl/320-0908_NPL_Technical_Report_Dec64.pdf 
 |publisher=[[IBM]]
 |access-date=January 1, 2024
}}
</ref> Additional goals for PL/I were:<ref name="AndEarly" />

* Performance of compiled code competitive with that of Fortran (but this was not achieved){{Citation needed|date=June 2019}} 
* [[Extensibility]] for new hardware and new application areas
* Improved productivity of the programming process, transferring effort from the programmer to the compiler
* [[Cross-platform software|Machine independence]] to operate effectively on the main computer hardware and operating systems

To achieve these goals, PL/I borrowed ideas from contemporary languages while adding substantial new capabilities and casting it with a distinctive concise and readable syntax. Many principles and capabilities combined to give the language its character and were important in meeting the language's goals:

* [[Block (programming)|Block structure]], with underlying semantics (including [[recursion]]), similar to [[Algol 60]]. Arguments are passed using [[call by reference]], using dummy variables for values where needed ([[call by value]]).
* A 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 and facilitate extending the language while minimizing keystrokes.
* Powerful iterative processing with good support for [[structured programming]].
* There were to be no [[reserved words]] (although the function names <code>DATE</code> and <code>TIME</code> initially proved to be impossible{{citation needed|date=August 2021}} to meet this goal). New attributes, statements and statement options could be added to PL/I without invalidating existing programs. Not even <code>IF, THEN, ELSE</code>, and <code>DO</code> were reserved.<ref>Some compilers chose to reserve these identifiers, or issue warnings if they found them used as identifiers. But the subsequent introduction of a [[case statement]] shows the value of the principle.</ref>
* [[Orthogonality (programming)|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". Orthogonality helps make the language "large".{{Clarify|date=April 2014}}
* [[Exception handling]] capabilities for controlling and intercepting exceptional conditions at run time.
* Programs divided into separately compilable sections, with extensive compile-time facilities (a.k.a. [[macro (computer science)|macro]]s), 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 language.

==Language summary==
The language is designed to provide sufficient facilities to be able to satisfy the needs of all programmers, regardless of what problems the language is being applied to.<ref>{{cite book|last1=Vowels|first1=Robin |title=Introduction to PL/I |year=2001|isbn=978-0-9596384-9-3|page=x|publisher=R.A. Vowels |quote="PL/I is the first language to provide adequate facilities for scientific computations, business data processing and systems programming in a single language" - [[Jean Sammet]], ''Some Approaches to, and Illustrations of, Programming Language History''}}</ref>  The summary is extracted from the ANSI PL/I Standard<ref name="ReferenceA">ANS Programming Language PL/I. X3.53-1976</ref>
and the ANSI PL/I General-Purpose Subset Standard.<ref name="SubsetG" />

A PL/I program consists of a set of procedures, each of which is written as a sequence of statements. The <code>%INCLUDE</code> construct is used to include text from other sources during program translation. All of the statement types are summarized here in groupings which give an overview of the language (the Standard uses this organization).
{|
|- style="vertical-align:top"
|
{| class="wikitable" 
|-
! Category
! Statement
|-
| Structural
| <code>PROCEDURE</code> (or <code>PROC</code>)<br/> <code>ENTRY</code><br/> <code>BEGIN</code><br/> <code>DO</code><br/> <code>END</code>
|-
| Declarative
| <code>DECLARE</code> (or <code>DCL</code>)<br/> <code>DEFAULT</code> (or <code>DFT</code>)<br/> <code>FORMAT</code>
|-
| Flow of control
| <code>CALL</code><br/> <code>IF</code><br/> <code>SELECT</code><br/><code>GO TO</code><br/> <code>RETURN</code><br/> <code>STOP</code><br/> Null statement
|-
|}
|
{| class="wikitable" 
|-
! Category
! Statement
|-
| Interrupt handling
| <code>ON</code><br/> <code>SIGNAL</code><br/> <code>REVERT</code>
|-
| Storage
| <code>ALLOCATE</code> (or <code>ALLOC</code>)<br/> <code>FREE</code><br/> Assignment statement
|-
| Input/Output
| <code>OPEN</code><br/> <code>CLOSE</code>
|-
| Stream input/output
| <code>GET</code><br/> <code>PUT</code>
|-
| Record input/output
| <code>READ</code><br/> <code>WRITE</code><br/> <code>REWRITE</code><br/> <code>LOCATE</code><br/> <code>DELETE</code>
|}
|}
(Features such as [[Computer multitasking|multi-tasking]] and the [[PL/I preprocessor]] are not in the Standard but are supported in the PL/I F compiler and some other implementations are discussed in the Language evolution section.)

Names may be declared to represent data of the following types, either as single values, or as aggregates in the form of arrays, with a lower-bound and upper-bound per dimension, or structures (comprising nested structure, array and scalar variables):
{|
|
* <code>Arithmetic</code> (expanded below)
* <code>CHARACTER</code>
* <code>PICTURE for Arithmetic data</code>
* <code>PICTURE for Character data</code>
|
* <code>AREA</code>
* <code>BIT</code>
* <code>ENTRY</code>
* <code>FILE</code>
|
* <code>FORMAT</code>
* <code>LABEL</code>
* <code>OFFSET</code>
* <code>POINTER</code>
|}

The <code>arithmetic</code> type comprises these attributes:
{|
|
* a base (<code>BINARY</code> or <code>DECIMAL</code>), and 
* a scale (<code>FIXED</code> or <code>FLOAT</code>), and
* a mode (<code>REAL</code> or <code>COMPLEX</code>), and
* a <code>PRECISION</code> (<code>number of digits</code>, and for fixed point numbers, a <code>scale factor</code>)
|}
The base, scale, precision and [[scale factor]] of the <code>Picture-for-arithmetic</code> type is encoded within the <code>picture-specification</code>. The mode is specified separately, with the <code>picture specification</code> applied to both the real and the imaginary parts.

Values are computed by expressions written using a specific set of operations and builtin functions, most of which may be applied to aggregates as well as to single values, together with user-defined procedures which, likewise, may operate on and return aggregate as well as single values. The assignment statement assigns values to one or more variables.

There are no reserved words in PL/I. A statement is terminated by a semi-colon. The maximum length of a statement is implementation defined. A comment may appear anywhere in a program where a space is permitted and is preceded by the characters forward slash, asterisk and is terminated by the characters asterisk, forward slash (i.e. {{code|/* This is a comment. */}}). Statements may have a label-prefix introducing an entry name (<code>ENTRY</code> and <code>PROCEDURE</code> statements) or label name, and a condition prefix enabling or disabling a computational condition{{snd}} e.g., <code>(NOSIZE)</code>). Entry and label names may be single identifiers or identifiers followed by a subscript list of constants (as in <code>L(12,2):A=0;</code>).

A sequence of statements becomes a ''group'' when preceded by a <code>DO</code> statement and followed by an <code>END</code> statement. Groups may include nested groups and begin blocks. The <code>IF</code> statement specifies a group or a single statement as the <code>THEN</code> part and the <code>ELSE</code> part (see the sample program). The group is the unit of iteration. The begin ''block'' (<code>BEGIN; stmt-list END;</code>) may contain declarations for names and internal procedures local to the block. A ''procedure'' starts with a <code>PROCEDURE</code> statement and is terminated syntactically by an <code>END</code> statement. The body of a procedure is a sequence of blocks, groups, and statements and contains declarations for names and procedures local to the procedure or <code>EXTERNAL</code> to the procedure.

An ''ON-unit'' is a single statement or block of statements written to be executed when one or more of these ''conditions'' occur:

a ''computational condition'',
{|
|
* <code>CONVERSION (CONV)</code>
* <code>FIXEDOVERFLOW (FOFL)</code>
* <code>OVERFLOW (OFL)</code>
* <code>SIZE</code>
|
* <code>STRINGRANGE (STRG)</code>
* <code>STRINGSIZE (STRZ)</code>
* <code>SUBSCRIPTRANGE (SUBRG)</code>
* <code>UNDERFLOW (UFL)</code>
|
* <code>ZERODIVIDE (ZDIV)</code>
*
*
*
|}
or an ''Input/Output'' condition,
{|
|
* <code>ENDFILE(file)</code>
* <code>ENDPAGE(file)</code>
* <code>KEY(file)</code>
* <code>NAME(file)</code>
|
* <code>RECORD(file)</code>
* <code>TRANSMIT(file)</code>
* <code>UNDEFINEDFILE(file) (UNDF)</code>
*
|}
or one of the conditions:
*<code>AREA</code>, <code>CONDITION (identifier)</code>, <code>ERROR</code>, <code>FINISH</code>

A declaration of an identifier may contain one or more of the following attributes (but they need to be mutually consistent):
{| class="wikitable"
|-
! Data attributes
! Input/output attributes
! Other attributes
|-
| <code>ALIGNED</code>
| <code>DIRECT</code>
| <code>AUTOMATIC or AUTO</code>
|-
| <code>AREA[(area-size)]</code>
| <code>ENVIRONMENT(options) or ENV...</code>
| <code>BASED[(reference)]</code>
|-
| <code>BINARY [(precision)] or BIN...</code>
| <code>INPUT</code>
| <code>BUILTIN</code>
|-
| <code>BIT [(maximum-length)]</code>
| <code>KEYED</code>
| <code>CONDITION or COND</code>
|-
| <code>CHARACTER[(maximum-length)] or CHAR...</code>
| <code>OUTPUT</code>
| <code>CONSTANT</code>
|-
| <code>COMPLEX [(precision)] or CPLX...</code>
| <code>PRINT</code>
| <code>CONTROLLED or CTL</code>
|-
| <code>DECIMAL [(precision)] or DEC...</code>
| <code>SEQUENTIAL or SEQL</code>
| <code>DEFINED[(reference)] or DEF...</code>
|-
| <code>(dimension-attribute)</code>
| <code>STREAM</code>
| <code>EXTERNAL or EXT</code>
|-
| <code>ENTRY[(parameter descriptor list]</code>
| <code>UPDATE</code>
| <code>GENERIC(criteria list)</code>
|-
| <code>FILE</code>
| <code>RECORD</code>
| <code>INITIAL(value-list) or INIT...</code>
|-
| <code>FIXED [(precision)]</code>
|
| <code>INTERNAL or INT</code>
|-
| <code>FLOAT  [(number of digits)]</code>
|
| <code>LIKE unsubscripted reference</code>
|-
| <code>FORMAT</code>
|
| <code>LOCAL</code>
|-
| <code>LABEL</code>
|
| <code>OPTIONS(options)</code>
|-
| <code>MEMBER</code>
|
| <code>PARAMETER or PARM</code>
|-
| <code>NONVARYING or NONVAR</code>
|
| <code>POSITION [(expression)] or POS...</code>
|-
| <code>OFFSET[(reference)]</code>
|
| <code>STATIC</code>
|-
| <code>PICTURE picture-specification or PIC...</code>
|
| <code>VARIABLE</code>
|-
| <code>POINTER or PTR</code>
|
|
|-
| <code>STRUCTURE</code>
|
|
|-
| <code>UNALIGNED or UNAL</code>
|
|
|-
| <code>VARYING or VAR</code>
|
|
|}
Current compilers from [[Micro Focus]], and particularly that from IBM implement many extensions over the standardized version of the language. The IBM extensions are summarised in the Implementation sub-section for the compiler later. Although there are some extensions common to these compilers the lack of a current standard means that compatibility is not guaranteed.

==Standardization==
Language standardization began in April 1966 in Europe with [[European Computer Manufacturers Association|ECMA]] TC10. In 1969 [[American National Standards Institute|ANSI]] established a "Composite Language Development Committee", nicknamed "Kludge", later renamed X3J1 PL/I.<ref>Reacting to IBM's involvement, a number of manufacturers had been reluctant to endorse an effort on a Standard. The initial remit of CLDG/X3J1 was to investigate whether PL/I was a suitable candidate for standardization. The joint effort processed over 3500 proposals for language or textual changes.</ref> Standardization became a joint effort of ECMA TC/10 and ANSI X3J1. A subset of the GY33-6003<ref>"PL/I Language Specifications. GY33-6003"</ref> document was offered to the joint effort by IBM and became the base document for standardization. The major features omitted from the base document were [[Computer multitasking|multitasking]] and the attributes for [[program optimization]] (e.g., <code>NORMAL</code> and <code>ABNORMAL</code>).

Proposals to change the base document were voted upon by both committees. In the event that the committees disagreed, the chairs, initially Michael Marcotty of [[General Motors]] and [[C.A.R. Hoare]] representing [[International Computers Limited|ICL]] had to resolve the disagreement. In addition to IBM, [[Honeywell]], [[Control Data Corporation|CDC]], [[Data General]], [[Digital Equipment Corporation]], [[Prime Computer]], [[Burroughs Corporation|Burroughs]], [[RCA]], and [[Univac]] served on X3J1 along with major users [[Eastman Kodak]], [[MITRE]], [[Union Carbide]], [[Bell Laboratories]], and various government and university representatives. Further development of the language occurred in the standards bodies, with continuing improvements in structured programming and internal consistency, and with the omission of the more obscure or contentious features.

As language development neared an end, X3J1/TC10 realized that there were a number of problems with a document written in English text. Discussion of a single item might appear in multiple places which might or might not agree. It was difficult to determine if there were omissions as well as inconsistencies. Consequently, David Beech (IBM), Robert Freiburghouse (Honeywell), Milton Barber (CDC), M. Donald MacLaren ([[Argonne National Laboratory]]), Craig Franklin (Data General), Lois Frampton (Digital Equipment Corporation), and editor, D.J. Andrews of IBM undertook to rewrite the entire document, each producing one or more complete chapters. The standard is couched as a formal definition<ref name="ReferenceA"/>  using a "PL/I Machine"<ref>The PL/I machine defined in the standard is covered in [http://www.cs.yale.edu/publications/techreports/tr75.pdf ''The Definition Mechanism for Standard PL/I'']. Michael Marcotty, Frederick G Sayward.</ref>  to specify the semantics. It was the first programming language standard to be written as a semi-formal definition.

A "PL/I General-Purpose Subset" ("Subset-G") standard was issued by ANSI in 1981<ref name=SubsetG>ANSI X3.74-1981 (R1998) ''Information Systems - Programming Language - PL/I General-Purpose Subset''</ref> and a revision published in 1987.<ref>1987 PL/I General-Purpose Subset (ANSI X3.74-1987)</ref> The General Purpose subset was widely adopted as the kernel for PL/I implementations.

==Implementations==
{{See also|List of compilers#PL/I_compilers}}
===IBM PL/I F and D compilers===
PL/I was first implemented by IBM, at its [[Hursley Laboratories]] in the United Kingdom, as part of the development of [[System/360]]. The first production PL/I [[compiler]] was the PL/I F compiler for the [[OS/360]] Operating System, built by John Nash's team at Hursley in the UK: the runtime library team was managed by I.M. (Nobby) Clarke. The PL/I F compiler was written entirely in System/360 assembly language.<ref name=Krasun>{{cite web|last1=Krasun|first1=Andy|title=The first 35+ years of Hursley software 1958-1993 with some hardware asides, a personal account|url=https://apsg.bcs.org/materials/presentations/20061026krasun.pdf|access-date=May 5, 2020}}</ref>   Release 1 shipped in 1966. OS/360 is a real-memory environment and the compiler was designed for systems with as little as 64 kilobytes of real storage – F being 64 kB in S/360 parlance. To fit a large compiler into the 44 kilobytes of memory available on a 64-kilobyte machine, the compiler consists of a control phase and a large number of compiler phases (approaching 100). The phases are brought into memory from disk, one at a time, to handle particular language features and aspects of compilation. Each phase makes a single pass over the partially-compiled program, usually held in memory.<ref>{{cite book|url=http://www.bitsavers.org/pdf/ibm/360/pli/Y28-6800-1_PL1(F)_PLM_Sep66.pdf|title=IBM System/360 Operating System PL/I (F) Compiler Program Logic Manual|id=Y28-6800-1|date=December 1966|publisher=IBM|at=Section 2: Compiler Phases}}</ref>

Aspects of the language were still being designed as PL/I F was implemented, so some were omitted until later releases. PL/I RECORD I/O was shipped with PL/I F Release 2. The [[list processing]] functions<ref>These were designed in 1966 for an early Optimizing compiler, written in PL/I and to be bootstrapped starting with the PL/I F compiler</ref>{{snd}} Based Variables, Pointers, Areas and Offsets and [[LOCATE-mode I/O]]{{snd}} were first shipped in Release 4. In a major attempt to speed up PL/I code to compete with Fortran object code, PL/I F Release 5 does substantial [[program optimization]] of DO-loops facilitated by the REORDER option on procedures.

A version of PL/I F was released on the [[TSS/360]] timesharing operating system for the [[System/360 Model 67]], adapted at the IBM Mohansic Lab. The IBM La Gaude Lab in France developed "Language Conversion Programs"<ref>There were many delays in shipping these, so a common PL/I joke at the time was that [[Charles de Gaulle|Gen de Gaulle]] forbade La Gaude from shipping them until the [[Concorde]] had its first flight</ref> to convert Fortran, Cobol, and Algol programs to the PL/I F level of PL/I.

The PL/I D compiler, using 16 kilobytes of memory, was developed by IBM Germany for the [[DOS/360]] low end operating system. It implements a subset of the PL/I language requiring all strings and arrays to have fixed extents, thus simplifying the run-time environment. Reflecting the underlying operating system, it lacks dynamic storage allocation and the ''controlled'' storage class.<ref>{{cite book|url=http://www.bitsavers.org/pdf/ibm/360/pli/C28-8202-0_PLIsubsetRM_1967.pdf|title=IBM System/360 PL/I Subset Reference Manual|id=C28-8202-0|date=1967|publisher=IBM}}</ref>  It was shipped within a year of PL/I F.

===Multics PL/I and derivatives===
Compilers were implemented by several groups in the early 1960s. The [[Multics]] project at [[MIT]], one of the first to develop an operating system in a [[High-level programming language|high-level language]], used Early PL/I (EPL), a subset dialect of PL/I, as their implementation language in 1964. EPL was developed at [[Bell Labs]] and MIT by [[Douglas McIlroy]], [[Robert Morris (cryptographer)|Robert Morris]], and others.<ref name="MulticsPL1"/> Initially, it was developed using the [[TMG (language)|TMG]] compiler-compiler.<ref>{{cite web |editor=Tom Van Vleck |editor-link=Tom Van Vleck |url=https://multicians.org/pl1.html#EPL |title=The Choice of PL/I |website=Multicians.org}}</ref> The influential Multics PL/I compiler<ref name="MulticsPL1">{{cite web|url=http://www.multicians.org/pl1-raf.html|title=The Multics PL/1 Compiler|author=R. A. Frieburghouse|website=Multicians.org}}</ref> [sic "PL/1"] was the source of compiler technology used by a number of manufacturers and software groups. EPL was a system programming language and a dialect of PL/I that had some capabilities absent in the original PL/I.

The Honeywell PL/I compiler (for Series 60) is an implementation of the full ANSI X3J1 standard.<ref>{{cite book|publisher=[[Honeywell]]|title=Series 60 (Level 66)/6000 PL/I Reference Manual|id=Order No. DE05|year=1976}}</ref>

===IBM PL/I optimizing and checkout compilers===
The PL/I Optimizer and Checkout compilers produced in Hursley support a common level of PL/I language<ref name="gc33-0009-4">{{cite book|url=http://www.bitsavers.org/pdf/ibm/360/pli/GC33-0009-4_PLI_Checkout_And_Opt_Compiler_Lang_Ref_Oct76.pdf|title=OS PL/I Checkout and Optimizing Compilers: Language Reference Manual|id=GC33-0009-04|date=October 1976|publisher=IBM}}</ref> and aimed to replace the PL/I F compiler. The checkout compiler is a rewrite of PL/I F in BSL, IBM's PL/I-like proprietary implementation language (later [[PL/S]]).<ref name=Krasun />  The performance objectives set for the compilers are shown in an IBM presentation to the BCS.<ref name=Krasun /> The compilers had to produce identical results{{snd}} the Checkout Compiler is used to debug programs that would then be submitted to the Optimizer. Given that the compilers had entirely different designs and were handling the full PL/I language this goal was challenging: it was achieved.

IBM introduced new attributes and syntax including {{tt|BUILTIN}}, case statements ({{tt|SELECT}}/{{tt|WHEN}}/{{tt|OTHERWISE}}), loop controls ({{tt|ITERATE}} and {{tt|LEAVE}}) and null argument lists to disambiguate, e.g., <code>DATE'''()'''</code>.

The PL/I optimizing compiler took over from the PL/I F compiler and was IBM's workhorse compiler from the 1970s to the 1990s. Like PL/I F, it is a multiple pass compiler with a 44 kilobyte design point, but it is an entirely new design. Unlike the F compiler, it has to perform compile time evaluation of constant expressions using the run-time library, reducing the maximum memory for a compiler phase to 28 kilobytes. A second-time around design, it succeeded in eliminating the annoyances of PL/I F such as cascading diagnostics.<ref name=CasD/> It was written in S/360 Macro Assembler by a team, led by Tony Burbridge, most of whom had worked on PL/I F. Macros were defined to automate common compiler services and to shield the compiler writers from the task of managing real-mode storage, allowing the compiler to be moved easily to other memory models. The gamut of program optimization techniques developed for the contemporary IBM Fortran H compiler were deployed: the Optimizer equaled Fortran execution speeds in the hands of good programmers. Announced with IBM S/370 in 1970, it shipped first for the [[DOS/360]] operating system in August 1971, and shortly afterward for OS/360,<ref name=OptPLI.1971/> and the first virtual memory IBM operating systems [[OS/VS1]], [[MVS]], and [[VM/CMS]].  (The developers were unaware that while they were shoehorning the code into 28 kb sections, IBM Poughkeepsie was finally ready to ship virtual memory support in OS/360). It supported the batch programming environments and, under TSO and CMS, it could be run interactively. This compiler went through many versions covering all mainframe operating systems including the operating systems of the Japanese [[plug compatible|plug-compatible machines]] (PCMs).

The compiler has been superseded by "IBM PL/I for OS/2, AIX, Linux, z/OS" below.

The PL/I checkout compiler,<ref>{{cite journal|title=A Conversational Compiler for Full PL/I|author=R. N. Cuff|journal=[[The Computer Journal]]|date=May 1972|volume=15|issue=2|pages=99–104|doi=10.1093/comjnl/15.2.99|doi-access=free}}</ref><ref>{{cite journal|title=The design of a checkout compiler|author=B. L. Marks|journal=[[IBM Systems Journal]]|volume=12|issue=3|pages=315–327|date=1973|doi=10.1147/sj.123.0315}}</ref> (colloquially "The Checker") announced in August 1970 was designed to speed and improve the debugging of PL/I programs. The team was led by Brian Marks. The three-pass design cut the time to compile a program to 25% of that taken by the F Compiler. It can be run from an interactive terminal, converting PL/I programs into an internal format, "H-text". This format is interpreted by the Checkout compiler at run-time, detecting virtually all types of errors. Pointers are represented in 16 bytes, containing the target address and a description of the referenced item, thus permitting "bad" pointer use to be diagnosed. In a conversational environment when an error is detected, control is passed to the user who can inspect any variables, introduce debugging statements and edit the source program. Over time the debugging capability of mainframe programming environments developed most of the functions offered by this compiler and it was withdrawn (in the 1990s?)

===DEC PL/I===
Perhaps the most commercially successful implementation aside from IBM's was Digital Equipment Corporation's VAX-11 PL/I, later known as VAX PL/I, then DEC PL/I. The implementation is "a strict superset of the ANSI X3.4-1981 PL/I General Purpose Subset and provides most of the features of the new ANSI X3.74-1987 PL/I General Purpose Subset", and was first released in 1980.<ref>{{cite web|url=https://bitsavers.org/pdf/dec/vax/lang/pl1/AE-J971B-TE_VAX-11_PLI_1.0_SPD_198010.pdf|title=VAX-11 PL/I, version 1.0|date=October 1980|publisher=Digital|access-date=2023-10-31}}</ref><ref>''Uniprise PL/I for UNIX Reference Manual,'' Uniprise Systems, Inc., Irvine, California, 1995, p. xxi.</ref> It originally used a compiler backend named the VAX Code Generator (VCG) created by a team led by [[Dave Cutler]].<ref>{{cite newsgroup|url=http://compgroups.net/comp.os.vms/re-dave-cutler-and-vms-2/514577|archive-url=https://web.archive.org/web/20210614015421/https://compgroups.net/comp.os.vms/re-dave-cutler-and-vms-2/514577|url-status=usurped|archive-date=June 14, 2021|title=RE: Dave Cutler and VMS #2|date=2004-05-21|author=Tom Linden|newsgroup=comp.os.vms|access-date=2021-02-26}}</ref> The front end was designed by Robert Freiburghouse, and was ported to [[VAX/VMS]] from [[Multics]].<ref>{{cite interview |last1=Cutler|first1=Dave|subject-link=Dave Cutler|interviewer=Grant Saviers|title=Dave Cutler Oral History|url=https://www.youtube.com/watch?v=29RkHH-psrY |archive-url=https://ghostarchive.org/varchive/youtube/20211211/29RkHH-psrY |archive-date=2021-12-11 |url-status=live|publisher=Computer History Museum|date=2016-02-25|website=youtube.com|access-date=2021-02-26}}{{cbignore}}</ref> It runs on VMS on [[VAX]] and [[DEC Alpha|Alpha]], and on [[Tru64]]. During the 1990s, Digital sold the compiler to [[UniPrise Systems]], who later sold it to a company named Kednos.<ref>{{cite newsgroup|url=https://comp.answers.narkive.com/t33zEl7i/pl-i-frequently-asked-questions-faq|title=PL/I Frequently Asked Questions (FAQ)|author=Robin Vowels|date=2010-04-01|newsgroup=comp.answers}}</ref> Kednos marketed the compiler as Kednos PL/I until October 2016 when the company ceased trading.<ref name="kednos">{{cite web|archive-url=https://web.archive.org/web/20210314190741/https://www.kednos.com/|archive-date=2021-03-14|url=https://www.kednos.com/|title=Kednos PL/I for OpenVMS and Tru64|date=2016-11-02|access-date=2021-03-30|website=kednos.com}}</ref>

===Teaching subset compilers===
In the late 1960s and early 1970s, many US and Canadian universities were establishing time-sharing services on campus and needed conversational compiler/interpreters for use in teaching science, mathematics, engineering, and computer science. [[Dartmouth College|Dartmouth]] was developing [[BASIC]], but PL/I was a popular choice, as it was concise and easy to teach. As the IBM offerings were unsuitable,<ref>{{cite web|url=http://plg.uwaterloo.ca/~holt/papers/fatal_disease.html|title=Teaching the Fatal Disease (or) Introductory Computer Programming Using PL/I|author=Richard C. Holt|date=November 5, 1972|access-date=May 30, 2010|archive-url=https://web.archive.org/web/20110415025435/http://plg.uwaterloo.ca/~holt/papers/fatal_disease.html|archive-date=April 15, 2011|url-status=live}}</ref> a number of schools built their own subsets of PL/I and their own interactive support. Examples are:

In the 1960s and early 1970s, [[Allen-Babcock]] implemented the Remote Users of Shared Hardware (RUSH) time sharing system for an [[IBM System/360 Model 50]] with custom [[microcode]] and subsequently implemented IBM's '''[[Conversational Programming System|CPS]]''', an interactive time-sharing system for [[OS/360]] aimed at teaching computer science basics, offered a limited subset of the PL/I language in addition to BASIC and a remote job entry facility.

'''[[PL/C]]''', a dialect for teaching, a compiler developed at [[Cornell University]], had the unusual capability of never failing to compile any program through the use of extensive automatic correction of many syntax errors and by converting any remaining syntax errors to output statements. The language was almost all of PL/I as implemented by IBM.<ref>Department of Computer Science, ''User's Guide to PL/C - The Cornell Compiler for PL/I,'' Cornell University, Ithaca, 1977.</ref> PL/C was a very fast compiler.

'''{{visible anchor|SL/1}}''' (Student Language/1, Student Language/One or Subset Language/1)<ref>{{cite web
 |url=http://teampli.net/plifamily.html#sli
 |title=SL/1 (Student Language/One)}}</ref><ref>{{cite web 
|url=http://www.bobspixels.com/kaibab.org/bob/ibm1130.htm 
|title=The IBM 1130 |website=BobsPixels.com}}</ref> was a PL/I subset, initially available late 1960s, that ran interpretively on the [[IBM 1130]]; instructional use was its strong point.

'''PLAGO''', created at the [[Polytechnic Institute of Brooklyn]], used a simplified subset of the PL/I language<ref>''PLAGO/360 User's Manual,'' Polytechnic Institute of Brooklyn.</ref> and focused on good diagnostic error messages and fast compilation times.

The Computer Systems Research Group of the University of Toronto produced the '''[[SP/k]]''' compilers which supported a sequence of subsets of PL/I called SP/1, SP/2, SP/3, ..., SP/8 for teaching programming. Programs that ran without errors under the SP/k compilers produced the same results under other contemporary PL/I compilers such as IBM's PL/I F compiler, IBM's checkout compiler or Cornell University's PL/C compiler.<ref>J. N. P. Hume and R. C. Holt, ''Structured Programming using PL/I and SP/k,'' Reston, Reston, 1975.</ref>

Other examples are '''PL0''' by P. Grouse at the University of New South Wales, '''PLUM''' by [[Marvin Victor Zelkowitz]] at the University of Maryland.,<ref>[[Marvin Victor Zelkowitz]], ''PL/I Programming with PLUM,'' 2nd Ed., Paladin House, Geneva (Ill.), 1978.</ref> and '''PLUTO''' from the University of Toronto.

===IBM PL/I for OS/2, AIX, Linux, z/OS===
In a major revamp of PL/I, IBM Santa Teresa in California launched an entirely new compiler in 1992. The initial shipment was for OS/2 and included most ANSI-G features and many new PL/I features.<ref name="pli-for-os2-acm">{{cite journal|title=PL/I for OS/2|author=Robin A. Vowels|journal=ACM SIGPLAN Notices|volume=31|issue=3|date=March 1996|pages=22–27|doi=10.1145/227717.227724|publisher=[[Association for Computing Machinery]]|s2cid=24441291|doi-access=free}}</ref> Subsequent releases provided additional platforms ([[MVS]], [[VM (operating system)|VM]], [[OS/390]], [[IBM AIX|AIX]] and [[Microsoft Windows|Windows]]), but as of 2021, the only supported platforms are [[z/OS]] and AIX.<ref>{{cite web |title=IBM PL/I Compiler Family |website=[[IBM]] |url=https://www.ibm.com/products/pli-compiler-family |access-date=5 July 2021}}</ref> IBM continued to add functions to make PL/I fully competitive with other languages (particularly C and C++) in areas where it had been overtaken. The corresponding "IBM Language Environment" supports inter-operation of PL/I programs with Database and Transaction systems, and with programs written in C, C++, and COBOL, the compiler supports all the data types needed for intercommunication with these languages.

The PL/I design principles were retained and withstood this major extension, comprising several new data types, new statements and statement options, new exception conditions, and new organisations of program source. The resulting language is a compatible super-set of the PL/I Standard and of the earlier IBM compilers. Major topics added to PL/I were:

* New attributes for better support of user-defined data types – the <code>DEFINE ALIAS</code>, <code>ORDINAL</code>, and <code>DEFINE STRUCTURE</code> statement to introduce user-defined types, the <code>HANDLE</code> locator data type, the <code>TYPE</code> data type itself, the <code>UNION</code> data type, and built-in functions for manipulating the new types.
* Additional data types and attributes corresponding to common PC data types (e.g.,  <code>UNSIGNED</code>, <code>VARYINGZ</code>).
* Improvements in readability of programs – often rendering implied usages explicit (e.g., <code>BYVALUE</code> attribute for parameters)
* Additional structured programming constructs.
* Interrupt handling additions.
* Compile time preprocessor extended to offer almost all PL/I string handling features and to interface with the Application Development Environment

The latest series of PL/I compilers for z/OS, called Enterprise PL/I for z/OS, leverage code generation for the latest z/Architecture processors (z14, z13, zEC12, zBC12, z196, z114) via the use of ARCHLVL parm control passed during compilation, and was the second High level language supported by z/OS Language Environment to do so (XL C/C++ being the first, and Enterprise COBOL v5 the last.)

====Data types====
{{tt|ORDINAL}} is a new computational data type. The ordinal facilities are like those in [[Pascal (programming language)|Pascal]],
e.g., {{code|DEFINE ORDINAL Colour (red, yellow, green, blue, violet);}}
but in addition the name and internal values are accessible via built-in functions. Built-in functions provide access to an ordinal value's predecessor and successor.

The {{tt|DEFINE}}-statement (see below) allows additional {{tt|TYPE}}s to be declared composed from PL/I's built-in attributes.

The <code>HANDLE(data structure)</code> locator data type is similar to the {{tt|POINTER}} data type, but strongly typed to bind only to a particular data structure. The <code>=></code> operator is used to select a data structure using a handle.

The {{tt|UNION}} attribute (equivalent to {{tt|CELL}} in early PL/I specifications) permits several scalar variables, arrays, or structures to share the same storage in a unit that occupies the amount of storage needed for the largest alternative.

====Competitiveness on PC and with C====
These attributes were added:

* The string attributes <code>VARYINGZ</code> (for zero-terminated character strings), <code>HEXADEC</code>, <code>WIDECHAR</code>, and <code>GRAPHIC</code>.
* The optional arithmetic attributes <code>UNSIGNED</code> and <code>SIGNED</code>,  <code>BIGENDIAN</code> and <code>LITTLEENDIAN</code>. <code>UNSIGNED</code> necessitated the  <code>UPTHRU</code> and <code>DOWNTHRU</code> option on iterative groups enabling a counter-controlled loop to be executed without exceeding the limit value (also essential for <code>ORDINAL</code>s and good for documenting loops).
* The <code>DATE(pattern)</code> attribute for controlling date representations and additions to bring time and date to best current practice. New functions for manipulating dates include{{snd}} <code>DAYS</code> and <code>DAYSTODATE</code> for converting between dates and number of days, and a general <code>DATETIME</code> function for changing date formats.
New string-handling functions were added{{snd}} to centre text, to edit using a picture format, and to trim blanks or selected characters from the head or tail of text, <code>VERIFYR</code> to <code>VERIFY</code> from the right. and  <code>SEARCH</code> and <code>TALLY</code> functions.

Compound assignment operators a la C e.g., <code>+=</code>, <code>&=</code>, <code>-=</code>, <code>||=</code> were added. <code>A+=1</code> is equivalent to <code>A=A+1</code>.

Additional parameter [[Data descriptor|descriptors]] and attributes were added for omitted arguments and variable length argument lists.

====Program readability – making intentions explicit====
The {{tt|VALUE}} attribute declares an identifier as a constant (derived from a specific literal value or restricted expression).

Parameters can have the {{tt|BYADDR}} (pass by address) or {{tt|BYVALUE}} (pass by value) attributes.

The {{tt|ASSIGNABLE}} and {{tt|NONASSIGNABLE}} attributes prevent unintended assignments.

<code>DO FOREVER;</code> obviates the need for the contrived construct {{code|DO WHILE ( '1'B );|rexx}}.

The {{tt|DEFINE}}-statement introduces user-specified names (e.g., {{tt|INTEGER}}) for combinations of built-in attributes (e.g., <code>FIXED BINARY(31,0)</code>). Thus <code>DEFINE ALIAS INTEGER FIXED BINARY(31.0)</code> creates the {{tt|TYPE}} name {{tt|INTEGER}} as an alias for the set of built-in attributes FIXED BINARY(31.0). <code>DEFINE STRUCTURE</code> applies to structures and their members; it provides a {{tt|TYPE}} name for a set of structure attributes and corresponding substructure member declarations for use in a structure declaration (a generalisation of the {{tt|LIKE}} attribute).

====Structured programming additions====
A {{tt|LEAVE}} statement to exit a loop, and an {{tt|ITERATE}} to continue with the next iteration of a loop.

{{tt|UPTHRU}} and {{tt|DOWNTHRU}} options on iterative groups.

The package construct consisting of a set of procedures and declarations for use as a unit. Variables declared outside of the procedures are local to the package, and can use {{tt|STATIC}}, {{tt|BASED}} or {{tt|CONTROLLED}} storage. Procedure names used in the package also are local, but can be made external by means of the {{tt|EXPORTS}} option of the {{tt|PACKAGE}}-statement.

====Interrupt handling====
The {{tt|RESIGNAL}}-statement executed in an ON-unit terminates execution of the ON-unit, and raises the condition again in the procedure that called the current one (thus passing control to the corresponding ON-unit for that procedure).

The {{tt|INVALIDOP}} condition handles invalid operation codes detected by the PC processor, as well as illegal arithmetic operations such as subtraction of two infinite values.

The {{tt|ANYCONDITION}} condition is provided to intercept conditions for which no specific ON-unit has been provided in the current procedure.

The {{tt|STORAGE}} condition is raised when an {{tt|ALLOCATE}} statement is unable to obtain sufficient storage.

===Other mainframe and minicomputer compilers===
A number of vendors produced compilers to compete with IBM PL/I F or Optimizing compiler on mainframes and minicomputers in the 1970s. In the 1980s the target was usually the emerging ANSI-G subset.

* In 1974 [[Burroughs Corporation]] announced PL/I for the B6700 and B7700.<ref>Burroughs Corporation, ''B 6700/B 7700: PL/I Language Reference Manual,'' Reference 5001530, Detroit, 1977.</ref>
* [[UNIVAC]] released a UNIVAC PL/I,<ref>Sperry-Univac Computer Systems, ''Sperry-Univac 1100 Series PL/I Programmer Reference,'' Reference UP-8277, 1976.</ref> and in the 1970s also used a variant of PL/I, PL/I PLUS, for system programming.
* From 1978 [[Data General]] provided PL/I on its [[Data General Eclipse|Eclipse]] and [[Data General Eclipse|Eclipse MV]] platforms running the [[Data General AOS|AOS]], [[AOS/VS]] & [[AOS/VS II]] operating systems.<ref>Data General Corporation, ''AOS PL/I Reference Manual,'' Order No. 093-000204, c. 1978.</ref> A number of operating system utility programs were written in the language.
* Paul Abrahams of NYU's Courant Institute of Mathematical Sciences wrote CIMS PL/I in 1972 in PL/I, bootstrapping via PL/I F. It supported "about 70%" of PL/I compiling to the CDC 6600<ref>{{cite conference |last1=Abrahams |first1=Paul W. |title=The CIMS PL/I compiler |conference=1979 SIGPLAN symposium on Compiler construction |pages=107–116 |doi=10.1145/800229.806960 |isbn=0-89791-002-8 |doi-access=free}}</ref>
* [[Control Data Corporation|CDC]] delivered an optimizing subset PL/I compiler for Cyber 70, 170 and 6000 series.<ref>Control Data Corporation, ''PL/I Reference Manual,'' 1978, Publication No. 60388100A.</ref>
* Fujitsu delivered a PL/I compiler equivalent to the PL/I Optimizer.
* Stratus Technologies PL/I is an ANSI G implementation for the [[Stratus VOS|VOS]] operating system.<ref>{{cite book|title=OpenVOS PL/I Language Manual (R009)|publisher=[[Stratus Computer|Stratus Computer, Inc.]]|location=[[Marlboro, Massachusetts]]|year=1995|url=http://stratadoc.stratus.com/vos/19.0.0/r009-05/index.html?context=r009-05&file=ch1r009-05.html|at=OpenVOS PL/I}}</ref>
* [[IBM Series/1]] PL/I<ref name=S1PliIntro>{{cite book
 |title=IBM Series/1 PL/I Introduction Program Numbers 5719-PL1 5719-PL3 
 |id=GC34-0084-0
 |date=February 1977
 |edition=1st
 |url=http://bitsavers.org/pdf/ibm/series1/GC34-0084-0_PL_I_Introduction_Feb77.pdf
 |publisher=IBM
}}
</ref><ref>{{cite book
 |title=IBM Series/1 PL/I: Language Reference Manual
 |id=GC34-0085-0
 |publisher =IBM
}}
</ref> is an extended subset of ANSI Programming Language PL/I (ANSI X3.53-1976) for the IBM Series/1 Realtime Programming System.

===PL/I compilers for Microsoft .NET===
* In 2011, Raincode designed a full legacy compiler for the [[Microsoft .NET]] and [[.NET Core]] platforms, named The Raincode PL/I compiler.

===PL/I compilers for personal computers and Unix===
* {{anchor|PL/I-80|PL/I-86}}In the 1970s and 1980s [[Digital Research]] sold a PL/I compiler for [[CP/M]] (PL/I-80), [[CP/M-86]] (PL/I-86) and Personal Computers with [[DOS]]<!-- PLI-86 -->.<ref name="norton-chronicles">{{cite magazine|title=The Norton chronicles|author=Peter Norton|author-link=Peter Norton|magazine=[[PC Magazine]]|date=May 15, 1984|url=http://members.dodo.com.au/~robin51/norton.htm|access-date=January 25, 2010|archive-date=July 6, 2011|archive-url=https://web.archive.org/web/20110706103943/http://members.dodo.com.au/~robin51/norton.htm|url-status=dead}}</ref> It was based on Subset G of PL/I<ref name="norton-chronicles"/> and was written in [[PL/M]].
* [[Micro Focus]] implemented Open PL/I for Windows<ref>{{cite web|url=https://www.microfocus.com/media/brochure/whats-new-in-studio-and-server_tcm6-8231.pdf|title=What's New in Studio and Server Enterprise Edition 6.0 Service Pack 2 - Wrap Pack 1|page=1|website=[[Micro Focus]]|archive-url=https://web.archive.org/web/20171107025457/https://www.microfocus.com/media/brochure/whats-new-in-studio-and-server_tcm6-8231.pdf|archive-date=November 7, 2017|url-status=dead}}</ref> and UNIX/Linux systems,<ref>{{cite web|url=http://documentation.microfocus.com/help/topic/com.microfocus.eclipse.infocenter.studee60ux/GUID-D3FC9AD2-25B7-47E6-8011-B67644AE987D.html?cp=3_15_0_2_0_0_0|title=Enterprise > Micro Focus Studio Enterprise Edition for UNIX > Welcome > Product Information > Installing Studio Enterprise Edition for UNIX > System Requirements|website=Micro Focus|access-date=2017-11-05|archive-url=https://web.archive.org/web/20171107014253/http://documentation.microfocus.com/help/topic/com.microfocus.eclipse.infocenter.studee60ux/GUID-D3FC9AD2-25B7-47E6-8011-B67644AE987D.html?cp=3_15_0_2_0_0_0|archive-date=2017-11-07|url-status=dead}}</ref> which they acquired from Liant.
* IBM delivered PL/I for [[OS/2]]<ref name="pli-for-os2-acm"/> in 1994, and PL/I for AIX in 1995.<ref name="pli-for-aix">{{cite web |title=IBM PL/I Set for AIX Version 1 |date=19 September 1995 |url=https://www-01.ibm.com/common/ssi/ShowDoc.wss?docURL=/common/ssi/rep_ca/4/897/ENUS295-394/index.html&lang=en&request_locale=en |access-date=13 May 2019}}</ref>
* Iron Spring PL/I for [[OS/2]] and later [[Linux]] was introduced in 2007.<ref>{{cite web|url=http://www.iron-spring.com/prog_guide.html|title=Iron Spring PL/I Compiler - Programming Guide|date=2020-09-15|access-date=2021-02-26|website=ironspring.com}}</ref>
* [[GNU Compiler Collection|GCC]] (pl1gcc) front end;<ref>{{cite web|url=https://gcc.gnu.org/frontends.html|title=Programming Languages Supported by GCC|access-date=2014-06-23|publisher=GNU Project|archive-date=January 18, 2023|archive-url=https://web.archive.org/web/20230118185814/https://gcc.gnu.org/frontends.html|url-status=live}}</ref> the project's last release was in September 2007.<ref>{{cite web |url=https://pl1gcc.sourceforge.net |title=PL/I front-end for GNU Compiler Collection}}</ref>

==PL/I dialects==
* [[IBM PL/S|PL/S]], a dialect of PL/I, initially called BSL was developed in the late 1960s and became the [[system programming]] language for IBM mainframes. Almost all IBM mainframe system software in the 1970s and 1980s was written in PL/S. It differed from PL/I in that there were no data type conversions, no run-time environment, structures were mapped differently, and assignment was a byte by byte copy. All strings and arrays had fixed extents, or used the <code>REFER</code> option. PL/S was succeeded by PL/AS, and then by PL/X, which is the language currently used for internal work on current operating systems, [[OS/390]] and now [[z/OS]]. It is also used for some [[z/VSE]] and [[z/VM]] components. [[IBM Db2]] for z/OS is also written in PL/X.
* [[PL/C]], is an instructional dialect of the PL/I computer programming language, developed at Cornell University in the 1970s.
* Two dialects of PL/I named PL/MP (Machine Product) and PL/MI (Machine Interface) were used by IBM in the system software of the [[System/38]] and [[AS/400]] platforms.<ref>{{cite book|title=Inside the AS/400, Second Edition|url=https://books.google.com/books?id=5DoPAAAACAAJ|isbn=978-1-882419-66-1|author=Frank G. Soltis|year=1997|publisher=Duke Press}}</ref><ref>{{cite journal |title=Lessons learned from the OS/400 OO project |first1=
William |last1=Berg |first2=Marshall |last2=Cline |first3=Mike |last3=Girou |journal=[[Communications of the ACM]] |volume=38 |issue=10 |date=October 1995 |pages=54–64 |doi=10.1145/226239.226253|s2cid=7492851 |doi-access=free}}</ref><ref>{{cite web |last1=Pigott |first1=Diarmuid |title=PL/MP |url=https://hopl.info/showlanguage.prx?exp=820&language=PL/MP |website=Online Historical Encyclopaedia of Programming Languages |access-date=Feb 24, 2021 |archive-date=August 2, 2020 |archive-url=https://web.archive.org/web/20200802182406/https://hopl.info/showlanguage.prx?exp=820&language=PL%2FMP |url-status=live}}</ref> PL/MP was used to implement the so-called [[System/38#Microcode|Vertical Microcode]] of these platforms, and targeted the IMPI instruction set. PL/MI targets the [[System/38#Machine Interface|Machine Interface]] of those platforms, and is used in the System/38 [[Control Program Facility]], and the [[IBM i#XPF|XPF]] layer of [[OS/400]].<ref>{{cite mailing list|url=https://archive.midrange.com/mi400/200310/msg00008.html|title=Re: Re: MI emulator|author=Leif Svalgaard|date=2003-10-08|access-date=2021-02-26|mailing-list=MI400}}</ref> The PL/MP code was mostly replaced with C++ when OS/400 was ported to the [[IBM RS64]] processor family, although some was retained and retargeted for the [[PowerPC]]/[[Power ISA]] architecture.<ref>{{cite newsgroup|url=https://archive.midrange.com/mi400/200409/msg00012.html|title=RE: Dave McKenzie's UNDELete utility - a LifeSaver!|author=Dave McKenzie|date=2004-09-01|access-date=2021-05-24|website=Midrange Archive MI400}}</ref> The PL/MI code was not replaced, and remains in use in IBM i.<ref>{{cite newsgroup|url=https://groups.google.com/g/comp.sys.ibm.as400.misc/c/OsgPyut_EE0/m/7QIMwg_0BxkJ|title=UNIX vs AS/400?|author=Dan Hicks|date=1998-08-21|newsgroup=comp.sys.ibm.as400.misc}}</ref>
* [[PL.8]], so-called because it was about 80% of PL/I,<ref>{{Cite journal
 |last1=Cocke
 |first1=John
 |last2=Markstein
 |first2=Victoria
 |date=January 1990
 |doi=10.1147/rd.341.0004
 |url=https://www.cis.upenn.edu/~milom/cis501-Fall11/papers/cocke-RISC.pdf
 |title=The evolution of RISC technology at IBM
 |journal=IBM Journal of Research and Development
 |volume=34
 |issue=1
 |pages=4–11
 |quote=The result was the PL.8 language, the ".8" implying that it had about 80 percent of the richness of PL/I.
 |access-date=2022-10-05
}}</ref> was originally developed by IBM Research in the 1970s for the [[IBM 801]] architecture.<ref name="gcc-pl8">{{cite journal |last1=Gellerich |first1=W |last2=Hendel |first2=T. |last3=Land |first3=R. |last4=Lehmann |first4=H. |last5=Mueller |first5=M. |last6=Oden |first6=P. H. |last7=Penner |first7=H. |date=May 2004 |url=http://pdfs.semanticscholar.org/3288/fc042cd474f0ec93d67753565d0cc83ac575.pdf |title=The GNU 64-bit PL8 compiler: Toward an open standard environment for firmware development |journal=IBM Journal of Research and Development |publisher=IBM |volume=48 |issue=3.4 |pages=543–556 |doi=10.1147/rd.483.0543 |s2cid=19020943 |url-status=dead |archive-url=https://web.archive.org/web/20210124040918/http://pdfs.semanticscholar.org/3288/fc042cd474f0ec93d67753565d0cc83ac575.pdf |archive-date=2021-01-24 |access-date=2021-02-26}}</ref> It later gained support for the [[Motorola 68000]] and [[System/370]] architectures.<ref>{{cite conference |last1=Auslander |first1=Marc |last2=Hopkins |first2=Martin |date=June 1982 |url=http://rsim.cs.illinois.edu/arch/qual_papers/compilers/auslander82.pdf |title=An overview of the PL.8 compiler |conference=SIGPLAN '82 Proceedings of the 1982 SIGPLAN symposium on Compiler construction|access-date=2021-02-26 |publisher=ACM |pages=22–31 |doi=10.1145/872726.806977}}</ref> It continues to be used for several IBM internal systems development tasks (e.g., [[millicode]] and [[firmware]] for [[z/Architecture]] systems) and has been re-engineered to use a [[64-bit]] [[GNU Compiler Collection|gcc]]-based backend.<ref name="gcc-pl8" /><ref>{{cite journal|url=https://pdfs.semanticscholar.org/4316/6a09a6d273006822b513074183157955160f.pdf|archive-url=https://web.archive.org/web/20200211224409/https://pdfs.semanticscholar.org/4316/6a09a6d273006822b513074183157955160f.pdf|url-status=dead|archive-date=2020-02-11|title=z/CECSIM: An efficient and comprehensive microcode simulator for the IBM eServer z900|author1=J. von Buttlar|author2=H. Bohm|author3=R. Ernst|author4=A. Horsch|author5=A. Kohler|author6=H. Schein|author7=M. Stetter|author8=K. Theurich|date=July 2002|journal=IBM Journal of Research and Development|access-date=2021-02-26|pages=607–615|doi=10.1147/rd.464.0607|publisher=IBM|volume=46|issue=4.5|s2cid=12745372}}</ref>
* [[Honeywell, Inc.]] developed [[PL-6]] for use in creating the [[Honeywell CP-6|CP-6]] operating system.
* [[Prime Computer]] used two different PL/I dialects as [[system programming language]]s for the [[PRIMOS]] [[operating system]]: [[PL/P]], starting from version 18, and then SP/L, starting from version 19.
* [[XPL]] is a dialect of PL/I used to write other compilers using the XPL compiler techniques. XPL added a heap string datatype to its small subset of PL/I.
* [[HAL/S]] is a real-time aerospace programming language, best known for its use in the Space Shuttle program. It was designed by Intermetrics in the 1970s for NASA. HAL/S was implemented in XPL.
* IBM and various subcontractors also developed another PL/I variant in the early 1970s to support signal processing for the Navy called SPL/I.
* [[SabreTalk]], a real-time dialect of PL/I used to program the [[Sabre (computer system)|Sabre]] airline reservation system.
* [[Apple (programming language)|Apple]], a PL/I dialect developed by [[General Motors Research Laboratories]] for their [[Control Data Corporation]] [[CDC STAR-100|STAR-100]] supercomputer, used extensively for graphic design.

==Usage==
PL/I implementations were developed for mainframes from the late 1960s, mini computers in the 1970s, and personal computers<ref name="norton-chronicles"/> in the 1980s and 1990s. Although its main use has been on [[Mainframe computer|mainframes]], there are PL/I versions for [[DOS]], [[Microsoft Windows]], [[OS/2]], [[AIX operating system|AIX]], [[OpenVMS]], and [[Unix]].

It has been widely used in business data processing<ref>{{cite magazine|url=http://www.highbeam.com/doc/1G1-17813799.html|title=Open PL/I: Liant addresses PL/I legacy applications|last1=Pearkins|first1=Jon E.|date=December 1, 1995|magazine=Enterprise Systems Journal|archive-url=https://web.archive.org/web/20121103013230/http://www.highbeam.com/doc/1G1-17813799.html|archive-date=November 3, 2012|quote=Open PL/I estimated that in 1995 20% of mainframe legacy applications were in PL/I, with 60% in COBOL: there were 300,000 PL/I programmers worldwide|accessdate=February 3, 2010|url-status=dead}}</ref> and for system use for writing operating systems on certain platforms. Very complex and powerful systems have been built with PL/I:

* The [[SAS (software)|SAS System]] was initially written in PL/I; the SAS data step is still modeled on PL/I syntax.
* The pioneering online airline reservation system [[Sabre (computer system)|Sabre]] was originally written for the IBM 7090 in assembler. The S/360 version was largely written using [[SabreTalk]], a purpose-built subset PL/I compiler for a dedicated control program.
* The [[Multics]] operating system was largely written in PL/I.
* PL/I was used to write an executable formal definition<ref>{{cite journal |last1=Schultz |first1=G. |last2=Rose |first2=D. |last3=West |first3=C. |last4=Gray |first4=J. |date=April 1980 |doi=10.1109/TCOM.1980.1094695 |title=Executable description and validation of SNA |pages=661–677 |volume=28 |journal=[[IEEE Transactions on Communications]] |issue=4}}</ref> to interpret IBM's [[System Network Architecture]].
* Some components of the [[OpenVMS]] operating system were originally written in PL/I, but were later rewritten in C during the port of VMS to the [[IA-64]] architecture.<ref>{{cite journal |last1=Grant |first1=Clair |date=June 2005 |url=http://www.decus.de/events/alphamigration/vortraege/porting_openvms_to_integrity.pdf |title=Porting OpenVMS to HP Integrity Servers |journal=OpenVMS Technical Journal |volume=6}}</ref>

PL/I did not fulfill its supporters' hopes that it would displace Fortran and COBOL and become the major player on mainframes. It remained a minority but significant player. There cannot be a definitive explanation for this, but some trends in the 1970s and 1980s militated against its success by progressively reducing the territory on which PL/I enjoyed a competitive advantage.

First, the nature of the mainframe software environment changed. Application subsystems for [[database]] and [[transaction processing]] ([[CICS]] and [[Information Management System|IMS]] and [[Oracle Database|Oracle]] on System 370) and application generators became the focus of mainframe users' application development. Significant parts of the language became irrelevant because of the need to use the corresponding native features of the subsystems (such as tasking and much of input/output). Fortran was not used in these application areas, confining PL/I to COBOL's territory; most users stayed with COBOL. But as the PC became the dominant environment for program development, Fortran, COBOL and PL/I all became minority languages overtaken by [[C++]], [[Java (programming language)|Java]] and the like.

Second, PL/I was overtaken in the system programming field. The IBM system programming community was not ready to use PL/I; instead, IBM developed and adopted a proprietary dialect of PL/I for system programming. – [[PL/S]].<ref>In his slides on ''IBM Operating System/360'' [[Fred Brooks]] says OS/360 should have been written in PL/I not PL/S and Assembler. The article is a great summary of the OS/360 program. [http://extras.springer.com/2002/978-3-642-59413-7/2/rom/pdf/Brooks_new.pdf "The /360 Architecture and Its Operating System"] {{Webarchive|url=https://web.archive.org/web/20200728071740/http://extras.springer.com/2002/978-3-642-59413-7/2/rom/pdf/Brooks_new.pdf |date=2020-07-28}}, 2001.</ref> With the success of PL/S inside IBM, and of C outside IBM, the unique PL/I strengths for system programming became less valuable.

Third, the development environments grew capabilities for interactive software development that, again, made the unique PL/I interactive and debugging strengths less valuable.

Fourth, features such as structured programming, character string operations, and object orientation were added to COBOL and Fortran, which further reduced PL/I's relative advantages.

On mainframes there were substantial business issues at stake too. IBM's hardware competitors had little to gain and much to lose from success of PL/I. Compiler development was expensive, and the IBM compiler groups had an in-built competitive advantage. Many IBM users wished to avoid being locked into proprietary solutions. With no early support for PL/I by other vendors it was best to avoid PL/I.

==Evolution of the PL/I language==
This article uses the PL/I standard as the reference point for language features. But a number of features of significance in the early implementations were not in the Standard; and some were offered by non-IBM compilers. And the de facto language continued to grow after the standard, ultimately driven by developments on the Personal Computer.

===Significant features omitted from the standard===

====Multithreading====
[[Thread (computing)|Multithreading]], under the name "multitasking", was implemented by PL/I F,<ref>{{cite book|url=http://bitsavers.org/pdf/ibm/360/pli/GC28-8201-4_PLI_F_Language_Reference_Dec72.pdf|title=IBM System/360 Operating System PL/I (F) Language Reference Manual|edition=Fifth|id=GC28-8201-4|at=Chapter 15: Multitasking|date=December 1972}}</ref> the PL/I Checkout and Optimizing compilers,<ref>{{cite book|url=http://bitsavers.org/pdf/ibm/360/pli/GC33-0009-4_PLI_Checkout_And_Opt_Compiler_Lang_Ref_Oct76.pdf|title=OS PL/I Checkout and Optimizing Compilers: Language Reference Manual|edition=Fifth|id=GC33-0009-4|at=Chapter 17: Multitasking|date=October 1976}}</ref> and the newer AIX and Z/OS compilers. It comprised the data types {{tt|EVENT}} and {{tt|TASK}}, the {{tt|TASK}}-option on the {{tt|CALL}}-statement ([[Fork–join model|Fork]]), the {{tt|WAIT}}-statement ([[Fork–join model|Join]]), the <code>DELAY(delay-time)</code>, {{tt|EVENT}}-options on the record I/O statements and the {{tt|UNLOCK}} statement to unlock locked records on {{tt|EXCLUSIVE}} files. Event data identify a particular event and indicate whether it is complete ('1'B) or incomplete ('0'B): task data items identify a particular task (or [[process (computing)|process]]) and indicate its priority relative to other tasks.

====Preprocessor====
{{Further|PL/I preprocessor}}
The first IBM ''Compile time [[preprocessor]]'' was built by the IBM Boston Advanced Programming Center located in Cambridge, Mass, and shipped with the PL/I F compiler. The <code>%INCLUDE</code> statement was in the Standard, but the rest of the features were not. The DEC and Kednos<ref name="kednos" /> PL/I compilers implemented much the same set of features as IBM, with some additions of their own. IBM has continued to add preprocessor features to its compilers. The preprocessor treats the written source program as a sequence of tokens, copying them to an output source file or acting on them. When a % token is encountered the following compile time statement is executed: when an identifier token is encountered and the identifier has been {{tt|DECLARE}}d, {{tt|ACTIVATE}}d, and assigned a compile time value, the identifier is replaced by this value. Tokens are added to the output stream if they do not require action (e.g., <code>+</code>), as are the values of ACTIVATEd compile time expressions. Thus a compile time variable {{tt|PI}} could be declared, activated, and assigned using <code>%PI='3.14159265'</code>. Subsequent occurrences of {{tt|PI}} would be replaced by <code>3.14159265</code>.

The data type supported are <code>FIXED DECIMAL</code> integers and {{tt|CHARACTER}} strings of varying length with no maximum length. The structure statements are:

* {{code|%[label_list:]DO iteration: statements; %[label_list:]END;|rexx}}
* <code>%procedure_name: PROCEDURE (parameter list) RETURNS (type); statements...; %[label_list:]END;</code>
* {{code|%[label_list:]IF...%THEN...%ELSE..|rexx}}
and the simple statements, which also may have a {{code|[label_list:]}}
* {{code|%ACTIVATE(identifier_list)}} and {{code|%DEACTIVATE}}
* ''assignment'' statement
* <code>%DECLARE identifier_attribute_list</code>
* <code>%GO TO label</code>
* <code>%INCLUDE</code>
* ''null'' statement

The feature allowed programmers to use identifiers for constants{{snd}} e.g., product part numbers or mathematical constants{{snd}} and was superseded in the standard by named constants for computational data. Conditional compiling and iterative generation of source code, possible with compile-time facilities, was not supported by the standard. Several manufacturers implemented these facilities.

====Structured programming additions====
Structured programming additions were made to PL/I during standardization but were not accepted into the standard. These features were the {{tt|LEAVE}}-statement to exit from an iterative {{tt|DO}}, the {{tt|UNTIL}}-option and {{tt|REPEAT}}-option added to {{tt|DO}}, and a [[case statement]] of the general form:
{{pre|SELECT (expression) {WHEN (expression) group}... OTHERWISE group}}
These features were all included in IBM's PL/I Checkout and Optimizing compilers<ref name="gc33-0009-4"/> and in DEC PL/I.<ref>{{cite book|url=http://www.kednos.com/pli/docs/REFERENCE_MANUAL/6291pro.html|title=Kednos PL/I for OpenVMS Systems Reference Manual|date=January 2007|chapter-url=http://www.kednos.com/pli/docs/REFERENCE_MANUAL/6291pro_contents_003.html#toc_chapter_8|chapter=Chapter 8: Program Control|access-date=2017-11-05|archive-date=2016-08-18|archive-url=https://web.archive.org/web/20160818141039/http://www.kednos.com/pli/docs/REFERENCE_MANUAL/6291pro.html|url-status=dead}}</ref>

====Debug facilities====
PL/I F had offered some debug facilities that were not put forward for the standard but were implemented by others{{snd}} notably the CHECK(variable-list) condition prefix, <code>CHECK</code> on-condition and the <code>SNAP</code> option. The IBM Optimizing and Checkout compilers added additional features appropriate to the conversational mainframe programming environment (e.g., an <code>ATTENTION</code> condition).

===Significant features developed since the standard===
Several attempts had been made to design a structure member type that could have one of several datatypes (<code>CELL</code> in early IBM). With the growth of [[Class (computer programming)|classes]] in programming theory, approaches to this became possible on a PL/I base{{snd}} <code>UNION</code>, <code>TYPE</code> etc. have been added by several compilers.

PL/I had been conceived in a single-byte character world. With support for Japanese and Chinese language becoming essential, and the developments on International Code Pages, the character string concept was expanded to accommodate wide non-ASCII/EBCDIC strings.

Time and date handling were overhauled to deal with the [[Y2K problem|millennium problem]], with the introduction of the DATETIME function that returned the date and time in one of about 35 different formats. Several other date functions deal with conversions to and from days and seconds.

==Criticisms==

===Implementation issues===
Though the language is easy to learn and use, implementing a PL/I compiler is difficult and time-consuming. A language as large as PL/I needed subsets that most vendors could produce and most users master. This was not resolved until "ANSI G" was published. The compile time facilities, unique to PL/I, took added implementation effort and additional compiler passes. A PL/I compiler was two to four times as large as comparable Fortran or COBOL compilers, and also that much slower—supposedly offset by gains in programmer productivity. This was anticipated in IBM before the first compilers were written.<ref name="characteristics1978"/>

Some argue that PL/I is unusually hard to parse.<ref>The compiler cannot tell whether a statement is a declaration or a multiple assignment statement until encountering the "=" of the assignment or ";" of the DECLARE—which can be several lines later. The fact that DECLARE/DCL were not reserved is the proximate cause in this example{{snd}} consider the fragment <code>DECLARE(I,J,K),L= </code> vs <code>DECLARE(I,J,K),L;</code>.</ref> The PL/I ''keywords'' are not reserved so programmers can use them as variable or procedure names in programs. Because the original PL/I(F)  compiler attempts ''auto-correction'' when it encounters a keyword used in an incorrect context, it often assumes it is a variable name. This leads to "cascading diagnostics",<ref name=CasD>{{cite web
|url=https://atlas.ion.uwplatt.edu/bitbucket/projects/SB/repos/buildscripts/raw/DotnetCore/sdk/NuGetFallbackFolder/microsoft.codeanalysis.csharp/2.3.1%2Flib%2Fnetstandard1.3%2FMicrosoft.CodeAnalysis.CSharp.xml?at=b1dc21b912b5570ba5f46c5733a261496f6cbf7d
|title=Microsoft.CodeAnalysis.CSharp A Binder converts names
}}{{Dead link|date=May 2020 |bot=InternetArchiveBot |fix-attempted=yes}}</ref> a problem solved by later compilers.

The effort needed to produce good object code was perhaps underestimated during the initial design of the language. [[Program optimization]] (needed to compete with the excellent program optimization carried out by available Fortran compilers) is unusually complex owing to [[Side effect (computer science)|side effects]] and pervasive problems with [[Aliasing (computing)|aliasing]] of variables. Unpredictable modification can occur asynchronously in [[Exception handling|exception handlers]], which may be provided by "{{tt|ON}} statements" in (unseen) callers. Together, these make it difficult to reliably predict when a program's variables might be modified at runtime. In typical use, however, user-written error handlers (the {{tt|ON}}-unit) often do not make assignments to variables. In spite of the aforementioned difficulties, IBM produced the PL/I Optimizing Compiler in 1971.<ref name=OptPLI.1971>{{cite web
 |url=https://www.computer.org/csdl/magazine/an/2013/04/man2013040018/13rRUxBrGiQ
 |title=Early Language and Compiler Developments at IBM Europe
 |author=A. Endres |year=2013}}</ref>

PL/I contains many rarely used features, such as [[Computer multitasking|multitasking]] support (an IBM extension to the language) which add cost and complexity to the compiler, and its co-processing facilities require a multi-programming environment with support for non-blocking multiple threads for processes by the [[operating system]]. Compiler writers were free to select whether to implement these features.

An undeclared variable is, by default, declared by first occurrence—thus misspelling might lead to unpredictable results. This  "implicit declaration" is no different from FORTRAN programs. For PL/I(F), however, an attribute listing enables the programmer to detect any misspelled or undeclared variable.

===Programmer issues===
Many programmers were slow to move from [[COBOL]] or [[Fortran]] due to a perceived complexity of the language and immaturity of the PL/I F compiler. Programmers were sharply divided into scientific programmers (who used Fortran) and business programmers (who used COBOL), with significant tension and even dislike between the groups. PL/I syntax borrowed from both COBOL and Fortran [[Syntax (programming languages|syntax]]. So instead of noticing features that would make their job easier, Fortran programmers of the time noticed COBOL syntax and had the opinion that it was a business language, while COBOL programmers noticed Fortran syntax and looked upon it as a scientific language.

Both COBOL and Fortran programmers viewed it as a "bigger" version of their own language, and both were somewhat intimidated by the language and disinclined to adopt it. Another factor was ''pseudo''-similarities to COBOL, Fortran, and ALGOL. These were PL/I elements that looked similar to one of those languages, but worked differently in PL/I. Such frustrations left many experienced programmers with a jaundiced view of PL/I, and often an active dislike for the language. An early UNIX [[fortune (Unix)|fortune]] file contained the following tongue-in-cheek description of the language:{{Citation needed|date=October 2022}}

<blockquote>Speaking as someone who has delved into the intricacies of PL/I, I am sure that only Real Men could have written such a machine-hogging, cycle-grabbing, all-encompassing monster. Allocate an array and free the middle third?  Sure!  Why not?  Multiply a character string times a bit string and assign the result to a float decimal?  Go ahead!  Free a controlled variable procedure parameter and reallocate it before passing it back?  Overlay three different types of variable on the same memory location?  Anything you say!  Write a recursive macro?  Well, no, but Real Men use rescan. How could a language so obviously designed and written by Real Men not be intended for Real Man use?</blockquote>

On the positive side, full support for [[pointer (computer programming)|pointer]]s to all data types (including pointers to structures), [[recursion]], [[Computer multitasking|multitasking]], string handling, and extensive built-in [[function (computer science)|function]]s meant PL/I was indeed quite a leap forward compared to the programming languages of its time. However, these were not enough to persuade a majority of programmers or shops to switch to PL/I.

The PL/I F compiler's compile time [[preprocessor]] was unusual (outside the [[Lisp programming language|Lisp]] world<ref>{{cite magazine |last1=Hart |first1=Timothy P. |date=October 1963 |title=MACRO Definitions for LISP |magazine=Artificial Intelligence Memos |number=57 |hdl=1721.1/6111 |hdl-access=free}}</ref>) in using its target language's syntax and semantics (''e.g.'' as compared to the [[C preprocessor]]'s "#" directives).

==Special topics in PL/I==

===Storage classes===
PL/I provides several 'storage classes' to indicate how the lifetime of variables' storage is to be managed{{snd}} <code>STATIC</code>, <code>AUTOMATIC</code>, <code>CONTROLLED</code>, and <code>BASED</code>, and <code>AREA</code>.

<code>STATIC</code> data is allocated and initialized at load-time, as is done in [[COBOL]] "working-storage" and early [[Fortran]]. This is the default for <code>EXTERNAL</code> variables (similar to C “extern” or Fortran “named common"),

<code>AUTOMATIC</code> is PL/I's default storage class for <code>INTERNAL</code> variables, similar to that of other block-structured languages influenced by [[ALGOL]], like the "auto" storage class in the [[C (programming language)|C]] language, the default storage allocation in [[Pascal (programming language)|Pascal]], and "local-storage" in IBM COBOL. Storage for <code>AUTOMATIC</code> variables is allocated upon entry into the procedure, <code>BEGIN</code>-block, or <code>ON</code>-unit in which they are declared. The compiler and runtime system allocate memory for a [[stack frame]] to contain them and other housekeeping information. If a variable is declared with an <code>INITIAL</code>-attribute, code to set it to an initial value is executed at this time. Care is required to manage the use of initialization properly. Large amounts of code can be executed to initialize variables every time a scope is entered, especially if the variable is an array or structure. Storage for <code>AUTOMATIC</code> variables is freed at block exit.

<code>STATIC</code>, <code>CONTROLLED</code>, or <code>BASED</code> variables are used to retain variables' contents between invocations of a procedure or block. 

<code>CONTROLLED</code> storage is managed using a stack, but the pushing and popping of allocations on the stack is managed by the programmer, using <code>ALLOCATE</code> and <code>FREE</code> statements.

Storage for <code>BASED</code> variables is also managed using <code>ALLOCATE</code>/<code>FREE</code>, but instead of a stack these allocations have independent lifetimes and are addressed through <code>OFFSET</code> or <code>POINTER</code> variables. <code>BASED</code> variables can also be used to address arbitrary storage areas by setting the associated <code>POINTER</code> variable, for example following a [[linked list]].

The <code>AREA</code> attribute is used to declare programmer-defined [[heap (programming)|heaps]]. Data can be allocated and freed within a specific area, and the area can be deleted, read, and written as a unit.<ref name="IBMLR43">{{cite book |publisher=IBM |title=Enterprise PL/I for z/OS PL/I for AIX Rational Developer for System z PL/I for Windows: Language Reference |date=September 2012 |edition=Third |id=SC14-7285-02 |url=https://publibfp.dhe.ibm.com/epubs/pdf/ibm4lr02.pdf |access-date=July 9, 2023}}</ref>{{rp|pp.235– 274}}

===Storage type sharing===
There are several ways of accessing allocated storage through different data declarations. Some of these are well defined and safe, some can be used safely with careful programming, and some are inherently unsafe or machine dependent.<ref name=IBMLR43 />{{rp|pp.262–267,178–180}}

Passing a variable as an argument to a parameter by reference allows the argument's allocated storage to be referenced using the parameter. The {{tt|DEFINED}} attribute (e.g., <code>DCL A(10,10), B(2:9,2:9) DEFINED A</code>) allows part or all of a variable's storage to be used with a different, but consistent, declaration. The language definition includes a {{tt|CELL}} attribute (later renamed {{tt|UNION}}) to allow different definitions of data to share the same storage. This was not supported by many early IBM compilers. These usages are safe and machine independent.

Record I/O and list processing produce situations where the programmer needs to fit a declaration to the storage of the next record or item, before knowing what type of data structure it has. Based variables and pointers are key to such programs. The data structures must be designed appropriately, typically using fields in a data structure to encode information about its type and size. The fields can be held in the preceding structure or, with some constraints, in the current one. Where the encoding is in the preceding structure, the program needs to allocate a based variable with a declaration that matches the current item (using expressions for extents where needed). Where the type and size information are to be kept in the current structure ("self defining structures") the type-defining fields must be ahead of the type dependent items and in the same place in every version of the data structure. The {{tt|REFER}}-option is used for self-defining extents (e.g., string lengths as in <code>DCL 1 A BASED, 2 N BINARY, 2 B CHAR(LENGTH REFER A.N.)</code>, etc {{snd}} where {{tt|LENGTH}} is used to allocate instances of the data structure. For self-defining structures, any typing and {{tt|REFER}}ed fields are placed ahead of the "real" data. If the records in a data set, or the items in a list of data structures, are organised this way they can be handled safely in a machine independent way.

PL/I implementations do not (except for the PL/I Checkout compiler) keep track of the data structure used when storage is first allocated. Any {{tt|BASED}} declaration can be used with a pointer into the storage to access the storage{{snd}} inherently unsafe and machine dependent. However, this usage has become important for "pointer arithmetic" (typically adding a certain amount to a known address). This has been a contentious subject in computer science. In addition to the problem of wild references and buffer overruns, issues arise due to the alignment and length for data types used with particular machines and compilers. Many cases where pointer arithmetic might be needed involve finding a pointer to an element inside a larger data structure. The {{tt|ADDR}} function computes such pointers, safely and machine independently.

Pointer arithmetic may be accomplished by aliasing a binary variable with a pointer as in
<pre>DCL P POINTER, N FIXED BINARY(31) BASED(ADDR(P));
N=N+255;</pre>
It relies on pointers being the same length as <code>FIXED BINARY(31)</code> integers and aligned on the same boundaries.

With the prevalence of C and its free and easy attitude to pointer arithmetic, recent IBM PL/I compilers allow pointers to be used with the addition and subtraction operators to giving the simplest syntax (but compiler options can disallow these practices where safety and machine independence are paramount).

===ON-units and exception handling===
When PL/I was designed, programs only ran in batch mode, with no possible intervention from the programmer at a terminal. An exceptional condition such as division by zero would abort the program yielding only a hexadecimal core dump. PL/I exception handling, via {{tt|ON}}-units, allowed the program to stay in control in the face of hardware or operating system exceptions and to recover debugging information before closing down more gracefully. As a program became properly debugged, most of the exception handling could be removed or disabled: this level of control became less important when conversational execution became commonplace.

Computational exception handling is enabled and disabled by condition prefixes on statements, blocks (including {{tt|ON}}-units) and procedures. – e.g., <code>(SIZE, NOSUBSCRIPTRANGE): A(I)=B(I)*C; </code>. Operating system exceptions for Input/Output and storage management are always enabled.

The {{tt|ON}}-unit is a single statement or {{tt|BEGIN}}-block introduced by an {{tt|ON}}-statement. Executing the {{tt|ON}} statement enables the condition specified, e.g., <code>ON ZERODIVIDE ON</code>-unit. When the exception for this condition occurs and the condition is enabled, the {{tt|ON}}-unit for the condition is executed. {{tt|ON}}-units are inherited down the call chain. When a block, procedure or {{tt|ON}}-unit is activated, the {{tt|ON}}-units established by the invoking activation are inherited by the new activation. They may be over-ridden by another {{tt|ON}}-statement and can be reestablished by the {{tt|REVERT}}-statement. The exception can be simulated using the {{tt|SIGNAL}}-statement – e.g., to help debug the exception handlers. The dynamic inheritance principle for {{tt|ON}}-units allows a routine to handle the exceptions occurring within the subroutines it uses.

If no {{tt|ON}}-unit is in effect when a condition is raised a standard system action is taken (often this is to raise the {{tt|ERROR}} condition). The system action can be reestablished using the {{tt|SYSTEM}} option of the {{tt|ON}}-statement. With some conditions it is possible to complete executing an ON-unit and return to the point of interrupt (e.g., the {{tt|STRINGRANGE}}, {{tt|UNDERFLOW}}, {{tt|CONVERSION}}, {{tt|OVERFLOW}}, {{tt|AREA}}, and {{tt|FILE}} conditions) and resume normal execution. With other conditions such as <code>(SUBSCRIPTRANGE)</code>, the {{tt|ERROR}} condition is raised when this is attempted. An ON-unit may be terminated with a <code>GO TO</code> preventing a return to the point of interrupt, but permitting the program to continue execution elsewhere as determined by the programmer.

An {{tt|ON}}-unit needs to be designed to deal with exceptions that occur in the {{tt|ON}}-unit itself. The <code>ON ERROR SYSTEM;</code> statement allows a nested error trap; if an error occurs within an {{tt|ON}}-unit, control might pass to the operating system where a system dump might be produced, or, for some computational conditions, continue execution (as mentioned above).

The PL/I {{tt|RECORD}} I/O statements have relatively simple syntax as they do not offer options for the many situations from end-of-file to record transmission errors that can occur when a record is read or written. Instead, these complexities are handled in the {{tt|ON}}-units for the various file conditions. The same approach was adopted for {{tt|AREA}} sub-allocation and the {{tt|AREA}} condition.

The existence of exception handling {{tt|ON}}-units can have an effect on optimization, because variables can be inspected or altered in {{tt|ON}}-units. Values of variables that might otherwise be kept in registers between statements, may need to be returned to storage between statements. This is discussed in the section on Implementation Issues above.<ref name=IBMLR43 />{{rp|pp.249–376}}

===GO TO with a non-fixed target===
PL/I has counterparts for COBOL and FORTRAN's specialized GO TO statements.

Syntax for both COBOL and FORTRAN exist for coding two special two types of {{mono|GO TO}}, each of which has a target that is not always the same.
* {{tt|ALTER}} (COBOL), {{tt|ASSIGN}} (FORTRAN):
** {{code|ALTER paragraph_name_xxx TO PROCEED TO para_name_zzz|cobolfree}} (“altered go to”).<ref name=COB.IBM>{{cite web
 |url=https://www.ibm.com/support/knowledgecenter/en/SS6SG3_4.2.0/com.ibm.entcobol.doc_4.2/PGandLR/ref/rlpsalte.htm
 |title=ALTER statement|website=[[IBM]] |date=24 September 2021}}</ref>
**: There are other/helpful restrictions on these, especially "in programs ... {{tt|RECURSIVE}} attribute, in methods, or .. {{tt|THREAD}} option."<ref name=COB.IBM/>
** {{code|ASSIGN 1860 TO IGOTTAGO|fortran}} (“assigned go to”)<ref name=ONLY2THESE>{{cite web
 |url=https://docs.oracle.com/cd/E19957-01/805-4939/6j4m0vn9j/index.html
 |title=GO TO (Assigned)}}</ref><br />{{code|GO TO IGOTTAGO}}
**: One enhancement, which adds built-in documentation, is {{code|GO TO IGOTTAGO (1860, 1914, 1939)}}
**:: (which restricts the variable's value to "one of the labels in the list.")<ref name=ONLY2THESE/>
* {{tt|GO TO}} ... based on a variable's subscript-like value.
** {{code|GO TO (1914, 1939, 2140), MYCHOICE}} (“computed go to”)<ref>{{cite web
 |url=https://docs.oracle.com/cd/E19957-01/805-4939/6j4m0vn9l/index.html
 |title=GO TO (Computed)}}</ref>
** {{code|GO TO para_One para_Two para_Three DEPENDING ON IDECIDE|cobol}} (“go to depending on”).<ref>{{cite web
 |url=https://www.tutorialride.com/cobol/go-to-statement-in-cobol.htm
 |title=GO TO Statement in COBOL}}</ref>

PL/I has statement label variables (with the {{tt|LABEL}} attribute), which can store the value of a statement label, and later be used in a {{tt|GOTO}} statement.<ref>{{cite book
 |title=Digital Research PL/I Language Programmer's Guide
 |page=103}}</ref><ref name="gc33-0009-4"/>{{rp|54}}<ref name="gc33-0009-4"/>{{rp|23}}
<pre>
LABL1: ....
.
.
LABL2: ...
.
.
.
MY_DEST = LABL1;
.
GO TO MY_DEST;
</pre>

The programmer can also create an array of static label constants by subscripting the statement labels.
 GO TO HERE(LUCKY_NUMBER); /* minus 1, zero, or ... */

 HERE(-1): PUT LIST ("I O U"); GO TO Lottery;
 HERE(0): PUT LIST ("No Cash"); GO TO Lottery;
 HERE(1): PUT LIST ("Dollar Bill"); GO TO Lottery;
 HERE(2): PUT LIST ("TWO DOLLARS"); GO TO Lottery;

Statement label variables can be passed to called procedures, and used to return to a different statement in the calling routine.

==Sample programs==

===Hello world program===
<syntaxhighlight lang="rexx">
Hello2: proc options(main);
     put list ('Hello, World!');
end Hello2;
</syntaxhighlight>

===Search for a string===
<syntaxhighlight lang="rexx">
/* Read in a line, which contains a string,
/* and then print every subsequent line that contains that string. */

find_strings: procedure options (main);
   declare pattern character (100) varying;
   declare line character (100) varying;
   declare line_no fixed binary;

   on endfile (sysin) stop;

   get edit (pattern) (L);
   line_no = 1;
   do forever;
      get edit (line) (L);
      if index(line, pattern) > 0 then
         put skip list (line_no, line);
      line_no = line_no + 1;
   end;

end find_strings;
</syntaxhighlight>

==See also==
{{Portal|Computer programming}}

* [[List of programming languages]]
* [[Timeline of programming languages]]

==Notes==
{{Reflist|30em}}

==References==

===Textbooks===
* {{cite book
 |last1=Neuhold
 |first1=E.J.
 |last2=Lawson
 |first2=H.W.
 |year=1971
 |title=The PL/I Machine: An Introduction to Programming
 |publisher=Addison-wesley
 |isbn=978-0-2010-5275-6}}
* {{cite book
 |last1=Barnes
 |first1=R.A.
 |year=1979
 |title=PL/I for Programmers
 |publisher=North-Holland
 }}
* {{cite book
 |last1=Hughes
 |first1=Joan K.
 |year=1973
 |title=PL/I Programming
 |edition=1st
 |publisher=Wiley
 |isbn=0-471-42032-8
 }}
* {{cite book
 |last1=Hughes
 |first1=Joan K.
 |year=1986
 |title=PL/I Structured Programming
 |edition=3rd
 |publisher=Wiley
 |isbn=0-471-83746-6
 }}
* {{cite book
 |last1=Groner
 |first1=G.F.
 |year=1971
 |title=PL/I Programming in Technological Applications
 |publisher=Books on Demand, Ann Arbor, MI
 }}
* {{cite book
 |last1=Anderson
 |first1=M.E.
 |year=1973
 |title=PL/I for Programmers
 |publisher=Prentice-Hall
 }}
* {{cite book
 |last1=Stoutemyer
 |first1=D.R.
 |year=1971
 |title=PL/I Programming for Engineering & Science
 |publisher=Prentice-Hall
 }}
* {{cite book
 |last1=Ziegler
 |first1=R.R. & C.
 |year=1986
 |title=PL/I: Structured Programming and Problem Solving
 |edition=1st
 |publisher=West
 |isbn=978-0-314-93915-9}}
* {{cite book
 |last1=Sturm
 |first1=E.
 |year=2009
 |title=The New PL/I ... for PC, Workstation and Mainframe
 |publisher=Vieweg-Teubner, Wiesbaden, Germany
 |isbn=978-3-8348-0726-7}}
* {{cite book
 |last1=Vowels
 |first1=R.A.
 |year=1997
 |title=Introduction to PL/I, Algorithms, and Structured Programming |edition=3rd
 |isbn=978-0-9596384-9-3
 |publisher=R.A. Vowels
}}
* {{cite book
 |last1=Abrahams
 |first1=Paul
 |year=1979
 |title=The PL/I Programming Language
 |publisher=Courant Mathematics and Computing Laboratory, New York University
 |url=http://www.iron-spring.com/abrahams.pdf
}}

===Standards===
* [[American National Standards Institute|ANSI]] X3.53-1976 (R1998) ''Information Systems - Programming Language - PL/I''
* ANSI ANSI X3.74-1981 (R1998) ''Information Systems - Programming Language - PL/I General-Purpose Subset''
* ANSI ANSI X3.74-1987 (R1998) ''Information Systems - Programming Language - PL/I General-Purpose Subset''
* [[Ecma International|ECMA]] 50 ''Programming Language PL/I'', 1st edition, December 1976
* [[International Organization for Standardization|ISO]] 6160:1979 ''Programming languages—PL/I''
* ISO/IEC 6522:1992 ''Information technology: Programming languages: PL/I general purpose subset''

===Reference manuals===
* Burroughs Corporation, "B 6700 / B 7700 PL/I Language Reference", 5001530. Detroit, 1977.
* CDC. R. A. Vowels, "PL/I for CDC Cyber". Optimizing compiler for the CDC Cyber 70 series.
* Digital Equipment Corporation, [http://bitsavers.org/pdf/dec/pdp10/TOPS10_softwareNotebooks/vol10/DEC-10-LCPLA-B-D_Conversational_Programming_Language_Users_Manual_Mar76.pdf "decsystem10 Conversational Programming Language User's Manual"], DEC-10-LCPUA-A-D. Maynard, 1975.
* Fujitsu Ltd, "Facom OS IV PL/I Reference Manual", 70SP5402E-1,1974. 579 pages. PL/I F subset.
* Honeywell, Inc., [http://www.bitsavers.org/pdf/honeywell/large_systems/multics/AG94-02_PLI_langSpec_Mar81.pdf "Multics PL/I Language Specification"], AG94-02. 1981.  
* IBM, [http://www.bitsavers.org/pdf/ibm/360/pli/C28-6571-1_PL_I_Language_Specifications_Jul65.pdf IBM Operating System/360 PL/I: Language Specifications], C28-6571. 1965.
* IBM, [http://www.bitsavers.org/pdf/ibm/360/pli/GC33-0009-4_PLI_Checkout_And_Opt_Compiler_Lang_Ref_Oct76.pdf OS PL/I Checkout and Optimizing Compilers: Language Reference Manual], GC33-0009. 1976.
* IBM, [http://bitsavers.org/pdf/ibm/npl/320-0908_NPL_Technical_Report_Dec64.pdf IBM, "NPL Technical Report"], December 1964.
* IBM, [http://publibfp.boulder.ibm.com/epubs/pdf/ibm4lr00.pdf Enterprise PL/I for z/OS Version 4 Release 1 Language Reference Manual] {{Webarchive|url=https://web.archive.org/web/20200728071742/http://publibfp.boulder.ibm.com/epubs/pdf/ibm4lr00.pdf |date=2020-07-28}}, SC14-7285-00. 2010.
* IBM, OS/2 PL/I Version 2: Programming: Language Reference, 3rd Ed., Form SC26-4308, San Jose. 1994.
* [https://www.kednos.com/pli/docs/reference_manual/6291pro.html Kednos PL/I for OpenVMS Systems. Reference Manual] {{Webarchive|url=https://web.archive.org/web/20040304150758/https://www.kednos.com/pli/docs/reference_manual/6291pro.html |date=2004-03-04}}, AA-H952E-TM. Nov 2003. 
* Liant Software Corporation (1994), Open PL/I Language Reference Manual, Rev. Ed., Framingham (Mass.).
* Nixdorf Computer, "Terminalsystem 8820 Systemtechnischer Teil PL/I-Subset",05001.17.8.93-01, 1976.
* Ing. C. Olivetti, "Mini PL/I Reference Manual", 1975, No. 3970530 V
* Q1 Corporation, "The Q1/LMC Systems Software Manual", Farmingdale, 1978.

==External links==
{{Wikibooks}}
* [https://www.ibm.com/us-en/marketplace/ibm-pli-compiler-family IBM PL/I Compilers] for [[z/OS]], [[AIX]], [[MVS]], [[VM (operating system)|VM]] and [[VSE (operating system)|VSE]]
* [http://www.iron-spring.com/ Iron Spring Software], PL/I for [[Linux]] and [[OS/2]]
* [http://www.microfocus.com/plus/pli/index.aspx Micro Focus' Mainframe PL/I Migration Solution]
* [http://www.cs.vu.nl/grammars/browsable/os-pli-v2r3/ OS PL/I V2R3 grammar Version 0.1]
* [http://pliedit.com/ Pliedit], PL/I editor for Eclipse
* [https://www.uni-muenster.de/ZIV.EberhardSturm/PL1andC.html Power vs. Adventure - PL/I and C], a side-by-side comparison of PL/I and [[C (programming language)|C]].
* [http://www.softpanorama.org/Lang/pl1.shtml Softpanorama PL/1] page] [sic "PL/1"] 
* [http://teampli.net The PL/I Language] 
* [http://pl1gcc.sourceforge.net PL1GCC project in SourceForge]
* [https://archive.org/details/print-signs/mode/2up PL/I software to print signs], source code in book form, by David Sligar (1977), for IBM PL/I F compiler.
* {{GitHub|Steadsoft/PLI-2000}}, Open-source Windows NT PL/I compiler
{{Portal bar|Computer programming}}
{{Authority control}}

{{DEFAULTSORT:Pl I}}
[[Category:Procedural programming languages]]
[[Category:PL/I programming language family]]
[[Category:Structured programming languages]]
[[Category:Concurrent programming languages]]
[[Category:Systems programming languages]]
[[Category:IBM software]]
[[Category:Programming languages created in 1964]]
[[Category:Programming languages with an ISO standard]]