PL/C: Difference between revisions

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search
VisualWikitext
imported>Citation bot
Added isbn. | Use this bot. Report bugs. | Suggested by Headbomb | Linked from Wikipedia:WikiProject_Academic_Journals/Journals_cited_by_Wikipedia/Sandbox | #UCB_webform_linked 678/748
 
imported>OAbot
m Open access bot: doi updated in citation with #oabot.
 
Line 55: Line 55:
Work on this project was based on a prior Cornell compiler for the programming language [[Cornell University Programming Language|CUPL]], which in turn was influenced by the earlier Cornell language implementation [[CORC]].<ref name="afips-plc"/>  Both of these were small, very restricted languages intended for the teaching of beginning programming.<ref name="PLCConwayWilcox"/>  CORC had been used at Cornell from 1962 to 1966 and CUPL from 1965 to 1969.<ref name="cornell-history-computing"/>  Conway's group had been involved in the development of both of those efforts,<ref name="pom-bio"/><ref name="cornell_cs_timeline"/> each of which attempted automatic repair of source code errors.<ref name="PLCConwayWilcox"/>
Work on this project was based on a prior Cornell compiler for the programming language [[Cornell University Programming Language|CUPL]], which in turn was influenced by the earlier Cornell language implementation [[CORC]].<ref name="afips-plc"/>  Both of these were small, very restricted languages intended for the teaching of beginning programming.<ref name="PLCConwayWilcox"/>  CORC had been used at Cornell from 1962 to 1966 and CUPL from 1965 to 1969.<ref name="cornell-history-computing"/>  Conway's group had been involved in the development of both of those efforts,<ref name="pom-bio"/><ref name="cornell_cs_timeline"/> each of which attempted automatic repair of source code errors.<ref name="PLCConwayWilcox"/>
   
   
As the 1970s began, Cornell was attempting to find a teaching language that had general commercial acceptance but also contained modern language features.<ref name="plcs"/>  As another Cornell computer science professor, [[David Gries]], wrote at the time, the first criterion effectively eliminated the [[ALGOL family]] of languages and the second criteria argued against [[FORTRAN]] and [[BASIC]] (with [[COBOL]] not even being considered); thus, they chose PL/I.<ref name="gries-what">{{cite conference | author-first=David |author-last=Gries | author-link=David Gries | title=SIGCSE '74: Proceedings of the fourth SIGCSE technical symposium on Computer science education | date=January 1974 | pages=81–89 | doi=10.1145/800183.810447 | contribution=What should we teach in an introductory programming course? | publisher=Association for Computing Machinery }}</ref> While PL/I did have a foothold in educational use,<ref name="nmsu-review"/> the decision went against the grain of most universities, where one survey found that some 70&nbsp;percent of American college students were being taught with FORTRAN.<ref name="gries-what"/>  However, Cornell was intent on having a language useful for showing computer science principles and best engineering practices and through which methods such as [[structured programming]] and [[stepwise refinement]] could be taught, and PL/I was a more expressive vehicle for that than FORTRAN.<ref name="conway-gries"/>
As the 1970s began, Cornell was attempting to find a teaching language that had general commercial acceptance but also contained modern language features.<ref name="plcs"/>  As another Cornell computer science professor, [[David Gries]], wrote at the time, the first criterion effectively eliminated the [[ALGOL family]] of languages and the second criteria argued against [[FORTRAN]] and [[BASIC]] (with [[COBOL]] not even being considered); thus, they chose PL/I.<ref name="gries-what">{{cite conference | author-first=David |author-last=Gries | author-link=David Gries | title=SIGCSE '74: Proceedings of the Fourth SIGCSE Technical Symposium on Computer Science Education | date=January 1974 | pages=81–89 | doi=10.1145/800183.810447 | contribution=What should we teach in an introductory programming course? | publisher=Association for Computing Machinery | doi-access=free }}</ref> While PL/I did have a foothold in educational use,<ref name="nmsu-review"/> the decision went against the grain of most universities, where one survey found that some 70&nbsp;percent of American college students were being taught with FORTRAN.<ref name="gries-what"/>  However, Cornell was intent on having a language useful for showing computer science principles and best engineering practices and through which methods such as [[structured programming]] and [[stepwise refinement]] could be taught, and PL/I was a more expressive vehicle for that than FORTRAN.<ref name="conway-gries"/>


For educational institutions that did choose to use the language, the production [[PL/I#IBM PL/I F and D compilers|IBM PL/I F compiler]] then available was much too slow, in both compile time and execution time, for its use to be practical for student programs.<ref name="nmsu-review"/>  A similar situation existed for FORTRAN, where the [[Fortran#FORTRAN IV|IBM FORTRAN IV G compiler]] was too slow and the [[University of Waterloo]]'s [[WATFOR]] implementation had become a very popular alternate solution.<ref name="nmsu-review"/>  So there was an opening for a student compiler for PL/I; indeed, IBM recognized this and contacted Cornell and suggested they make a 'WATFOR for PL/I'.<ref name=CUPL.Conway>{{cite interview |last=Conway |first=Richard W. |subject-link= |interviewer=David Gries |title=A Conversation with Richard W. Conway |work=An Oral History of Computer Science  |date=July 31, 2015 |publisher= Cornell University Library |location= |url=https://ecommons.cornell.edu/handle/1813/40564?show=full }} See segments at 35:00 and 40:30.</ref> Indeed, this simile would be made explicit; as one university would explain to their computer center users, "PL/C is to PL/I what WATFOR is to FORTRAN IV, a fast compile-and-go system with some batching capabilities intended primarily for student use."<ref name="mts-jan71">{{cite news | url=https://books.google.com/books?id=aBxVAAAAMAAJ&pg=PA7 | title=Availability of PL/C in MTS | work=Computing Center Newsletter | publisher=University of Michigan | date=January 21, 1971 | page=5 }}</ref>
For educational institutions that did choose to use the language, the production [[PL/I#IBM PL/I F and D compilers|IBM PL/I F compiler]] then available was much too slow, in both compile time and execution time, for its use to be practical for student programs.<ref name="nmsu-review"/>  A similar situation existed for FORTRAN, where the [[Fortran#FORTRAN IV|IBM FORTRAN IV G compiler]] was too slow and the [[University of Waterloo]]'s [[WATFOR]] implementation had become a very popular alternate solution.<ref name="nmsu-review"/>  So there was an opening for a student compiler for PL/I; indeed, IBM recognized this and contacted Cornell and suggested they make a 'WATFOR for PL/I'.<ref name=CUPL.Conway>{{cite interview |last=Conway |first=Richard W. |subject-link= |interviewer=David Gries |title=A Conversation with Richard W. Conway |work=An Oral History of Computer Science  |date=July 31, 2015 |publisher= Cornell University Library |location= |url=https://ecommons.cornell.edu/handle/1813/40564?show=full }} See segments at 35:00 and 40:30.</ref> Indeed, this simile would be made explicit; as one university would explain to their computer center users, "PL/C is to PL/I what WATFOR is to FORTRAN IV, a fast compile-and-go system with some batching capabilities intended primarily for student use."<ref name="mts-jan71">{{cite news | url=https://books.google.com/books?id=aBxVAAAAMAAJ&pg=PA7 | title=Availability of PL/C in MTS | work=Computing Center Newsletter | publisher=University of Michigan | date=January 21, 1971 | page=5 }}</ref>
    
    
IBM supplied some of the funding for the initial PL/C development effort, which took place during 1968 and 1969,<ref name="cornell-history-computing">{{cite book | url=http://cac.cornell.edu/about/pubs/History_Computing_Cornell_Rudan.pdf | title=The History of Computing at Cornell University | author-first=John W. | author-last=Rudan | publisher=The Internet-First University Press | location=Ithaca, New York | year=2005 | pages=48, 57, 62, 65–66, 86–87 }}</ref> with the "C" in the name standing for Cornell.<ref name="pom-bio">{{cite journal | title=Richard Conway | journal= Production and Operations Management | volume=19 | number= 3 | date=May 2010 | pages= 2-ix, x | url= https://www.proquest.com/docview/356759223 | id= {{ProQuest|356759223}} | via=ProQuest }}</ref>  PL/C began being used on a regular basis in September 1970.<ref name="cornell-history-computing"/>
IBM supplied some of the funding for the initial PL/C development effort, which took place during 1968 and 1969,<ref name="cornell-history-computing">{{cite book | url=https://cac.cornell.edu/about/pubs/History_Computing_Cornell_Rudan.pdf | title=The History of Computing at Cornell University | author-first=John W. | author-last=Rudan | publisher=The Internet-First University Press | location=Ithaca, New York | year=2005 | pages=48, 57, 62, 65–66, 86–87 }}</ref> with the "C" in the name standing for Cornell.<ref name="pom-bio">{{cite journal | title=Richard Conway | journal= Production and Operations Management | volume=19 | number= 3 | date=May 2010 | pages= 2-ix, x | url= https://www.proquest.com/docview/356759223 | id= {{ProQuest|356759223}} }}</ref>  PL/C began being used on a regular basis in September 1970.<ref name="cornell-history-computing"/>


== Dialect and features ==
== Dialect and features ==
PL/C, a large subset of PL/I, eliminated a few of the more complex features of PL/I – record I/O, list processing, multitasking, and the compile-time preprocessor.<ref name="PLCConwayWilcox"/>  It added extensive debugging and error recovery facilities. PL/C was upwardly compatible with PL/I, meaning that a program that runs without error under the PL/C compiler should run under PL/I and produce the same results.<ref name="afips-plc">{{cite conference | author-first=Howard L. | author-last=Morgan | author2-first=Robert A. | author2-last=Wagner | year=1971 | contribution= PL/ C:—The design of a high-performance compiler for PL/I | title= Proceedings of the May 18–20, 1971, spring joint computer conference (AFIPS '71 (Spring)) | publisher= Association for Computing Machinery | pages= 503–510 | doi=10.1145/1478786.1478858 | doi-access=free }}</ref> The only exception is if certain incompatible diagnostic features of PL/C were used. 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.
PL/C, a large subset of PL/I, eliminated a few of the more complex features of PL/I – record I/O, list processing, multitasking, and the compile-time preprocessor.<ref name="PLCConwayWilcox"/>  It added extensive debugging and error recovery facilities. PL/C was upwardly compatible with PL/I, meaning that a program that runs without error under the PL/C compiler should run under PL/I and produce the same results.<ref name="afips-plc">{{cite conference | author-first=Howard L. | author-last=Morgan | author2-first=Robert A. | author2-last=Wagner | year=1971 | contribution=PL/C:—The design of a high-performance compiler for PL/I | title= Proceedings of the May 18–20, 1971, Spring Joint Computer Conference (AFIPS '71 (Spring)) | publisher= Association for Computing Machinery | pages= 503–510 | doi=10.1145/1478786.1478858 | doi-access=free }}</ref> The only exception is if certain incompatible diagnostic features of PL/C were used. 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.


PL/C provided extensions to PL/I's own <code>CHECK</code> facility for flow tracing, and additionally provided new facilities, such as the <code>PUT ALL;</code> and <code>PUT ARRAY;</code> statements for printing the values of every scalar and every array variable at that point in the program.<ref name="conway-gries"/>  PL/C also provided pseudo-comments, which could be used to conditionally turn on code based on options supplied in the PL/C job control card:
PL/C provided extensions to PL/I's own <code>CHECK</code> facility for flow tracing, and additionally provided new facilities, such as the <code>PUT ALL;</code> and <code>PUT ARRAY;</code> statements for printing the values of every scalar and every array variable at that point in the program.<ref name="conway-gries"/>  PL/C also provided pseudo-comments, which could be used to conditionally turn on code based on options supplied in the PL/C job control card:
Line 80: Line 80:
The comments value shown here would result in the first <code>PUT</code> statement being "uncommented" and invoked during the run, while the second one whose number did not match would still be a comment.  Pseudo-comments also provided a way to use PL/C-specific statements in an upwardly compatible way with PL/I, as in the second case, since the PL/I compiler would see them as comments only.<ref name="conway-gries"/>
The comments value shown here would result in the first <code>PUT</code> statement being "uncommented" and invoked during the run, while the second one whose number did not match would still be a comment.  Pseudo-comments also provided a way to use PL/C-specific statements in an upwardly compatible way with PL/I, as in the second case, since the PL/I compiler would see them as comments only.<ref name="conway-gries"/>


PL/C handles [[Floating-point arithmetic|floating point arithmetic]] by computing all [[Single-precision floating-point format|single-precision]] values as double precision, which can complicate attempts by the programmer to validate rounding behavior of particular computations.<ref>{{Cite book |last=Hull |first=T.E. |url=https://www.worldcat.org/oclc/3311037 |title=Portability of numerical software |publisher=Springer-Verlag |year=1977 |isbn=0-387-08446-0 |editor-last=Cowell |editor-first=Wayne |location=Berlin |pages=42 |chapter=Semantics of floating point arithmetic and elementary functions |oclc=3311037}}</ref>
PL/C handles [[Floating-point arithmetic|floating point arithmetic]] by computing all [[Single-precision floating-point format|single-precision]] values as double precision, which can complicate attempts by the programmer to validate rounding behavior of particular computations.<ref>{{Cite book |last=Hull |first=T.E. |title=Portability of numerical software |publisher=Springer-Verlag |year=1977 |isbn=0-387-08446-0 |editor-last=Cowell |editor-first=Wayne |location=Berlin |pages=42 |chapter=Semantics of floating point arithmetic and elementary functions |oclc=3311037}}</ref>


A simple example of PL/C's error repair has been presented as:<ref name="afips-plc"/>
A simple example of PL/C's error repair has been presented as:<ref name="afips-plc"/>
Line 113: Line 113:
"PL/C seems praiseworthy. Its purchase price ($1,800) is probably its biggest drawback. It has all of the built-in functions PL/I has, is much faster in both compilation and execution, and runs in 86K of a 100K partition leaving 14K for the student program. Its only real possible deficiency for student programs is its lack of record I/O capability. The PL/C compiler not only diagnoses errors, but often corrects them properly. It inserts missing parentheses and semicolons and shows both the invalid statement and the corrected statement. If PL/C finds a statement completely unrecognizable it deletes it and attempts execution anyway."<ref name="nmsu-review">{{cite journal | author-first=J. Mack | author-last=Adams | author2-first=William H. | author2-last=Inmon | author3-first= Jim | author3-last=Shirley | title=PL/I in the computer science curriculum | journal=ACM SIGCSE Bulletin | volume=4 | number=1 | date=March 1972 | pages= 116–126 | doi=10.1145/873684.873713 | s2cid=32179236 }}</ref>
"PL/C seems praiseworthy. Its purchase price ($1,800) is probably its biggest drawback. It has all of the built-in functions PL/I has, is much faster in both compilation and execution, and runs in 86K of a 100K partition leaving 14K for the student program. Its only real possible deficiency for student programs is its lack of record I/O capability. The PL/C compiler not only diagnoses errors, but often corrects them properly. It inserts missing parentheses and semicolons and shows both the invalid statement and the corrected statement. If PL/C finds a statement completely unrecognizable it deletes it and attempts execution anyway."<ref name="nmsu-review">{{cite journal | author-first=J. Mack | author-last=Adams | author2-first=William H. | author2-last=Inmon | author3-first= Jim | author3-last=Shirley | title=PL/I in the computer science curriculum | journal=ACM SIGCSE Bulletin | volume=4 | number=1 | date=March 1972 | pages= 116–126 | doi=10.1145/873684.873713 | s2cid=32179236 }}</ref>


Some universities, including [[Washington State University]], found success in teaching an introductory class that used PL/C first and then Fortran (using WATFIV) second, which was found to be a beneficial order in terms of student learning.<ref>{{cite conference | author-first=Glen E. | author-last=Newton | author2-first=J. Denbigh | author2-last=Starkey | year= 1976 | contribution= Teaching both PL/I and Fortran to Beginners | title= Proceedings of the sixth SIGCSE technical symposium on Computer science education (SIGCSE '76) | publisher=Association for Computing Machinery | pages= 106–107 | doi=10.1145/800144.804769 | doi-access=free }}</ref>  Indeed, Cornell at one point restructured their introductory course offering to allow students the option to do that.<ref name="sigcse-cs100">{{cite conference | author-first=Richard W. | author-last=Conway | year=1974 | contribution=Introductory instruction in programming | title= Proceedings of the fourth SIGCSE technical symposium on Computer science education (SIGCSE '74) | publisher= Association for Computing Machinery | pages= 6–10 | doi=10.1145/800183.810430 }}</ref>
Some universities, including [[Washington State University]], found success in teaching an introductory class that used PL/C first and then Fortran (using WATFIV) second, which was found to be a beneficial order in terms of student learning.<ref>{{cite conference | author-first=Glen E. | author-last=Newton | author2-first=J. Denbigh | author2-last=Starkey | year= 1976 | contribution= Teaching both PL/I and Fortran to Beginners | title= Proceedings of the Sixth SIGCSE Technical Symposium on Computer Science Education (SIGCSE '76) | publisher=Association for Computing Machinery | pages= 106–107 | doi=10.1145/800144.804769 | doi-access=free }}</ref>  Indeed, Cornell at one point restructured their introductory course offering to allow students the option to do that.<ref name="sigcse-cs100">{{cite conference | author-first=Richard W. | author-last=Conway | year=1974 | contribution=Introductory instruction in programming | title= Proceedings of the Fourth SIGCSE Technical Symposium on Computer Science Education (SIGCSE '74) | publisher= Association for Computing Machinery | pages= 6–10 | doi=10.1145/800183.810430 }}</ref>


PL/C release numbers were to some extent synchronized to releases of the IBM PL/I F compiler, so that for instance Release 4 of PL/C was intended to match Version 4 of the IBM F compiler in terms of upward compatibility.<ref name="mts-jan71"/>  In terms of some instances of PL/C distributions, Release 4 was available by January 1971;<ref name="mts-jan71"/> Release 6 by August 1971;<ref name="PLCConwayWilcox" /><!--see footnotes--> Release 6.5 by November 1973;<ref>See program listing image.</ref> Release 7.1 in March 1975;<ref name="mts-mar75">{{cite news | url=https://books.google.com/books?id=6hxVAAAAMAAJ&pg=RA2-PA12| title=New Version of PL/C | work=Computing Center Newsletter | publisher=University of Michigan | date=March 12, 1975 | page=2 }}</ref> and Release 7.5 in March 1976.<ref name="cw-mar76"/>  The last version of PL/C appears to have been Release 7.6, put out in 1977.<ref>See for example {{cite book | title=Concepts of Programming Languages | author-first=Robert W. | author-last=Sebesta | publisher=Addison-Wesley | year=2010 | page=739 | url=https://books.google.com/books?id=Z1Y_AQAAIAAJ&q=%22PL/C%22+%22release+7.6%22 | location= | isbn=9780136073475 | edition=Ninth }}<!-- haven't found a 7.7 or anything later in web searches --></ref>
PL/C release numbers were to some extent synchronized to releases of the IBM PL/I F compiler, so that for instance Release 4 of PL/C was intended to match Version 4 of the IBM F compiler in terms of upward compatibility.<ref name="mts-jan71"/>  In terms of some instances of PL/C distributions, Release 4 was available by January 1971;<ref name="mts-jan71"/> Release 6 by August 1971;<ref name="PLCConwayWilcox" /><!--see footnotes--> Release 6.5 by November 1973;<ref>See program listing image.</ref> Release 7.1 in March 1975;<ref name="mts-mar75">{{cite news | url=https://books.google.com/books?id=6hxVAAAAMAAJ&pg=RA2-PA12| title=New Version of PL/C | work=Computing Center Newsletter | publisher=University of Michigan | date=March 12, 1975 | page=2 }}</ref> and Release 7.5 in March 1976.<ref name="cw-mar76"/>  The last version of PL/C appears to have been Release 7.6, put out in 1977.<ref>See for example {{cite book | title=Concepts of Programming Languages | author-first=Robert W. | author-last=Sebesta | publisher=Addison-Wesley | year=2010 | page=739 | url=https://books.google.com/books?id=Z1Y_AQAAIAAJ&q=%22PL/C%22+%22release+7.6%22 | location= | isbn=9780136073475 | edition=Ninth }}<!-- haven't found a 7.7 or anything later in web searches --></ref>
Line 127: Line 127:
A different implementation of the PL/CS definition came with Professor [[Tim Teitelbaum]] and his pioneering [[Cornell Program Synthesizer]] work.<ref name="cps">{{cite journal | author-first=Tim | author-last=Teitelbaum | author2-first= Thomas | author2-last=Reps | title= The Cornell Program Synthesizer: A Syntax-Directed Programming Environment | journal= Communications of the ACM | volume=24 | number=9 | date=September 1981 | pages= 563–573 | doi=10.1145/358746.358755 | s2cid=14317073 | doi-access=free }}</ref>  This  early instance of an [[integrated development environment]] was developed in 1978 for the [[PDP-11#Models|PDP-11/60]],<ref name="OHCS-Teitelbaum">{{cite interview |last=Teitelbaum |first=Tim |subject-link= |interviewer=David Gries |title=A Conversation with Tim Teitelbaum |work=An Oral History of Computer Science  |date=September 10, 2015 |publisher= Cornell University Library |location= |url=https://ecommons.cornell.edu/handle/1813/40865 }} See segments at 10:15 and 16:18.</ref> and contained a [[structured editor]] for PL/CS along with an [[incremental compiler]] as well as an [[Interpreter (computing)|interpreter]].<ref>{{cite book | title=The Synthesizer Generator: A System for Constructing Language-Based Editors | author-first=Thomas W. | author-last=Reps | author2-first= Tim | author2-last=Teitelbaum | publisher=Springer Verlag | location=New York | year= 1989 | pages=3, 9 | isbn=9781461396239 | url=https://books.google.com/books?id=yoXkBwAAQBAJ&pg=PA9 }}</ref>  The Cornell Program Synthesizer was soon adapted for the [[Terak desktop workstation]], an early personal computer,<ref name="OHCS-Teitelbaum"/> which was based on the [[LSI-11]] processor.<ref name="siguccs-marches"/>  The Terak computer found popularity for instructional use at Cornell and at other universities, as did the PL/CS available on it.<ref name="siguccs-marches"/><ref name="cdsun-111578"/>  In addition, Cornell built a link between the Terak and their IBM 370 mainframe, that would allow batch-mode execution of programs under PL/C and the obtaining of results on printers.<ref name="cornell-history-computing"/>
A different implementation of the PL/CS definition came with Professor [[Tim Teitelbaum]] and his pioneering [[Cornell Program Synthesizer]] work.<ref name="cps">{{cite journal | author-first=Tim | author-last=Teitelbaum | author2-first= Thomas | author2-last=Reps | title= The Cornell Program Synthesizer: A Syntax-Directed Programming Environment | journal= Communications of the ACM | volume=24 | number=9 | date=September 1981 | pages= 563–573 | doi=10.1145/358746.358755 | s2cid=14317073 | doi-access=free }}</ref>  This  early instance of an [[integrated development environment]] was developed in 1978 for the [[PDP-11#Models|PDP-11/60]],<ref name="OHCS-Teitelbaum">{{cite interview |last=Teitelbaum |first=Tim |subject-link= |interviewer=David Gries |title=A Conversation with Tim Teitelbaum |work=An Oral History of Computer Science  |date=September 10, 2015 |publisher= Cornell University Library |location= |url=https://ecommons.cornell.edu/handle/1813/40865 }} See segments at 10:15 and 16:18.</ref> and contained a [[structured editor]] for PL/CS along with an [[incremental compiler]] as well as an [[Interpreter (computing)|interpreter]].<ref>{{cite book | title=The Synthesizer Generator: A System for Constructing Language-Based Editors | author-first=Thomas W. | author-last=Reps | author2-first= Tim | author2-last=Teitelbaum | publisher=Springer Verlag | location=New York | year= 1989 | pages=3, 9 | isbn=9781461396239 | url=https://books.google.com/books?id=yoXkBwAAQBAJ&pg=PA9 }}</ref>  The Cornell Program Synthesizer was soon adapted for the [[Terak desktop workstation]], an early personal computer,<ref name="OHCS-Teitelbaum"/> which was based on the [[LSI-11]] processor.<ref name="siguccs-marches"/>  The Terak computer found popularity for instructional use at Cornell and at other universities, as did the PL/CS available on it.<ref name="siguccs-marches"/><ref name="cdsun-111578"/>  In addition, Cornell built a link between the Terak and their IBM 370 mainframe, that would allow batch-mode execution of programs under PL/C and the obtaining of results on printers.<ref name="cornell-history-computing"/>


There was an even more experimental dialect being worked on, starting in 1975,<ref name="popl-plcv"/> that was known as PL/CV, which supplied some language support for [[formal verification|formal proof of correctness]] and which ran as a separate verifier step.<ref name="plcs"/>  The PL/CV work was led by Professor [[Robert L. Constable]].<ref name="popl-plcv"/><ref name="OHCS-Constable"/>  PL/CV used PL/CS as part of what it did,<ref name="popl-plcv"/> and indeed Constable had participated in the creation of PL/CS,<ref name="plcs"/> especially working with Conway and David Gries on the adding of assertions.<ref name="OHCS-Constable">{{cite interview |last=Constable |first=Robert L. |subject-link= |interviewer=David Gries |title=A Conversation with Robert L. Constable |work=An Oral History of Computer Science |date=July 21, 2015 |publisher= Cornell University Library |location= |url=https://ecommons.cornell.edu/handle/1813/40560 }} See segment at 16:30.</ref> A second version, PL/CV2, was released in 1978 and was presented at the [[Symposium on Principles of Programming Languages]] in 1979.<ref name="popl-plcv">{{cite conference | author-first=Robert L. | author-last=Constable | author2-first= Scott D. | author2-last=Johnson | year=1979 | contribution= A PL/CV Precis | title= Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages (POPL '79) | publisher=Association for Computing Machinery | pages= 7–20 | doi=10.1145/567752.567754 }}</ref>
There was an even more experimental dialect being worked on, starting in 1975,<ref name="popl-plcv"/> that was known as PL/CV, which supplied some language support for [[formal verification|formal proof of correctness]] and which ran as a separate verifier step.<ref name="plcs"/>  The PL/CV work was led by Professor [[Robert L. Constable]].<ref name="popl-plcv"/><ref name="OHCS-Constable"/>  PL/CV used PL/CS as part of what it did,<ref name="popl-plcv"/> and indeed Constable had participated in the creation of PL/CS,<ref name="plcs"/> especially working with Conway and Gries on the adding of assertions.<ref name="OHCS-Constable">{{cite interview |last=Constable |first=Robert L. |subject-link= |interviewer=David Gries |title=A Conversation with Robert L. Constable |work=An Oral History of Computer Science |date=July 21, 2015 |publisher= Cornell University Library |location= |url=https://ecommons.cornell.edu/handle/1813/40560 }} See segment at 16:30.</ref> A second version, PL/CV2, was released in 1978 and was presented at the [[Symposium on Principles of Programming Languages]] in 1979.<ref name="popl-plcv">{{cite conference | author-first=Robert L. | author-last=Constable | author2-first= Scott D. | author2-last=Johnson | year=1979 | contribution= A PL/CV Precis | title= Proceedings of the 6th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages (POPL '79) | publisher=Association for Computing Machinery | pages= 7–20 | doi=10.1145/567752.567754 }}</ref>


== Cross compilers ==
== Cross compilers ==
Line 134: Line 134:
The first of these cross compilers was PLCV (not to be confused with the PL/CV verifier), a cross compiler for [[Varian Data Machines]] minicomputers,<ref name="acm-sat"/> specifically the 620/i and 620/f, and was created around 1971.<ref name="erda-plcv">{{cite book | url=https://books.google.com/books?id=DklNGDnHC5AC&pg=PA474 | title=ERDA Research Abstracts| volume=1 / #3 | publisher=United States Energy Research and Development Administration | location=Oak Ridge, Tennessee | date=March 1976 | page=474 }} Entry 4422.</ref>  An improved version of PLCV came out around 1973.<ref name="erda-plci"/>  The second, PLCI, was targeted at the [[Interdata]] Model 3; it also had a revised version around the same time.<ref name="erda-plci"/>  The third was PLCD, used to target the [[Digital Equipment Corporation]]'s [[PDP-11/45]] minicomputer, which came out in 1973.<ref name="acm-sat"/>  Again, PLCD used PL/C but with the IBM 360 code generator replaced by one for PDP-11/45.<ref name="acm-sat"/><!-- the source mangles the description of this -->
The first of these cross compilers was PLCV (not to be confused with the PL/CV verifier), a cross compiler for [[Varian Data Machines]] minicomputers,<ref name="acm-sat"/> specifically the 620/i and 620/f, and was created around 1971.<ref name="erda-plcv">{{cite book | url=https://books.google.com/books?id=DklNGDnHC5AC&pg=PA474 | title=ERDA Research Abstracts| volume=1 / #3 | publisher=United States Energy Research and Development Administration | location=Oak Ridge, Tennessee | date=March 1976 | page=474 }} Entry 4422.</ref>  An improved version of PLCV came out around 1973.<ref name="erda-plci"/>  The second, PLCI, was targeted at the [[Interdata]] Model 3; it also had a revised version around the same time.<ref name="erda-plci"/>  The third was PLCD, used to target the [[Digital Equipment Corporation]]'s [[PDP-11/45]] minicomputer, which came out in 1973.<ref name="acm-sat"/>  Again, PLCD used PL/C but with the IBM 360 code generator replaced by one for PDP-11/45.<ref name="acm-sat"/><!-- the source mangles the description of this -->


The University of North Carolina used these cross compilers for real projects, not just education; in particular, PLCD was used in support of a [[graphical programming]] environment that would use the same programming language for both a general purpose mainframe and a graphical support minicomputer, thereby allowing easier shifting of code from one to the other.<ref name="siggraph-sat">{{cite conference | author-first=Griffith | author-last=Hamlin |author2-first=James D. | author2-last=Foley |year= 1975 | contribution=Configurable applications for graphics employing satellites (CAGES) | title= Proceedings of the 2nd annual conference on Computer graphics and interactive techniques (SIGGRAPH '75) | publisher= Association for Computing Machinery | pages= 9&ndash;19 | doi=10.1145/563732.563734 | doi-access=free }}</ref> The IBM PL/I F compiler was used on the mainframe, with programmers restricting themselves to the PL/C subset of the language, and PLCD was used to generate code for the PDP-11/45.<ref name="acm-sat">{{cite conference | author-first=James D. | author-last=Foley | year=1973 | contribution=Software for satellite graphics systems | title= Proceedings of the ACM annual conference (ACM '73) | publisher= Association for Computing Machinery  | pages= 76&ndash;80 | doi=10.1145/800192.805684 | doi-access=free }} </ref>
The University of North Carolina used these cross compilers for real projects, not just education; in particular, PLCD was used in support of a [[graphical programming]] environment that would use the same programming language for both a general purpose mainframe and a graphical support minicomputer, thereby allowing easier shifting of code from one to the other.<ref name="siggraph-sat">{{cite conference | author-first=Griffith | author-last=Hamlin |author2-first=James D. | author2-last=Foley |year= 1975 | contribution=Configurable applications for graphics employing satellites (CAGES) | title= Proceedings of the 2nd annual conference on Computer Graphics and Interactive Techniques (SIGGRAPH '75) | publisher= Association for Computing Machinery | pages= 9&ndash;19 | doi=10.1145/563732.563734 | doi-access=free }}</ref> The IBM PL/I F compiler was used on the mainframe, with programmers restricting themselves to the PL/C subset of the language, and PLCD was used to generate code for the PDP-11/45.<ref name="acm-sat">{{cite conference | author-first=James D. | author-last=Foley | year=1973 | contribution=Software for satellite graphics systems | title= Proceedings of the ACM annual conference (ACM '73) | publisher= Association for Computing Machinery  | pages= 76&ndash;80 | doi=10.1145/800192.805684 | doi-access=free }} </ref>


== Textbooks ==
== Textbooks ==
Line 161: Line 161:


== Legacy ==
== Legacy ==
PL/C was still in use at the beginning of the 1980s.<ref name="siguccs-marches"/><ref name="cps"/>  However, by then the [[Pascal (programming language)|Pascal]] programming language was beginning to come to the fore as a teaching language, and the move of student access towards smaller and more distributed computer systems than IBM mainframes also continued.<ref name="siguccs-marches">{{cite conference | author-first=Rich | author-last=Stillman | year=1980 | contribution=Technology marches on: Using microcomputers to deliver elementary computer science instruction | title=Proceedings of the 8th annual ACM SIGUCCS conference on User services (SIGUCCS '80) | publisher= Association for Computing Machinery | pages= 135–139 | doi=10.1145/800086.802776 }}</ref><ref name="cornell-history-computing"/>  And PL/I itself never gained the dominance its designers had hoped for in either the business or scientific programming fields.<ref name="cornell-history-computing"/>
[[Image:PL C program and data card deck at Cornell University 1976.jpg|thumb|right|PL/C program and data card deck, run at Cornell in 1976 for a numerical analysis research task]]


At Cornell itself, the switch to using Pascal in its introductory computer programming classes took place during 1984.<ref>Compare {{cite book | url=https://ecommons.cornell.edu/handle/1813/38057 | title=Cornell University Announcements: Courses of Study, 1983&ndash;84 | publisher=Cornell University | date=July 15, 1983 | page=261 }} with {{cite book | url=https://ecommons.cornell.edu/handle/1813/38065 | title=Cornell University Announcements: Courses of Study, 1984&ndash;85 | publisher=Cornell University | date=July 16, 1984 | page=268 }}</ref>  Conway has said he does not know how long PL/C remained in use at the various sites where it was installed.<ref name=CUPL.Conway/>
PL/C was still in use at the beginning of the 1980s.<ref name="siguccs-marches"/><ref name="cps"/>  However, by then the [[Pascal (programming language)|Pascal]] programming language was beginning to come to the fore as a teaching language, and the move of student access towards smaller and more distributed computer systems than IBM mainframes also continued.<ref name="siguccs-marches">{{cite conference | author-first=Rich | author-last=Stillman | year=1980 | contribution=Technology marches on: Using microcomputers to deliver elementary computer science instruction | title=Proceedings of the 8th annual ACM SIGUCCS Conference on User Services (SIGUCCS '80) | publisher= Association for Computing Machinery | pages= 135–139 | doi=10.1145/800086.802776 }}</ref><ref name="cornell-history-computing"/>  And PL/I itself never gained the dominance its designers had hoped for in either the business or scientific programming fields.<ref name="cornell-history-computing"/>
 
At Cornell itself, the switch to using Pascal in its introductory computer programming classes took place during 1984.<ref>Compare {{cite book | url=https://ecommons.cornell.edu/handle/1813/38057 | title=Cornell University Announcements: Courses of Study, 1983&ndash;84 | publisher=Cornell University | date=July 15, 1983 | page=261 }} with {{cite book | url=https://ecommons.cornell.edu/handle/1813/38065 | title=Cornell University Announcements: Courses of Study, 1984&ndash;85 | publisher=Cornell University | date=July 16, 1984 | page=268 }}</ref>  Conway later said that he did not know how long PL/C remained in use at the various sites where it was installed.<ref name=CUPL.Conway/>


In 2012, an effort was ongoing to resurrect the popular [[Michigan Terminal System]] and the software that ran on it as part of an archival effort on IBM 360/370 simulators. Among the things they requested was permission to run the PL/C object code, which was informally granted by those staff associated with it who were still at Cornell.<ref>{{cite web | url=http://archive.michigan-terminal-system.org/discussions/permission-to-include-licensed-programs/forplc | title=For *PLC | publisher=Michigan Terminal System Archive | date=April 3, 2012 | access-date=September 19, 2022 }}</ref>
In 2012, an effort was ongoing to resurrect the popular [[Michigan Terminal System]] and the software that ran on it as part of an archival effort on IBM 360/370 simulators. Among the things they requested was permission to run the PL/C object code, which was informally granted by those staff associated with it who were still at Cornell.<ref>{{cite web | url=http://archive.michigan-terminal-system.org/discussions/permission-to-include-licensed-programs/forplc | title=For *PLC | publisher=Michigan Terminal System Archive | date=April 3, 2012 | access-date=September 19, 2022 }}</ref>

Latest revision as of 06:39, 8 September 2025

Template:Short description Template:Use American English Template:Use mdy dates Script error: No such module "Infobox".Template:Template otherScript error: No such module "Check for unknown parameters". PL/C is an instructional dialect of the programming language PL/I, developed at the Department of Computer Science of Cornell University in the early 1970s in an effort headed by Professor Richard W. Conway and graduate student Thomas R. Wilcox.[1] PL/C was developed with the specific goal of being used for teaching programming. The PL/C compiler, which implemented almost all of the large PL/I language, had the unusual capability of never failing to compile a program, through the use of extensive automatic correction of many syntax errors and by converting any remaining syntax errors to output statements. This was important because, at the time, students submitted their programs on IBM punch cards and might not get their output back for several hours.[2] Over 250 other universities adopted PL/C;[3] as one late-1970s textbook on PL/I noted, "PL/C ... the compiler for PL/I developed at Cornell University ... is widely used in teaching programming."[4] Similarly, a mid-late-1970s survey of programming languages said that "PL/C is a widely used dialect of PL/I."[5]

Origins and rationale

File:Cornell Engineering Quad in rain 1998.jpg
PL/C came from Cornell University's Department of Computer Science, located in Upson Hall on the Engineering Quadrangle[6] (building on center-left with yellow bands, here seen in the 1990s)

Work on this project was based on a prior Cornell compiler for the programming language CUPL, which in turn was influenced by the earlier Cornell language implementation CORC.[7] Both of these were small, very restricted languages intended for the teaching of beginning programming.[1] CORC had been used at Cornell from 1962 to 1966 and CUPL from 1965 to 1969.[8] Conway's group had been involved in the development of both of those efforts,[9][10] each of which attempted automatic repair of source code errors.[1]

As the 1970s began, Cornell was attempting to find a teaching language that had general commercial acceptance but also contained modern language features.[11] As another Cornell computer science professor, David Gries, wrote at the time, the first criterion effectively eliminated the ALGOL family of languages and the second criteria argued against FORTRAN and BASIC (with COBOL not even being considered); thus, they chose PL/I.[12] While PL/I did have a foothold in educational use,[13] the decision went against the grain of most universities, where one survey found that some 70 percent of American college students were being taught with FORTRAN.[12] However, Cornell was intent on having a language useful for showing computer science principles and best engineering practices and through which methods such as structured programming and stepwise refinement could be taught, and PL/I was a more expressive vehicle for that than FORTRAN.[14]

For educational institutions that did choose to use the language, the production IBM PL/I F compiler then available was much too slow, in both compile time and execution time, for its use to be practical for student programs.[13] A similar situation existed for FORTRAN, where the IBM FORTRAN IV G compiler was too slow and the University of Waterloo's WATFOR implementation had become a very popular alternate solution.[13] So there was an opening for a student compiler for PL/I; indeed, IBM recognized this and contacted Cornell and suggested they make a 'WATFOR for PL/I'.[15] Indeed, this simile would be made explicit; as one university would explain to their computer center users, "PL/C is to PL/I what WATFOR is to FORTRAN IV, a fast compile-and-go system with some batching capabilities intended primarily for student use."[16]

IBM supplied some of the funding for the initial PL/C development effort, which took place during 1968 and 1969,[8] with the "C" in the name standing for Cornell.[9] PL/C began being used on a regular basis in September 1970.[8]

Dialect and features

PL/C, a large subset of PL/I, eliminated a few of the more complex features of PL/I – record I/O, list processing, multitasking, and the compile-time preprocessor.[1] It added extensive debugging and error recovery facilities. PL/C was upwardly compatible with PL/I, meaning that a program that runs without error under the PL/C compiler should run under PL/I and produce the same results.[7] The only exception is if certain incompatible diagnostic features of PL/C were used. 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.

PL/C provided extensions to PL/I's own CHECK facility for flow tracing, and additionally provided new facilities, such as the PUT ALL; and PUT ARRAY; statements for printing the values of every scalar and every array variable at that point in the program.[14] PL/C also provided pseudo-comments, which could be used to conditionally turn on code based on options supplied in the PL/C job control card: 

*PL/C ID='JANE SMITH' COMMENTS=(2)

...

   /*2 PUT SKIP LIST('AT POINT Y, THE VALUE OF POPULATION IS', POPULATION); */

   /*4 PUT ALL; */

...

The comments value shown here would result in the first PUT statement being "uncommented" and invoked during the run, while the second one whose number did not match would still be a comment. Pseudo-comments also provided a way to use PL/C-specific statements in an upwardly compatible way with PL/I, as in the second case, since the PL/I compiler would see them as comments only.[14]

PL/C handles floating point arithmetic by computing all single-precision values as double precision, which can complicate attempts by the programmer to validate rounding behavior of particular computations.[17]

A simple example of PL/C's error repair has been presented as:[7] 

   PUT LIST (A B)
ERROR SY06 MISSING COMMA
ERROR SY07 MISSING SEMI-COLON
PL/C USES PUT LIST (A, B);

While many cases such as this one can be successfully repaired, there are also cases where the repair does not achieve what the programmer likely intended.[1]

There were several other education-related PL/I compilers, including PLAGO from the Polytechnic Institute of Brooklyn and SP/k from the University of Toronto, however they tended to use much more restricted subsets of PL/I, whereas PL/C supported almost the entire language.[13][18] And PL/C was the only PL/I educational dialect mentioned in languages expert Jean E. Sammet's extensive survey of programming languages in use for 1976–77.[5]

Design and implementation

File:PL C source listing and run printout for CS 100 at Cornell University 1973.jpg
Line printer listing of PL/C program, from a Cornell first-semester programming class in 1973

The implementation of the PL/C compiler itself was done in IBM 360 Assembly Language, with a heavy use of assembly language macros.[7] It was done as a three-pass compiler, with the first pass doing syntax analysis and error correction of syntactical mistakes, the second pass doing semantic analysis and further error correction, and the third pass doing code generation.[7] PL/C needed to avoid the longstanding problem of "cascading diagnostics", wherein one error is internally but often mistakenly "fixed" by the compiler, resulting in a secondary, tertiary and additional series of unhelpful error messages.[19] The design of the intermediate language used between the passes and of the accompanying symbol table was tailored towards, and key to the achievement of, the error-repair and diagnostic reporting capabilities of PL/C.[1] While a number of these techniques dated from the Cornell CORC and CUPL efforts, here they were being used for the first time on large programming language with a full set of commercial-grade features.[1] This was especially notable given that the PL/I language was notoriously challenging for compilers to deal with.[20]

The compilation speed of PL/C was quite good – some 10,000–20,000 sources lines of code per minute on an IBM System/360 Model 65.[1] The work done on PL/C was described in a paper presented at an AFIPS joint conference in Spring 1971.[7] More prominent was the paper "Design and Implementation of a Diagnostic Compiler for PL/I" by Conway and Wilcox, published in the March 1973 issue of the flagship journal Communications of the ACM, which gave the project considerable visibility within the computer science world.[1]

PL/C was implemented as a compile and go system,[1] similar to WATFOR.[21] It ran on the IBM System/360 and System/370 under OS and HASP.[22] As such, it was designed to run within a 128K byte partition, where the PL/C software and the generated object code took a maximum of 100K bytes.[7] Error correction was attempted at runtime as well, with the PL/C execution supervisor trapping or otherwise detecting use of uninitialized variables, division by zero, out-of-range array indexes, and the like, by issuing a diagnostic and making some adjustment to allow the program to keep running.[1] Overall, use of PL/C significantly reduced the severity of the wait-times-for-batch-runs problem (although Cornell itself developed a job entry system for turning around most student batch jobs very quickly).[8]

Use and distribution

File:CS 202 PL C programming assignment 1974.jpg
Assignment using PL/C, from a Cornell second-semester programming class in 1974

As soon as it was ready, PL/C was distributed beyond Cornell itself,[11] in the form of magnetic tapes sent to interested parties.[8] For instance, PL/C was first used at the University of Michigan in the Fall 1970 semester.[16] The PL/C project was considered a research effort, not a commercial endeavor; however, those installations who wanted to use PL/C were asked to pay a "research grant" in exchange.[6] This amount was $1,800 as of 1972,[13] and had risen to $2,400 by 1976.[6] Cornell's further development work on PL/C was partly funded by these payments.[8]

PL/C quickly became the most popular of any education version of PL/I;[10] in 1970–71 alone, it was sent to 100 different institutions, resulting in 60 of them purchasing it.[8] By 1976, there were more than 200 sites around the world that had installed PL/C.[11][23] Eventually, over 250 universities had used it.[3] There was also some interest in PL/C from non-academic entities, thus resulting in PL/C adding support for some business-oriented features such as PICTURE variables.[6]

A survey conducted by New Mexico State University in 1972 looked at various possibilities for teaching languages and implementations and concluded regarding PL/C: "PL/C seems praiseworthy. Its purchase price ($1,800) is probably its biggest drawback. It has all of the built-in functions PL/I has, is much faster in both compilation and execution, and runs in 86K of a 100K partition leaving 14K for the student program. Its only real possible deficiency for student programs is its lack of record I/O capability. The PL/C compiler not only diagnoses errors, but often corrects them properly. It inserts missing parentheses and semicolons and shows both the invalid statement and the corrected statement. If PL/C finds a statement completely unrecognizable it deletes it and attempts execution anyway."[13]

Some universities, including Washington State University, found success in teaching an introductory class that used PL/C first and then Fortran (using WATFIV) second, which was found to be a beneficial order in terms of student learning.[24] Indeed, Cornell at one point restructured their introductory course offering to allow students the option to do that.[22]

PL/C release numbers were to some extent synchronized to releases of the IBM PL/I F compiler, so that for instance Release 4 of PL/C was intended to match Version 4 of the IBM F compiler in terms of upward compatibility.[16] In terms of some instances of PL/C distributions, Release 4 was available by January 1971;[16] Release 6 by August 1971;[1] Release 6.5 by November 1973;[25] Release 7.1 in March 1975;[26] and Release 7.5 in March 1976.[6] The last version of PL/C appears to have been Release 7.6, put out in 1977.[27]

Variants

Within the computer science department at Cornell there was a sense of pride about PL/C being associated with the university, and there were several variants of PL/C worked on by Conway, other faculty members, and graduate students.[28]

In 1974, the PL/CT variant of PL/C, for use on interactive terminals rather than in batch job submissions, was first made available at Cornell.[29] A second release was made in 1975,[30] and then it was made available to outside institutions in 1976.[6] PL/CT primarily ran on an IBM System/370 under VM/CMS;[30] it could also run in the IBM TSO environment.[29] Somewhat unusually, PL/CT was not interpreted but rather was still implemented as a compiler.[29]

A variant under development by 1976 was PL/CS, which was a far more restricted subset of PL/I than regular PL/C and which provided direct language support for assertions.[11] The subset was enough, however, that PL/CS would still be suitable for teaching introductory programming classes.[31] It was implemented as an alternate lexical and syntactic analyzer that then plugged into the common PL/C code generator and runtime system.[11] PL/CS was also used in research on the formal semantics of programming languages.[31]

A different implementation of the PL/CS definition came with Professor Tim Teitelbaum and his pioneering Cornell Program Synthesizer work.[32] This early instance of an integrated development environment was developed in 1978 for the PDP-11/60,[33] and contained a structured editor for PL/CS along with an incremental compiler as well as an interpreter.[34] The Cornell Program Synthesizer was soon adapted for the Terak desktop workstation, an early personal computer,[33] which was based on the LSI-11 processor.[2] The Terak computer found popularity for instructional use at Cornell and at other universities, as did the PL/CS available on it.[2][23] In addition, Cornell built a link between the Terak and their IBM 370 mainframe, that would allow batch-mode execution of programs under PL/C and the obtaining of results on printers.[8]

There was an even more experimental dialect being worked on, starting in 1975,[35] that was known as PL/CV, which supplied some language support for formal proof of correctness and which ran as a separate verifier step.[11] The PL/CV work was led by Professor Robert L. Constable.[35][36] PL/CV used PL/CS as part of what it did,[35] and indeed Constable had participated in the creation of PL/CS,[11] especially working with Conway and Gries on the adding of assertions.[36] A second version, PL/CV2, was released in 1978 and was presented at the Symposium on Principles of Programming Languages in 1979.[35]

Cross compilers

In the early 1970s, three cross compilers based on PL/C were created at the University of North Carolina; in these, the host platform was the IBM 360,[37] and the target machine was one of several minicomputers in use at the time. The PL/C language subset was used in these cross compilers,[38] as was the PL/C compiler's first two passes for syntax and semantic analysis.[39] However the IBM 360 code generation pass and storage allocation modules were replaced by ones specific to the target architecture.[39]

The first of these cross compilers was PLCV (not to be confused with the PL/CV verifier), a cross compiler for Varian Data Machines minicomputers,[40] specifically the 620/i and 620/f, and was created around 1971.[37] An improved version of PLCV came out around 1973.[39] The second, PLCI, was targeted at the Interdata Model 3; it also had a revised version around the same time.[39] The third was PLCD, used to target the Digital Equipment Corporation's PDP-11/45 minicomputer, which came out in 1973.[40] Again, PLCD used PL/C but with the IBM 360 code generator replaced by one for PDP-11/45.[40]

The University of North Carolina used these cross compilers for real projects, not just education; in particular, PLCD was used in support of a graphical programming environment that would use the same programming language for both a general purpose mainframe and a graphical support minicomputer, thereby allowing easier shifting of code from one to the other.[38] The IBM PL/I F compiler was used on the mainframe, with programmers restricting themselves to the PL/C subset of the language, and PLCD was used to generate code for the PDP-11/45.[40]

Textbooks

The textbook An Introduction to Programming: A Structured Approach Using PL/I and PL/C was written by Conway and Gries using PL/C as the programming language and was published in 1973.[14] It presented top-down design,[23] and stressed the discipline of structured programming throughout, becoming one of the most prominent textbooks to do so.[41] One section of the book was devoted to considerations of program correctness, such as the Invariant Relation Theorem;[14] it is said to have been the first programming textbook to incorporate such material.[10] The book had a potential market at any university using PL/C, and Conway later said that the book had sold very well.[15]

A second edition was published in 1975.[41] Besides reorganizing some material on the development and testing of computer programs,[41] it incorporated changes due to Release 7 of the PL/C compiler.[42] A third edition was published in 1979 and, besides pitching the textbook material at a somewhat higher level to reflect that many college students had previous programming exposure in high school, incorporated additions to reflect the PL/CT and PL/CS variants of PL/C.[43]

An Introduction to Programming: A Structured Approach was used as the basis for several offshoot textbooks, sometimes with additional co-authors, that were either aimed at a more beginning level or that covered other languages or dialects.[44]

Legacy

File:PL C program and data card deck at Cornell University 1976.jpg
PL/C program and data card deck, run at Cornell in 1976 for a numerical analysis research task

PL/C was still in use at the beginning of the 1980s.[2][32] However, by then the Pascal programming language was beginning to come to the fore as a teaching language, and the move of student access towards smaller and more distributed computer systems than IBM mainframes also continued.[2][8] And PL/I itself never gained the dominance its designers had hoped for in either the business or scientific programming fields.[8]

At Cornell itself, the switch to using Pascal in its introductory computer programming classes took place during 1984.[45] Conway later said that he did not know how long PL/C remained in use at the various sites where it was installed.[15]

In 2012, an effort was ongoing to resurrect the popular Michigan Terminal System and the software that ran on it as part of an archival effort on IBM 360/370 simulators. Among the things they requested was permission to run the PL/C object code, which was informally granted by those staff associated with it who were still at Cornell.[46]

since 2022Template:Dated maintenance category (articles)Script error: No such module "Check for unknown parameters"., the source for PL/C appears to have been lost.

See also

References

<templatestyles src="Reflist/styles.css" />

  1. ↑ a b c d e f g h i j k l Script error: No such module "Citation/CS1".
  2. ↑ a b c d e Script error: No such module "citation/CS1".
  3. ↑ a b Script error: No such module "citation/CS1".
  4. ↑ Script error: No such module "citation/CS1".
  5. ↑ a b Script error: No such module "Citation/CS1".
  6. ↑ a b c d e f Script error: No such module "citation/CS1".
  7. ↑ a b c d e f g Script error: No such module "citation/CS1".
  8. ↑ a b c d e f g h i j Script error: No such module "citation/CS1".
  9. ↑ a b Script error: No such module "Citation/CS1".
  10. ↑ a b c Script error: No such module "citation/CS1".
  11. ↑ a b c d e f g Script error: No such module "citation/CS1".
  12. ↑ a b Script error: No such module "citation/CS1".
  13. ↑ a b c d e f Script error: No such module "Citation/CS1".
  14. ↑ a b c d e Script error: No such module "citation/CS1". (Note the first edition uses "PL/1" on the cover but "PL/I" on the title page and in the text itself.)
  15. ↑ a b c Script error: No such module "citation/CS1". See segments at 35:00 and 40:30.
  16. ↑ a b c d Script error: No such module "citation/CS1".
  17. ↑ Script error: No such module "citation/CS1".
  18. ↑ Script error: No such module "Citation/CS1".
  19. ↑ Script error: No such module "citation/CS1".
  20. ↑ Script error: No such module "citation/CS1".
  21. ↑ Script error: No such module "citation/CS1".
  22. ↑ a b Script error: No such module "citation/CS1".
  23. ↑ a b c Script error: No such module "citation/CS1".
  24. ↑ Script error: No such module "citation/CS1".
  25. ↑ See program listing image.
  26. ↑ Script error: No such module "citation/CS1".
  27. ↑ See for example Script error: No such module "citation/CS1".
  28. ↑ Script error: No such module "citation/CS1". See segment at 28:30.
  29. ↑ a b c Script error: No such module "citation/CS1".
  30. ↑ a b Script error: No such module "citation/CS1".
  31. ↑ a b Script error: No such module "Citation/CS1".
  32. ↑ a b Script error: No such module "Citation/CS1".
  33. ↑ a b Script error: No such module "citation/CS1". See segments at 10:15 and 16:18.
  34. ↑ Script error: No such module "citation/CS1".
  35. ↑ a b c d Script error: No such module "citation/CS1".
  36. ↑ a b Script error: No such module "citation/CS1". See segment at 16:30.
  37. ↑ a b Script error: No such module "citation/CS1". Entry 4422.
  38. ↑ a b Script error: No such module "citation/CS1".
  39. ↑ a b c d Script error: No such module "citation/CS1". Entry 2956; also entry 2957.
  40. ↑ a b c d Script error: No such module "citation/CS1".
  41. ↑ a b c Script error: No such module "citation/CS1".
  42. ↑ See Second Edition, "Preface", p. xiv.
  43. ↑ See Third Edition, "Preface", pp. xv–xvi.
  44. ↑ Script error: No such module "citation/CS1".
  45. ↑ Compare Script error: No such module "citation/CS1". with Script error: No such module "citation/CS1".
  46. ↑ Script error: No such module "citation/CS1".

Script error: No such module "Check for unknown parameters".

External links

Template:Authority control

Retrieved from "http://debianws.lexgopc.com/wiki143/index.php?title=PL/C&oldid=4673597"