H ? « ‹ ← → › »

Language peer sets for GENIE:
United States↑
United States/1961↑
Designed 1961 ↑
1960s languages ↑
Second generation↑
Early Cold War↑
Genus True ALGOL60s ↑
Multi-purpose ↑
True ALGOL60s↑
Generation of Algol 60↑
Algol family ↑
True ALGOL60s/1961↑
Generation of Algol 60/1961↑
Algol family/1961↑
True ALGOL60s/United States↑
Generation of Algol 60/United States↑
Algol family/United States↑
Multi-purpose ↑
Multi-purpose/1961↑
Multi-purpose/us ↑

GENIE(ID:3070/gen012)

Algorithmic language for the Rice R1

alternate simple view

Country: United States
Designed 1961
Genus: True ALGOL60s
Sammet category: Multi-purpose

J. Iliffe Rice University 1960

Algolish programming language, with extensibility

Ran on the Rice R1, was intended to run on the Basic Language Machine (purpose built) but problems with transistor circuit pins prevented that machine being finished

Work taken up again by Iliffe at ICL Stevanage in the UK in 1968

Places

Rice usA

Related languages

GENIE

→

Base Language

Incorporates some features of

References:

Blum (1961) Blum, E. K. review in ACM of Goodman (1961) Abstract Extract: Review Extract: Extract regarding GENIE

Iliffe (1961) Iliffe, J. "The Use of the GENIE System in Numerical Calculation" pp1-28 Extract: General Introduction Extract: Particular Aspects Of Genie Organization Extract: Conclusion
in Goodman (ed) (1961) Goodman, Richard (ed) "Annual Review in Automatic Programming" (2) 1961 Pergamon Press, Oxford

Barron (1962) Barron, D. W. review of Goodman, Richard (ed) "Annual Review in Automatic Programming", Vol. 2 Abstract Extract: Genie
in [Computer Bulletin] (1962) The Computer Bulletin June 1962

Iliffe, J. K., and Jodeit, J. G. (1962) Iliffe, J. K., and Jodeit, J. G. "A dynamic storage allocation scheme" p200
in (1962) The Computer Journal 5(3) October 1962

Iliffe, JK (1962) Iliffe, JK "Continuous Evaluation"
in Wegner, Peter (ed.) (1964) Wegner, Peter (ed.) "An Introduction to Systems Programming" proceedings of a Symposium held at the LSE 1962 (APIC Series No 2)

Rice University. (1964) Rice University. Notes on the Genie Compiler. Houston: Rice University, January 1964
in Wegner, Peter (ed.) (1964) Wegner, Peter (ed.) "An Introduction to Systems Programming" proceedings of a Symposium held at the LSE 1962 (APIC Series No 2)

Iliffe (1968) Iliffe, J,. K. "Basic Machine Principles", Macdonald, London, and American Elsevier Publishing Co. Inc. 1968
in Wegner, Peter (ed.) (1964) Wegner, Peter (ed.) "An Introduction to Systems Programming" proceedings of a Symposium held at the LSE 1962 (APIC Series No 2)

Jodeit, J. T, (1968) Jodeit, J. T, "Storage organization in programming systems"
in [ACM] (1968) [ACM] CACM 11(11) November 1968

Iliffe (1969) Iliffe, JK "Elements of BLM" Abstract Extract: BLM
in (1969) The Computer Journal 12(3) 1969

Sitton, G. A.: (1970) Sitton, G. A.: "Operations on generalzed arrays with the GENIE compiler"
in [ACM] (1970) [ACM] CACM 13(05) (May 1970).

Stock (1971) Stock, Karl F. "A listing of some programming languages and their users" in RZ-Informationen. Graz: Rechenzentrum Graz 1971 115 Abstract
in [ACM] (1970) [ACM] CACM 13(05) (May 1970).

Sammet (1972) Sammet, Jean E., "Roster of Programming Languages 1972" 113
in (1972) Computers & Automation 21(6B), 30 Aug 1972

Stock and Stock (1973) Stock, Marylene and Stock, Karl F. "Bibliography of Programming Languages: Books, User Manuals and Articles from PLANKALKUL to PL/I" Verlag Dokumentation, Pullach/Munchen 1973 262 Abstract
in (1972) Computers & Automation 21(6B), 30 Aug 1972
Resources

The Rice University Computer Genie was the system application compiler. It depended heavily on SPIREL to achieve its aims and therefore would only be used when the programmer went to the trouble of using system access calls to manage his program.

Genie "definition sets" could consist of any number of programs, although it was usual to only have one program per definition set. Names (variables, functions, named constants, etc.) could be up to five characters. There were three categories of variables: internal, external, and parametric. Internal variables were global only to the program in which they appeared, and could only be statement labels, integers, floating point numbers, or booleans--in other words, scalar quantities.

External variables could be scalar or non-scalar. Non-scalar variables would refer to a program, a vector, or a matrix. These variables would simply point to a codeword, which would then reference some object in memory. External variables were accessible to all programs in the machine, as they were memory structures pointed to by symbolically-named codewords.
Finally, parameters were used for passing information to and from programs within a definition set; they would be internal or external variables to the calling function. Any data type was acceptable as a parameter.

Since functions could be passed as generic codewords, this made an object-oriented view of problems to be solved a very natural approach. One surprising feature of Genie was that, while "[e]very Genie program is a function [and] may be used as such by any other Genie program...it may not use itself."[43] This seems odd, as tail recursion appears to be a very intuitive mechanism to use with such a calling convention, and the overhead of saving context would not have been large.

Arithmetic operations were fairly standard. The only surprising feature to modern eyes is that exponential operations were actually indicated with superscription[44] using the superscription capability of the Flexowriter. Similarly, accessing an element of a vector or matrix was done using the subscription capability of the Flexowriter[45].

Control transfer was provided with what was essentially a GO TO: the statement was CC = #LABEL, where LABEL was a statement label within the program; conditional branching was handled by CC = #A1 if P1, #A2 if P2, ... , #An if Pn, thus providing a rudimentary switch statement[46]. Loop structuring was fairly advanced for the time: a FOR...REPEAT construct was given[47], and FOR loops could be nested.

Execution of functions could be either implicit or explicit. With a function that returned a single value, implicit execution--for example, "A = F(P) + 2" was allowed. For a function returning multiple values, "EXECUTE F(P)" would have been required[48].

A set of instructions to read from paper or magnetic tape, to punch tape, or to print, were also included, as was support for inline assembly code in the AP2 format. An interesting feature of Genie was that, if compilation required more physical memory than was available, a scratch tape was mounted and the tape would be used as temporary storage for code. In that manner, programs of arbitrary length could be compiled.

Genie would typically have been used for complex mathematical programs that did not require complicated data structures. Assuming that the only entities the programmer wanted to use were supported Genie data types, it would have been easier to code a program in Genie. If the program needed only a few features not available in Genie, it would have been possible to code a program in Genie with additional functionality added in AP2. AP1 would only have been necessary to get Genie implemented and to write programs which extensively used features of the machine not supported by Genie, such as the Mode Light Register. The assembler would also have been used to write programs which bypassed SPIREL entirely and ran on the bare hardware.[49]

Search in: Google Google scholar World Cat Yahoo Overture DBLP Monash bib NZ IEEE ACM portal CiteSeer CSB ncstrl jstor Bookfinder