Dartmouth ALGOL 30 (original) (raw)
Dartmouth ALGOL 30 was a 1960s-era implementation, first of the ALGOL 58 programming language and then of ALGOL 60. It is named after the computer on which it ran: a Librascope General Precision (LGP-30) desk-size computer acquired by Dartmouth College in 1959. Since the limited size of the LGP-30 (4K 30-bit words) precluded a full implementation of ALGOL 60, certain features (arrays called by value, own arrays, strings, variable array bounds, and recursion) were omitted; but the implementation did include parameters called by name, using thunks and integer labels.
| Property | Value |
|---|---|
| dbo:abstract | Dartmouth ALGOL 30 was a 1960s-era implementation, first of the ALGOL 58 programming language and then of ALGOL 60. It is named after the computer on which it ran: a Librascope General Precision (LGP-30) desk-size computer acquired by Dartmouth College in 1959. Since the limited size of the LGP-30 (4K 30-bit words) precluded a full implementation of ALGOL 60, certain features (arrays called by value, own arrays, strings, variable array bounds, and recursion) were omitted; but the implementation did include parameters called by name, using thunks and integer labels. ALGOL 30 was implemented by four undergraduate students. wrote the compiler, discovering as a sophomore that compound statements and blocks could be included in the Samelson and Bauer translation algorithm. This simple fact was not published until some years later by David Gries. Robert F. Hargraves, Jorge Llacer, and Anthony W. Knapp developed the run-time system, which included an interpreter for floating-point arithmetic (not supported by the limited instruction set of the LGP-30). ALGOL 30 was a two-pass system. The first pass loaded the compiler and processed source code typed by the user; it generated intermediate code, similar to relocatable binary, and punched it onto paper tape. The second pass loaded both the run-time system and the intermediate code. Compilations could be "batched," but the delay between entering the source code tape and executing the compiled program were too great to allow widespread student use. To enable wider use, Garland and Knapp developed a "load-and-go" system known as SCALP, a Self Contained ALgol Processor, for a smaller subset of ALGOL 60 (which did not allow boolean variables or operators, blocks, procedures, own or dynamic arrays, conditional expressions, and step-until for statements). SCALP devoted a third of the LGP's memory to the compiler, a third to the run-time system (which included a floating-point interpreter and numeric functions), and a third for compiled user code. Students prepared source code off-line and punched it on paper tape with a Friden flexowriter. Compilation occurred almost as quickly as the tape could be read in. This enabled student jobs to be completed in three minutes. Hundreds of students used SCALP before BASIC became available on the Dartmouth Time Sharing System in 1965. ALGOL 30 was the basis for an implementation in 1965 of ALGOL 60 on the Dartmouth Time Sharing System. Several years later, Sidney Marshall produced an implementation of ALGOL 68. (en) |
| dbo:developer | dbr:Dartmouth_College |
| dbo:influenced | dbr:Dartmouth_Time_Sharing_System |
| dbo:influencedBy | dbr:ALGOL_58 dbr:ALGOL_60 |
| dbo:wikiPageExternalLink | https://archives-manuscripts.dartmouth.edu/repositories/2/resources/2533 https://people.csail.mit.edu/garland/publications/Abstracts/1964-Dartmouth_Algol.html |
| dbo:wikiPageID | 30863656 (xsd:integer) |
| dbo:wikiPageLength | 5799 (xsd:nonNegativeInteger) |
| dbo:wikiPageRevisionID | 1105005869 (xsd:integer) |
| dbo:wikiPageWikiLink | dbr:Anthony_W._Knapp dbr:Multi-paradigm_programming_language dbr:Thomas_E._Kurtz dbr:LGP-30 dbr:Structured_programming dbr:ALGOL dbr:ALGOL_58 dbr:ALGOL_60 dbc:Procedural_programming_languages dbr:Dartmouth_College dbr:Dartmouth_Time_Sharing_System dbr:Floating-point_arithmetic dbr:Procedural_programming dbc:Dartmouth_College_history dbr:Assembly_language dbc:ALGOL_60_dialect dbr:Thunk dbr:Imperative_programming dbr:Robert_F._Hargraves dbr:Stephen_J._Garland |
| dbp:designers | dbr:Anthony_W._Knapp dbr:Thomas_E._Kurtz dbr:Robert_F._Hargraves dbr:Stephen_J._Garland |
| dbp:developer | dbr:Dartmouth_College |
| dbp:discontinued | Yes (en) |
| dbp:family | dbr:ALGOL |
| dbp:influenced | Algol 60 for the Dartmouth Time Sharing System (en) SCALP for the LGP-30 (en) |
| dbp:influencedBy | dbr:ALGOL_58 dbr:ALGOL_60 |
| dbp:name | Dartmouth ALGOL 30 (en) |
| dbp:operatingSystem | None (en) |
| dbp:paradigms | dbr:Multi-paradigm_programming_language dbr:Structured_programming dbr:Procedural_programming dbr:Imperative_programming |
| dbp:platform | dbr:LGP-30 |
| dbp:programmingLanguage | dbr:Assembly_language |
| dbp:wikiPageUsesTemplate | dbt:Infobox_programming_language dbt:Reflist dbt:Short_description dbt:Start_date_and_age |
| dct:subject | dbc:Procedural_programming_languages dbc:Dartmouth_College_history dbc:ALGOL_60_dialect |
| gold:hypernym | dbr:Implementation |
| rdf:type | owl:Thing dbo:Language dbo:Software schema:Language wikidata:Q315 wikidata:Q9143 yago:Artifact100021939 yago:Instrumentality103575240 yago:Object100002684 yago:PhysicalEntity100001930 dbo:ProgrammingLanguage yago:System104377057 yago:Whole100003553 yago:WikicatSystemsProgrammingLanguages |
| rdfs:comment | Dartmouth ALGOL 30 was a 1960s-era implementation, first of the ALGOL 58 programming language and then of ALGOL 60. It is named after the computer on which it ran: a Librascope General Precision (LGP-30) desk-size computer acquired by Dartmouth College in 1959. Since the limited size of the LGP-30 (4K 30-bit words) precluded a full implementation of ALGOL 60, certain features (arrays called by value, own arrays, strings, variable array bounds, and recursion) were omitted; but the implementation did include parameters called by name, using thunks and integer labels. (en) |
| rdfs:label | Dartmouth ALGOL 30 (en) |
| owl:sameAs | freebase:Dartmouth ALGOL 30 yago-res:Dartmouth ALGOL 30 wikidata:Dartmouth ALGOL 30 https://global.dbpedia.org/id/4isNt |
| prov:wasDerivedFrom | wikipedia-en:Dartmouth_ALGOL_30?oldid=1105005869&ns=0 |
| foaf:isPrimaryTopicOf | wikipedia-en:Dartmouth_ALGOL_30 |
| foaf:name | Dartmouth ALGOL 30 (en) |
| is dbo:influencedBy of | dbr:DOPE_(Dartmouth_Oversimplified_Programming_Experiment) |
| is dbo:wikiPageDisambiguates of | dbr:Algol_(disambiguation) |
| is dbo:wikiPageRedirects of | dbr:Dartmouth_ALGOL_implementation |
| is dbo:wikiPageWikiLink of | dbr:List_of_Dartmouth_College_faculty dbr:Thomas_E._Kurtz dbr:LGP-30 dbr:ALGOL dbr:ALGOL_58 dbr:ALGOL_60 dbr:DOPE_(Dartmouth_Oversimplified_Programming_Experiment) dbr:Dartmouth_BASIC dbr:Dartmouth_College dbr:Dartmouth_Time_Sharing_System dbr:John_G._Kemeny dbr:Mary_Kenneth_Keller dbr:Dartmouth_ALGOL_implementation dbr:Algol_(disambiguation) |
| is foaf:primaryTopic of | wikipedia-en:Dartmouth_ALGOL_30 |