Autocode - Versionsgeschichte

Invisigoth67: typo, form

2024-09-05T13:43:49Z

typo, form

← Nächstältere Version		Version vom 5. September 2024, 15:43 Uhr
Zeile 2:		Zeile 2:

	== Entstehungsgeschichte ==		== Entstehungsgeschichte ==
	Autocode ist eine Familie von [[Programmiersprache~~\|Programmiersprachen~~]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], sind sie nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Literatur \|Autor=Donald E. Knuth, Luis Trabb Pardo \|Titel=Early development of programming languages \|Sammelwerk=Encyclopedia of Computer Science and Technology \|Band=7 \|Verlag=Marcel Dekker \|Datum= \|Seiten=419–493}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.		Autocode ist eine Familie von [[Programmiersprache]]n, die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], sind sie nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Literatur \|Autor=Donald E. Knuth, Luis Trabb Pardo \|Titel=Early development of programming languages \|Sammelwerk=Encyclopedia of Computer Science and Technology \|Band=7 \|Verlag=Marcel Dekker \|Datum= \|Seiten=419–493}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.

	Brooker entwickelte in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]]. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der ''Mercury'' verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Ein etwas veränderter ''Mercury''-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren ''Atlas-Autocode'' zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.		Brooker entwickelte in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]]. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der ''Mercury'' verfügbaren relativ kleinen Speicher zurechtzukommen, wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren, war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Ein etwas veränderter ''Mercury''-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren ''Atlas-Autocode'' zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.

	Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von [[D. F. Hartley]] von der Universität [[Cambridge]] 1961 entwickelt. Der EDSAC-2-Autocode war eine nachfolgende Entwicklung aus dem ''Mercury''-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, die heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' entschieden beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.		Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von [[D. F. Hartley]] von der Universität [[Cambridge]] 1961 entwickelt. Der EDSAC-2-Autocode war eine nachfolgende Entwicklung aus dem ''Mercury''-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, die heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' entschieden beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.

Crazy1880: Vorlagen-fix (Sprache)

2024-06-16T09:40:44Z

Vorlagen-fix (Sprache)

@@ Zeile 2: / Zeile 2: @@
 == Entstehungsgeschichte ==
-Autocode ist eine Familie von [[Programmiersprache|Programmiersprachen]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester|Manchester]] und [[University of Cambridge|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z.&nbsp;B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], sind sie nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Literatur |Autor=Donald E. Knuth, Luis Trabb Pardo |Titel=Early development of programming languages |Sammelwerk=Encyclopedia of Computer Science and Technology |Band=7 |Verlag=Marcel Dekker |Seiten=419–493}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker|R.A. Brooker]] 1954 entwickelt.
+Autocode ist eine Familie von [[Programmiersprache|Programmiersprachen]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester|Manchester]] und [[University of Cambridge|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z.&nbsp;B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], sind sie nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Literatur |Autor=Donald E. Knuth, Luis Trabb Pardo |Titel=Early development of programming languages |Sammelwerk=Encyclopedia of Computer Science and Technology |Band=7 |Verlag=Marcel Dekker |Datum= |Seiten=419–493}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker|R.A. Brooker]] 1954 entwickelt.
 Brooker entwickelte in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]]. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung|dynamisch allozierte]] [[Feld (Datentyp)|Arrays]]. Um mit dem auf der ''Mercury'' verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Ein etwas veränderter ''Mercury''-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren ''Atlas-Autocode'' zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.
@@ Zeile 9: / Zeile 9: @@
 == Literatur ==
 == Weblinks ==

Ulanwp: 1 Vorlage Cite Book nach Vorlage Literatur konvertiert; siehe WP-Empfehlung und Fehler beseitigt

2023-01-03T20:03:03Z

1 Vorlage Cite Book nach Vorlage Literatur konvertiert; siehe WP-Empfehlung und Fehler beseitigt

← Nächstältere Version		Version vom 3. Januar 2023, 22:03 Uhr
Zeile 2:		Zeile 2:

	== Entstehungsgeschichte ==		== Entstehungsgeschichte ==
	Autocode ist eine Familie von [[Programmiersprache\|Programmiersprachen]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], sind sie nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{~~Cite~~ ~~journal \|last=Knuth~~\|~~first~~=Donald E.~~\|last2=Pardo\|first2=~~Luis Trabb\|~~title~~=Early development of programming languages\|~~journal~~=Encyclopedia of Computer Science and Technology\|~~volume~~=7\|~~pages=419–493\|publisher~~=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.		Autocode ist eine Familie von [[Programmiersprache\|Programmiersprachen]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], sind sie nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Literatur \|Autor=Donald E. Knuth, Luis Trabb Pardo \|Titel=Early development of programming languages \|Sammelwerk=Encyclopedia of Computer Science and Technology \|Band=7 \|Verlag=Marcel Dekker \|Seiten=419–493}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.

	Brooker entwickelte in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]]. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der ''Mercury'' verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Ein etwas veränderter ''Mercury''-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren ''Atlas-Autocode'' zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.		Brooker entwickelte in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]]. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der ''Mercury'' verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Ein etwas veränderter ''Mercury''-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren ''Atlas-Autocode'' zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.
Zeile 9:		Zeile 9:

	== Literatur ==		== Literatur ==
	* {{~~cite journal~~ \|~~last~~=Campbell-Kelly\|~~first=Martin\|title~~=Programming the Mark 1: Early Programming Activity at the University of Manchester\|~~journal~~=Annals of the History of Computing\|~~volume~~=2\|~~issue~~=2\|~~publisher~~=IEEE\|~~date~~= 1980\|~~pages~~=130–167 \|~~doi~~=10.1109/MAHC.1980.10018}}		* {{Literatur \|Autor=Martin Campbell-Kelly \|Titel=Programming the Mark 1: Early Programming Activity at the University of Manchester \|Sammelwerk=Annals of the History of Computing \|Band=2 \|Nummer=2 \|Verlag=IEEE \|Datum=1980 \|Sprache=en \|Seiten=130–167 \|DOI=10.1109/MAHC.1980.10018}}
	* {{~~cite book~~ \|~~last~~=Garcia Camarero\|~~first~~=~~Ernesto\| title=~~ AUTOCODE un sistema simplificado de codificacion para la computadora MERCURY\|~~publisher~~=Universidad de Buenos Aires\| ~~date~~= 1961\| ~~pages~~= 70\| ~~url~~=http://elgranerocomun.net/AUTOCODE-un-sistema-simplificado.html}} (spanisch)		* {{Literatur \|Autor=Ernesto Garcia Camarero \|Titel=AUTOCODE un sistema simplificado de codificacion para la computadora MERCURY \|Verlag=Universidad de Buenos Aires \|Datum=1961 \|Sprache=es \|Seiten=70 \|Online=[http://elgranerocomun.net/AUTOCODE-un-sistema-simplificado.html Online]}} (spanisch)

	== Weblinks ==		== Weblinks ==
	*[http://web.archive.org/web/20121201041342/http://www.chemeng.ed.ac.uk/people/jack/history/autocodes/ The Autocodes: a User’s Perspective] (Archiv)		* [http://web.archive.org/web/20121201041342/http://www.chemeng.ed.ac.uk/people/jack/history/autocodes/ The Autocodes: a User’s Perspective] (Archiv)

	== Einzelnachweise ==		== Einzelnachweise ==

Craeosh 77: -Überarbeiten-Baustein

2019-06-02T19:00:25Z

-Überarbeiten-Baustein

← Nächstältere Version		Version vom 2. Juni 2019, 21:00 Uhr
Zeile 1:		Zeile 1:
	{{überarbeiten}}
	'''Autocode''' ist eine Familie von „vereinfachten Codiersystemen“, einer frühen Form von [[Programmiersprache]]n.		'''Autocode''' ist eine Familie von „vereinfachten Codiersystemen“, einer frühen Form von [[Programmiersprache]]n.

Craeosh 77: Sprachliche Überarbeitung

2019-06-02T18:56:54Z

Sprachliche Überarbeitung

← Nächstältere Version		Version vom 2. Juni 2019, 20:56 Uhr
Zeile 3:		Zeile 3:

	== Entstehungsgeschichte ==		== Entstehungsgeschichte ==
	Autocode ist eine Familie von [[Programmiersprache\|Programmiersprachen]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.		Autocode ist eine Familie von [[Programmiersprache\|Programmiersprachen]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], sind sie nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.

	~~Von~~ Brooker ~~wurde~~ in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] ~~entwickelt~~. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. ~~Leicht~~ ~~unterschiedlicher~~ Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.		Brooker entwickelte in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]]. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der ''Mercury'' verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Ein etwas veränderter ''Mercury''-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren ''Atlas-Autocode'' zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.

	Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität ~~des Cambridges Mathematisches Laboratorium~~ 1961 entwickelt. Der EDSAC-2-Autocode war eine nachfolgende Entwicklung aus dem Mercury-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, ~~welche~~ heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' ~~entscheidend~~ beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.		Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von [[D. F. Hartley]] von der Universität [[Cambridge]] 1961 entwickelt. Der EDSAC-2-Autocode war eine nachfolgende Entwicklung aus dem ''Mercury''-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, die heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' entschieden beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.

	== Literatur ==		== Literatur ==
Zeile 14:		Zeile 14:

	== Weblinks ==		== Weblinks ==
	* [http://www.chemeng.ed.ac.uk/people/jack/history/autocodes/ The Autocodes: a User’s Perspective]		*[http://web.archive.org/web/20121201041342/http://www.chemeng.ed.ac.uk/people/jack/history/autocodes/ The Autocodes: a User’s Perspective] (Archiv)

	== Einzelnachweise ==		== Einzelnachweise ==

Craeosh 77: Kleinigkeiten, aber immer noch nicht verständlich

2019-05-18T14:43:24Z

Kleinigkeiten, aber immer noch nicht verständlich

← Nächstältere Version		Version vom 18. Mai 2019, 16:43 Uhr
Zeile 3:		Zeile 3:

	== Entstehungsgeschichte ==		== Entstehungsgeschichte ==
	Autocode ist eine [[Programmiersprache]]~~nfamilie~~, die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.		Autocode ist eine Familie von [[Programmiersprache\|Programmiersprachen]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.

	Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.		Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.

		⚫	Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt. Der EDSAC-2-Autocode war eine nachfolgende Entwicklung aus dem Mercury-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, welche heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' entscheidend beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.
	Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.
⚫	Der EDSAC-2-Autocode war eine ~~gerade~~ Entwicklung aus dem Mercury-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, welche heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' entscheidend beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.

	== Literatur ==		== Literatur ==

95.112.212.8: /* Entstehungsgeschichte */ überflüssiges Wort weg

2017-04-29T20:08:24Z

Entstehungsgeschichte: überflüssiges Wort weg

← Nächstältere Version		Version vom 29. April 2017, 22:08 Uhr
Zeile 5:		Zeile 5:
	Autocode ist eine [[Programmiersprache]]nfamilie, die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.		Autocode ist eine [[Programmiersprache]]nfamilie, die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.

	Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte ~~aus~~ des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.		Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.

	Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.		Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.

Podge15: /* Entstehungsgeschichte */ Variablen korrigiert

2017-04-03T20:21:07Z

Entstehungsgeschichte: Variablen korrigiert

← Nächstältere Version		Version vom 3. April 2017, 22:21 Uhr
Zeile 5:		Zeile 5:
	Autocode ist eine [[Programmiersprache]]nfamilie, die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.		Autocode ist eine [[Programmiersprache]]nfamilie, die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.

	Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], ~~‚a‘~~ – ~~‚z‘~~ und ‚-z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte aus des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.		Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], a – z und a‘ - z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte aus des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.

	Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.		Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.

Trustable: Kapitelreihenfolge

2017-01-30T17:22:46Z

Kapitelreihenfolge

← Nächstältere Version		Version vom 30. Januar 2017, 19:22 Uhr
Zeile 1:		Zeile 1:
	{{überarbeiten}}		{{überarbeiten}}
	'''Autocode''' ist ~~der Name einer~~ Familie von „vereinfachten Codiersystemen“, einer frühen Form von [[Programmiersprache~~\|Programmiersprachen~~]].		'''Autocode''' ist eine Familie von „vereinfachten Codiersystemen“, einer frühen Form von [[Programmiersprache]]n.
	__TOC__

	== Entstehungsgeschichte ==		== Entstehungsgeschichte ==
	Autocode ist eine [[Programmiersprache~~\|Programmiersprachenfamilie~~]], die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.		Autocode ist eine [[Programmiersprache]]nfamilie, die in den 1950er Jahren und 1960er Jahren an den Universitäten [[University of Manchester\|Manchester]] und [[University of Cambridge\|Cambridge]] für verschiedene [[Computer]] entwickelt wurde. Autocode ist dabei als Oberbegriff zu verstehen; die verschiedenen Autocodes für unterschiedliche Rechner sind, anders als z. B. die verschiedenen Versionen der einzelnen Sprache [[Fortran]], nicht notwendigerweise verwandt. Der erste Autocode und der dazugehörige [[Compiler]] wurden 1952 von [[Alick Glennie]] für den [[Manchester Mark I]] entwickelt und wird von einigen als die erste kompilierte Programmiersprache betrachtet.<ref>{{Cite journal \|last=Knuth\|first=Donald E.\|last2=Pardo\|first2=Luis Trabb\|title=Early development of programming languages\|journal=Encyclopedia of Computer Science and Technology\|volume=7\|pages=419–493\|publisher=Marcel Dekker}}</ref> Der zweite Autocode, der „Mark 1-Autocode“ wurde für den Mark I [[Tony Brooker\|R.A. Brooker]] 1954 entwickelt.

		⚫	Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], ‚a‘ – ‚z‘ und ‚-z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte aus des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher]]s und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.

⚫	Von Brooker wurde in Zusammenarbeit mit der Universität Manchester in den 1950er Jahren auch ein Autocode für den [[Ferranti Mercury]] entwickelt. „Mercury-Autocode“ hatte eine beschränkte Anzahl von [[Variable (Programmierung)\|Variablen]], ‚a‘ – ‚z‘ und ‚-z‘, und ähnelte in manchen Dingen frühen Versionen des späteren „Dartmouth [[BASIC]]“. Es hat einige Konzepte aus des späteren [[ALGOL]] ''('''Algo'''rithmic '''L'''anguage)'' vorweggenommen, jedoch noch ohne Umsetzung eines [[Stapelspeicher~~\|Stapelspeichers~~]] und somit auch ohne [[Rekursion]] und [[Speicherverwaltung\|dynamisch allozierte]] [[Feld (Datentyp)\|Arrays]]. Um mit dem auf der Mercury verfügbaren relativ kleinen Speicher zurechtzukommen wurden große Programme in „Kapitel“ unterteilt, die durch [[Overlay (Programmierung)\|Overlay]] genutzt wurden. Um den zeitraubenden Kontrollwechsel zwischen einzelnen Kapiteln zu minimieren war einige Sachkenntnis erforderlich. Dieses Konzept des Overlays im [[Trommelspeicher]] durch Benutzerkontrolle war üblich, bis in späteren Maschinen [[Virtuelle Speicherverwaltung]] zur Verfügung stand. Leicht unterschiedlicher Mercury-Autocode wurde auch für die [[Ferranti Atlas]] (von späteren Atlas-Autocode zu unterscheiden), der [[ICT 1300]] und der [[ICT 1900]] implementiert.

	Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.		Die Version für den [[Electronic Delay Storage Automatic Calculator\|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.
	Der EDSAC-2-Autocode war eine gerade Entwicklung aus dem Mercury-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, welche heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' entscheidend beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.		Der EDSAC-2-Autocode war eine gerade Entwicklung aus dem Mercury-Autocode. Er wurde nur an die Verhältnisse des Rechners angepasst und wurde für seine [[Objektcode]]-Optimierung und Quellsprachen-Diagnostik bekannt, die für die damalige Zeit fortschrittlich war. Eine weitere Version wurde für den [[Colossus]]-Nachfolger „Titan“ (den Prototyp des ATLAS-2-Computers) als eine vorläufige Notlösung verwendet, während eine wesentlich fortschrittlichere Sprache entwickelt wurde, welche heute als [[Combined Programming Language\|CPL]] ''('''C'''ombined '''P'''rogramming '''L'''anguage)'' bekannt ist. CPL wurde nie vollendet, hat aber das von [[Martin Richards]] entwickelte [[Basic Combined Programming Language\|BCPL]] ''('''B'''asic '''C'''ombined '''P'''rogramming '''L'''anguage)'' entscheidend beeinflusst, welches der Reihe nach zu den Programmiersprachen [[B (Programmiersprache)\|B]] und [[C (Programmiersprache)\|C]] weiterentwickelt wurde. Ein zeitgenössischer, aber getrennter Entwicklungsfaden, der [[Atlas-Autocode]], wurde von der Universität Manchester für die [[Manchester Mark I]] entwickelt.

		⚫	== Literatur ==
		⚫	* {{cite journal \|last=Campbell-Kelly\|first=Martin\|title=Programming the Mark 1: Early Programming Activity at the University of Manchester\|journal=Annals of the History of Computing\|volume=2\|issue=2\|publisher=IEEE\|date= 1980\|pages=130–167 \|doi=10.1109/MAHC.1980.10018}}
		⚫	* {{cite book \|last=Garcia Camarero\|first=Ernesto\| title= AUTOCODE un sistema simplificado de codificacion para la computadora MERCURY\|publisher=Universidad de Buenos Aires\| date= 1961\| pages= 70\| url=http://elgranerocomun.net/AUTOCODE-un-sistema-simplificado.html}} (spanisch)

	== Weblinks ==		== Weblinks ==
	* [http://www.chemeng.ed.ac.uk/people/jack/history/autocodes/ The Autocodes: a User’s Perspective]		* [http://www.chemeng.ed.ac.uk/people/jack/history/autocodes/ The Autocodes: a User’s Perspective]

	== Einzelnachweise ==		== Einzelnachweise ==
	<references />		<references />

⚫	== Literatur ==
⚫	* {{cite journal \|last=Campbell-Kelly\|first=Martin\|title=Programming the Mark 1: Early Programming Activity at the University of Manchester\|journal=Annals of the History of Computing\|volume=2\|issue=2\|publisher=IEEE\|date= 1980\|pages=130–167 \|doi=10.1109/MAHC.1980.10018}}
⚫	* {{cite book \|last=Garcia Camarero\|first=Ernesto\| title= AUTOCODE un sistema simplificado de codificacion para la computadora MERCURY\|publisher=Universidad de Buenos Aires\| date= 1961\| pages= 70\| url=http://elgranerocomun.net/AUTOCODE-un-sistema-simplificado.html}} (spanisch)

	[[Kategorie:Programmiersprache]]		[[Kategorie:Programmiersprache]]

DerMaxdorfer: Stil, nur im Quelltext sichtbare Absätze entfernt

2016-09-26T21:21:07Z

Stil, nur im Quelltext sichtbare Absätze entfernt

@@ Zeile 4: / Zeile 4: @@
 == Entstehungsgeschichte ==
 Die Version für den [[Electronic Delay Storage Automatic Calculator|EDSAC]] 2 ''('''E'''lectronic '''D'''elay '''S'''torage '''A'''utomatic '''C'''alculator)'' wurde von D. F. Hartley von Universität des Cambridges Mathematisches Laboratorium 1961 entwickelt.
 == Weblinks ==