Rust und Go - warum alle anderen den Anschluss verlieren

Lange Zeit schien im Backend alles auf Schienen zu laufen: Wer Performance brauchte, griff zu Java. Wer schnell mal was bauen wollte, nahm Node. Und wer irgendwo dazwischen lag, fand sich oft in der .NET-Welt mit C# wieder. Aber irgendwie passt das alles nicht mehr so richtig.

2025 fühlt sich die Landschaft anders an. Irgendwas ist in Bewegung. Vielleicht liegt es am wachsenden Sicherheitsdruck. Oder daran, dass viele Frameworks einfach zu schwerfällig geworden sind. Jedenfalls kristallisieren sich gerade zwei Sprachen heraus, die für viele das neue Backend-Zeitalter einläuten: Rust und Go.

Ich selbst komme aus einer recht klassischen Richtung - PHP, JavaScript, etwas Node. Ich will das nicht schlechtreden. Das hat alles funktioniert. Aber ich hab immer öfter gemerkt: Ich will nicht nur irgendwie „weiterarbeiten“, ich will bewusster entwickeln. Weniger Gefrickel, mehr Substanz. Die Frage war also: Wenn ich heute neu starte - womit?

Der Status Quo: Altbewährtes auf dem Prüfstand

Java, C#, Node - alles produktionsreif, alles bekannt, alles solide. Aber gleichzeitig auch: altbacken, träge.

Heute geht es um mehr. Heute geht es um:

• Code, der einem nicht ständig auf die Füße fällt.
• Strukturen, die skalieren, ohne dass sie gleich wie ein Konzernmonolith wirken.
• Performance - ja, bitte -, aber nicht auf Kosten von Lesbarkeit.

Genau hier fangen Rust und Go an, spannend zu werden.

Go - Weniger Drama, mehr liefern

Go ist keine Sprache, die dich mit Features zuschüttet. Sie ist eher wie jemand, der dir auf die Schulter klopft und sagt: "Mach einfach."

Go will nicht clever wirken. Es will lesbar sein. Es will, dass du deine Sachen erledigst. Und es bringt alles mit, was du dafür brauchst - aber eben nicht mehr.

Mich hat Go zuerst ein bisschen irritiert. Besonders diese Sache mit den Interfaces: Keine explizite Implementierung, keine Vererbung, sondern einfach Duck-Typing. "Wenn's aussieht wie 'ne Ente, klingt wie ne Ente, watschelt wie ne Ente - dann ist es eine Ente".

Für jemanden, der jahrelang klassisch objektorientiert unterwegs war, fühlt sich das im ersten Moment wie Kontrollverlust an. Aber irgendwann klickts. Und dann merkst du: Das ist eigentlich ziemlich genial. Du schreibst plötzlich viel weniger überflüssigen Code, du denkst einfacher - und trotzdem bleibt alles stabil.

Kein Wunder, dass halbe Infrastruktur-Tools wie Docker, Kubernetes oder Prometheus auf Go setzen. Das ist kein Zufall, das ist die DNA dieser Sprache: Mach dein Ding - sauber, einfach, fertig.

Rust - Die Sprache mit dem Zeigefinger

Rust ist da ganz anders. Rust lässt dich nicht einfach machen. Es fragt: "Bist du dir sicher?" - und zwar bei allem. Das fühlt sich manchmal anstrengend an, aber eben auch: sicher. Kein Nullpointer, keine Race Conditions, keine Ausreden.

Du wirst gezwungen, deinen Code wirklich zu durchdenken. Ownership, Borrowing, Lifetimes - das alles klingt erstmal wie Raketenphysik. Aber es hat einen Sinn. Rust will, dass du es richtig machst. Nicht später, nicht beim Refactor - direkt beim ersten Commit.

Ich habe (noch) kein großes Projekt in Rust umgesetzt, aber ich sehe den Reiz. Für sicherheitskritische Sachen, für performante APIs, für Anwendungen, bei denen es auf absolute Kontrolle ankommt - da ist Rust nicht nur eine Alternative. Da ist Rust wahrscheinlich genau das, was man will.

Mein Zwischenfazit

Ich hab mich entschieden. Für Go.

Nicht, weil Rust schlechter wäre. Ganz im Gegenteil - ich glaube, Rust ist eine beeindruckende Sprache mit einem echten Purpose. Aber für das, was ich aktuell vorhabe - produktiv arbeiten, gute Systeme bauen, ohne ewig mit dem Compiler zu kämpfen - ist Go einfach näher an meinem Alltag.

Und ja: Der Anfang war holprig. Duck-Typing, wenige Sprachfeatures, wenig syntaktischer Zucker - das fühlt sich erstmal fast "zu wenig" an. Aber das ist es eben nicht. Es ist konsequent wenig. Und das macht es wieder stark.

Go fühlt sich für mich nicht an wie ein Hype. Es fühlt sich an wie ein solides Werkzeug. Kein Alleskönner, aber auch keine Blackbox. Kein akademischer Overkill, sondern praktische Eleganz. Ich weiß, was passiert - und das ist mir in Zeiten von komplexen Stacks wichtiger denn je.

Und Rust?

Rust bleibt auf dem Radar. Vielleicht nicht für den nächsten Release, aber für später. Wenn ich wirklich tief einsteigen will - wenn Sicherheit über alles geht, wenn ich maximal sauber arbeiten will - dann wird Rust wieder auf den Tisch kommen. Und vielleicht werde ich es dann genauso schätzen lernen wie Go.