Julia (Programmiersprache)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Julia
Official Julia logo
Basisdaten
Paradigmen: Multiparadigmen (prozedural, funktional, Multimethode („objektorientiert“), Metaprogrammierung)
Erscheinungsjahr: 2012
Designer: Jeff Bezanson, Stefan Karpinski, Viral B. Shah, Alan Edelman
Entwickler: Jeff Bezanson, Stefan Karpinski, Viral B. Shah, et al.[1][2]
Aktuelle Version: 0.3.9  (30.5.2015[3][4])
Aktuelle Vorabversion: 0.4.0-dev  (Tägliche updates)
Typisierung: dynamisch mit Typinferenz.
Wichtige Implementierungen: Julia JIT (just-in-time) compiler
Beeinflusst von: Matlab, Scheme, Lisp, ML, Cecil, Dylan, PyPy, Ruby, Perl, R, Ruby, Lua[5]
Betriebssystem: Linux, Mac OS X, FreeBSD, Windows
Lizenz: MIT-Lizenz, GPL, LGPL, BSD
julialang.org

Julia ist eine höhere High-Performance Programmiersprache, welche vor allem für numerisches und wissenschaftliches Rechnen entwickelt wurde, während sie dennoch als eine General Purpose Language verwendet werden kann, bei gleichzeitiger Wahrung einer hohen Ausführungsgeschwindigkeit.[6][7][8][9][10] Die Syntax erinnert stark an Matlab, wie auch andere technische Programmiersprachen. Julia wurde in C, C++ und Scheme geschrieben, die Standardbibliothek ist aber in Julia selbst geschrieben. Die Entwicklung begann schon im Jahr 2009, die erste Open-Source-Version hingegen wurde erst im Februar 2012 veröffentlicht. Von der Geschwindigkeit her kann Julia in dem Bereich von C und auch Fortran eingeordnet werden, wohingegen andere wissenschaftliche Sprachen wie beispielsweise MATLAB, GNU Octave oder R signifikant langsamer sind. Charakterisiert wird das Design der Sprache durch ein Typsystem das parametrisierte Typen erlaubt, eine komplett dynamische Programmierumgebung und Multiple Dispatch als zentrales Paradigma. Julia erlaubt paralleles und verteiltes Ausführen von Programmen, und den direkten Aufruf von C und Fortran Bibliotheken. Julia enthält standardmäßig einen Garbage Collector[11] und enthält effiziente Implementierungen von Fließkommazahlen, linearer Algebra, Generierung zufälliger Zahlen und regulären Ausdrücken.

Features[Bearbeiten]

Die offizielle Website führt diese Liste als Hauptfeatures auf:

  • Multiple dispatch: Liefert die Möglichkeit, das Verhalten von Funktionen durch Kombination der Argumenttypen zu bestimmen.
  • Dynamisches Typ-System: Typen können zur Laufzeit erstellt werden.
  • Gute Performance, welche im Bereich von statisch typisierten Sprachen wie C liegt.
  • Integrierter Paketmanager
  • Lisp-ähnliche Macros und weitere Elemente der Metaprogrammierung
  • Aufruf von Python-Funktionen durch die Verwendung des PyCall-Packets (auch möglich für das neuere Python 3[12][13])
  • Direkter Aufruf von C-Funktionen: keine Wrapper oder spezielle APIs nötig
  • Mächtige Shell-ähnliche Möglichkeiten um andere Prozesse zu verwalten
  • Entwickelt für parallelism und verteiltes Rechnen
  • Koroutinen: leichtgewichtiges „grünes“ Multithreading
  • Benutzerdefinierte Typen sind so schnell wie eingebaute Typen.
  • Automatische Generierung von effizientem, spezialisiertem Code für unterschiedliche Argumententypen
  • Elegante und erweiterbare Konvertierung und Typpromotion für numerische und andere Typen
  • Unicode wird effizient unterstützt, unter anderem auch UTF-8.

Julia wurde nicht nur stark von Lisp-Dialekten, primär Scheme und Common Lisp, beeinflusst, sondern teilt auch Elemente von Dylan, wie beispielsweise die ALGOL-ähnliche Syntax statt der Lisp-ähnlichen Präfix-Syntax, welche ebenfalls eine dynamische Multiple Dispatch Sprache ist und Fortress, ebenfalls eine numerische Multiple Dispatch Programmiersprache mit umfangreichem parametrischem Typ-System. Während CLOS Common Lisp um Multiple Dispatch erweitert, muss dies explizit angegeben werden: Nur benutzerdefinierte Funktionen welche als generisch deklariert wurden, können mit Multimethoden erweitert werden.

Jedoch ist in Julia, Dylan und Fortress die Multimethode der Standard und die eingebauten Funktionen sind gänzlich generisch und erweiterbar. In Dylan wird Multiple Dispatch genauso grundlegend behandelt wie in Julia: Sämtliche benutzerdefinierte Funktionen und sogar eingebaute mathematische Operatoren wie die Addition mit + sind generisch. Dylans Typ-System unterstützt jedoch nicht vollständig parametrische Typen, was sich eher in von ML abstammenden Sprachen findet. Standardmäßig unterstützt CLOS keine parametrische Typen für Multimethoden; dies muss durch das Metaobject Protocol hinzugefügt werden. Fortress erlaubt wie Julia parametrische Typen für Multimethoden, jedoch ist Fortress statisch typisiert, während Kompilierung und Ausführung in getrennten Phasen sind, anders als in Julia. Diese Matrix aus Sprachfeatures lässt sich zusammengefasst in der folgenden Tabelle finden:

Sprache Typ-System Multimethoden Parametrische Typen
Julia dynamisch Standard ja
Common Lisp dynamisch als Erweiterung partiell (nicht für Multimethoden)
Dylan dynamisch Standard partiell (nicht für Multimethoden)
Fortress statisch Standard ja

Version 0.4[14] macht es möglich eigenständig lauffähige ausführbare Dateien mit build_executable.jl[15] zu erstellen, während Julia standardmäßig, ähnlich wie Python, vorinstalliert sein muss.

Benutzerinteraktion[Bearbeiten]

Julia enthält standardmäßig ein interaktives Kommandozeilenprogramm („Julia's REPL“), welches zum Experimentieren und schnellen Testen von Code verwendet werden kann.[16] Ein Ausschnitt aus dem REPL könnte wie folgt aussehen:[17]

julia> p(x) = 2x^2 + 1; f(x, y) = 1 + 2p(x)y
julia> println("Hello world!", " I'm on cloud ", f(0, 4), 
               " as Julia supports recognizable syntax!")
Hello world! I'm on cloud 9 as Julia supports recognizable syntax!

Das REPL gibt dem Benutzer Zugriff auf die System-Shell und stellt einen Help-Mode zur Verfügung, indem man ; bzw. ?, dem Kommando vorangestellt, nach der Eingabeaufforderung eingibt. REPL speichert auch die Chronik aus eingegebenen Kommandos, sogar zwischen Sitzungen. Siehe die Julia Dokumentation für weitere Beispiele,[18] welche Codebeispiele liefert, die direkt in REPL eingegeben oder in einer separater Datei mit einer .jl-Endung gespeichert werden können, welche durch folgendes in der System-Shell aufgerufen wird:[19]

$ julia <filename>

Paketmanager[Bearbeiten]

In Julias Paketmanager ist jedes Paket ein Git Repository, welches an einem beliebigen öffentlich erreichbaren Ort gespeichert werden kann. Die Abhängigkeiten zu Paketen wird in METADATA.jl[20] verwaltet, wodurch eine Installation von Paketen über Julia mit Pkg.add("PaketName") ermöglicht wird.

Üblicherweise werden Pakete in Julia geschrieben, sie können jedoch auch Quellcode für C, Fortran, Python oder andere Sprachen (durch BinDeps.jl) enthalten, solange ein entsprechender Compiler installiert ist, welcher den Quellcode beim Installieren des Pakets kompiliert. Alternativ ist es möglich Maschinencode durch WinRPM.jl zu inkludieren. Um installierte Pakete in Julia zu laden, wird using PaketName verwendet. Ein Update von Julias installierten Paketen ist mit Pgk.update() möglich.

Julia in Verwendung mit anderen Sprachen[Bearbeiten]

Viele Pakete[21] sind verfügbar um andere Sprachen innerhalb von Julia aufzurufen. Beispielsweise ist das Paket JavaCall.jl verfügbar, um Java von Julia aus aufzurufen;[22] Mathematica.jl, um Mathematica aufzurufen,[23] das Aufrufen von Rust ist möglich,[24][25] und node-julia erlaubt (jedoch z. Z. nicht unter Windows)[26] JavaScript/node.js die Verwendung für asynchrone (Web-) Server. Für PHP, Perl und andere Sprachen, Polyglot.jl erlaubt „transparenten Fernaufruf und rekursive Auswertung von Funktionen in anderen Sprachen, so als wären sie reguläre Julia Funktionen. Es erlaubt auch anderen Sprachen Julia Funktionen aufzurufen, so als wären sie nativ.“ [27] Julia hat ebenfalls native und Wrapper-Pakete für symbolische Mathematik.

Standardmäßig unterstützt Julia UTF-8, UTF-16 und UTF-32, jedoch können eine erweiterte Unicodeunterstützung die optionalen Pakete ICU.jl (ein Wrapper für International Components for Unicode) und UnicodeExtras.jl verwendet werden. Außerdem ist für „die Erstellung und das Arbeiten mit Browserfenstern“ das Paket Blink.jl verfügbar.

Weitere[Bearbeiten]

Für Julia gibt es Wrapper-Bibliotheken um mit graphischen Benutzeroberflächen (GUIs) zu arbeiten, wie z. B. das (zumindest für Linux, Windows und OS X) plattformunabhängige GTK+ (verwendet PySide welches in Python geschrieben wurde), Qt oder Tk - oder JGUI.jl, welches die Unterschiede der vorherigen verbirgt und das verwendet, was verfügbar ist.

Es gibt zahlreiche einzelne SQL oder NoSQL Datenbankenschnittstellen und das generische ODBC.jl für datenbankübergreifenden Zugriff.

Während Julia standardmäßig „Eager Evaluation“ (frühe Auswertung) verwendet, liefert das Lazy.jl-Paket „Grundlagen für funktionales Programmieren - Lazily-evaluated-Listen und eine große Bibliothek von Funktionen um mit diesen zu arbeiten“[28]

Zur Verwendung für Statistik- und Datenanalyse[Bearbeiten]

Julia wurde „mit dem Ziel erstellt, so einfach für Statistik zu sein wie R es ist“.[29]

Für den Fall das Julia Statistikfunktionen fehlen, die in R verfügbar sind, stehen die Pakete RCall.jl und Rif.jl zur Verfügung,[30] und für den umgekehrten Fall, RJulia.jl um Julia von R aufzurufen.

Mindestens Gadfly.jl ist verfügbar um in Julia „statistische Grafiken“ zu erstellen; ein „Graphisches Datendarstellungssystem in Julia“. Um mit Verteilungen zu arbeiten gibt es das Paket Distributions.jl.[31]

Bezüglich dem, was in Julia selbst verfügbar ist (d.h. ohne eine gemeinsame Verwendung mit R): „Rmath ist eine Bibliothek von R, welchen einfach statistische Funktionen enthält. Julia verwendet eine gepatchte Version von Rmath, welche DSFMT als zu Grunde liegenden Zufallsgenerator, für schnellere normalverteilte Zufallszahlgeneratoren.“[32][33]

Ein Wissenschaftler meinte: „Julias Code sieht sehr ähnlich wie R-Code und/oder Matlab/Octave code aus. Es ist selbstverständlich nicht identisch, jedoch ähnlich genug um lesbar zu sein.“

„Es gibt mittlerweile genug Pakete, welche zusammengenommen Julia in ihrem gesamten Potential aufleben lassen könnten und sie zur next generation Sprache für Datenanalyse werden lassen könnte.“[34] Für einen Überblick, siehe den STATISTICS-Abschnitt (und OPERATIONS RESEARCH, Economics and Valuation - Finance).

„Praktisch gesehen stellt Multiple Dispatch die objektorientierte Programmierung auf den Kopf, statt das Verkapseln von Funktionen oder Methoden in Datenstrukturen oder Objekten, werden die Funktionen effektiv für verschiedene Datenstrukturen überladen. Das objektorientierte Paradigma ist kein natürlicher Weg für Daten- und Algorithmenwissenschaftler zu arbeiten, einer der großartigen Dinge von R ist, dass es erlaubt, Programme einfach und schnell zu schreiben indem man eine angenehme und mächtige Programmierschittstelle zur Verfügung stellt. Julia bringt dies einen Schritt weiter und macht es explizit und klar, dass wir Funktionen für spezifische Datenstrukturen schreiben, jedoch mit der Option, „catch-all“ Funktionen zu schreiben, um mit beliebigen Datentypen umzugehen. Manchmal wird gefragt, ob R oder Python die am häufigsten verwendete „datenwissenschaftliche“ Programmiersprache sein wird, jetzt haben wir ein dunkles Pferd, einen Späteinsteiger im Rennen, ein neues Kind im Block, das sich eines Tages diese besondere Krone schnappen könnte.“[35]

Anzeigen von Assemblercode[Bearbeiten]

Es lässt sich der kompilierte Assemblercode für jede gerade erst eingegebene Funktion anzeigen, selbst für eingebaute Funktionen wie der Additionsoperator +, jedoch diese erst, nachdem sie mindestens ein Mal aufgerufen wurden. Man bedenke, dass es sich bei + in Julia ebenso lediglich um Funktionen handelt, was durch syntaktischen Zucker ermöglicht wird:

julia> code_native(+, (Float64, Float64))
Warning: Unable to find function pointer
ERROR: no method found for the specified argument types
 in code_native at reflection.jl:159

julia> 1.0 + 2.0
3.0
julia> code_native(+, (Float64, Float64))
	.text
Filename: float.jl
Source line: 120
	push	RBP
	mov	RBP, RSP
Source line: 120
	addsd	XMM0, XMM1
	pop	RBP
	ret

Implementation[Bearbeiten]

Der Kern von Julia wurde in C und C++ implementiert, der Parser in Scheme („femtolisp“), außerdem wurde das LLVM Compilerframework dazu verwendet, optimierten 64-bit oder 32-bit Maschinencode Just-in-time (JIT) zu generieren. Abgesehen von ein paar Ausnahmen (wie libuv) wurde die Standardbibliothek in Julia selbst geschrieben. Der wohl bemerkenswerteste Aspekt von der Implementierung von Julia ist die Ausführungsgeschwindigkeit, welche oft im Vergleich zu optimiertem C-Code den Faktor zwei nicht überschreitet. Julia ist daher meistens eine Größenordnung schneller als Python oder R.[36] Die Entwicklung von Julia begann 2009, eine open-source Version wurde im Februar 2012 veröffentlicht. [29][37]

Julia verwendet einen Mark-and-Sweep Garbage Collector (GC) Algorithmus. Für typische hochperformante Zahlenverarbeitung stellt diese Wahl kein Problem dar, jedoch kann dies für Berechnungen in Echtzeit, wie z. B. bei Audioverarbeitung, durchaus der Fall sein, hier liefert eine inkrementelle Implementierung des GC deutlich bessere Performance.[38] In der Version 0.4-dev wurde ein neuer GC implementiert, welcher bis zu doppelt so schnell sein kann wie der in den stable Versionen 0.3.x.[39]

Der 0.3 Versionszweig hat einen Zeitplan von einem Release pro Monat in welchem Bugs gefixt werden und einige neue Features von 0.4 übertragen werden.

Aktuelle und geplante Plattformen[Bearbeiten]

Auch wenn Julia JIT der LLVM verwendet,[40] (MCJIT[41] der LLVM) wird dennoch nativer Maschinencode generiert, direkt sobald eine Funktion das erste Mal ausgeführt wird. Im Gegensatz zu Java oder Dalvik wird in Julia kein in einer VM laufender Bytecode generiert.

Unterstützt werden neuere x86 und ältere i386 Prozessorarchitekturen, außerdem wird in der Version 0.4.0-dev die 32-Bit ARMv7 unterstützt („Experimental and early support“[42] während die Ergebnisse noch unfertig sind, „Von einigen Tests ist bekannt, dass sie fehlschlagen, und Backtraces sind nicht verfügbar“[43] with alpha support for Raspberry Pi 1/2[44][45] jedoch „startet Julia [auf ARMv7] Samsung Chromebook [..] ohne Probleme“[46]), an PowerPC wird noch gearbeitet.[47][48]

Einbinden in andere Sprachen[Bearbeiten]

Die Julia C API erlaubt es, dass Julia-Funktionen (d. h. die gesamte Laufzeitumgebung incl. Bibliotheken) von C Programmen ausgeführt werden können, ohne Daten kopieren zu müssen. Sprachen, die C aufrufen können, werden auch unterstützt (ausgenommen dem Fall, dass die CPU nicht von allen drei Umgebungen unterstützt wird), wie z. B. C++, möglicherweise C# (für C# unter Windows 8.1 ist die Version 0.4 nötig, jedoch kann die 0.3 Version unter älteren Windows-Versionen laufen[49]), außerdem wird Python unterstützt,[50] wobei Aufrufe, auch rekursive, in beide Richtungen möglich sind.[51] Für Sprachen, die Ausnahmen unterstützen, können die Ausnahmen, die in Julia geworfen werden, abgefangen werden und in der Zielsprache erneut geworfen werden (in C, welches keine Exceptions unterstützt, sollten diese in Julia abgefangen und behandelt werden).

Es gibt eine Bibliothek um C++ aufzurufen (ohne dass man C verwenden muss um „Name-Mangling“ zu vermeiden), welche auf sog. „Staged Functions“ angewiesen sind; dies ist jedoch erst ab Version 0.4.0-dev möglich.

Ein Compiler nach JavaScript um Ausführungen im Browser zu erlauben befindet sich in Entwicklung.[52]

Julia2C source-to-source Compiler[Bearbeiten]

Der source-to-cource Compiler Julia2C[53], ein Fork von Julia, erstellt von Intel Labs, kann Funktionen oder ganze Programme mit der Syntax von Julia, statt nativen Maschinencode, C-Code produzieren, um Kompatibilität mit anderen CPUs zu gewährleisten. Der Compiler soll es auch ermöglichen, Code auf einem höheren Level als C zu analysieren.[54]

Siehe auch[Bearbeiten]

Weblinks[Bearbeiten]

Einzelnachweise[Bearbeiten]

  1. LICENSE.md. GitHub.
  2. Contributors to JuliaLang/julia. GitHub.
  3. https://github.com/JuliaLang/julia/releases/tag/v0.3.9
  4. https://github.com/JuliaLang/julia/tree/v0.3.9
  5. http://julia.readthedocs.org/en/latest/manual/introduction/
  6. The Julia Language.
  7. Avi Bryant: Matlab, R, and Julia: Languages for data analysis. O'Reilly Strata. 15 October 2012.
  8. Paul Krill: New Julia language seeks to be the C for scientists. InfoWorld. 18 April 2012.
  9. Klint Finley: Out in the Open: Man Creates One Programming Language to Rule Them All. Wired. 3 February 2014.
  10. dotnetpro: Julia schlägt Python, Matlab, Octave und R, 3. April 2012, abgerufen am 20. September 2013
  11. Suspending Garbage Collection for Performance...good idea or bad idea?.
  12. https://groups.google.com/forum/#!topic/julia-users/lDM7-YXT2LU
  13. https://github.com/stevengj/PyCall.jl/blob/master/src/PyCall.jl#L419
  14. https://groups.google.com/forum/#!topic/julia-users/MtF4wHc77sw
  15. build_executable.jl
  16. Julia REPL documentation
  17. Siehe auch: http://julia.readthedocs.org/en/latest/manual/strings/ für String Interpolation und string(greet, ", ", whom, ".\n") Beispiel als bevorzugten Weg, Strings zu verbinden. Auch wenn der + Operator nicht für die Verkettung von Strings verwendet wird, wäre es ein Leichtes dies zu tun.
  18. Julia Documentation. Abgerufen am 18. November 2014.
  19. Learn Julia in Y Minutes
  20. METADATA.jl“ (central package listing for Julia)
  21. Julia Package Library. Abgerufen am 18. November 2014.
  22. http://aviks.github.io/JavaCall.jl/
  23. Julia aus Mathematica aufrufen. Abgerufen am 9. April 2015.
  24. Verwendung von Rust in Perl und Julia. Abgerufen am 15 May 2015: „Julia is even easier to use [than Perl, in the given example]“
  25. Stefan Karpinski: Julia and the Rust Language. 5 September 2013. Abgerufen am 15 May 2015: „Since Rust uses the C ABI, we can already call Rust libraries just as well as C. I have no idea what Erlang's ABI is like, but if it can expose a C ABI, then we can call it. Beyond that would take some work but is certainly possible.“
  26. Limitations. In: node-julia.
  27. https://github.com/wavexx/Polyglot.jl
  28. https://github.com/one-more-minute/Lazy.jl
  29. a b Why We Created Julia. February 2012. Abgerufen am 7 February 2013.
  30. https://github.com/lgautier/Rif.jl
  31. http://distributionsjl.readthedocs.org/en/latest/
  32. http://dmbates.blogspot.com/2012/03/julia-functions-for-rmath-library.html
  33. https://github.com/JuliaLang/julia/blob/master/DISTRIBUTING.md
  34. http://www.johnmyleswhite.com/notebook/2012/12/02/the-state-of-statistics-in-julia/
  35. http://active-analytics.com/blog/chainladder-julia-r-rcpp/
  36. Julia: A Fast Dynamic Language for Technical Computing (PDF) 2012.
  37. Mark Gibbs: Pure and Julia are cool languages worth checking out. In: Network World. 9 January 2013. Abgerufen am 7 February 2013.
  38. https://github.com/JuliaLang/julia/pull/5227 WIP: Incremental GC
  39. https://github.com/JuliaLang/julia/pull/8699 Generational behavior for the garbage collector
  40. Support MCJIT. Abgerufen am 26 May 2015.
  41. Using MCJIT with the Kaleidoscope Tutorial. 22 July 2013. Abgerufen am 26 May 2015.
  42. https://github.com/JuliaLang/julia/
  43. https://github.com/JuliaLang/julia/blob/master/README.arm.md
  44. Cross-compiling for ARMv6. Abgerufen am 16 May 2015: „I believe #10917 should fix this. The CPU used there arm1176jzf-s.“
  45. ARM build failing during bootstrap on Raspberry Pi 2. Abgerufen am 16 May 2015: „I can confirm (FINALLY) that it works on the Raspberry Pi 2 [..] I guess we can announce alpha support for arm in 0.4 as well.“
  46. https://github.com/JuliaLang/julia/issues/10488
  47. https://github.com/JuliaLang/julia/blob/master/Make.powerpc
  48. Porting Julia to PowerPC. Abgerufen am 9. Mai 2015: „Wow, the latest git allows me to build to completion.“
  49. Unable to use 'libjulia.dll' in a C# application on Windows 8.1.
  50. https://github.com/JuliaLang/pyjulia
  51. http://julia.readthedocs.org/en/latest/manual/embedding/
  52. Support compiling to JavaScript with Emscripten. Abgerufen am 28. Januar 2015.
  53. https://github.com/IntelLabs/julia/tree/j2c/j2c
  54. Julia2C initial release.: „By translating Julia to C, we leverage the high-level abstractions (matrix, vector, ..), which are easier to analyze, and can potentially add the rich extensions of C (like openmp, tbb, ...).
    The tool may also extend Julia to new architectures where the only available tool chain is for C [..]
    Translation from C to Julia might be harder.“