Scala-Befehle – Schnellreferenz für die JVM

Scala vereint objektorientierte und funktionale Programmierung auf der Java Virtual Machine (JVM). Code in Scala ist oft deutlich kompakter als in Java, läuft aber im selben Ökosystem. Bekannt wurde Scala durch Apache Spark für Big Data und Akka für nebenläufige Systeme.

Erste Schritte: REPL und Projekt

scala          # REPL starten
scala-cli run  app.scala   # Skript direkt ausführen
sbt new scala/scala3.g8   # neues Projekt (sbt-Build-Tool)

Grundlagen: val, var und Typen

val name: String = "KIT"   // unveränderlich (immutable)
var count: Int = 0          // veränderlich (selten nötig)
val list = List(1, 2, 3)    // Typ-Inferenz

Funktionale Bausteine

list.map(_ * 2)        // [2, 4, 6]
list.filter(_ > 1)     // [2, 3]
list.foldLeft(0)(_ + _) // 6

// Lambda-Funktion
val double: Int => Int = x => x * 2

Case Classes und Pattern Matching

case class Punkt(x: Int, y: Int)
val p = Punkt(3, 4)

p match {
  case Punkt(0, 0) => "Ursprung"
  case Punkt(x, y) => s"x=$x, y=$y"
}

Warum Scala?

• Interoperabel – nutzt Java-Bibliotheken direkt, läuft auf der JVM.
• Unveränderliche Datenstrukturen standardmäßig – weniger Nebenwirkungen, besser parallelisierbar.
• Nebenläufigkeit – Akka-Actors machen Concurrency handhabbar, siehe Glossar Thread und Process.
• Domain-Specific Languages – durch Operator-Überladung und Currying.

Alternativen im Vergleich

• Kotlin – moderner, pragmatischer, ebenfalls JVM.
• Elm – rein funktional, aber im Browser statt auf der JVM.
• F# – funktional auf .NET.

Weiterführend: Compiler, Garbage Collection und JVM.

Elixir und Erlang – Schnellreferenz

Erlang wurde bei Ericsson für Telefonvermittlungen entwickelt: extrem robust, fehlertolerant, nebenläufig. Elixir ist eine moderne Sprache auf der gleichen VM (BEAM), die Erlangs Stärken mit einer angenehmeren Syntax verbindet – bekannt durch das Web-Framework Phoenix und LiveView.

Erste Schritte

iex             # Elixir-REPL starten
erl             # Erlang-Shell
mix new my_app  # neues Projekt anlegen
mix run         # Projekt starten

Unveränderliche Daten und Pattern Matching

name = "Devon"          # Neuzuweisung erzeugt neuen Wert
[head | tail] = [1, 2, 3]  # head = 1, tail = [2, 3]

case {1, 2} do
  {a, b} when a < b -> "kleiner"
  _ -> "unbekannt"
end

Pipe-Operator: Datenfluss lesbar machen

"Hanse Computing"
|> String.upcase()
|> String.split(" ")
# ["HANSE", "COMPUTING"]

Der Pipe-Operator erinnert an Pipes in der Shell – das Ergebnis jeder Funktion wird als erstes Argument der nächsten übergeben.

Prozesse: das Herz von BEAM

# Prozess starten
pid = spawn(fn -> IO.puts("Hallo") end)

# Nachricht senden und empfangen
send(pid, {:hallo, "KIT"})
receive do
  {:hallo, msg} -> IO.puts("Erhalten: " <> msg)
end

Millionen leichtgewichtiger Prozesse laufen parallel – kein Thread-Chaos wie in klassischen Sprachen. Dazu kommt OTP mit Supervisoren, die Prozesse bei Abstürzen automatisch neu starten („Let it crash").

Typische Befehle

• mix test – Tests ausführen
• mix phx.new app – Phoenix-Projekt erzeugen
• mix deps.get – Abhängigkeiten laden (Hex-Paketmanager)
• mix format – Code formatieren

Verwandte Themen

Mehr zu Concurrency und Nebenläufigkeit: Process, Thread, Queue. Funktional programmiert auch Elm und Scala.

Julia-Befehle – Schnellreferenz für Scientific Computing

Julia ist eine moderne Sprache für numerische Berechnungen, Datenanalyse und wissenschaftliches Rechnen. Sie verbindet die Einfachheit von Python mit der Geschwindigkeit von C – dank Just-in-Time-Kompilierung (JIT).

Erste Schritte

julia           # REPL starten
julia script.jl # Skript ausführen
julia -e 'println("Hallo")'  # Einzeiler

Variablen und Typen

x = 42                # Int
y = 3.14              # Float
s = "Hanse"           # String
const PI = 3.14159    # Konstante
::Int64               # Typannotation

Multiple Dispatch: Julia-Spezialität

flaeche(r::Float64) = π * r^2
flaeche(r::Int) = flaeche(Float64(r))
# Gleicher Funktionsname, verschiedene Typen

Arrays und Comprehensions

v = [1, 2, 3]              # Vektor
m = [1 2; 3 4]              # 2x2-Matrix
quadrate = [x^2 for x in 1:5]  # [1, 4, 9, 16, 25]
sum(v), mean(v)             # Statistik

Ökosystem (Paketmanager Pkg)

using Pkg
Pkg.add("DataFrames")   # Datenanalyse
Pkg.add("Plots")        # Visualisierung
Pkg.add("CUDA")         # GPU-Computing

Damit lassen sich DataFrames (vergleichbar mit R und pandas) und GPU-Berechnungen direkt nutzen – siehe auch GPU und Compiler.

Kontrollfluss

for i in 1:3
  println(i)
end

if x > 10
  println("groß")
else
  println("klein")
end

Warum Julia?

• Schnell – JIT-Kompilierung, nahe C-Geschwindigkeit.
• Mathematisch lesbar – Unicode-Symbole wie π, √, ∈ sind erlaubt.
• Wissenschaftlich stark – Differentialgleichungen, Optimierung, ML (Flux.jl).
• Interoperabel – ruft Python, R und C-Bibliotheken auf.

Weiterführend: Python-Befehle, R-Befehle, Machine Learning.

Haskell – Pure Functional Programming

Haskell ist eine rein funktionale, statisch typisierte Programmiersprache mit Lazy Evaluation. Das bedeutet: Funktionen haben keine Seiteneffekte, Variablen sind unveränderlich, und Ausdrücke werden erst ausgewertet, wenn ihr Wert wirklich gebraucht wird. Haskell eignet sich hervorragend, um komplexe Algorithmen kompakt und nachweisbar korrekt zu formulieren.

GHC & GHCi – Compiler und REPL

• ghc --version – Compiler-Version prüfen
• ghc Datei.hs – kompiliert zu einer ausführbaren Datei
• ghc -O2 Datei.hs – mit Optimierung kompilieren
• ghci – interaktive REPL (Read-Eval-Print-Loop) starten
• :load Datei.hs bzw. :l – Modul in GHCi laden
• :t ausdruck – Typ eines Ausdrucks anzeigen
• :info name – Informationen zu einer Funktion
• :quit bzw. :q – GHCi beenden

Basissyntax

-- Kommentar
fac :: Integer -> Integer      -- Typ-Signatur
fac 0 = 1                     -- Basisfall
fac n = n * fac (n - 1)       -- Rekursion

main :: IO ()
main = print (fac 20)

Wichtige Konzepte

• Pure Functions: gleiche Eingabe, gleiche Ausgabe, keine Seiteneffekte
• Immutable Data: Werte sind unveränderlich; „Ändern“ erzeugt neue Werte
• Lazy Evaluation: Ausdrücke werden nur bei Bedarf ausgewertet – erlaubt unendliche Listen wie take 5 [1..]
• Higher-Order Functions: map, filter, foldr/foldl
• Typklassen: Num, Eq, Ord, Show – generische Funktionen
• Monaden: kapseln Seiteneffekte (IO), Fehler (Maybe/Either) und Zustand – z. B. do-Notation

Nützliche Funktionen

map (*2) [1,2,3]        -- [2,4,6]
filter even [1..10]     -- [2,4,6,8,10]
foldr (+) 0 [1..100]    -- 5050
take 5 (repeat 7)       -- [7,7,7,7,7]

Pakete: Cabal und Stack

• cabal update – Paketindex aktualisieren
• cabal install <paket> – Paket installieren
• stack build – Projekt bauen
• stack ghci – REPL im Projektkontext

Weitere Sprachen im Glossar: Scala, Elixir & Erlang und Julia. Grundlagen funktionaler Konzepte: Algorithmus und Compiler.