Rust für IoT: Abwägung von Sicherheit, Leistung und Komplexität

Das Internet der Dinge ist eine neue Realität in unserer Welt. Es hilft Menschen, ihr Leben zu automatisieren, zu überwachen und zu steuern. Das IoT ermöglicht es jedem Gerät der Welt, Daten über sich selbst zu senden und ermöglicht die Erstellung intelligenter Städte und sogar intelligenter Länder.

Das Internet der Dinge ist eine transformative Kraft, die Branchen verändert, unseren Alltag verbessert und uns in eine Ära führt, in der unsere Geräte und Umgebungen zunehmend vernetzt und intelligent werden.

Laut IoT Analytics, 16% Laut Prognosen wird die Zahl der vernetzten IoT-Geräte bis 2026 auf 16,7 Milliarden ansteigen und weltweit insgesamt 75 Milliarden erreichen. Quelle:

Laut PRIMEIQ RESEARCH (OPC) PRIVATE LIMITED, Der IoT-Markt soll voraussichtlich von 0,20 Milliarden US-Dollar im Jahr 2022 auf 1,07 Milliarden US-Dollar im Jahr 2030 wachsen, mit einem durchschnittlichen jährlichen Wachstumsbeitrag von 23,10 Prozent im Prognosezeitraum.

Mit dem weiteren Ausbau des IoT wird die Notwendigkeit für robuste und zuverlässige Technologie immer offensichtlicher. Hier kommt die Rolle der Programmierung als grundlegender Bestandteil zum Tragen. IoT-Entwicklungsdienste Dies ist das sichtbarste. Unter ihnen rückt Rust hervor, bekannt für seine Betonung von Sicherheit und Leistung, und stellt damit eine besonders attraktive Wahl für IoT-Anwendungen mit Rust dar. Seine einzigartigen Funktionen bieten Lösungen für einige der drängendsten Herausforderungen in der IoT-Entwicklung, darunter Speicherzuverlässigkeit, Konkurrentenverhalten und Systemverfügbarkeit.

In den nächsten Minuten werden wir die Essenz von IoT, seine tiefgreifenden Auswirkungen und die Vor- und Nachteile der Nutzung von Rust, einer modernen Programmiersprache, bei der Entwicklung von IoT untersuchen.

Zuverlässigkeit, Effizienz und Sicherheit sind in der IoT-Branche besonders wichtig, weshalb Rust sich als rationaler Wahl für Entwickler herausstellt. Diese Programmiersprache, die für ihre hohe Sicherheits- und Performance-Orientierung bekannt ist, adressiert mehrere kritische Herausforderungen, die bei der Entwicklung von IoT-Systemen auftreten. Lassen Sie uns die Gründe für die zunehmende Beliebtheit von Rust bei IoT-Projekten näher betrachten.

Rust ist eine beliebte Programmiersprache mit mehreren Paradigmen, die eine erhebliche Leistungsfähigkeit, Sicherheit und erhebliche Flexibilität bietet. Da Rust eine kompilierte Sprache mit kostengünstigen Abstraktionen ist, kann sie aufgrund ihrer Geschwindigkeit, Sicherheit und Flexibilität in denselben Wettbewerbsbereich wie C und C++ konkurrieren.

Laut dem Benchmark Rust ist mindestens so schnell wie C++ und in einigen Fällen sogar noch schneller.

Da IoT-Produkte mindestens zwei Komponenten des Systems umfassen: Smart Devices (z. B. Sensoren) und Cloud- oder Edge-Server, die alle Informationen von den Geräten verarbeiten, wollen wir uns mit IoT-Geräten befassen und darüber, wie Rust dabei helfen kann.

Die meisten IoT-Geräte enthalten einen CPU mit geringer Leistung (wie ARM usw.) und verfügen über minimale RAM-Speicher und eine permanente Speicherkapazität. Dies bedeutet, dass die Firmware für solche Geräte sehr leistungsstark sein und möglichst klein sein sollte.

Rust ist eine Systemprogrammierungssprache, was bedeutet, dass diese Sprache für die Programmierung auf der niedrigen Ebene effektiv ist und es auch dem Benutzer ermöglicht, die Speicherverwaltung zu steuern und die volle Leistung jeglicher Hardware zu nutzen. Rust eignet sich gut für eingebettete Systeme, da sie eine kostengünstige Abstraktion bietet und Ingenieuren die Möglichkeit gibt, in der Programmierung auf der niedrigen Ebene hochgradige Konzepte anzuwenden, wodurch Code leichter zu lesen, wartungsfreundlicher und für die Zukunft flexibler wird. Diese Funktionen machen Rust zu einer idealen Wahl für die gesamte Softwareentwicklung. IoT-Services und -Lösungen die eine zuverlässige Integration zwischen eingebetteten Geräten, Gateways und der Cloud-Infrastruktur erfordern.

Rust für das IoT. Vorteile

Sicherheit und Zuverlässigkeit: Rusts starkes Gewicht auf Sicherheit und Speicherverwaltung erstreckt sich auch auf Cloud-Server-Anwendungen. Dies kann dazu beitragen, häufige Sicherheitslücken zu verhindern und die Zuverlässigkeit Ihrer Cloud-basierten Dienste zu gewährleisten – was besonders wichtig ist, wenn es um IoT-Daten geht.

Konkurrenten: Cloud-Lösungen erfordern oft die Verwaltung einer großen Anzahl von gleichzeitigen Verbindungen und Aufgaben. Rusts Eigentumsmodell und sein Konkurrentenmodell machen es ideal für die Entwicklung skalierbarer und konvergenter Serveranwendungen.

Leistung: Der Fokus von Rust auf der Leistungsoptimierung kann zu schnelleren und effizienteren Cloud-Services führen, die eine schnelle Verarbeitung und Reaktion auf Daten von IoT-Geräten ermöglichen. Diese Leistungsvorteile machen Rust besonders geeignet für Industrielle IoT-Lösungen, Hier sind Echtzeitdatenverarbeitung und vorausschauende Instandhaltung entscheidend, um die Betriebsabläufe zu optimieren und die Ausfallzeiten zu minimieren.

Plattformübergreifende Kompatibilität: Die plattformübergreifenden Funktionen von Rust erstrecken sich auf die Cloud-Infrastruktur, was es ermöglicht, Rust-basierte Dienste auf verschiedenen Cloud-Anbietern und -Architekturen zu betreiben.

Unterstützung für Web Assembly (Wasm): Rust kann in WebAssembly (Wasm) kompiliert werden, was es geeignet für die Entwicklung von IoT-bezogenen Webanwendungen und -diensten macht und die Benutzeroberfläche sowie die Interaktion mit IoT-Geräten verbessert.

Open Source-Community: Rust verfügt über eine wachsende und aktive Open-Source-Community, die Bibliotheken und Tools bereitstellt, die für die Cloud-Entwicklung nützlich sein können, wie etwa Web-Frameworks und Datenbank-Connector.

Nachteile von IoT mit Rust könnten auftreten

Lernkurve: Wie bereits erwähnt, hat Rust eine Lernkurve. Neue Entwickler müssen möglicherweise Zeit und Schulung investieren, um in der Sprache geschickt zu werden, was die Projektlaufzeiten beeinträchtigen kann.

Ecosystem-Reife: Während das Rust-Ökosystem wächst, verfügt es möglicherweise nicht über so ausgewogene und umfassende Bibliotheken und Frameworks für die Cloud-Entwicklung wie andere Sprachen.

Talentpool: Die Suche nach Rust-Entwicklern mit Expertise in der Cloud-Entwicklung kann schwieriger sein als die Suche nach Entwicklern für etabliertere Sprachen wie Python oder JavaScript.
Integration: Wenn Ihre Cloud-Lösung mit anderen Diensten und Technologien integriert werden soll, sollten Sie sicherstellen, dass es kompatible Rust-Bibliotheken gibt, oder die erforderlichen Integrationsanstrengungen berücksichtigen.

Vergleichen wir Rust mit C und C++

Wie wir sehen können, ist Rust eine kluge Technologiewahl und weist gegenüber C und C++ mehrere Vorteile auf. Das Rust-Ökosystem wächst weiter und wird im Toolchain immer besser als C und C++. Darüber hinaus bieten das Build-System und die ‘göttliche’ Infrastruktur in Rust erhebliche Vorteile für die Gründung neuer Projekte. Das ständig weiterentwickelnde Ökosystem bietet immer mehr hochwertige Bibliotheken und Frameworks für die Arbeit mit Projekten unterschiedlicher Komplexität.

Die theoretischen Vorteile von Rust für die IoT-Entwicklung sind überzeugend, doch in der Praxis kommen die Fähigkeiten des Programmiersprachen wirklich zum Tragen. In diesen Szenarien kommen professionelle Entwickler zum Einsatz. IoT-App-Entwicklungsservices Hilft dabei, die Kluft zwischen angeschlossener Hardware und Endanwendungsprogrammen zu überbrücken und einen nahtlosen Datenfluss und eine optimale Benutzerfreundlichkeit zu gewährleisten. Hier sind einige bemerkenswerte Einsatzfälle, die zeigen, wie Rust in IoT-Projekten eingesetzt wird und seine Vielseitigkeit und Effektivität unter Beweis stellt.

Smart-Home-Geräte

Im Bereich der Smart-Home-Technologie wurde Rust verwendet, um sichere, zuverlässige und leistungsstarke Geräte zu entwickeln. Unternehmen nutzen Rust, um Firmware und Steuerungssysteme für Geräte wie intelligente Thermostate, Beleuchtung und Sicherheitssysteme zu entwickeln. Die Speicher-Sicherheit und die Konkurrentenfunktionen von Rust gewährleisten, dass diese Geräte über lange Zeiträume zuverlässig funktionieren, oft mit minimaler Wartung, während ihre Sicherheitsfunktionen vor häufigen Schwachstellen schützen, was in der Domotikbranche von entscheidender Bedeutung ist. Tatsächlich unterstreichen diese Funktionen die Rolle von IoT-Produktdesign bei der Gewährleistung der Zuverlässigkeit und Sicherheit von Smart-Homes.

Samsung – einer der weltweit führenden Anbieter von Technologie – verwendet Rust für IoT-Geräte in der Smart Home-Lösung.

Rust für IoT-Projekte in der industriellen Automatisierung

Der Industriebereich nutzt Rust zunehmend für die Entwicklung von IoT-Lösungen, die hohe Zuverlässigkeit und Leistung erfordern. So wird Rust beispielsweise bei der Entwicklung von Sensoren und Steuerungen in Fertigungsanlagen eingesetzt. Diese Geräte müssen häufig große Datenmengen in Echtzeit verarbeiten und schnelle Entscheidungen treffen. Die hohe Performance und die Möglichkeit, mehrere Vorgänge gleichzeitig auszuführen, machen Rust zu einer idealen Wahl für solche Anwendungen.

Eine der größten Open-Source-Lösungen für die industrielle Automatisierung Plattformen Es wurde in Rust neu geschrieben.

Landwirtschaftliche IoT-Lösungen

Die Landwirtschaft ist ein weiterer Bereich, in dem IoT-Lösungen auf Rust-Basis Wirkung erzeugen. Entwickler nutzen Rust, um Sensornetzwerke zu erstellen, die Umweltbedingungen wie Temperatur, Luftfeuchtigkeit und Bodenfeuchtigkeit überwachen. Diese Sensoren helfen dabei, datengetriebene Entscheidungen für die Kultivierung von Pflanzen zu treffen. Die effiziente Nutzung von Ressourcen durch Rust ist hier besonders vorteilhaft, da viele landwirtschaftliche IoT-Geräte wie Slowtec oder Netlume werden in abgelegenen Orten eingesetzt, wo die Stromversorgung und die Verbindungen begrenzt sind.

Leistungsfähigkeit von Rust für IoT in Transport und Logistik

Rust findet auch Anwendungen in der Transport- und Logistikbranche. So wird er beispielsweise in IoT-Systemen zur Fahrzeugverfolgung, Flottenmanagement und Ladungserfassung eingesetzt. Diese Systeme profitieren von Rusts Robustheit und seiner Fähigkeit, unabhängig von unterschiedlichen Hardware- und Netzwerkbedingungen konsequent zu funktionieren.

Beispielsweise:, Routific Verwendet Rust zur Routenoptimierung im Bereich der Lieferdienstleistungen. Nextbilion, Deliveroo und Bepark Es gibt weitere großartige Einsatzmöglichkeiten von Rust in der IoT-Technologie für die Logistik.

Diese Anwendungsfälle illustrieren nur einige Beispiele dafür, wie Rust in verschiedenen IoT-Bereichen effektiv eingesetzt wird. Seine Kombination aus Sicherheit, Leistung und Cross-Plattform-Funktionalitäten macht es nicht nur zu einer praktischen Wahl für aktuelle IoT-Anforderungen, sondern positioniert es auch als zukunftsweisende Lösung für die Herausforderungen der vernetzten Welt von morgen.

Tockos

TockOS ist ein Open-Source-Betriebssystem, das speziell für die Verwendung in Mikrocontrollern in IoT-Geräten entwickelt wurde. Es ist einzigartig in seiner Herangehensweise, da es vollständig in Rust geschrieben wurde, einer Programmiersprache, die für ihr besonderes Augenmerk auf Sicherheit und Effizienz bekannt ist.

Hauptmerkmale von TockOS

Speicher-Sicherheit: Eine der zentralen Vorteile von TockOS, die auf seiner Rust-Basis basieren, ist die Speicherzuverlässigkeit. Diese Funktion ist entscheidend, um häufige Programmierfehler zu verhindern, die zu Sicherheitslücken führen können, insbesondere bei IoT-Geräten, die oft in sicherheitskritischen Umgebungen eingesetzt werden.

Multitasking mit Sicherheit: TockOS unterstützt Multitasking und ermöglicht es IoT-Geräten, mehrere Anwendungen gleichzeitig zu betreiben. Dies geschieht mithilfe eines Kapselmodells, das Anwendungen voneinander isoliert und somit Sicherheit und Stabilität bietet.

Niedrige Betriebskosten: TockOS wurde so konzipiert, dass es leicht ist und daher für IoT-Geräte geeignet ist, die über begrenzte Rechenressourcen verfügen. Seine Effizienz ist ein wesentlicher Vorteil in Situationen, in denen Geräte mit minimalem Stromverbrauch und geringer Speicheranforderung arbeiten müssen.

Open Source und Community-Driven: Da TockOS ein Open-Source-Projekt ist, profitieren es von Beiträgen der Community. Diese Aspekt fördert kontinuierliche Verbesserung und Anpassung, sodass das Betriebssystem stets auf dem neuesten Stand der technologischen Fortschritte und Sicherheitsstandards ist.

Zielgerichtete Nutzung von eingeschränkten Geräten: TockOS ist speziell für Mikrocontroller und beschränkte Geräte zugeschnitten, die in IoT-Anwendungen häufig verwendet werden. Diese Ausrichtung sorgt dafür, dass das Betriebssystem auf die Arten von Hardware optimiert ist, die in IoT-Systemen normalerweise verwendet wird.

RIOT

Dies ist ein Betriebssystem für das Internet der Dinge (IoT), das in C geschrieben wurde. Es ist jedoch ein beliebtes Betriebssystem und Framework, speziell für das IoT entwickelt, mit Unterstützung für verschiedene Protokolle wie MQTT, TCP, QUIC, LoRaWAN, Bluetooth, Wi-Fi usw. Riot bietet native Unterstützung für verschiedene Mikrocontroller, einschließlich Achtbits-Mikrocontrollern.

Eine der Vorteile und wichtigen Schritte ist die Einführung der Rust-Unterstützung. Man kann Anwendungen in Rust schreiben, aber wenn man sich die Dokumentation ansieht, wird man eher in die Details verwickelt als in die Grundlagen zu verstehen. Dies deutet jedoch darauf hin, dass Riot die Verwendung von Rust für die Softwareentwicklung erwägt – ein positiver Schritt für die Zukunft. Riot ist gut dokumentiert, sogar besser als TOCKOS, und verfügt über effiziente Tools, einschließlich Unterstützung für Cargo.

Botschaft

Dies ist kein Betriebssystem, sondern ein Framework für das Internet der Dinge, das über einen eigenen asynchronen Ausführender verfügt. Sein Hauptvorteil ist, dass es asynchrone Operationen ermöglicht, was das Schreiben von Funktionen mithilfe von async/await vereinfacht. Das Framework verfügt über einen eigenen Task-Scheduler und unterstützt eine breite Palette von Aufgaben.

Andere

Es gibt auch andere kleinere Projekte, die für das IoT und Rust von Vorteil sein werden. Zum Beispiel die Hardware Abstraction Layer (HAL), die auf GitHub einen kompletten Repository mit Beschreibungen der Hardware-Abstraktion für Rust enthält, ist für die Nutzung auf verschiedenen Plattformen gedacht. Ein weiteres Beispiel ist AWS IoT Core, das ein Ökosystem für IoT as a Service bietet. Sie haben ein SDK für Rust, das es ermöglicht, Anwendungen für Mikrocontroller mit Rust zu schreiben und mit ihren Protokollen zu arbeiten. Eva ist ein weiteres IoT-Framework, das Unterstützung für verschiedene Protokolle bietet und es ermöglicht, Anwendungen in Rust zu schreiben. Einige weniger beliebte Bibliotheken und Protokolle finden Sie auf Create.io, wie beispielsweise Bibliotheken für LoRaWAN, MQTT, Quic, LWM2M, CoAP sowie für Sicherheit, Bluetooth, Wi-Fi und andere IoT-Protokolle. Obwohl einige dieser Bibliotheken möglicherweise weniger ausgereift sind, entwickeln sie sich ständig weiter, und mit der wachsenden Nachfrage wird in diesem Bereich eine ausreichende Anzahl neuer und besserer Lösungen bereitgestellt.

Ich habe ein kleines Projekt mit dem ESP32 erstellt, das zwar einfach erscheint, aber gleichzeitig sehr nützlich ist, um zu verstehen, wie eingebettete Geräte mit Rust funktionieren.

Hier finden Sie anständige Anleitungen für ESP32 und Rust: github

Zunächst müssen wir Rust installieren.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Und danach müssen wir einen Ladegenerator installieren, der es uns ermöglicht, Vorlagen zu verwenden.

Cargo-Installieren – Cargo generieren

ESP verfügt über eigene Projektvorlagen, die verwendet werden können. Es gibt Vorlagen sowohl für den std- als auch für den no-std-Verwendungszweck. Erstellen wir ein Projekt unter Verwendung von std.

Cargo generiert die esp-rs/esp-idf-Vorlage

Der Generator selbst ist sehr interaktiv und ermöglicht neben dem Projektnamen außerdem die Auswahl der folgenden Optionen:

• MCU-Ziel – der Chip, auf dem die Firmware geschrieben wird.
• Eine Version der ESP-IDF-Bibliothek
• std oder no-std
• Verwendung von Dev Containers – eine sehr praktische Funktion, die es Ihnen ermöglicht, das Programm in einem Docker-Container zu entwickeln, wo alle notwendigen Programme bereits installiert sind. Dies ist in Kombination mit VS Code sehr praktisch. Da es Ihnen ermöglicht, einfach den Projektordner zu öffnen und mit der Entwicklung zu beginnen, ohne sich Sorgen um installierte Bibliotheken oder Programme machen zu müssen.
• Verwendung des Wokwi-Simulators – dies ist ein Programm, mit dem Sie die Arbeit mit verschiedenen Mikrocontrollern sowie mit Peripheriegeräten simulieren können, die an diese Mikrocontrollere angeschlossen werden können. Sehr praktisch für diejenigen, die noch kein echtes Gerät besitzen.

Nachdem der Generator das Projekt generiert hat, sieht seine Struktur folgendermaßen aus:

Diese Struktur ermöglicht es Ihnen vollständig, ohne sich um die Infrastruktur zu kümmern, an der Programmierung teilzunehmen, da diese bereits hier bereitgestellt ist.

• Im Verzeichnis „Scripts“ befinden sich die notwendigen Skripts, um das Projekt zu kompilieren und es auf einem echten Gerät hochzuladen.
• wokwi.toml und diagram.json sind Konfigurationsdateien, mit denen Sie den Simulator starten können. Sie benötigen eine Lizenz für den Simulator; diese ist kostenlos und kann hier heruntergeladen werden: https://wokwi.com/license?v=2.1.1&r=LicenseMissing&s=v

Lass uns ein ziemlich einfaches Projekt mit einem LCD-Display erstellen, das an ein ESP32 angeschlossen ist und auf dem Bildschirm angezeigt wird: Hello World, Rust & Yalantis. Tatsächlich wurde dieses Beispiel vom Wokwi-Website entnommen und dient dazu, die Möglichkeiten von Rust und seinem Ökosystem zu zeigen.

Ich werde nicht alle Details zum Arbeiten mit dem LCD detaillieren, sondern werde nur main.rs zeigen, wo die gesamte Logik ausgeführt wird:

Verwenden Sie esp_idf_hal::i2c.*;
Verwenden Sie esp_idf_hal::prelude.*;
Verwenden Sie esp_idf_hal::delay::FreeRtos; Verwenden Sie esp_idf_hal::peripherals::Peripherals;


Modell LCD;


fn main() -> anyhow::Result{let peripherals = Peripherals::take().unwrap(); let i2c = peripherals.i2c0;
   let sda = Peripheriegeräte.Pins.gpio6; let scl = Peripheriegeräte.Pins.gpio5;


   let config = I2cConfig::Neu()baudrate(100.kHz().into());
   let mut i2c = I2cDriver::Neu(i2c, sda, scl, &config)?;


   let _ = lcd::init(&mut i2c);
   let _ = lcd::backlight(&mut i2c);


   let _ = lcd::set_cursor(&mut i2c, 0, 1);
   let _ = lcd::print_str(&mut i2c, " Hallo, Welt"Ich habe eine Menge Spaß dabei.“
   let _ = lcd::set_cursor(&mut i2c, 0, 2);
   let _ = lcd::print_str(&mut i2c, " Rust & Yalantis"Ich habe eine Menge Spaß dabei.“


   loop {
     für _ in 0..3 {
      lcd::scroll_left(&mut i2c);
      FreeRtos::delay_ms(100);
   }


   für _ in 0..2 {
    für _ in 0..6 {
     lcd::scroll_right(&mut i2c);
     FreeRtos::delay_ms(100);
   }


   für _ in 0..6 {
     lcd::scroll_left(&mut i2c);
     FreeRtos::delay_ms(100);
    }
 }


 für _ in 0..3 {
   lcd::scroll_right(&mut i2c);
   FreeRtos::delay_ms(100);
 }


 für _ in 0..3 {
   lcd::no_backlight(&mut i2c);
   FreeRtos::delay_ms(250);
   lcd::rücklicht (&mut i2c);
   FreeRtos::delay_ms(250);
  }
 }
}

Der Programmcode ist recht einfach: Er zeigt den angegebenen Text auf dem LCD an und bewegt ihn mit Abständen von 100 ms über den LCD. Anschließend können wir das Projekt kompiliieren:

Cargo-Bau

Und legen Sie den Pfad zur Binärdatei in wokwi.toml fest.

[wokwi]
Version = 1
>gdbServerPort = 3333
elf = "target/riscv32imc-esp-espidf/debug/example"
Firmware = "target/riscv32imc-esp-espidf/debug/example"

Durch Klicken auf diagram.json wird der Simulator gestartet. Er übernimmt automatisch die Firmware aus dem angegebenen Speicherort und startet das Projekt, als ob es auf einem echten Gerät ausgeführt würde.

Das ist alles, was dieser Beispielcode tut; viel wichtiger sind jedoch die Möglichkeiten, die diese Infrastruktur und Rust bieten, um Prototypen zu entwickeln und sie zu debuggen. Wokwi ermöglicht es Ihnen außerdem, das Programm im Debugmodus zu starten und es zu debuggen.

Rust ist also eine gute Wahl für IoT- und Embedded-Projekte. Die Sprache bietet typenspezifische Sicherheit und hilft dabei, Nullpointer zu vermeiden, und eliminiert außerdem undefinierte Verhaltensweisen. Für komplexere Projekte sind die Unterstützung für Konkurrentenz und die Möglichkeit, den Multitasking-Modus zu verwenden, wichtig, und Rust bietet diese Möglichkeit. Für den Erfolg der Sprache muss das Ökosystem weiter wachsen und mit verschiedenen Bibliotheken und Frameworks gefüllt werden. Die Unterstützung von großen Unternehmen wie Microsoft und Google spricht ebenfalls für das Potenzial der Sprache. Trotz all der Vorteile hat Rust auch Nachteile: die Reife des Ökosystems, eine hohe Einstiegshürde und eine Vielzahl an Werkzeugen. Rust zeichnet sich durch seine Vielseitigkeit aus, da es in verschiedenen Bereichen eingesetzt werden kann, darunter Embedded-, Game- und Backend-Entwicklung. Obwohl die Entwicklung mit Rust langsamer sein kann als mit anderen Sprachen, kompensiert dies die Sicherheit, Produktivität und die Bequemlichkeit der Tools.