HTML Microdata document

This HTML5 document contains 59 embedded RDF statements represented using HTML+Microdata notation.

The embedded RDF content will be recognized by any processor of HTML5 Microdata.

Namespace Prefixes

Prefix	IRI
dcterms	http://purl.org/dc/terms/
yago-res	http://yago-knowledge.org/resource/
n12	http://dbpedia.org/resource/PL/
dbo	http://dbpedia.org/ontology/
foaf	http://xmlns.com/foaf/0.1/
n13	https://global.dbpedia.org/id/
yago	http://dbpedia.org/class/yago/
dbt	http://dbpedia.org/resource/Template:
rdfs	http://www.w3.org/2000/01/rdf-schema#
freebase	http://rdf.freebase.com/ns/
rdf	http://www.w3.org/1999/02/22-rdf-syntax-ns#
owl	http://www.w3.org/2002/07/owl#
wikipedia-en	http://en.wikipedia.org/wiki/
dbp	http://dbpedia.org/property/
dbc	http://dbpedia.org/resource/Category:
prov	http://www.w3.org/ns/prov#
xsdh	http://www.w3.org/2001/XMLSchema#
wikidata	http://www.wikidata.org/entity/
dbr	http://dbpedia.org/resource/

Statements

Subject Item: dbr:GEORGE_(DEUCE)
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)
dbo:wikiPageRedirects: dbr:GEORGE_(programming_language)

Subject Item: dbr:GEORGE_(Hamblin)
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)
dbo:wikiPageRedirects: dbr:GEORGE_(programming_language)

Subject Item: dbr:GEORGE_(RPN)
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)
dbo:wikiPageRedirects: dbr:GEORGE_(programming_language)

Subject Item: dbr:GEORGE_(autocode_system)
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)
dbo:wikiPageRedirects: dbr:GEORGE_(programming_language)

Subject Item: dbr:List_of_programming_languages
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)

Subject Item: dbr:English_Electric_DEUCE
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)

Subject Item: dbr:Timeline_of_programming_languages
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)

Subject Item: dbr:GEORGE_(programming_language)
rdf:type: yago:Communication100033020 yago:Abstraction100002137 yago:WikicatProgrammingLanguages yago:ArtificialLanguage106894544 yago:ProgrammingLanguage106898352 yago:Language106282651 owl:Thing
rdfs:label: GEORGE (programming language)
rdfs:comment: GEORGE (General Order Generator) is a programming language invented by Charles Leonard Hamblin in 1957. It was designed around a push-down pop-up stack for arithmetic operations, and employed reverse Polish notation. The language included loops, subroutines, conditionals, vectors, and matrices. Algebraic expressions were written in reverse Polish notation; thus, was written a b +, and similarly for the other arithmetic operations of subtraction, multiplication, and division. The algebraic expression was written a x dup × × b x × + c +, where 'dup' meant 'duplicate the value'. 0 a > 5 ↑
owl:differentFrom: dbr:George_(algebraic_compiler)
dcterms:subject: dbc:Programming_languages_created_in_1957 dbc:Stack-oriented_programming_languages dbc:Programming_languages
dbo:wikiPageID: 36133392
dbo:wikiPageRevisionID: 991723416
dbo:wikiPageWikiLink: dbc:Stack-oriented_programming_languages dbr:Stack_machine dbr:Conditional_(programming) dbr:Matrix_(mathematics) dbr:Reverse_Polish_notation dbr:Loop_(computing) dbr:Programming_language dbr:English_Electric_DEUCE dbr:Array_data_structure dbr:Subroutine dbc:Programming_languages dbr:Charles_Leonard_Hamblin dbc:Programming_languages_created_in_1957
owl:sameAs: yago-res:GEORGE_(programming_language) wikidata:Q5513190 n13:4k6qs freebase:m.0k0qv_y
dbp:wikiPageUsesTemplate: dbt:Authority_control dbt:Use_dmy_dates dbt:Confuse dbt:Reflist
dbp:cs1Dates: y
dbp:date: July 2020
dbo:abstract: GEORGE (General Order Generator) is a programming language invented by Charles Leonard Hamblin in 1957. It was designed around a push-down pop-up stack for arithmetic operations, and employed reverse Polish notation. The language included loops, subroutines, conditionals, vectors, and matrices. Algebraic expressions were written in reverse Polish notation; thus, was written a b +, and similarly for the other arithmetic operations of subtraction, multiplication, and division. The algebraic expression was written a x dup × × b x × + c +, where 'dup' meant 'duplicate the value'. Following the reverse Polish form, an assignment statement to evaluate the formula was written as a x dup × × b x × + c + (y). The computer evaluated the expression as follows: the values of a, then x, were pushed onto the top of the accumulator stack; 'dup' caused a copy of the top-most value (x) to be pushed onto the top of the accumulator stack; Multiply (×) caused the top two values, namely, x and x, to be removed (popped) and multiplied, returning the product to the top of the accumulator stack. The second multiply (×) then caused the top two values on the stack (namely, a and x**2) to be popped and multiplied, and the product (a×x**2) to be pushed onto the top of the accumulator stack. And so on the remaining components of the expression. The final operation, namely (y), 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 . The following program reads in eight values and forms their sum: 0,1, 8 rep (j) R +](P)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 8 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. Manipulation of vectors and matrices requires subscript notation. In GEORGE, the subscript(s) preceded the vector or matrix name. Thus A(j) was written j | A.The following program reads in vector a of 10 values, then forms the squares of those values, and finally prints those values. 1, 10 R1 (a)1, 10 rep (j) j | a dup * j | (a) ;]1, 10 P1 (a)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 through 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. The above GEORGE coding table assisted in transcribing a program onto punch cards. Conditional operations were written as jumps, as follows:if a > 0 go to 5 (which transfers to label 5 if a is greater than zero)would be written 0 a > 5 ↑ Label 5 was indicated by including *5 elsewhere in the program.Unconditional transfers were written 5↑ Subroutine calls were made with the down arrow, .g., to call subroutine labelled 17, write 17↓, where the label 17 was encoded using column 3 of the above table.
prov:wasDerivedFrom: wikipedia-en:GEORGE_(programming_language)?oldid=991723416&ns=0
dbo:wikiPageLength: 10857
foaf:isPrimaryTopicOf: wikipedia-en:GEORGE_(programming_language)

Subject Item: n12:I
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)

Subject Item: dbr:George
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)
dbo:wikiPageDisambiguates: dbr:GEORGE_(programming_language)

Subject Item: dbr:General_Order_Generator
dbo:wikiPageWikiLink: dbr:GEORGE_(programming_language)
dbo:wikiPageRedirects: dbr:GEORGE_(programming_language)

Subject Item: wikipedia-en:GEORGE_(programming_language)
foaf:primaryTopic: dbr:GEORGE_(programming_language)