Softpanorama
May the source be with you, but remember the KISS principle ;-)

Contents Bulletin Scripting in shell and Perl Network troubleshooting History Humor

PL/1 Programming Language

the Cobol replacement  that never materialized

News See also Recommended Links Books Articles Sample Programs
REXX C Perl Structured programming as a religious cult Program proofs pseudoscience A Slightly Skeptical View on the Object-Oriented Programming
PL/C PL/M Multics History Humor Etc

Introduction

PL/1 is an important language with two extremely high quality compliers created by IBM.  Unfortunately it suffered tragic, undeserved destiny and is almost forgotten today.  It should have been the Cobol replacement, but never managed to perform this role with the exception of USSR and Eastern block countries. Like any innovative technology it suffered severe blows from IBM mis-marketing (IBM did a tremendous job in development of the language and compilers, but excessive greed doomed those efforts). IBM should have made debugging compiler free and charge money only for optimizing complier.  Another helpful move would be releasing of old F-complier as a public domain product.

Until PL/1 was developed, all previous languages had focused on one particular area of application, such as numerical computations, artificial intelligence, or business. PL/1 was the first designed as universal language and that was a tremendous breakthrough. It was the first successful attempt to design a language that could be used in a variety of application areas.  Again, in many areas it was far advanced for its time (it is a higher level language then C that was created  a decade later based on its creator  experience with usage of PL/1 in Multics) and that hurt the adoption. Another factor that contributed to PL/1 demise was absence of free high quality compilers. We well as  complexity of compilers as such. Commercial compilers were pretty expensive. In Eastern Europe they were supplied as part of the standard OS distribution for mainframes. That contributed to tremendous success of PL/1 in this region and suggests that if IBM provided PL/1 compilers for free the language might be tremendously more successful that it was in the USA.

The language also suffered from misguided or plain vanilla stupid "gurus" of programming language community such as "father of structured programming". It became a favorite target of misguided criticism from "purists" in language design. Niklaus Wirth and Edgar Dijkstra were particularly influential and particularly misguided; Edgar Dijkstra despite his early achievements was especially damaging with his misguided religious fervor toward program proofs and as a creator the first CS cult which perverted computer science for a decade or more...

The main reason of failure was that fact that it was probably 20 years ahead of its time and compilers were way too complex which depressed portability. Especially toxic for complier writers were  "no reserved keywords" feature and excessive syntax flexibility of Declare statement. Still it is important to understand that this was  very innovative language with very innovative compilers.

As a very innovative language that was in may respects too far ahead of its time to survive. It was the first language that contained decent string handling, pointers, three types of allocation of storage -- static, automatic (stack-based) and controlled (heap-based), exception handling, rudimentary multitasking.  It was and probably still is one of the most complex and interesting algorithmic languages in existence, although it's popularity by-and-large disappeared ( similar to popularity of many other interesting IBM products with VM/CMS and OS/2).

Such feature as exception handling, was so well integrated into the language that it was really used on day to day basis by most programmers. 

Pl/1 also has good string handling capabilities, although the implementation decision used in IBM compilers to prefix string with its length was a kind of premature optimization.

While language is almost dead PL/1 features live in many other languages and first on all in C, which semantically can be considered as a direct derivative (limited subset) of PL/1.

Now both books and compilers on PL/1 became rarity, although IBM optimizing and debugging compilers on system 360/370 remain an unsurpassed masterpiece of software engineering. But I would like to stress that PL/1 (as a system programming language for Multics) has large influence on C -- one of the most widely used compiled programming languages and many of it's ideas directly or indirectly found its way into other programming languages (I have no information about Larry Wall possible exposure to PL/1) can be found in Perl. IMHO he demonstrated some understanding if not PL/1 structure and semantic, but PL/1 philosophy: at some point simplicity becomes self-defeating and paradoxically complex non-orthogonal languages become simpler to use that "extensions" of a simpler language. Despite complexity they are better integrated and errors are better diagnosed as compiler recognized those structures and features as language elements and is able to perform some static checks.

This PL/1 idea is a close relative of Perl philosophy  which is some way was counter reaction of Unix pushing simplicity way too far and defeating it this way. The key question that should be asked is: What is so simple in a hundred or so "simple" Unix utilities ? Just the number of them and difference in approaches in naming and handling parameters (without iron fist of corporate standard like in Microsoft GUI interfaces) made them a mess. In this sense complexity can benefit programming community much more simplicity if the latter means simple language with a maze of libraries/classes, etc. Also PL/1 is free from any religious doctrines and this make it a welcome member of programming languages family unlike all those strongly type languages or crappy, "promise much deliver little" OO languages like Java ;-). True believers in OO should probably stop reading this page at this point ;-).

History of development

PL/1 was developed as an IBM product in the mid 1960's, and was originally named NPL (New Programming Language). The name was changed to PL/1 to avoid confusion of acronym NPL with the National Physical Laboratory in England. Here is relevant quote form Wikipedia:

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[10]. Control of the PL/I language[11] was vested initially in the New York Programming Center and later at the IBM UK Laboratory at Hursley. The SHARE and 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 language was first specified in detail in the manual “PL/I Language Specifications. C28-6571” written in New York from 1965 and superseded by “PL/I Language Specifications. GY33-6003” written in Hursley from 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.

The first PL/1 compiler that was shipped with OS/360 was so called F-compiler. In was slow multipass compiler that was designed to operate with tiny memory amount of memory (64K) that was available in first mainframes.

Attacks from "structured programming" and verification fanatics

The fits significant blow to PL/1 was from made in early 70th by religious fanatics connected to "structured programming" dogma and, especially, "verification frenzy". The latter was mostly related to bogus mathematic masturbation called "correctness proofs". The idea was "simple, attractive and wrong" and due to this it soon became more fashionable that drunks fights in pubs in England. It attracted huge amount of verification snake oil salesmen and "computer science crooks" who often flooded computer science departments and eliminated useful research.  While there was a positive component if structured programming movement (it  did helped to introduce richer set of programming control structured in the language and PL/1 was again pioneer in this area) but most affects were creation of some unrealistic expectations (that number of errors in a program without goto statements is less then for the program with many goto statements; but in reality if not presence of absence of goto statements, but the usage of structured control statements that matter and if some are not available in the language they should be emulated using goto statements) or simply harmful.

Edsger W. Dijkstra played the role of a fervent Ayatollah. This controversial character has the religious zeal of Luther, but was more misguided.  At the height of his delusion Ayatollah Dijkstra  completely lost common sense and  issued a fatwa in which he declared PL/1 to be a "fatal disease". Those spikes of  religious fervor damaged the language standing and helped more primitive languages with much simpler compilers such as Pascal and C to get ground Another advantage of Pascal was that it has freely available complier and was specifically designed to make complier reasonably fast and simple which probably was the only innovative feature of the language.  c-compiler was also much simpler then complier for equipment subset of PL/1. Creators of C discarded no reserved keywords idea   and greatly simplified the declaration of variables syntax.

Later object orientation became fashionable with its own crowd of snake oil salesmen.  Each of those splashes generated huge crowd of crooks and religious fanatics, as well as promoted corruption in computer science departments. As for computer science departments, the level of corruption was pretty close to corruption of economic professions with its bunch of highly paid intellectual prostit3utes masquerading as professors.   

 

IBM wiped the floor with completion due to quality of PL/1 optimizing and debugging compilers

Brilliance of IBM design team and technical vision was demonstrated not only in the language, but even more so in the design of  compilers for the language. Even the first PL/1 compiler (F-compiler) simply wiped the floor with the competition:

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.[18] Release 1 shipped in 1966. OS/360 was a real-memory environment and the compiler was designed for systems with as little as 64kBytes of real storage – F being 64k in S/360 parlance. To fit a large compiler into the 44kByte memory allowed on a 64kByte machine, the compiler consisted of a control phase and a large number of compiler phases (approaching 100). The phases were brought into memory from disk, and released, one at a time to handle particular language features and aspects of compilation.

The level of diagnostics was good although not perfect. A smaller subset of PL/1 was implemented in DOS/360 PL/I D-compiler which was developed at IBM Germany:

The PL/I D compiler, using 16 kilobytes of memory, was developed by IBM Germany for the DOS/360 low end operating system. It implemented 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 lacked dynamic storage allocation and the controlled storage class.[21] It was shipped within a year of PL/I F.

But the real breakthrough and the real masterpieces of software engineering were IBM PL/I optimizing and checkout compilers. They are still unsurpassed pair of compilers for a very complex language despite being 40 years old.

The PL/I Optimizer and Checkout compilers produced in Hursley supported a common level of PL/I language[24] and aimed to replace the PL/I F compiler. The checkout compiler was a rewrite of PL/I F in BSL, IBM's PL/I-like proprietary implementation language (later PL/S).[18] The performance objectives set for the compilers are shown in an IBM presentation to the BCS.[25] The compilers had to produce identical results - the Checkout Compiler was 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.

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 was a multiple pass compiler with a 44kByte design point, but it was an entirely new design. Unlike the F compiler it had 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. 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 the IBM S/370 in 1970, it shipped first for the DOS/360 operating system in Aug 1971, and shortly afterward for OS/360, 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 28kB 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 PCMs.

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

The PL/I checkout compiler,[26][27] (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 was run from an interactive terminal, converting PL/I programs into an internal format, “H-text”. This format was interpreted by the Checkout compiler at run-time, detecting virtually all types of errors. Pointers were 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 was detected, control was passed to the user who could 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?)

IBM did a tremendous job in developing PL/1 and, especially, PL/1 compilers. This was a good, old IBM with strong engineering core, before the current wave of outsourcing destroyed the company engineering culture.

What is interesting that despite their age PL/1 optimizing and debugging compilers for OS/360 and 370 are probably the best compliers for any language of similar complexity in existence despite being 40 years old. The real masterpieces of software engineering...  Incredible achievement of IBM engineering talent.  Like System 360 hardware and assembler language they stood as monuments to "good old IBM".

Despite their age PL/1 optimizing and debugging compilers for OS/360 and 370 are probably the best compliers for any language of similar complexity in existence despite being 40 years old. The real masterpieces of software engineering...  Incredible achievement of IBM engineering talent.  Like System 360 hardware and assembler language they stood as monuments to "good old IBM".

Three compilers for PL/1 (IBM debugging and optimizing compiler) and PL/C form Cornell were of such high quality that even today they are heads above average compiler in many respects including quality of diagnostic (I do not thing any other compiler manager even to get even with the quality of diagnostics of IBM debugging compiler and PL/C) and code generation. 

PL/1 as system development language in Multics

Multics (Multiplexed Information and Computing Service) is a mainframe timesharing operating system which was designed around 1965 and used until 2000. It was often called Multix, which is formally incorrect but a shorter name.  Although Multics was much derided at the time by its critics, history has shown that it was a real pioneer on OS design which introduced concepts now taken for granted.

Many ideas implemented in Multics were 30-40 years ahead of their time. Ideas “discarded” in Unix were eventually added back (e.g., dynamic linking,  doors were reintroduced in Solaris a few years back.)

Key ideas (see multix ) were extremely difficult to implement on primitive hardware that existed at mid 60th, so the fact that they materialized is nothing but amazing.   Multics began as a research project and was an important influence on operating system development. It also pioneered the use of high-level languages for writing operating systems.  It also was one of the first OS which paid serious attention o the security. As Professor Wilkes noted   (iee90):

There has been some discussion of ways in which the operating system might be structured so as to facilitate, and make more systematic, the task of the inspector. One suggestion has been to restrict to an absolute minimum the amount of information that the running process can access at any given moment. This is expressed by saying that the domain of protection in which the process runs is small. Unfortunately, if everything is done in software, the frequent change of domain which this approach makes necessary leads to unacceptable loss of performance. Attention was accordingly directed to providing hardware support for domain switching.

An early suggestion, implemented in MULTICS, was to have rings of protection. The amount of information available to a process decreased as it moved from the inner to the outer rings. Unfortunately, the hierarchical model of protection which this implied is fundamentally flawed, and it was found that rings of protection were little improvement if any on the simple system of a privileged and an unprivileged mode.

PL/1 was used as system programming language, and proved to be up to the task. due to this role it served as a prototype of a simplified dialect that became C, which was used for writing Unix OS. Unfortunately many key ideas such as exceptions handing, built-in strings, etc were dropped. Later they were  "reinvented" on C++ and Java many years after they were introduced in PL/1. 

Multics also was a pioneer in computer security, being essentially an opposite of Unix.  Many of security innovations in  Multics find its way in Unix only 30 years later.  Here is how Wikipedia  described the situation that existed in early 60th.

In the early 60s, IBM was struggling to define its technical direction. The company had identified a problem with its past computer offerings: incompatibility between the many IBM products and product lines. Each new product family, and each new generation of technology, forced customers to wrestle with an entirely new set of technical specifications. IBM products incorporated a wide variety of processor designs, memory architectures, instruction sets, input/output strategies, etc. (This was not, of course, unique to IBM. All computer vendors seemed to begin each new system with a "clean sheet" design.) IBM saw this as both a problem and an opportunity. The cost of software migration was an increasing barrier to hardware sales. Customers could not afford to upgrade their computers, and IBM wanted to change this.

IBM embarked on a very risky undertaking: the System/360. This product line was intended to replace IBM's diverse earlier offerings, including the IBM 7000 series, the (canceled) IBM 8000 series, the IBM 1130 series, and various other specialized machines used for scientific and other applications. The System/360 would span an unprecedented range of processing power, memory size, device support, and cost; and more important, it was based on a pledge of backward compatibility, such that any customer could move software to a new system without modification. In today's world of standard interfaces and portable systems, this may not seem such a radical goal; but at the time, it was revolutionary. Before the System/360, each computer model often had its own specific devices that could not be used with other systems. Buying a bigger CPU also meant buying new printers, card readers, tape drives, etc. With the S/360, IBM wanted to offer a huge range of computer systems, all sharing a single processor architecture, instruction set, I/O interface, and operating system. Customers would be able to "mix and match" to meet current needs; and they could confidently upgrade their systems in the future, without the need to rewrite all their software applications. IBM's focus remained on its traditional customer base: large organizations doing administrative and business data processing.

At the start of System/360 project, IBM did not fully appreciate the amount of risk involved. The System/360 ultimately gave IBM total dominance over the computer industry; but first, it nearly put IBM out of business. IBM took on one of the largest and most ambitious engineering projects in history, and in the process discovered diseconomies of scale and the mythical man-month. Extensive literature on the period, such as that by Fred Brooks, illustrate the pitfalls.

It was during the period of System/360 panic that Project MAC asked IBM to provide computers with extensive time-sharing capabilities. This was not the direction the System/360 project was going. Time-sharing wasn't seen as important to IBM's main customer base; batch processing was key. Moreover, time-sharing was new ground. Many of the concepts involved, such as virtual memory, remained unproven. (For example: At the time, nobody could explain why the troubled Manchester/Ferranti Atlas virtual memory "didn't work"[2]. This was later explained as due to thrashing, based on CP/CMS and M44/44X research.) As a result, IBM's System/360 announcement in April 1964 did not include key elements sought by the time-sharing advocates, particularly virtual memory capabilities. Project MAC researchers were crushed and angered by this decision. The System/360 design team met with Project MAC researchers, and listened to their objections; but IBM chose another path.

In February 1964, at the height of these events, IBM had launched its Cambridge Scientific Center (CSC), headed by Norm Rassmussen. CSC was to serve as the link between MIT researchers and the IBM labs, and was located in the same building with Project MAC. IBM fully expected to win the Project MAC competition, and to retain its perceived lead in scientific computing and time-sharing.

One of CSC's first projects was to submit IBM's Project MAC proposal. IBM had received intelligence that MIT was leaning toward the GE proposal, which was for a modified 600-series computer with virtual memory hardware and other enhancements; this would eventually become the GE 645. IBM proposed a modified S/360 that would include a virtual memory device called the "Blaauw Box" – a component that had been designed for, but not included in, the S/360. The MIT team rejected IBM's proposal. The S/360-67 was seen as too different from the rest of the S/360 line; MIT did not want to use a customized or special-purpose computer for Multics, but sought hardware that would be widely available. GE was prepared to make a large commitment to time-sharing, while IBM was seen as obstructive. Bell Laboratories, another important IBM customer, soon made the same decision, and rejected the S/360 for time-sharing.

Ken Thompson was one of about 25 members of the Bell Labs Technical Staff who worked on Multics in 1965-1969.  He got many key ideas from the system and PL/1 language in which it was written as well as the spirit of free development environment with free sharing of ideas that was created by Fernando Corbato and that  later became an important factor in Unix success.  As Corbato noted in his Turing lecture:

The UNIX system [12] was a reaction to Multics. Even the name was a joke. Ken Thompson was part of the Bell Laboratories' Multics effort, and, frustrated with the attempts to bring a large system development under control, decided to start over. His strategy was clear. Start small and build up the ideas one by one as he saw how to implement them well. As we all know, UNIX has evolved and become immensely successful as the system of choice for workstations. Still there are aspects of Multics that have never been replicated in UNIX.

 

PL/1 as USSR Cobol

Paradoxically, PL/1 played a role of freeware at least in one country ;-). And in this environment it quickly became the dominant programming language on mainframes in the USSR, far outpacing Cobol and Fortran that still dominated the mainframe arena in the USA and other Western countries. So here analogy with Perl hold perfectly. PL/1 dominated despite the fact the Soviet IBM 360/370 clones (called EC -- Russian abbreviation of "Uniform System of Computers") were much less powerful (and far less reliable) that Western counterparts.

Cornell PL/C compiler

PL/C was a brilliant implementation of subset of PL/1 for teaching purposes at Cornell University 

It was written in early 1970s and has diagnostic capabilities that were comparative with the capabilities of IBM Pl/1 complier, beating it in some areas. The PL/C compiler 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.

Cornell also developed a compiler for the language that was based on its earlier CUPL compiler, and it was widely used in college-level programming courses. The two researchers and academic teachers who designed PL/C were Richard W. Conway and Thomas R. Wilcox.

They submitted the famous article "Design and implementation of a diagnostic compiler for PL/I" published in the Communications of ACM in March 1973, pages 169-179.

PL/C eliminated some of the more complex features of PL/I, and added extensive debugging and error recovery facilities. PL/C is a subset of PL/I. A program that runs without error under the PL/C compiler should run under IBM PL/I compiler and produce the same results, unless certain incompatible diagnostic features were used.

Shot lived renaissance in CP/M world

When personal computers start their triumphal conquest of the world, PL/1 enjoyed a short lived renaissance due to valiant efforts of Gary Kindal. PL/M was a subset of PL/1 very similar to IBM DOS compiler subset that gained popularity in CP/M world.  But as CP/M was overtaken by PC DOS/MS DOS, PL/M have had fallen into sidelines too. Both Turbo Pascal and C had eaten PL/M lunch mainly due to availability of cheaper compilers and  in case of Turbo Pascal an innovative IDE (which actually was reimplemented for C in a form of Turbo C too -- giving C the same huge edge as Pascal). Here again the complexity (and the costs of ) compilers were huge negative factor. Here is additional info from Wikipedia:

  • In 1972 Gary Kildall implemented a subset "PL/M" for Intel. PL/M was used to write the CP/M operating system proper - and much application software running on CP/M and MP/M. Digital Research sold a PL/I compiler[43] for the Personal Computer written in PL/M. PL/M was used to write much other software at Intel for the 8080, 8085, and Z-80 processors during the 1970s.
  • PL/M-86 was a version of the PL/M language for the 8086 and 8088 microprocessor. It was heavily used by Daisy Systems for electronic design automation software on the "Logician" family of special-purpose workstations.
  • Micro Focus implemented Open PL/I[44] for Windows and UNIX/Linux systems, which they acquired from Liant.

 

Port to OS/2 and premature death

Later PL/1 was ported to OS/2 in 1992. Here is how this event was described in Wikipedia

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.[36] Subsequent releases covered additional platforms (MVS, VM, OS/390, AIX and Windows)[37] and continued to add functions to make PL/I fully competitive with other languages offered on the PC (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 object-oriented programming – the DEFINE ALIAS, ORDINAL, and DEFINE STRUCTURE statement to introduce user-defined types, the HANDLE locator data type, the TYPE data type itself, the UNION data type, and built-in functions for manipulating the new types.
  • Additional data types and attributes corresponding to common PC data types (e.g. UNSIGNED, VARYINGZ).
  • Improvements in readability of programs – often rendering implied usages explicit (e.g. BYVALUE 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

This port was died with OS/2. IBM port to AIX of OS/2 PL/1 compiler was the last in this line of PL/1 compiler development and I think that IBM still sells it.   There was also a much later port from Iron Spring for OS/2 and later Linux which was introduced in 2007.

Difficulties of writing compiler from a full language

To write a decent compiler for PL/1 was not easy. Along with natural complexity of the language there were couple of features that unnecessary complicated the creation of compiler:

Due to those shortcomings and the compete absence of high quality portable open source  compilers PL/1 popularity suffered greatly. 

Complex non-orthogonal programming language rarely became hugely popular.  Popularity is reserved for simplistic, dumb-down languages. Cobol, Basic, Pascal and Java popularity are primary examples here. All of them are dull uninventive languages designed for novices (with Pascal explicitly designed as for teaching programming at universities).  PL/1 was the first complex non-orthogonal language that managed to achieve world wide popularity.

Language Features

Historically PL/1 was a very elegant and innovative blend of Fortran, Cobol and  Algol-60 in one language (It also introduced  three major innovations in programming languages design:

Both of those features were far ahead of time and complicated the complier. That was especially true of exceptions which are essentially a frozen coroutines which can be activated in the context that is different from the context of the procedure in which they are contained. As such need allocation of memory on heap.

I would mentions the following significant language features:

Exceptions in PL/1

PL/1 was the first mainstream language that introduced exceptions. It is interesting to note that half of extensions of C++ including exceptions was related to features that creators of C removed from PL/1 when they created the language :-).

It is interesting to note that PL/1 was the first programming language that provides correct handing of such a common problem as detection of the end of the sequential file while reading. In PL/1 endfile condition is raised which activates stopped coroutine (exception handler) within which  programmer can do whatever he wish but typically jump to the statement after the loop. This usage of goto is definitely superior to misguided attempts to make this test in the header of the loop like was done in C and Perl.

  ON ENDFILE (SYSIN) GOTO EOF_SYSIN; 
 
  OPEN FILE (SYSIN) RECORD SEQUENTIAL; 
  READ FILE (SYSIN) INTO (RECORD); 
  DO WHILE (TRUE); 
      . 
      . 
      . 
    READ FILE (SYSIN) INTO (RECORD); 
  END; 
EOF_SYSIN:
   ... ... ...

It is important to note that PL/1 was used as a system programming language for such an important operating system as  Multics -- the originator of many ideas that later were reimplemented in Unix.  In partially bastardized way, key ideas and most of PL/1 semantics can be found in C which should probably be considered to be an indirect derivative and great simplification of PL/1 core.

A good free guides to PL/1 is available from IBM:

Almost free old books devoted to PL/1 are still available on Amazon with average price of $1 or so. For example

Paradoxically PL/1 was never a success in the USA. In Europe PL/1 was used extensively in both business and scientific applications. In Eastern Europe on mainframes PL/1 decimated Cobol as the language of choice for writing business applications. 

However, it's popularity has drastically declined with the introduction of personal computers. For some reason C (which for many programming tasks is inferiors to PL/1) and Pascal (which was in comparison with PL/1 a toy language) became more popular. That might be connected with the absence of low cost compilers for PL/1 although its dialect PL/M enjoyed some popularity before being displaced with C.

One reason for this situation might be that programming in complex, non-orthogonal languages like PL/1 requires higher level of abilities  and higher level of sophistication (as in such languages there are several ways of accomplishing a task) then in simpler languages and that this limitation of human abilities gave simpler languages tremendous boost. 

In scripting languages PL/1 influence can be found in REXX and Perl, especially in the latter. Perl is another complex non-orthogonal language which like PL/1 played tremendous innovative role but later was superseded by various derivatives more simpler derivatives like PHP Python and Ruby; two of the latter also tried to milk OO fashion...

These are still a few companies were PL/1 is widely used (almost exclusively on mainframes). Among them is Ford. 

Program structure

Good comparison of PL/1 and C is provided in Power vs. Adventure - PL-I and C.

A good info of file handling in PL/1 can be found at File handling in PL-1 « mainframegeek

Slides describing PL/1 structure are available from Sanjay Sinha ( pl-1)

Although this is a typical IBM style that are some useful IBM documents too:

Sample Programs

Level of diagnostic of Checkout complier was nothing but amazing. To understand the level of this achievement you need to use it.

Problem with free/open source compilers availability remains

The key problems with PL/1 were always availability of high quality free or reasonably cheap compilers. Even now this problem is not solved. Here are some options (see PL-I Frequently Asked Questions (FAQ)  for more up-to-date infor about PL/1 compilers available):

See also PL-I Frequently Asked Questions (FAQ)


Top updates

Bulletin Latest Past week Past month
Google Search


NEWS CONTENTS

Old News ;-)

Of PL-I, Line Printers, Punch Cards, and Carriage Control Jeff Barr's Blog

...I learned Fortran IV in my first semester. Around the same time I started my first programming job, at a small Bethesda company called Moshman Associates. My first task there was to write a macro assembler for the 6502 microprocessor. I wrote a Fortran simulation of the hashing algorithm that we had planned to use for instructions and labels, found that it had an excessively high number of collisions, and was given a nice raise for my trouble.

In my second semester I took a class in PL/I programming. Designed by IBM, PL/I was a clean, structured, and relatively complex language. The compiler had many, many options for optimization and for diagnostic output. I spent a lot of time experimenting with the options and carefully inspecting the resulting printouts in an attempt to write the most efficient code possible.

I need to explain how we would write and run our code at that time. We didn’t have our own PCs and we didn’t have terminals to log in to a time-sharing system. Instead, we would use an IBM 029 card punch to punch each line of code into a punched card. The 029 was a complex mechanical device, with noises, rhythms, and so forth. The cards were assembled into a deck, preceded by some job control language (JCL) statements which provided a name for the job and instructed the computer how to set up input and out devices and how to compile and run the code. Small decks could be rubber-banded together for safekeeping; larger decks (usually for COBOL programs) were best kept in the cardboard boxes that originally held the blank, unpunched cards.

Once the deck was ready, I would walk up the hall to the job submission window, hand it in to the woman behind the counter, and she would stack it up in the card reader for eventual processing. At crunch times there would be line of students and a big pile of unprocessed jobs.

When it was my deck’s turn to be run, she would load it into the card reader, the computer would read and process the cards, and print the results on a very fast IBM printer. The attendant would take the printout, wrap it around the cards, and file it away until I came back to the window to collect the results.

On a good day the turnaround time would be about 3 to 4 hours. At crunch time it might take slightly longer. If all went well the printout would include two sections — the evidence of a successful compilation, and the results of actually running the program. I quickly learned to be careful with my code and with my algorithms, so that my code would compile and run after just a few iterations. Others were not so fortunate, and would spend many hours waiting for their results, only to find that they’d misplaced some punctuation, forgotten to declare a variable, or made an algorithmic mistake. I remember one of my fellow students “bragging” that “I am getting pretty good at this, it only took me 30 tries to get it to compile.”

I remember taking away a couple of things from these early experiences. First, there was great value in desk checking your code and your algorithms to increase the odds of a successful run. Second, it was good to have several projects going simultaneously to make the best of your your time. Third, I was always shocked (from reading my printouts) to see that my code could wait in the queue for several hours in order to be compiled and run in the space of 2 or 3 seconds.

As I mentioned earlier, the IBM line printer had a unique feature known as carriage control. By punching different special characters in the first column you could make the printer do some special things when it printed out your code. For example a “1″ would make it advance to the top of the next page of green bar paper before it would print. This was a good way to make sure that each function was on a page of its own. The “+” (plus) sign was magic; it would inhibit the printer from advancing the paper to the next line after printing. The next line would overstrike the current line.

I learned how to put it to very good use at the end of my PL/I class. The instructor asked us to make our final assignment look as pretty as possible. For most people this meant clean comments, good variable names, a clean structure, and so forth.

I decided to go a step further! Because this was a school, they would do their best to get as much use of each printer ribbon as possible. Instead of printing in a solid black color, the printer would usually produce text that was, at best, a medium gray. I did some experimenting, and found that 3 overstrikes would create nice, black text.

I decided to see if I could use the overprinting feature to make my final PL/I program look really nice. After getting my code to work as desired, I set out to use bold highlighting on all of the variable names. This turned out to be easy, although I spent a lot of time on the card punch. Here’s what I did.

First, before going any further, I should explain that PL/I used the characters /* to open a comment and */ to close one. The comments were free-form, and could flow from one card to the next as desired.

Let’s say that I was writing a simple loop. The actual, unadorned PL/I code and comment would look like this:

To make the MONTH variable bold I punched a series of cards like this:

The compiler saw a DO statement with a very long comment. The DO statement would look like this on the printout:

DO MONTH = 1 TO 12; /* PROCESS EACH MONTH */ The use of this irregular carriage control upset the otherwise rhythmic sounds made by the printer and the operators sometimes thought that the printer had jammed and would cancel the job. Once they realized that it was me (one benefit of going to a small school) they allowed it to run to completion.

Needless to say, I aced the class!

My PL/I knowledge turned out to be quite useful. Within a year I worked on a project for the National Science Foundation. I wrote a very cool program that would verify the accuracy of grant data, basically adding up the rows and columns to make sure that they matched in the application (an inverse spreadsheet). A year or two later I used Digital Research’s very capable PL/I-80 compiler to prototype some of my own ideas for a spreadsheet.

Note: I used Ralf Kloth’s Punchcard emulator to create the card images.

[Sep 26, 2012] Iron Spring PL-I Compiler Release Notes - Linux version 0.9.3

Introduction

This document provides information on using the Iron Spring PL/I compiler and compiled programs on the Linux platform. For information on the OS/2 platform, see the corresponding document
readme_os2.

Installing PL-1 on to Linux. - YouTube by redbear8174

 Jul 25, 2012

Download the free PL/1 compiler from Iron Spring as a zipped tar file - unpack it using gzip -d and tar xvf within your own PL1 sub folder (directory). within the pli-0.9.1 sub folder, run make install as superuser, then make your own code sub directory. Copy the Makefile from samples, edit this file to call the name of your own pl/1 program. Run make to compile it (still within your own code sub - dir ). Thanks for watching

[Sep 26, 2012] Any PL1 for Linux - Mombu the Programming Forum

The Liant product was licensed from us originally as the ANSI subset G
implementation, and they extended it quite a bit. It is a good compiler
at least when I last tried it under HP-UX ca. 1993, I was able to compile
our PL/I compiler with it. Their debugger, Codewatch, wasn't bad. Don't
know what they have done with it in the intervening years.

Tom

Google Groups

Jan 02, 2008

Hanz Schmidt :

What is ther status os PLI-GCC??

Henrik

It currently parses most of the PL/I language, but no code generation is done. Currently I have little time to work on the pl1gcc project. Given the interest in a free working PL/I compiler, I am inviting more developers, docu-writers and testers to join the effort. The more the merrier. It is a huge task to create a compiler, let alone when there is only one active developer (me). 

Henrik Sorensen

The recent availability of a rather larger body of Multics code is doubtless a useful thing from a testing point of view...

[Sep 26, 2012] PL-I for GCC

This is the fifteenth code drop of the GCC front-end for the PL/I programming language.
PL/I for GCC is released under the terms of the GNU Public License; version 2.

With pl1gcc-0.0.15 the preprocessor do loop, %DO, has been partly implemented. Only one level is allowed.
This required quite a bit of restructuring of the internal code. But now it is easy to add more preprocessor statements like %IF and preprocessor %PROCEDUREs. Expect some more releases soon.
Further the internal parse tree has also been improved, so code generation should begin really soon now (tm).

There is still no code generation taking place, so don't run out and uninstall your production PL/I compiler just yet :-)

Changes in v0.0.15:

Convert PL-I PL-1 PLI PL1 to C with PL1C Translators

The Pl1C® family of software translator tools convert existing PL/I programs to C. The powerful dual conversion PL1C® translators accept PL/I programs in numerous dialects, check their syntax, analyze the syntax tree and generate C source code. Comments are moved transparently from the source file to the target file. Any built-in functions for math, string manipulation, and I/O in PL/I are converted to calls to external procedure. (to see PL/I to C sample translation(PDF)) The translator family currently supports the following PL/I dialects: For other dialects or custom translation, please contact us for a price quote.

Dialect type 1: PL/C Cornell University PL/I
Dialect type 2: PL/I for IBM series 1
Dialect type 3: PL/I-D IBM PL/I subset compiler that runs under DOS
Dialect type 4: PL/I-F IBM PL/I full language compiler runs under DOS
Dialect type 5: DRI PL/I-D DIGITAL RESEARCH PL/I general purpose subset
Dialect type 6: IBM optimizer PL/I compiler runs under DOS
Dialect type 7: IBM optimizer PL/I - OS
Dialect type 8: ANSI X3.7-1987 PL/I general purpose subset
Dialect type 9: ANSI x3.53-1976, ISO 6160-1979 PL/I
Dialect type A: Prime PL/I
Dialect type B: Stratus PL/I
Dialect type C: Data General PL/I
Dialect type D: VAX PL/I

ORDER: PL1C type x ( select one from above)

The PL1C® translators contain a syntax analyzer, a PL/I to tertiary converter, and a tertiary to C converter. The syntax analyzer scans the PL/I input file for syntactic errors and generates a listing file of the PL/I program. Any syntactic errors will be flagged with detailed English messages in the listing file. If no errors are encountered, then the PL/I input file is converted to tertiary language.

The transfer of the PL/I source language into an intermediate tertiary language ensures the logical equivalence between the source and target languages. This tertiary language is common to the entire family of our translators. The tertiary language is automatically converted to C while maintaining the logical equivalence between the output C program and the input PL/I program.

[Dec 12, 2010] IBM Enterprise PL/I for z/OS , V4.1 delivers performance improvements and usability enhancements ...

July 22, 2010 | IBM

IBM Enterprise PL/I is a leading-edge, z/OS-based compiler that helps you create and maintain mission-critical, line-of-business PL/I applications to execute on your z/OS systems. It gives you access to IBM DB2®, IBM CICS®, and IBM IMSTM systems, and other data and transaction systems. This compiler facilitates your new On Demand Business endeavors by helping to integrate PL/I and Web-based business processes in Web services, XML, Java, and PL/I applications. This compiler's interoperability helps you capitalize on existing IT investment while more smoothly incorporating new, Web-based applications as part of your organization's infrastructure. Version 4 offers exploitation for the latest hardware architecture contained in the new zEnterprise 196, compiler enhancements for improved debugging using Debug Tool, and a number of usability enhancements, as well as additional quality improvements, many of them customer-requested. This new version of Enterprise PL/I for z/OS V4.1 underscores the continuing IBM commitment to the PL/I programming language on the z/OS platform. With Enterprise PL/I for z/OS V4.1, you can leverage more than 30 years of IBM experience in application development.

PL/1 for Windows Programming Guide

Demo of IBM old compiler for Windows: Download PLIWINTB.ZIP from
ftp://ftp.software.ibm.com/ps/products/pli/demos/

PL-1 for Win32 - Application Forum at ObjectMix.com

Recommended Links

IBM docs

Multics

University courses

Etc

IBM Red Books

Recommended Books

Rich, Robert P. Internal Sorting Methods Illustrated with PL/I Programs. Englewood Cliffs: Prentice-Hall, 1972.

Sebesta, Robert W. Concepts of Programming Languages. 3rd ed. Menlo Park: Addison-Wesley, 1996.

Abel, Peter Structured programming in PL/I and PL/C: a problem-solving approach Reston, VA, Reston Publishing Co., 1985; 571p. ISBN: 0-83597122-8

Abrahams, Paul The PL/I Programming Language New York, NY, The Courant Instutute of Mathematical Sciences, New York University, 1979; 151p.

Alber, K., Oliva, P., and Urschler, H. The Concrete Syntax of PL/I Vienna, At, IBM Laboratory, 1968
Technical Report TR 25.084

Alber, K., and Oliva, P. Translation of PL/I into Abstract Text  Vienna, At, IBM Laboratory, 1968
Technical Report TR 25.086

Allen, C.D., et. al. An abstract interpreter of PL/I IBM United Kingdom Labs, 1966 Technical Note TN3004
American National Standards Institute
American National Standard: programming language PL/I
New York, NY, American National Standards Institute, 1979 (Rev 1998); 403p.
ANSI Standard X3.53-1976 

American National Standards Institute
American National Standard: information systems - programming language - PL/I general-purpose subset New York, NY, American National Standards Institute, 1987; 449p.
ANSI Standard X3.74-1987
 

American National Standards Institute
Information Processing Systems Technical Report Real-Time Extensions for PL/I (NOT AN AMERICAN NATIONAL STANDARD)
New York, NY, American National Standards Institute, 1989.
ANSI Standard ANSI X3/TR-7-1989
 

Anderson, Mary Ellen
PL/I for Business Applications
Englewood Cliffs, NJ, Prentice-Hall, 1973; 397p.
ISBN: 0-136-76957-8

Anklam, Patricia, et. al.
Engineering a Compiler; VAX-11 Code Generation and Optimization
Bedford, MA, Digital Press, 1982; 269p.
ISBN: 0-932-37619-3

Augenstein, Moshe and Tenenbaum, Aaron
Data Structures and PL/I Programming
Englewood Cliffs, NJ, Prentice-Hall, 1979; 643p.
ISBN: 0-131-97731-8

Barnes, Robert Arthur
PL/I for programmers
New York, NY, North Holland, 1979; 561p.
ISBN: 0-444-00284-7

Bates, Frank, and Douglas, Mary L.
Programming Language/One, 2nd ed.
Englewood Cliffs, NJ, Prentice-Hall, 1970; 420p.
 

Beech, D. et. al.
Abstract Syntax of PL/I
IBM United Kingdom Labs, 1966
Technical Note TN3002

Beech, D. et. al.
Concrete Syntax of PL/I
IBM United Kingdom Labs, 1966
Technical Note TN3001

Beech, D. Nicholls, J.E., and Rowe, R.
A PL/I translator
IBM United Kingdom Labs, 1966
Technical Note TN3003

Brown, Gary DeWard
Fortran to PL1 Dictionary PL/1 to Fortran Dictionary
New York, NY, John Wiley and Sons, 1975
ISBN: 0-471-10796-4

Clark, Frank James
Introduction to PL/1 Programming
Boston, MA, Allyn and Bacon, 1971; 244p.

Conway, Richard
Programming for Poets: A Gentle Introduction Using PL/1
Cambridge, MA, Winthrop Publishers, 1978; 347p.
ISBN: 0-876-26724-X

Conway, Richard, and Gries, David
An Introduction to Programming.
A Structured Approach Using PL/I and PL/C

Cambridge, MA, Winthrop Publishers, Inc., 1973; 460p.
ISBN: 0-876-26406-2

Dadashzadeh, M.
PL/1 Programming Language Essentials
Piscataway, NJ, Research and Education Association, 1990; 112p.
ISBN: 0-878-91695-4

Davis, Charles Hargis
Illustrative Computer Programming for Libraries
Westport, CT, Greenwood Press, 1981; 129p.
ISBN: 0-313-22151-0

Davis, Kathi H., and Domina, Lyle
Structured Programming: PL/I with PL/C
New York, NY, Holt, Rinehart and Winston, 1988; 683p.
ISBN: 0-030-03723-9

Edwards, Leonard E.
PL/I for Business Applications
Reston, VA, Reston Pub. Co., 1973; 480p.
ISBN: 0-879-09631-4, 0-879-09630-6

Fike, C[harles]. T.
PL/I for scientific programmers
Englewood Cliffs, NJ, Prentice-Hall, 1970; 241p.

Fosdick, Howard
Structured PL/I Programming: for textual and library processing
Littleton, CO: Libraries Unlimited, 1982; 304p.
ISBN: 0-872-87328-5

Groner, Gabriel F.
PL/I programming in technological applications
New York, NY, Wiley-Interscience, 1971; 230p.
ISBN: 0-471-32795-6

Harrow, Keith, Goldberg, David E., and Langsam, Yedidyah
Problem Solving Using PL/I and PL/C
Englewood Cliffs, NJ, Prentice-Hall, 1984

Hughes, Joan Kirkby
PL/I Structured Programming, 3rd Ed.
New York, NY, John Wiley & Sons, 1987; 656p.

Hughes, Joan K., and La Pearl, Barbara J.
Structured Programming Using PL/C
New York, NY, John Wiley & Sons, 1981; 414p.
ISBN: 0-471-04969-7

IBM Corporation
A Guide to PL/I for Commercial Programmers
White Plains, NY, International Business Machines Corp.
IBM Publication number C20-1651

IBM Corporation
A Guide to PL/I for FORTRAN Users
White Plains, NY, International Business Machines Corp., 1967; 36p.
IBM Publication number C20-1637

IBM Corporation
An Introduction to Structured Programming in PL/I
White Plains, NY, International Business Machines Corp., 1967; 51p.
IBM Publication number SC20-1777-1

IBM Corporation
An Introduction to the List Processing Facilities of PL/I
White Plains, NY, International Business Machines Corp., 1971; 87p.
IBM Publication number GF20-0015-1

IBM Corporation
Student Language - A Teaching Subset of PL/I - Teaching Guide
White Plains, NY, International Business Machines Corp.
IBM Publication number GR09-0004-1

IBM Corporation
Student Text; A PL/I Primer
White Plains, NY, International Business Machines Corp., 1977; 72p.
IBM Publication number C28-6808-0

Kennedy, Michael, and Solomon, Martin B.
Structured PL/zero plus PL/one
Englewood Cliffs, NY, Prentice-Hall, 1977; 695p.
ISBN: 0-138-54901-X

Lamie, Edward L.
PL/I Programming: A Structured, Disciplined Approach
Belmont, CA, Wadsworth Publishing Co., 1982; 330p.
ISBN: 0-534-01067-9

Lecht, Charles Philip
The Programmer's PL/I; a Complete Reference.
Forward by Robert Bemer
New York, NY, McGraw-Hill, 1968; 427p.

Lewi, Johan, and Pardaens, Jan
Data Structures of Pascal, Algol 68, PL/I, and Ada
New York, Springer-Verlag, 1986; 395p.

Logicon, inc.
Guide to PL/I / prepared under contract F19628-67-C-0396 by Logicon Incorporated
Detroit, MI, American Data Processing, inc., 1969; 2v.

Lucas, P., et. al.
Informal Introduction to the abstract syntax and interpretation of PL/I
Vienna, At, IBM Laboratory, 1968
Technical Report TR 25.083

Mott, Thomas H., Artandi, Susan, and Struminger, Leny
Introduction to PL/1 Programming for Library and Information Science
New York, NY, Academic Press, 1972; 231p.

Pollack, S.V., and Sterling, T.D.
A Guide to PL/I
New York, NY, Holt, Rinehart and Winston, Inc.,1969; 556p.
 

Pritsker, A. Alan B., and Young, Robert E.
Simulation with GASP-PL/I: a PL/I based continuous/discrete simulation language
New York, NY, Wiley, 1975; 351p.
ISBN: 0-471-70046-0, 0-608-11634-3

Reddy, Rama N. and Ziegler, Carol A.
PL/I: Structured Programming and Problem Solving
Saint Paul, MN, West Publishing Company, 1986; 739p.
ISBN: 0-314-93915-6

Rich, Robert P.
Internal sorting methods illustrated with PL/1 programs
Englewood Cliffs, NJ., Prentice-Hall, 1972; 154p.
ISBN: 0-134-72357-0

SHARE Inc.
The PL/I programming project techniques library
Chicago, IL, SHARE, Inc., 1975; 129p.

Shelly, Gary B., and Cashman, Thomas J.
Introduction to Computer Programming IBM System/360 PL/I
Fullerton, CA, Anaheim Publishers, 1978
ISBN: 0-882-36190-2

Shortt, Joseph, and Wilson, Thomas C.
Problem solving and the Computer: A structured Concept with PL/I (PL/C)
Reading, MA, Addison-Wesley, 1976; 372p.
ISBN: 0-201-06916-4

Sprowls, R. Clay
PL/C: a processor for PL/I
San Francisco, CA, Canfield Press, 1972; 247p.
ISBN: 0-063-88591-3

Sterling, Theodor D. and Pollack, Seymour V.
Computing & Computer Science; A First Course with PL/I
New York, NY, Macmillan Co., 1970; 414p.

Stoutemyer, David R.
PL/I Programming for Engineering and Science
Englewood Cliffs, NJ, Prentice-Hall, 1971; 363p.
ISBN: 0-136-76528-9

Tremblay, Jean-Paul, and Sorenson, Paul G.
An Implementation Guide to Compiler Writing
New York, NY, McGraw-Hill, 1982
ISBN: 0-070-65166-3
 

Vowels, Robin A.
Introduction to PL/I, Algorithms and Structured Programming, 3rd Ed.
Parkville, Vic. AU, Robin Vowels, 1998
ISBN: 0-959-63849-0 [includes disc]

Walk, K., et. al.
Abstract syntax for interpretation of PL/I
Vienna, At, IBM Laboratory, 1968
Technical Report TR 25.082

Weinberg, Gerald M.
PL/I Programming: A Manual of Style
New York, NY, McGraw-Hill, 1970; 441p.

Weinberg, Gerald M.
PL/I Programming Primer
New York, NY, McGraw-Hill, 1966; 278p.

Weinberg, Gerald M., Yasukawa, Norie, and Marcus, Robert
Structured Programming in PL/C; an Abecedarian
New York, NY, John R. Wiley and Sons, 1973; 220p.

Weiss, Eric A.
The PL/1 Converter
New York, NY, McGraw-Hill, 1966; 113p.

Yalow, Edward C.
YAQ: A 360 Assembler Version of the Algorithm A and Comparison with other PL/I Programs
Urbana-Champaign, IL, University of Illinois at Urbana-Champaign, 1977; 31p.
 


[Books]

Articles:

Abrahams, Paul W.
"The CIMS PL/I Compiler"
Proceedings of the SIGPLAN Symposium on Compiler Construction
Denver, CO; Aug 6-10, 1979; 107-116.

Abrahams, Paul
"The PL/I Standard: An Apostate's View"
ACM SIGPLAN Notices, Sep 1979; 15-16.

Abrahams, Paul W.
"Subset/G PL/I and the PL/I Standard"
Proceedings of the 1983 Annual Conference on Computers: Extending the Human Resource, 1983; 130-132.

Adams, J. Mack, Inmon, William H., and Shirley, Jim.
"PL/I in the computer science curriculum"
Papers of the second ACM SIGCSE symposium on Education in computer science, 1972; 116-126.

Barnes, Richard
"A Working Definition of the Proposed Extensions for PL/I Real-Time Applications"
ACM SIGPLAN Notices, Oct 1979; 77-99.

Battarel, G.J., and Chevance, R.J.
"Requirements for a Safe PL/1 Implementation"
ACM SIGPLAN Notices, May 1978; 12-22.

Beech, D.
"A structural view of PL/I"
Computing Surveys  2(1970); 33-64.

Beech, David, and Marcotty, Michael
"Unfurling the PL/I Standard"
ACM SIGPLAN Notices, Oct 1973; 12-43.

Boulton, P.I.P., and Jeanes, D.L.
"The Structure and Performance of PLUTO, a Teaching Oriented PL/I Compiler System"
INFOR, Jun 1972; 140-153.

Burkhardt, Walter H.
"PL/I: An Evaluation"
Datamation, Nov 1966; 31-39.

Busam, Vincent A.
"A dictionary structure for a PL/I compiler"
International Journal of Parallel Programming 1.3 (1972): 235-253.

Chroust, Gerhard
"History of PL/I"
ICNL, 9(1978); p.148.

Conrow, Kenneth, and Smith, Ronald G.
"NEATER2: a PL/I source statement reformatter"
CACM 13(1970); 669-675.

Conway, Richard W., and Wilcox, Thomas R.
"Design and implementation of a diagnostic compiler for PL/I"
CACM  16(1973); 169-179.

Corbató, F. J.
"PL/I as a Tool for System Programming"
Datamation, 6 May 1969; 68-76.

Elshoff, James L.
"A Numerical Profile of Commercial PL/I Programs"
Software—Practice and Experience  6(1976): 505-525.

Elshoff, James L.
"The Influence of Structured Programming on PL/I Program Profiles"
IEEE Transactions on Software Engineering  3(1977): 364-368.

Elshoff, James L.
"A Study of the Structural Composition of PL/I Programs"
ACM SIGPLAN Notices, Jun 1978; 29-37.

Elson,M., and Rake, S.T.
"Code-generation technique for large-language compilers"
IBM Systems Journal  9(1970):166-188.

Epley, Donald, and Sjoerdsma, Ted.
"A two-semester course sequence in introductory programming using PL/1 - a rationale and overview"
The papers of the ACM SIGCSE ninth technical symposium on Computer science education, 1978; 113-119.

Frantz, Donald G.
"A PL/1 program to assist the comparative linguist"
CACM 13(1970); 353-356.

Freiburghouse, R.A.
"The Multics PL/I Compiler"
AFIPS Conference Proceedings: 1969 Fall Joint Computer Conference, Nov 1969; 187-199.

Gauthier, Richard L.
"PL/I compile time facilities"
Datamation, Dec 1968; 32-34.

Hac, Anna
"PL/I as a Discrete Event Simulation Tool"
Software - Practice and Experience  14(1984):697-702.

Harrow, Keith, Langsam, Yedidyah, and Goldberg, David E.
"Teaching PL/I Using a Microcomputer"
ACM SIGCSE Bulletin  Sep 1986:19-25.

Hopkins, Mark
"SABRE/PLI"
Datamation, Dec 1968; 35-38.

Hopkins, Martin
"Problems of PL/I for System Programming"
Proceedings of the SIGPLAN symposium on Languages for System Implementation, Oct 1971; 89-91.

Irwin, Larry
"Implementing phrase-structure productions in PL/I"
CACM 10(1967); 424.

Jalics, Paul J.
"Cobol vs. PL/1: some performance comparisons"
CACM 27(1984); 216-221.

Lawson, Harold W.
"PL/I list processing"
CACM 10(1967); 358-367.

Lucas, P., and Walk, K.
"On the formal description of PL/I"
Annual Review of Automatic Programming 6(1969): 105-182.

Marco, Lou
"In Praise of PL/I"
Enterprise Systems Journal, Dec 1995; 32-37.

MacLaren, M. Donald
"Exception handling in PL/I"
Proceedings of an ACM conference on Language design for reliable software, Mar, 1977; 101-104.

McCracken, Daniel D.
"The New Programming Language"
Datamation, Jul 1964; 31-36.

Myers, G.J.
"Composite design facilities of six programming languages"
IBM Systems Journal 15(1976): 212-224.

Pantages, Angela
"Language Objectives of the Late 60's"
Datamation, Nov 1965; 141-142.

Pohl, Ira
"Phas-structure productions in PL/I: Phas-structure productions in PL/I0"
CACM 10(1967); 757.

Radin, George
"The Early History and Characteristics of PL/I"
ACM SIGPLAN History of Programming Languages Conference, Jun 1978; 227-241.

Rubey, Raymond J.
"A comparative evaluation of PL/I"
Datamation, Dec 1968; 22-25.

Schroeder, E.B.
"Odes to a new language"
Datamation, Dec 1968; 39.
[verse]

Shaw, Christopher J.
"PL/I for C&C"
Datamation, Dec 1968; 26-31.

Sibley, R.A.
"A New Programming Language: PL/I"
Proceedings of the 20th National Conf., Assoc. for Computing Machinery (1965):543-563.

Siler, Kenneth F.
"A PL/I model of an emergency medical system"
Proceedings of the 6th Conference on Winter Simulation, Assoc. for Computing Machinery (1973):882.

Sitton, Gary A., Kendrick, Thomas A., and Carrick, jr., A. Gil.
"The PL/EXUS Language and Virtual Machine"
Proceedings of the ACM-IEEE symposium on high-level-language computer architecture, Nov 1973:124-130.

Sugimoto, Masakatsu
"PL/I Reducer and Direct Parser"
Proceedings of the 24th National Conf., Assoc. for Computing Machinery (1969):519-538.

Symonds, A.J.
"Interactive Graphics in Data Processing: Auxiliary-storage associative data structure for PL/I"
IBM Systems Journal  7(1968):229-245.

Tenny, T.
"Program Readability: Procedures vs. Comments"
IEEE Transactions on Software Engineering; 14(1988): 1271-1279.

Vowels, Robin A.
"PL/I for OS/2"
ACM SIGPLAN Notices, March 1996; 22-27.

Voysey, Hedley
"PL/I in the UK"
Datamation, Sep 1967; 73-74.

Wade, Bradford W., and Schneider, Victor B.
"A general-purpose high-level language machine for minicomputers"
Proceedings of the meeting on SIGPLAN/SIGMICRO interface, May 1973:169-171.

Wagner, R.A., and Morgan, H.L.
"PL/C: The design of a high performance compiler for PL/I"
AFIPS Conference Proceedings: 1971 Spring Joint Computer Conference, 1971; 503-510.

Wegner, P.
"The Vienna Definition Language"
Computing Surveys  4(1972): 5-63.

Weisert, Conrad
"Has the King Returned?"
ACM SIGPLAN Notices, April, 1993; 9-10.

Wolman, Barry L.
"Debugging PL/I Programs in the Multics Environment"
AFIPS Conference Proceedings: 1972 Fall Joint Computer Conference, 1972; 507-514.

Wortman, D. B.
"Student PL - A PL/I Dialect Designed for Teaching"
Proceedings of Canadian Computer Conference, Montreal, Jun 1972

Wortman, David B., Khaiat, Phillip J., and Lasker, David M.
"Six PL/I Compilers"
Software—Practice and Experience 6.3 (1976): 411-422




Etc

Society

Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotesSomerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose BierceBernard Shaw : Mark Twain Quotes

Bulletin:

Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOSProgramming Languages History : PL/1 : Simula 67 : C : History of GCC developmentScripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-MonthHow to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least


Copyright © 1996-2014 by Dr. Nikolai Bezroukov. www.softpanorama.org was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Site uses AdSense so you need to be aware of Google privacy policy. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine. This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

You can use PayPal to make a contribution, supporting hosting of this site with different providers to distribute and speed up access. Currently there are two functional mirrors: softpanorama.info (the fastest) and softpanorama.net.

Disclaimer:

The statements, views and opinions presented on this web page are those of the author and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with. We do not warrant the correctness of the information provided or its fitness for any purpose.

Created: May 16, 1996; Last modified: July 03, 2014