Seit den letzten fünf bis zehn Jahren zeichnet sich ein Trend ab: Es erscheinen vermehrt statisch typisierte Programmiersprachen, die vor allem den Fokus auf Typsicherheit legen. Die Sprachen sind nicht nur unfassbar beliebt, sondern wachsen auch mit hoher Geschwindigkeit.

Programmiersprache	Erscheinungsjahr	Typisierung
Q#	2017	statisch, stark
Ring	2016	dynamisch, schwach
Simit	2016	statisch
Swift	2014	statisch, stark
Hack	2014	statisch, schwach, dynamisch
TypeScript	2012	statisch, dynamisch, stark, schwach
Julia	2012	dynamisch
Ceylon	2011	statisch, stark
Dart	2011	dynamisch
Elm	2011	statisch, stark
Kotlin	2011	statisch, stark
Chapel	2010	statisch
Rust	2010	statisch, stark
CoffeeScript	2009	dynamisch, schwach
Go	2009	statisch, stark

Wirft man einen Blick auf ein Großteil der seit 2009 neu veröffentlichten Programmiersprachen und gleicht diese mit der aktuellen Stackoverflow-Entwicklerumfrage ab, so fallen einige Sprachen auf: Neben Python führen Rust, Kotlin, TypeScript, Go und Swift die Liste der beliebtesten Programmiersprachen an – allesamt mit statischer Typisierung, hoher Typsicherheit und Interoperabilität. Sucht man genau diese Sprachen im Octoverse Report von GitHub, so stellt man fest, dass zu den Top Ten der am schnellsten wachsenden Sprachen Kotlin, TypeScript, Rust und Go gehören. Lediglich Swift taucht hier nicht weiter auf. TypeScript klettert sogar auf Rang sieben der am meisten benutzten Sprachen auf GitHub – noch vor C oder Ruby. Die Sprachen machen den Klassikern des 20. Jahrhunderts mächtig Druck.

Doch warum gehen die noch sehr jungen Programmiersprachen derart durch die Decke? Was haben sie, was den älteren Sprachen fehlt? Die statische Typisierung ist nichts Neues. Auch Java oder C++ setzen darauf. Doch vor über 20 Jahren, als Java, C++ oder JavaScript entstanden sind, war die Computer-Welt noch eine andere. Inzwischen gibt es neue Technologien, Möglichkeiten und auch andere Anforderungen. Auch wenn viele der älteren Programmiersprachen regelmäßig aktualisiert werden, um auch moderne Features zu unterstützen, kommen sie trotzdem aus einer ganz anderen Zeit. Das heißt nicht, dass die Sprachen unwichtig sind oder gar nicht mehr genutzt werden. Im Gegenteil: Es gibt immer noch Bereiche wie hardwarenahe Programmierung, für die beispielsweise die von 1972 stammende Sprache C immer noch mit am besten geeignet ist. Doch was ist mit der Entwicklung von mobilen Apps oder Webanwendungen? Dort dienen viele der aus dem letzten Jahrtausend stammenden Sprachen als Grundlage für neue, bessere Programmiersprachen. Ja, es können weiterhin Objective-C für iOS, Java für Android und JavaScript für das Web genutzt werden. Doch sind sie noch zeitgemäß? Die Unzufriedenheit einiger Unternehmen über die bisherigen Programmiersprachen ging teilweise so weit, dass einige komplett eigene Sprachen entwickelten. Das Bedürfnis nach etwas Neuem und Modernem scheint nicht nur dort groß zu sein, denn auch die Umfragen und Berichte von Stack Overflow und GitHub sprechen diese Sprache.

Geht es um die Typisierung bei Programmiersprachen, gibt es mehrere Varianten. Zwei davon sind die dynamische und statische Typisierung. Auf erstere setzen beispielsweise JavaScript oder Python. Dabei findet die Typprüfung erst während der Laufzeit statt. Manchmal stehen in einer Anwendung Typen erst zur Laufzeit fest. Das erhöht die Flexibilität eines Entwicklers in einer solchen Situation. Bei manchen Anwendungsfällen kann das ein Segen sein. Auf der anderen Seite werden viele Fehler jedoch erst zur Laufzeit und in gewissen Konstellationen erkannt. Ausgiebiges Testen ist also unabdingbar (sollte es unabhängig von der Typisierung sowieso sein). Im Alltag kann das jedoch sehr nervenaufreibend werden. Auch wird ein höherer Rechenaufwand zur Laufzeit benötigt, um die Typüberprüfung zu bewerkstelligen. Ein Code-Ausschnitt in Python könnte beispielsweise so aussehen:

# Typ von a ist durch Zuweisung eine ganze Zahl
a = 1
# addiert die Gleitkommazahl 2.0 und legt neuen Wert und Typ in a ab
a += 2.0
# Laufzeit-Fehler: a ist kein String
a.upper()

Bei statischer Typisierung hingegen steht der Typ bereits während der Kompilierung fest. Viele Fehler werden also früher als bei der dynamischen Typisierung erkannt. Wenn der Typ jedoch bereits während der Kompilierung feststeht, erhöht sich für den Entwickler genauso wie für den Compiler der Aufwand. Im Vergleich zum obigen Beispiel sieht ein Kotlin-Code etwas anders aus:

// Int kann auch weggelassen werden,
// Typ-Zuweisung erfolgt automatisch durch Compiler
var a: Int = 1
// a += 2.0 würde Compiler-fehler verursachen
// Neue Variable nötig
var b = a.toDouble() + 2.0
// Compiler-Fehler: a ist kein String
a.toUpperCase()

Bei den oben erwähnte Sprachen lässt sich ein klarer Trend ableiten. Vor allem Kotlin, Swift und Rust nutzen nicht nur allesamt statische Typisierung, sondern setzen zudem auf eine hohe Typsicherheit. Das macht sich unter anderem bei einem der wohl am häufigsten vorkommenden Fehler bei der Programmierung bemerkbar: Null-Pointer-Exceptions. In Rust beispielsweise kommen solche Null-Pointer schlicht nicht vor. Die Abwesenheit eines Wertes wird anders dargestellt. Auch bei Kotlin und Swift wurde ein Konzept entwickelt, um solche Fehler während der Laufzeit so gut es geht zu unterbinden. Eine höhere Typsicherheit sorgt kurzfristig zwar für einen höheren Aufwand und schränkt zudem die Flexibilität ein, die man beispielsweise mit dynamisch typisierten Sprachen hat. Langfristig gibt es dem Programmierer jedoch mehr Kontrolle über den Code, da weniger unvorhergesehene Dinge passieren können – und das sorgt für weniger Laufzeitfehler.

Lies passend dazu: Wechsle jetzt von Java zu Kotlin: So gelingt dein Einstieg

Ein weiterer Punkt ist die Interoperabilität. Also die Zusammenarbeit einer Programmiersprache mit einer anderen. So wird Kotlin-Code nicht nur in für die Java Virtual Machine (kurz: JVM) lesbaren Bytecode übersetzt. Sondern es können auch Java-Funktionen und -Klassen in Kotlin benutzt werden und umgekehrt. Auch kann Kotlin in JavaScript transpiliert werden. Zudem versteht sich Rust super mit C, Swift mit Objective-C und auch TypeScript weiß, wie JavaScript-Code funktioniert. Auch in Go geschriebene Funktionen können von den verschiedensten anderen Sprachen aus genutzt werden. Interoperabilität ist für neue Programmiersprachen wichtig, um in einer Welt, in der andere Sprachen die Vorherrschaft haben, Fuß fassen zu können. Nicht das Rad neu erfinden, sondern bestehende Bibliotheken und Frameworks der etablierten Programmiersprachen verstehen. Denn wer würde noch TypeScript nutzen, wenn mit der Sprache nicht die riesige Vielfalt an JavaScript-Frameworks und -Libraries verwendet werden könnte?

Die Mischung aus hoher Typsicherheit und Interoperabilität gepaart mit den modernen Sprach-Features sorgen für einen regelrechten Boom der noch jungen Programmiersprachen. Die Interoperabilität der Sprachen sorgt dafür, dass sie sich überhaupt erstmal gegen die großen Player behaupten können, bis sie vielleicht irgendwann selbst zu einem werden. Allen voran TypeScript, das im Vergleich zum Vorjahr fast zwei Mal so viel auf GitHub genutzt wird und sich damit den siebten Platz der meistgenutzten Sprachen auf der Plattform sichert. Doch auch die anderen jungen Sprachen haben reichlich zugelegt und werden in den kommenden Jahren immer wichtiger werden.

Passend zum Thema:

• Stehen wir am Anfang einer JavaScript-Ära?
• Kotlin: Warum die neue Programmiersprache so unfassbar beliebt ist