Glasgow Haskell Compiler - Versionsgeschichte

2A06:93C1:301:3:A82B:8213:93A5:3E6C: Entfernen von "sehr" und unbelegten claims

2022-11-26T17:47:00Z

Entfernen von "sehr" und unbelegten claims

← Nächstältere Version		Version vom 26. November 2022, 19:47 Uhr
Zeile 33:		Zeile 33:
	== Funktionsweise ==		== Funktionsweise ==

	Zunächst wird der Haskell-Code in eine einzige Datenstruktur geparst, um [[Typsicherheit\|Typprüfungen]] durchzuführen. Haskell ist eine sehr [[Starke Typisierung\|stark typisierte]] Sprache, weshalb dieser Schritt ~~sehr~~ wichtig ist ~~(falls hier keine Fehler auftreten, ist die Wahrscheinlichkeit, dass das Programm fehlerfrei ist, sehr hoch)~~.		Zunächst wird der Haskell-Code in eine einzige Datenstruktur geparst, um [[Typsicherheit\|Typprüfungen]] durchzuführen. Haskell ist eine sehr [[Starke Typisierung\|stark typisierte]] Sprache, weshalb dieser Schritt wichtig ist.

	Nach dieser ersten Phase wird das Programm in eine [[Zwischencode\|Zwischensprache]] namens ''Core'' umgeformt. Die ''Core''-Sprache (ursprünglich basierend auf dem [[Lambda-Kalkül]]) besitzt eine sehr überschaubare Definition, was es einfach macht, Routinen zu schreiben, die sie umformen, zum Beispiel um das Programm zu optimieren. Die ''Core''-Sprache ist eine der Stärken des GHC, da sie eine modulare Optimierungsarchitektur darstellt, die gut angepasst werden kann.<ref name="Jones 1996">Simon Peyton Jones: [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.55.4431&rep=rep1&type=pdf Compiling Haskell by program transformation: a report from the trenches] (1996)</ref>		Nach dieser ersten Phase wird das Programm in eine [[Zwischencode\|Zwischensprache]] namens ''Core'' umgeformt. Die ''Core''-Sprache (ursprünglich basierend auf dem [[Lambda-Kalkül]]) besitzt eine sehr überschaubare Definition, was es einfach macht, Routinen zu schreiben, die sie umformen, zum Beispiel um das Programm zu optimieren. Die ''Core''-Sprache ist eine der Stärken des GHC, da sie eine modulare Optimierungsarchitektur darstellt, die gut angepasst werden kann.<ref name="Jones 1996">Simon Peyton Jones: [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.55.4431&rep=rep1&type=pdf Compiling Haskell by program transformation: a report from the trenches] (1996)</ref>

93.193.29.235 am 16. Juni 2022 um 11:59 Uhr

2022-06-16T11:59:06Z

← Nächstältere Version		Version vom 16. Juni 2022, 13:59 Uhr
Zeile 19:		Zeile 19:
	}}		}}

	Der '''Glasgow Haskell Compiler''', auch '''The Glorious Glasgow Haskell Compilation System'''<ref><code>ghc --version</code></ref>, aber vor allem bekannt als '''GHC''', ist ein quelloffener [[Compiler]] für die [[Programmiersprache]] [[Haskell (Programmiersprache)\|Haskell]]. Er ist selbst in Haskell geschrieben und erzeugt ~~inzwischen~~ nativen [[Maschinencode]] für die jeweilige Plattform.		Der '''Glasgow Haskell Compiler''', auch '''The Glorious Glasgow Haskell Compilation System'''<ref><code>ghc --version</code></ref>, aber vor allem bekannt als '''GHC''', ist ein quelloffener [[Compiler]] für die [[Programmiersprache]] [[Haskell (Programmiersprache)\|Haskell]]. Er ist selbst in Haskell geschrieben und erzeugt nativen [[Maschinencode]] für die jeweilige Plattform.

	GHC gilt heute als die Haskell-Implementierung mit den meisten Features und der weitesten Verbreitung. 2011 erhielt er den [[Programming Languages Software Award]] von ACM SIGPLAN.		GHC gilt heute als die Haskell-Implementierung mit den meisten Features und der weitesten Verbreitung. 2011 erhielt er den [[Programming Languages Software Award]] von ACM SIGPLAN.

Dr Lol: /* Kritik */

2021-07-18T03:26:28Z

Kritik

← Nächstältere Version		Version vom 18. Juli 2021, 05:26 Uhr
Zeile 79:		Zeile 79:
	=== Kritik ===		=== Kritik ===

	Häufig genannte und 2005 in einer Umfrage bestätigte Kritikpunkte am GHC sind unter anderem seine geringe Geschwindigkeit, die oft schwierig zu entziffernden Fehlermeldungen, die Größe und mangelhafte Ausführungsgeschwindigkeit des erzeugten Codes und die Größe und Unübersichtlichkeit des Quellcodes von GHC.<ref>{{Webarchiv\|text=GHC Survey \|url=http://www.haskell.org/ghc/survey2005-summary \|wayback=20130608000313 ~~\|archiv-bot=2018-04-12 13:05:11 InternetArchiveBot~~ }}</ref>		Häufig genannte und 2005 in einer Umfrage bestätigte Kritikpunkte am GHC sind unter anderem seine geringe Geschwindigkeit, die oft schwierig zu entziffernden Fehlermeldungen, die Größe und mangelhafte Ausführungsgeschwindigkeit des erzeugten Codes und die Größe und Unübersichtlichkeit des Quellcodes von GHC.<ref>{{Webarchiv\|text=GHC Survey \|url=http://www.haskell.org/ghc/survey2005-summary \|wayback=20130608000313 }}</ref>

	== Einzelnachweise ==		== Einzelnachweise ==

UKoch: /* Funktionsweise */ +1 Komma

2020-03-14T19:58:02Z

Funktionsweise: +1 Komma

← Nächstältere Version		Version vom 14. März 2020, 21:58 Uhr
Zeile 33:		Zeile 33:
	== Funktionsweise ==		== Funktionsweise ==

	Zunächst wird der Haskell-Code in eine einzige Datenstruktur geparst, um [[Typsicherheit\|Typprüfungen]] durchzuführen. Haskell ist eine sehr [[Starke Typisierung\|stark typisierte]] Sprache, weshalb dieser Schritt sehr wichtig ist (falls hier keine Fehler auftreten ist die Wahrscheinlichkeit, dass das Programm fehlerfrei ist, sehr hoch).		Zunächst wird der Haskell-Code in eine einzige Datenstruktur geparst, um [[Typsicherheit\|Typprüfungen]] durchzuführen. Haskell ist eine sehr [[Starke Typisierung\|stark typisierte]] Sprache, weshalb dieser Schritt sehr wichtig ist (falls hier keine Fehler auftreten, ist die Wahrscheinlichkeit, dass das Programm fehlerfrei ist, sehr hoch).

	Nach dieser ersten Phase wird das Programm in eine [[Zwischencode\|Zwischensprache]] namens ''Core'' umgeformt. Die ''Core''-Sprache (ursprünglich basierend auf dem [[Lambda-Kalkül]]) besitzt eine sehr überschaubare Definition, was es einfach macht, Routinen zu schreiben, die sie umformen, zum Beispiel um das Programm zu optimieren. Die ''Core''-Sprache ist eine der Stärken des GHC, da sie eine modulare Optimierungsarchitektur darstellt, die gut angepasst werden kann.<ref name="Jones 1996">Simon Peyton Jones: [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.55.4431&rep=rep1&type=pdf Compiling Haskell by program transformation: a report from the trenches] (1996)</ref>		Nach dieser ersten Phase wird das Programm in eine [[Zwischencode\|Zwischensprache]] namens ''Core'' umgeformt. Die ''Core''-Sprache (ursprünglich basierend auf dem [[Lambda-Kalkül]]) besitzt eine sehr überschaubare Definition, was es einfach macht, Routinen zu schreiben, die sie umformen, zum Beispiel um das Programm zu optimieren. Die ''Core''-Sprache ist eine der Stärken des GHC, da sie eine modulare Optimierungsarchitektur darstellt, die gut angepasst werden kann.<ref name="Jones 1996">Simon Peyton Jones: [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.55.4431&rep=rep1&type=pdf Compiling Haskell by program transformation: a report from the trenches] (1996)</ref>

UKoch: /* Geschichte */ +1 Komma

2020-03-14T19:52:26Z

Geschichte: +1 Komma

← Nächstältere Version		Version vom 14. März 2020, 21:52 Uhr
Zeile 29:		Zeile 29:
	Kurz darauf begann Kevin Hammond an der [[University of Glasgow\|Universität von Glasgow]] (daher auch der Name des Compilers) die Entwicklung einer Implementierung in [[ML (Programmiersprache)\|Lazy ML]], die praktisch ein [[Compiler#Frontend (auch „Analysephase“)\|Frontend]] für eine existierende Lazy-ML-Implementierung darstellte. Als diese Implementierung lauffähig war (Juni 1989), stieß [[Simon Peyton Jones]] zu der Entwicklergruppe. Der Prototyp besaß zu diesem Zeitpunkt bereits alle in Haskell 1.0 beschriebenen Eigenschaften und war verhältnismäßig stabil. Allerdings wurde die steigende Komplexität der Implementierung zunehmend zum Problem, da der Compiler groß und langsam wurde. Daraufhin wurden einige Features wieder aus dem offiziellen Standard entfernt.		Kurz darauf begann Kevin Hammond an der [[University of Glasgow\|Universität von Glasgow]] (daher auch der Name des Compilers) die Entwicklung einer Implementierung in [[ML (Programmiersprache)\|Lazy ML]], die praktisch ein [[Compiler#Frontend (auch „Analysephase“)\|Frontend]] für eine existierende Lazy-ML-Implementierung darstellte. Als diese Implementierung lauffähig war (Juni 1989), stieß [[Simon Peyton Jones]] zu der Entwicklergruppe. Der Prototyp besaß zu diesem Zeitpunkt bereits alle in Haskell 1.0 beschriebenen Eigenschaften und war verhältnismäßig stabil. Allerdings wurde die steigende Komplexität der Implementierung zunehmend zum Problem, da der Compiler groß und langsam wurde. Daraufhin wurden einige Features wieder aus dem offiziellen Standard entfernt.

	Im Herbst desselben Jahres begann dann die Arbeit an einer völlig neuen Implementierung (allein der [[Parser]], geschrieben in [[C (Programmiersprache)\|C]] und mit der Hilfe von [[Yacc]], wurde übernommen), wieder unter Mitarbeit von S. P. Jones, außerdem Cordelia Hall und Will Partain. Entwickelt wurde komplett in Haskell, möglich wurde dies durch [[Bootstrapping (Programmierung)\|Bootstrapping]], indem der neue Compiler zunächst mit der alten Implementierung kompiliert wurde bis die neue Implementierung sich selbst kompilieren konnte (self-hosting). 1992 erschien die erste komplette Version, 0.10.<ref name="Hudak 2007">Hudak, Paul, John Hughes, Simon Peyton Jones und Philip Wadler: [http://research.microsoft.com/~simonpj/papers/history-of-haskell/index.htm A History of Haskell: Being Lazy With Class] (2007). ''Proceedings of the Third ACM SIGPLAN History of Programming Languages Conference (HOPL-III)''</ref>		Im Herbst desselben Jahres begann dann die Arbeit an einer völlig neuen Implementierung (allein der [[Parser]], geschrieben in [[C (Programmiersprache)\|C]] und mit der Hilfe von [[Yacc]], wurde übernommen), wieder unter Mitarbeit von S. P. Jones, außerdem Cordelia Hall und Will Partain. Entwickelt wurde komplett in Haskell, möglich wurde dies durch [[Bootstrapping (Programmierung)\|Bootstrapping]], indem der neue Compiler zunächst mit der alten Implementierung kompiliert wurde, bis die neue Implementierung sich selbst kompilieren konnte (self-hosting). 1992 erschien die erste komplette Version, 0.10.<ref name="Hudak 2007">Hudak, Paul, John Hughes, Simon Peyton Jones und Philip Wadler: [http://research.microsoft.com/~simonpj/papers/history-of-haskell/index.htm A History of Haskell: Being Lazy With Class] (2007). ''Proceedings of the Third ACM SIGPLAN History of Programming Languages Conference (HOPL-III)''</ref>

	== Funktionsweise ==		== Funktionsweise ==

MichaelSchoenitzer: Veraltete Versionsnummer raus, beziehe die Versionsnummer aus Wikidata

2019-11-27T19:12:27Z

Veraltete Versionsnummer raus, beziehe die Versionsnummer aus Wikidata

← Nächstältere Version		Version vom 27. November 2019, 21:12 Uhr
Zeile 8:		Zeile 8:
	\|Hersteller = [[Simon Peyton Jones]], Simon Marlow		\|Hersteller = [[Simon Peyton Jones]], Simon Marlow
	\|Erscheinungsjahr = Dezember 1992<ref>Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler: [https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf A History of Haskell: Being Lazy With Class], 16. April 2007</ref>		\|Erscheinungsjahr = Dezember 1992<ref>Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler: [https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf A History of Haskell: Being Lazy With Class], 16. April 2007</ref>
	\|AktuelleVersion = 8.6.4
	\|AktuelleVersionFreigabeDatum = 5. März 2019<ref>[https://www.haskell.org/ghc/ Release-Log]</ref>
	\|AktuelleVorabVersion =		\|AktuelleVorabVersion =
	\|AktuelleVorabVersionFreigabeDatum =		\|AktuelleVorabVersionFreigabeDatum =

Alquantor: Update version-info

2019-04-08T12:22:42Z

Update version-info

← Nächstältere Version		Version vom 8. April 2019, 14:22 Uhr
Zeile 8:		Zeile 8:
	\|Hersteller = [[Simon Peyton Jones]], Simon Marlow		\|Hersteller = [[Simon Peyton Jones]], Simon Marlow
	\|Erscheinungsjahr = Dezember 1992<ref>Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler: [https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf A History of Haskell: Being Lazy With Class], 16. April 2007</ref>		\|Erscheinungsjahr = Dezember 1992<ref>Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler: [https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf A History of Haskell: Being Lazy With Class], 16. April 2007</ref>
	\|AktuelleVersion = 8.6.3		\|AktuelleVersion = 8.6.4
	\|AktuelleVersionFreigabeDatum = 7. ~~Dezember~~ ~~2018~~<ref>[https://www.haskell.org/ghc/ Release-Log]</ref>		\|AktuelleVersionFreigabeDatum = 5. März 2019<ref>[https://www.haskell.org/ghc/ Release-Log]</ref>
	\|AktuelleVorabVersion =		\|AktuelleVorabVersion =
	\|AktuelleVorabVersionFreigabeDatum =		\|AktuelleVorabVersionFreigabeDatum =

Claude J am 26. Februar 2019 um 15:57 Uhr

2019-02-26T15:57:09Z

← Nächstältere Version		Version vom 26. Februar 2019, 17:57 Uhr
Zeile 23:		Zeile 23:
	Der '''Glasgow Haskell Compiler''', auch '''The Glorious Glasgow Haskell Compilation System'''<ref><code>ghc --version</code></ref>, aber vor allem bekannt als '''GHC''', ist ein quelloffener [[Compiler]] für die [[Programmiersprache]] [[Haskell (Programmiersprache)\|Haskell]]. Er ist selbst in Haskell geschrieben und erzeugt inzwischen nativen [[Maschinencode]] für die jeweilige Plattform.		Der '''Glasgow Haskell Compiler''', auch '''The Glorious Glasgow Haskell Compilation System'''<ref><code>ghc --version</code></ref>, aber vor allem bekannt als '''GHC''', ist ein quelloffener [[Compiler]] für die [[Programmiersprache]] [[Haskell (Programmiersprache)\|Haskell]]. Er ist selbst in Haskell geschrieben und erzeugt inzwischen nativen [[Maschinencode]] für die jeweilige Plattform.

	GHC gilt heute als die Haskell-Implementierung mit den meisten Features und der weitesten Verbreitung.		GHC gilt heute als die Haskell-Implementierung mit den meisten Features und der weitesten Verbreitung. 2011 erhielt er den [[Programming Languages Software Award]] von ACM SIGPLAN.

	== Geschichte ==		== Geschichte ==

Invisigoth67: form

2018-12-17T16:40:38Z

form

← Nächstältere Version		Version vom 17. Dezember 2018, 18:40 Uhr
Zeile 31:		Zeile 31:
	Kurz darauf begann Kevin Hammond an der [[University of Glasgow\|Universität von Glasgow]] (daher auch der Name des Compilers) die Entwicklung einer Implementierung in [[ML (Programmiersprache)\|Lazy ML]], die praktisch ein [[Compiler#Frontend (auch „Analysephase“)\|Frontend]] für eine existierende Lazy-ML-Implementierung darstellte. Als diese Implementierung lauffähig war (Juni 1989), stieß [[Simon Peyton Jones]] zu der Entwicklergruppe. Der Prototyp besaß zu diesem Zeitpunkt bereits alle in Haskell 1.0 beschriebenen Eigenschaften und war verhältnismäßig stabil. Allerdings wurde die steigende Komplexität der Implementierung zunehmend zum Problem, da der Compiler groß und langsam wurde. Daraufhin wurden einige Features wieder aus dem offiziellen Standard entfernt.		Kurz darauf begann Kevin Hammond an der [[University of Glasgow\|Universität von Glasgow]] (daher auch der Name des Compilers) die Entwicklung einer Implementierung in [[ML (Programmiersprache)\|Lazy ML]], die praktisch ein [[Compiler#Frontend (auch „Analysephase“)\|Frontend]] für eine existierende Lazy-ML-Implementierung darstellte. Als diese Implementierung lauffähig war (Juni 1989), stieß [[Simon Peyton Jones]] zu der Entwicklergruppe. Der Prototyp besaß zu diesem Zeitpunkt bereits alle in Haskell 1.0 beschriebenen Eigenschaften und war verhältnismäßig stabil. Allerdings wurde die steigende Komplexität der Implementierung zunehmend zum Problem, da der Compiler groß und langsam wurde. Daraufhin wurden einige Features wieder aus dem offiziellen Standard entfernt.

	Im Herbst desselben Jahres begann dann die Arbeit an einer völlig neuen Implementierung (allein der [[Parser]], geschrieben in [[C (Programmiersprache)\|C]] und mit der Hilfe von [[Yacc]], wurde übernommen), wieder unter Mitarbeit von S. P. Jones, außerdem Cordelia Hall und Will Partain. Entwickelt wurde komplett in Haskell, möglich wurde dies durch [[Bootstrapping (Programmierung)\|Bootstrapping]], indem der neue Compiler zunächst mit der alten Implementierung kompiliert wurde bis die neue Implementierung sich selbst kompilieren konnte (self-hosting). 1992 erschien die erste komplette Version, 0.10. <ref name="Hudak 2007">Hudak, Paul, John Hughes, Simon Peyton Jones und Philip Wadler: [http://research.microsoft.com/~simonpj/papers/history-of-haskell/index.htm A History of Haskell: Being Lazy With Class] (2007). ''Proceedings of the Third ACM SIGPLAN History of Programming Languages Conference (HOPL-III)''</ref>		Im Herbst desselben Jahres begann dann die Arbeit an einer völlig neuen Implementierung (allein der [[Parser]], geschrieben in [[C (Programmiersprache)\|C]] und mit der Hilfe von [[Yacc]], wurde übernommen), wieder unter Mitarbeit von S. P. Jones, außerdem Cordelia Hall und Will Partain. Entwickelt wurde komplett in Haskell, möglich wurde dies durch [[Bootstrapping (Programmierung)\|Bootstrapping]], indem der neue Compiler zunächst mit der alten Implementierung kompiliert wurde bis die neue Implementierung sich selbst kompilieren konnte (self-hosting). 1992 erschien die erste komplette Version, 0.10.<ref name="Hudak 2007">Hudak, Paul, John Hughes, Simon Peyton Jones und Philip Wadler: [http://research.microsoft.com/~simonpj/papers/history-of-haskell/index.htm A History of Haskell: Being Lazy With Class] (2007). ''Proceedings of the Third ACM SIGPLAN History of Programming Languages Conference (HOPL-III)''</ref>

	== Funktionsweise ==		== Funktionsweise ==

Alquantor: Version update

2018-12-09T13:53:29Z

Version update

← Nächstältere Version		Version vom 9. Dezember 2018, 15:53 Uhr
Zeile 1:		Zeile 1:

	{{Infobox Software		{{Infobox Software
	\|Name =		\|Name =
Zeile 7:		Zeile 8:
	\|Hersteller = [[Simon Peyton Jones]], Simon Marlow		\|Hersteller = [[Simon Peyton Jones]], Simon Marlow
	\|Erscheinungsjahr = Dezember 1992<ref>Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler: [https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf A History of Haskell: Being Lazy With Class], 16. April 2007</ref>		\|Erscheinungsjahr = Dezember 1992<ref>Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler: [https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf A History of Haskell: Being Lazy With Class], 16. April 2007</ref>
	\|AktuelleVersion = 8.4.3		\|AktuelleVersion = 8.6.3
	\|AktuelleVersionFreigabeDatum = 29. ~~Mai~~ 2018<ref>[https://www.haskell.org/ghc/ Release-Log]</ref>		\|AktuelleVersionFreigabeDatum = 7. Dezember 2018<ref>[https://www.haskell.org/ghc/ Release-Log]</ref>
	\|AktuelleVorabVersion =		\|AktuelleVorabVersion =
	\|AktuelleVorabVersionFreigabeDatum =		\|AktuelleVorabVersionFreigabeDatum =