GEORGE (programming language): Difference between revisions

Revision as of 01:54, 1 February 2013

Latest revision as of 18:25, 14 April 2023

(16 intermediate revisions by 11 users not shown)

Line 1:

{{confuse|George (algebraic compiler)}}

In 1957, [[Charles Leonard Hamblin]] invented the [[programming language]] '''GEORGE'''.<ref >C. L. Hamblin [1957]: ''An addressless coding scheme based on mathematical notation.'' Proceedings of the First Australian Conference on Computing and Data Processing, Salisbury, South Australia: Weapons Research Establishment, June 1957.</ref><ref >C. L. Hamblin [1957]: ''Computer Languages.'' The Australian Journal of Science, 20: 135-139. Reprinted in The Australian Computer Journal, 17(4): 195-198 (November 1985).</ref>

{{use dmy dates|date=July 2020|cs1-dates=y}}

'''GEORGE''' (General Order Generator) is a [[programming language]] invented by [[Charles Leonard Hamblin]] in 1957.<ref name="Hamblin_1957_1" /><ref name="Hamblin_1957_2" /><ref name="Hamblin_1957_3" /><ref name="Hamblin_1958" /> It was designed around a push-down pop-up stack for arithmetic operations, and employed [[reverse Polish notation]].<ref name="Beard_1997" /> The language included [[loop (computing)|loop]]s, [[subroutine]]s, [[conditional (programming)|conditional]]s, [[array data structure|vector]]s, and [[matrix (mathematics)|matrices]].

The language included [[loop (computing)|loop]]s, [[subroutine]]s, [[conditional (programming)|conditional]]s, [[array data structure|vector]]s, and [[matrix (mathematics)|matrices]].

==Description==

Algebraic expressions were written in reverse Polish notation; thus, <math>a + b</math> was written <code>a b +</code>, and similarly for the other arithmetic operations of subtraction, multiplication, and division.

Line 11 ⟶ 10:

Following the reverse Polish form, an assignment statement to evaluate the formula <math>y = ax^2 + bx + c</math> was written as <code>a x dup × × b x × + c + (y)</code>.

The computer evaluated the expression as follows: the values of <code>a</code>, then <code>bx</code>, were pushed onto the top of the [[stack machine|accumulator stack]]; '<code>dup</code>' caused a copy of the top-most value (<code>x</code>) to be pushed onto the top of the accumulator stack; Multiply (<code>×</code>) caused the top two values, namely, <code>x</code> and <code>x</code>, to be removed (popped) and multiplied, returning the product to the top of the accumulator stack. The second multiply (<code>×</code>) then caused the top two values on the stack (namely, <code>a</code> and <code>x**2</code>) to be popped and multiplied, and the product (<code>a×x**2</code>) to be pushed onto the top of the accumulator stack. And so on the remaining components of the expression. The final operation, namely (<code>y</code>), returned the value of the expression to storage without changing the status of the accumulator stack.

Assuming that the value on the top of the accumulator stack was not required immediately, it would be removed (cleared) by using the operator (<code>;</code>).

Line 24 ⟶ 23:

</pre>

: The first line initialises the sum by pushing the value zero onto the top of the accumulator stack.

: The second line introduces a loop, is spoken as "for 1 to 108 repeat for j", and is terminated by the square bracket.

: In the third line, R causes one number to be read in and pushed onto the top of the accumulator stack, and the plus sign (+) causes that value to be added to the (partial) sum, leaving only the partial sum on the top of the accumulator stack.

: After the loop terminates, the (P) causes the final sum to be punched on a card.

Line 38 ⟶ 37:

</pre>

: In the program, the first line is a vector read that reads in the ten values into a(1) through a(10).

: The second line introduces a loop to run thoughthrough the ten values of j.

: The third line fetches a(j), duplicates it, multiplies those two values giving the square, and then stores it in a(j). Note the semicolon (;), which clears (or cancels) the top entry in the accumulator stack. Were this not done, the accumulator would gradually fill up with the squares of the values.

: The final line is a vector punch (i.e., print) to write out the ten squares.

{| class="wikitable" style="text-align: center; width: 200px; height: 200px;"

|+ GEORGE coding table<ref name="Programming_Course" />

|+ GEORGE coding table<ref>''Programming Course,'' School of Electrical Engineering, The University of New South Wales, n.d., p. 24</ref>

|-

! scope="col" |

Line 125 ⟶ 124:

==References==

{{reflist|refs=

{{Reflist}}

<ref name="Hamblin_1957_1">{{cite book |title=An Addressless Coding Scheme based on Mathematical Notation |author-first=Charles Leonard |author-last=Hamblin |author-link=Charles Leonard Hamblin |___location=[[New South Wales University of Technology]] |date=May 1957 |type=Typescript}}</ref>

<ref name="Hamblin_1957_2">{{cite journal |title=An addressless coding scheme based on mathematical notation |author-first=Charles Leonard |author-last=Hamblin |author-link=Charles Leonard Hamblin |date=June 1957 |journal=Proceedings of the First Australian Conference on Computing and Data Processing |___location=Salisbury, South Australia |publisher=[[Weapons Research Establishment]]}}</ref>

<ref name="Hamblin_1958">{{cite book |author-first=Charles Leonard |author-last=Hamblin |author-link=Charles Leonard Hamblin |title=GEORGE IA and II: A semi-translation programming scheme for DEUCE: Programming and Operation Manual |publisher=School of Humanities, University of New South Wales, Kensington, New South Wales |date=1958 |url=http://members.iinet.net.au/~dgreen/deuce/GEORGEProgrammingManual.pdf |access-date=2020-07-27 |url-status=live |archive-url=https://web.archive.org/web/20200404093021/http://members.iinet.net.au/~dgreen/deuce/GEORGEProgrammingManual.pdf |archive-date=2020-04-04}}</ref>

<ref name="Beard_1997">{{cite magazine |magazine=[[Resurrection (magazine)|Resurrection]] - The Bulletin of the Computer Conservation Society |issn=0958-7403 |publisher=[[Computer Conservation Society]] (CCS) |number=18 |date=Autumn 1997 |orig-year=1996-10-01 |title=The KDF9 Computer — 30 Years On |author-first=Bob |author-last=Beard |pages=7–15 |url=http://www.cs.man.ac.uk/CCS/Archive/Resurrection/pdf/res18.pdf |access-date=2020-07-27 |url-status=live |archive-url=https://web.archive.org/web/20200727140754/http://www.cs.man.ac.uk/CCS/Archive/Resurrection/pdf/res18.pdf |archive-date=2020-07-27 |quote=[…] The [[KDF9]] is remarkable because it is the believed to be the first zero-address instruction format computer to have been announced (in 1960). It was first delivered at about the same time (early 1963) as the other famous zero-address computer, the [[Burroughs B5000]] in America. Like many modern pocket calculators, a zero-address machine allows the use of Reverse Polish arithmetic; this offers certain advantages to compiler writers. It is believed that the attention of the English Electric team was first drawn to the zero-address concept through contact with George (General Order Generator), an autocode programming system written for a [[English Electric DEUCE|Deuce]] computer by the [[University of Sydney]], Australia, in the latter half of the 1950s. George used [[Reversed Polish]], and the KDF9 team were attracted to this convention for the pragmatic reason of wishing to enhance performance by minimising accesses to main store. This may be contrasted with the more `theoretical' line taken independently by [[Burroughs Corporation|Burroughs]]. Besides a hardware [[nesting store]] or stack - the basic mechanism of a zero-address computer - the KDF9 had other groups of central registers for improving performance which gave it an interesting internal structure. […]}} [https://web.archive.org/web/20200427075718/http://www.cs.man.ac.uk/CCS/res/res18.htm#c] (NB. This is an edited version of a talk given to North West Group of the Society at the Museum of Science and Industry, Manchester, UK on 1996-10-01.)</ref>

<ref name="Hamblin_1957_3">{{cite journal |title=Computer Languages |author-first=Charles Leonard |author-last=Hamblin |author-link=Charles Leonard Hamblin |date=1957 |journal=The Australian Journal of Science |number<!-- or volume? -->=20? |pages=135–139 |postscript=;}} {{cite journal |title=Computer Languages |author-first=Charles Leonard |author-last=Hamblin |author-link=Charles Leonard Hamblin |date=November 1985 |journal=The Australian Computer Journal |volume=17 |issue=4 |pages=195–198 |type=Reprint}}</ref>

|+<ref GEORGEname="Programming_Course">{{cite codingbook table<ref>''|title=Programming Course,'' |publisher=School of Electrical Engineering, [[The University of New South Wales,]] |date=n.d., p. |page=24}}</ref>

}}

{{Authority control}}

[[Category:Programming languages]]

[[Category:1957Stack-oriented inprogramming computer sciencelanguages]]

[[Category:Programming languages created in 1957]]