Grundlagen in

Über Grundlagen

Julia ist eine dynamische, streng typisierte Programmiersprache. Der Programmierstil ist hauptsächlich funktional, allerdings mit mehr Flexibilität als in Sprachen wie Haskell.

Es gibt ein starkes und vielseitiges Typsystem, das in späteren Konzepten wichtig wird. In der Praxis leitet Julia meistens einen passenden Standardtyp aus dem Kontext ab.

Obwohl der Schwerpunkt auf Lesbarkeit liegt und Julia dadurch wie eine Skriptsprache à la Python oder Ruby wirkt, wird Julia-Code vor der Ausführung kompiliert. Der Just-in-Time-Compiler (JIT) erzeugt hoch optimierten Code für jede Funktion, sobald sie auftritt, was zu einer hohen Laufzeitgeschwindigkeit führt.

Julia ist keine objektorientierte Sprache, und es gibt keine Klassenhierarchie, wie sie für viele andere Sprachen zentral ist.

Stattdessen (und bitte keine Panik beim Lesen!) setzt Julia auf:

• Eine Typ-Hierarchie.
• Komponierbare Funktionen (darauf ausgelegt, sich leicht, vielseitig und mächtig zu kombinieren).
• Multiple Dispatch, das heißt, Funktionen können mit unterschiedlicher Anzahl und unterschiedlichen Typen von Argumenten aufgerufen werden.

Diese etwas verwirrenden Begriffe sollten klarer werden, wenn wir den Lehrplan durchgehen.

Die offizielle Dokumentation enthält viele wertvolle Informationen zur aktuellen Version, kann für Anfänger aber etwas überwältigend sein.

• Handbuch
• Tutorials
• Erste Schritte mit Julia
• Hinweise für Python-Programmierer
• Hinweise für R-Programmierer
• Hinweise für C/C++-Programmierer
• Hinweise für Matlab-Programmierer (eine proprietäre Sprache, die bei Ingenieuren sehr beliebt ist und eine Inspiration für Julia war)

Zu den Videos gehören:

• Eine kurze Einführung in Julia von der Exercism-Leitung!
• Eine sanfte Einführung in Julia
• Lerne Julia mit uns: eine vierteilige Serie

Kommentare

Kommentare im Code sind extrem wichtig, damit Menschen deinen Code lesen und deine Absichten verstehen können: vielleicht andere Leute, aber auch dein zukünftiges Ich. Vom Compiler werden sie (größtenteils) ignoriert.

In Julia gibt es zwei Möglichkeiten:

• Einzeilige Kommentare beginnen mit #
• Mehrzeilige Kommentare beginnen mit #= und enden mit =#. Verschachtelung ist erlaubt.

# This is a single-line comment

x = 3  # This is an inline comment

#=
	Multi-line comments can be used for longer explanations.

	They are especially useful to comment out blocks of code during debugging.
=#

Variablen und Zuweisung

Um eine Variable zu erstellen, weise ihr einfach einen Wert zu:

julia> myvar = 42  # an integer (in fact, Int64)
42

julia> bigint = 1_234_567_890  # optionally use underscore as digit separator, for readability
1234567890

julia> name = "Maria"  # strings are surrounded by double-quotes ""
"Maria"

Eine Zuweisung bindet einen Wert an die Variable.

Die Angabe eines Typs ist optional, und meistens leitet Julia einen passenden Standardtyp aus dem Kontext ab.

Typen sind ein wichtiges Thema in Julia. Wir werden sie in späteren Konzepten genauer untersuchen. Vorerst ist es am besten, sich keine Gedanken darüber zu machen.

Anders als in vielen funktionalen Sprachen können Variablen in Julia neu zugewiesen werden, und du kannst sowohl den Wert als auch den Typ ändern, der an die Variable gebunden ist:

julia> myvar = 3
3

julia> myvar = "now a string"
"now a string"

Konstanten

Globale Variablen, die außerhalb jeder Funktion erstellt werden, sind:

• Erlaubt.
• Manchmal notwendig.
• Normalerweise nicht empfehlenswert (allerdings nur in *.jl-Dateien; die REPL funktioniert anders).

Wenn ein Wert im gesamten Programm verfügbar sein muss, sich aber voraussichtlich nicht ändert, verwende stattdessen eine Konstante.

Wenn du der Zuweisung das Schlüsselwort const voranstellst, kann der Compiler effizienteren Code erzeugen.

Wenn du versehentlich versuchst, den const-Wert zu ändern, erhältst du eine Warnung:

julia> const answer = 42
42

julia> answer = 24
WARNING: redefinition of constant Main.answer. This may fail, cause incorrect answers, or produce other errors.
24

Arithmetische Operatoren

Arithmetik funktioniert größtenteils wie gewohnt:

2 + 3  # 5 (addition)
2 - 3  # -1 (subtraction)
2 * 3  # 6 (multiplication)
8 / 2  # 4.0 (division)
8 % 3  # 2 (remainder)
2 ^ 3  # 8 (exponentiation)

Beachte, dass eine Division mit / immer einen Gleitkommawert ergibt.

Wir kommen in späteren Konzepten darauf zurück, in denen es um ganzzahlige Division mit div() oder ÷ zum Abschneiden und um // für eine rationale Zahl geht.

Funktionen

Für die beste Laufzeitleistung ist es am besten, den größten Teil des Codes in Funktionen unterzubringen. Viele kleine Funktionen sind völlig in Ordnung, anders als in manchen anderen Sprachen.

Es gibt zwei gängige Arten, eine benannte Funktion in Julia zu definieren:

1. Mit dem Schlüsselwort function

   function muladd(x, y, z)
       x * y + z
   end
   

   Eine Einrückung um 4 Leerzeichen ist aus Gründen der Lesbarkeit üblich, aber der Compiler ignoriert sie. Das Schlüsselwort end ist unverzichtbar: eher wie in Ruby als wie in Python.

   Beachte, dass wir return x * y + z hätten schreiben können. Julia-Funktionen geben jedoch immer den zuletzt ausgewerteten Ausdruck zurück, daher ist das Schlüsselwort return optional. Viele Programmierer fügen es lieber hinzu, um ihre Absichten deutlicher zu machen.

2. Mit der „Zuweisungsform“

   muladd(x, y, z) = x * y + z
   

   Diese Form wird am häufigsten für einzeilige Funktionsdefinitionen oder mathematische Funktionen verwendet, bei denen der Funktionskörper aus einem einzigen Ausdruck besteht. In der Zuweisungsform wird nie ein return-Schlüsselwort verwendet.

Die beiden Formen sind gleichwertig und werden genau gleich verwendet, wähle also die, die besser lesbar ist.

Eine Funktion rufst du auf, indem du ihren Namen angibst und für jeden Parameter der Funktion ein Argument übergibst:

# invoking a function
muladd(10, 5, 1)

# and of course you can invoke a function within the body of another function:
square_plus_one(x) = muladd(x, x, 1)

Daraus, dass wir sie als „benannte“ Funktionen bezeichnen, könntest du schließen, dass es auch „anonyme“ Funktionen gibt. Diese werden in einem späteren Konzept behandelt.

Namenskonventionen

Wie viele Sprachen verlangt Julia, dass Namen (von Variablen, Funktionen und vielem anderen) mit einem Buchstaben beginnen, gefolgt von einer beliebigen Kombination aus Buchstaben, Ziffern und Unterstrichen.

Konventionell werden Namen von Variablen, Konstanten und Funktionen kleingeschrieben, wobei Unterstriche vermieden werden, außer wenn sie nötig sind, um Verwechslungen zu vermeiden.

Julia verwendet jedoch durchgehend Unicode, daher wird „Buchstabe“ recht flexibel ausgelegt.

Andere Sprachen als Englisch werden unterstützt, ebenso Emojis (bitte mit gutem Geschmack ausgewählt und etwas Passendes).

Insbesondere stehen alle griechischen Buchstaben zur Verfügung, die Mathematiker lieben (und einige nützliche Werte sind vordefiniert):

julia> π   # a built-in constant
π = 3.1415926535897...

Editoren mit Julia-Unterstützung, darunter die REPL, Pluto.jl und VS Code mit dem Julia-Plugin, machen die Eingabe dieser Zeichen einfach.

Für π tippst du \pi und drückst dann <Tab>. Deine Eingabe wird durch das griechische Zeichen ersetzt.

In späteren Konzepten wirst du noch viele weitere Beispiele dafür sehen.

Tatsächlich sind die Backslash-Abkürzungen nichts, was spezifisch für Julia wäre. Sie stammen aus LaTeX, einem Satzsystem, das viele Wissenschaftler und Ingenieure fast täglich zum Schreiben von Berichten verwenden.