Vorwort

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com

Ich kenne das Ende schon \ Es ist der Teil, der dein Gesicht implodieren lässt

They Might Be Giants, "Experimental Film" (2004)

Um eine Sprache zu beherrschen, musst du viele Programme in dieser Sprache schreiben. Ich erinnere mich noch gut daran, als 1995 eine neue Sprache namens "JavaScript" auf den Markt kam. Ich beschloss, sie zu lernen, und kaufte mir ein dickes Nachschlagewerk, das ich von vorne bis hinten durchlas. Das Buch war gut geschrieben und erklärte die Sprache bis ins kleinste Detail, von Strings über Listen bis hin zu Objekten. Aber als ich mit dem Buch fertig war, konnte ich immer noch kein JavaScript schreiben. Ohne dieses Wissen durch das Schreiben von Programmen anzuwenden, habe ich nur sehr wenig gelernt. Seitdem habe ich gelernt, wie man eine Sprache lernt, was vielleicht die wertvollste Fähigkeit ist, die man als Programmierer entwickeln kann. Für mich bedeutet das, dass ich Programme, die ich bereits kenne, wie Tic-Tac-Toe umschreibe.

Rust ist der neue Trend und vielleicht hast du dieses Buch in die Hand genommen, um zu sehen, was es damit auf sich hat. Dieses Buch ist kein Nachschlagewerk über die Sprache. Die gibt es schon, und sie sind ziemlich gut. Stattdessen habe ich ein Buch geschrieben, das dich herausfordert, viele kleine Programme zu schreiben, die dir wahrscheinlich vertraut sind. Rust hat den Ruf, eine ziemlich steile Lernkurve zu haben, aber ich glaube, dieser Ansatz wird dir helfen, schnell produktiv mit der Sprache zu werden.

Konkret wirst du Rust-Versionen von zentralen Unix-Kommandozeilen-Tools wie head und cal schreiben. So lernst du mehr über die Tools und warum sie so nützlich sind, während du gleichzeitig den Kontext für die Verwendung von Rust-Konzepten wie Strings, Vektoren und Filehandles erhältst. Wenn du dich nicht mit Unix oder der Kommandozeilenprogrammierung auskennst, lernst du Konzepte wie Programmausgabewerte, Kommandozeilenargumente, die Umleitung von Ausgaben, Pipes, um die Ausgabe eines Programms (STDOUT oder Standard Out) mit der Eingabe eines anderen Programms (STDIN oder Standard In) zu verbinden, und wie man STDERR (Standard Error) verwendet, um Fehlermeldungen von anderen Ausgaben zu trennen. Die Programme, die du schreibst, zeigen Muster auf, die du bei der Erstellung deiner eigenen Rust-Programme verwenden kannst - Muster wie die Validierung von Parametern, das Lesen und Schreiben von Dateien, das Parsen von Text und die Verwendung von regulären Ausdrücken. Viele dieser Werkzeuge und Konzepte gibt es nicht einmal unter Windows, daher werden Benutzer dieser Plattform gute Versionen einiger zentraler Unix-Programme erstellen.

Was ist Rost (und warum reden alle darüber)?

Rust ist "eine Sprache, die es jedem ermöglicht, zuverlässige und effiziente Software zu entwickeln". 2006 wurde Rust von Graydon Hoare und vielen anderen entwickelt, während Hoare bei Mozilla Research arbeitete. Die Sprache fand so viel Interesse und Nutzer, dass Mozilla die Entwicklung bis 2010 gesponsert hat. In der Stack Overflow-Entwicklerumfrage von 2023 wählten über 90.000 Entwickler Rust zum achten Mal in Folge zur "beliebtesten" Sprache.

clru 0001
Abbildung P-1. Hier ist ein Logo, das ich aus einem alten Rush-Logo gemacht habe. Als Kind, das in den 1980er Jahren Schlagzeug spielte, hörte ich viel Rush. Wie auch immer, Rush ist cool, und dieses Logo beweist es.

Die Sprache ist syntaktisch ähnlich wie C, d.h. du findest Dinge wie for Schleifen, mit Semikolon beendete Anweisungen und geschweifte Klammern, die Blockstrukturen bezeichnen. Entscheidend ist, dass Rust Speichersicherheit durch die Verwendung eines Borrow-Checkers garantieren kann, der verfolgt, welcher Teil eines Programms sicheren Zugriff auf verschiedene Teile des Speichers hat. Diese Sicherheit geht jedoch nicht auf Kosten der Leistung. Rust-Programme lassen sich zu nativen Binärdateien kompilieren und sind oft genauso schnell oder schneller als Programme, die in C oder C++ geschrieben wurden. Aus diesem Grund wird Rust oft als Systemprogrammiersprache bezeichnet, die auf Leistung und Sicherheit ausgelegt ist.

Rust ist eine statisch typisierte Sprache wie C/C++ oder Java. Das bedeutet, dass eine Variable niemals ihren Typ ändern kann, z. B. von einer Zahl zu einer Zeichenkette. Du musst den Typ einer Variablen in Rust nicht immer deklarieren, da der Compiler ihn oft aus dem Kontext herausfinden kann. Dies steht im Gegensatz zu dynamisch typisierten Sprachen wie Perl, JavaScript oder Python, in denen eine Variable ihren Typ an jedem Punkt des Programms ändern kann, z. B. von einer Zeichenkette zu einem Filehandle.

Rust ist keine objektorientierte (OO) Sprache wie C++ oder Java, da es in Rust keine Klassen oder Vererbung gibt. Stattdessen verwendet Rust eine struct (Struktur), um komplexe Datentypen darzustellen und Traits, um zu beschreiben, wie sich Typen verhalten können. Diese Strukturen können Methoden haben, den internen Zustand der Daten verändern und werden in der Dokumentation vielleicht sogar als Objekte bezeichnet, aber sie sind keine Objekte im formalen Sinne des Wortes.

Rust hat viele spannende Konzepte von anderen Sprachen und Programmierparadigmen übernommen, darunter auch rein funktionale Sprachen wie Haskell. So sind Variablen in Rust standardmäßig unveränderlich, d.h. sie können nicht von ihrem Anfangswert aus verändert werden; du musst dem Compiler ausdrücklich mitteilen, dass sie veränderbar sind. Funktionen sind außerdem Werte erster Klasse, d.h. sie können als Argumente an andere sogenannte Funktionen höherer Ordnung übergeben werden. Am spannendsten finde ich Rusts Verwendung von Aufzählungs- und Summentypen, auch algebraische Datentypen (ADTs) genannt, mit denen du z. B. darstellen kannst, dass eine Funktion einen Result zurückgeben kann, der entweder ein Ok mit einem Wert oder ein Err mit einem anderen Wert sein kann. Jeder Code, der mit diesen Werten umgeht, muss alle Möglichkeiten berücksichtigen, sodass du nie Gefahr läufst, einen Fehler zu übersehen, der dein Programm unerwartet zum Absturz bringen könnte.

Wer sollte dieses Buch lesen?

Du solltest dieses Buch lesen, wenn du die Grundlagen der Sprache Rust erlernen möchtest, indem du praktische Kommandozeilenprogramme schreibst, die sich mit gängigen Programmieraufgaben befassen. Ich gehe davon aus, dass die meisten Leserinnen und Leser bereits einige Grundlagen der Programmierung aus mindestens einer anderen Sprache kennen. Du weißt zum Beispiel wahrscheinlich, wie man Variablen erstellt, Schleifen verwendet, um eine Aktion zu wiederholen, Funktionen erstellt und so weiter. Ich kann mir vorstellen, dass Rust eine schwierige Einstiegssprache sein könnte, da sie sehr viel mit Typen arbeitet und das Verständnis einiger Details des Computerspeichers voraussetzt. Ich gehe auch davon aus, dass du zumindest eine Vorstellung davon hast, wie man die Kommandozeile benutzt und einige grundlegende Unix-Befehle kennst, z. B. wie man Verzeichnisse anlegt, entfernt und wechselt. Dieses Buch konzentriert sich auf die praktische Seite und zeigt dir, was du wissen musst, um die Dinge zu erledigen. Die Feinheiten überlasse ich umfassenderen Büchern wie Programming Rust, 2nd ed, von Jim Blandy, Jason Orendorff und Leonora F. S. Tindall (O'Reilly); The Rust Programming Language von Steve Klabnik und Carol Nichols (No Starch Press) und Rust In Action von Tim McNamara (Manning). Ich empfehle dir, eines oder mehrere davon zusammen mit diesem Buch zu lesen, um tiefer in die Sprache einzutauchen.

Du solltest dieses Buch auch lesen, wenn du wissen willst, wie du Tests schreibst und ausführst, um Rust-Programme zu überprüfen. Ich bin ein Verfechter der Verwendung von Tests, nicht nur um zu überprüfen, ob Programme richtig funktionieren, sondern auch als Hilfe, um ein Problem in kleine, verständliche, testbare Teile zu zerlegen. Ich zeige dir, wie du die von mir bereitgestellten Tests verwendest und wie du testgetriebene Entwicklung (TDD) einsetzt, bei der du zuerst Tests schreibst und dann Code, der diese Tests besteht. Ich hoffe, dass dieses Buch zeigt, dass die Strenge des Rust-Compilers in Kombination mit Tests zu besseren Programmen führt, die einfacher zu warten und zu ändern sind.

Warum du Rosten lernen solltest

Es gibt viele Gründe, Rust zu lernen. Erstens finde ich, dass die Typüberprüfung von Rust mich davor bewahrt, viele grundlegende Fehler zu machen. Ich komme aus eher dynamisch typisierten Sprachen wie Perl, Python und JavaScript, in denen es wenig bis gar keine Typüberprüfung gibt. Je mehr ich mit statisch typisierten Sprachen wie Rust gearbeitet habe, desto mehr habe ich gemerkt, dass dynamisch typisierte Sprachen mir viel mehr Arbeit aufbürden, weil ich meine Programme verifizieren und viel mehr Tests schreiben muss. Allmählich hatte ich das Gefühl, dass der Rust-Compiler zwar sehr streng ist, aber mein Tanzpartner und nicht mein Feind. Zugegeben, es ist ein Tanzpartner, der dich jedes Mal ermahnt, wenn du ihm auf die Zehen trittst oder ein Stichwort verpasst, aber das macht dich schließlich zu einem besseren Tänzer, und das ist schließlich das Ziel. Wenn ich ein Rust-Programm kompilieren kann, funktioniert es in der Regel so, wie ich es mir vorgestellt habe.

Zweitens ist es einfach, ein Rust-Programm mit jemandem zu teilen, der Rust nicht kennt oder gar kein Entwickler ist. Wenn ich ein Python-Programm für einen Arbeitskollegen schreibe, muss ich ihm den Python-Quellcode zum Ausführen geben und sicherstellen, dass er die richtige Python-Version und alle erforderlichen Module hat, um meinen Code auszuführen. Im Gegensatz dazu werden Rust-Programme direkt in eine maschinenausführbare Datei kompiliert. Ich kann ein Programm auf meinem Rechner schreiben und debuggen, eine ausführbare Datei für die Architektur erstellen, auf der es laufen soll, und meinem Kollegen eine Kopie des Programms geben. Vorausgesetzt, er hat die richtige Architektur, muss er Rust nicht installieren und kann das Programm direkt ausführen.

Drittens baue ich oft Container mit Docker oder Singularity, um Arbeitsabläufe zu kapseln. Ich stelle fest, dass die Container für Rust-Programme oft um Größenordnungen kleiner sind als die für Python-Programme. Ein Docker-Container mit der Python-Laufzeitumgebung kann zum Beispiel mehrere hundert MB groß sein. Im Gegensatz dazu kann ich eine virtuelle Linux-Maschine mit einer Rust-Binärdatei bauen, die nur ein paar Dutzend MB groß ist. Solange ich nicht wirklich bestimmte Funktionen von Python benötige, wie z. B. maschinelles Lernen oder Modulezur Verarbeitung natürlicherSprache, ziehe ich es vor, in Rust zu schreiben und kleinere, schlankereContainer zu haben.

Ich habe viele nützliche Rust Crates - so werden Bibliotheken in Rust genannt - auf crates.io gefunden, und die Dokumentation auf Docs.rs ist gründlich und einfach zu navigieren.

Die Herausforderungen bei der Codierung

In diesem Buch lernst du, wie du Rust-Code schreibst und testest, indem du komplette Programme erstellst. Jedes Kapitel zeigt dir, wie du ein Programm von Grund auf neu erstellst, Funktionen hinzufügst, Fehlermeldungen abarbeitest und deine Logik testest. Ich möchte nicht, dass du dieses Buch passiv im Bus auf dem Weg zur Arbeit liest und dann weglegst. Du lernst am meisten, wenn du deine eigenen Lösungen schreibst, aber ich glaube, dass auch das Abtippen des Quellcodes, den ich vorstelle,von Nutzen sein wird.

Die Probleme, die ich für dieses Buch ausgewählt habe, stammen aus der Unix-Befehlszeile coreutils, weil ich davon ausgehe, dass sie vielen Lesern bereits vertraut sind. Ich nehme an, dass du zum Beispiel head und tail benutzt hast, um dir die ersten oder letzten Zeilen einer Datei anzusehen, aber hast du jemals deine eigenen Versionen dieser Programme geschrieben? Andere Rustaceans (Menschen, die Rust verwenden) hatten die gleiche Idee, also gibt es viele andere Rust-Implementierungen dieser Programme, die du im Internet finden kannst. Darüber hinaus handelt es sich um relativ kleine Programme, die sich dazu eignen, ein paar Fertigkeiten zu vermitteln. Ich habe die Projekte so angeordnet, dass sie aufeinander aufbauen, also ist es wahrscheinlich am besten, wenn du die Kapitel der Reihe nach durcharbeitest.

Ein Grund dafür, dass ich mich für viele dieser Programme entschieden habe, ist, dass sie eine Art Basiswahrheit darstellen. Es gibt zwar viele Unix-Varianten und viele Implementierungen dieser Programme, aber in der Regel funktionieren sie alle gleich und liefern die gleichen Ergebnisse. Ich verwende macOS für meine Entwicklung, was bedeutet, dass ich meistens die BSD- (Berkeley Standard Distribution) oder GNU- (GNU's Not Unix) Varianten dieser Programme verwende. Im Allgemeinen sind die BSD-Versionen älter als die GNU-Versionen und haben weniger Optionen. Für jedes Herausforderungsprogramm verwende ich ein Shell-Skript, um die Ausgabe des Originalprogramms in eine Ausgabedatei umzuleiten. Ziel ist es dann, dass die Rust-Programme dieselbe Ausgabe für dieselben Eingaben erzeugen. Ich habe darauf geachtet, dass ich sowohl Windows-kodierte Dateien als auch einfachen ASCII-Text mit Unicode-Zeichen einbeziehe, um meine Programme zu zwingen, mit verschiedenen Vorstellungen von Zeilenenden und Zeichen auf dieselbe Weise umzugehen wie die Originalprogramme.

Für die meisten Herausforderungen werde ich nur eine Teilmenge der Originalprogramme implementieren, da sie ziemlich kompliziert werden können. Ich habe mich auch dafür entschieden, einige kleine Änderungen an der Ausgabe einiger Programme vorzunehmen, damit sie leichter zu lernen sind. Sieh es so, als würdest du ein Instrument lernen, indem du zu einer Aufnahme mitspielst. Du musst nicht jede Note der Originalversion spielen. Wichtig ist, dass du allgemeine Muster wie den Umgang mit Argumenten und das Lesen von Eingaben lernst, damit du mit dem Schreiben deines Materials weitermachen kannst. Als zusätzliche Herausforderung kannst du versuchen, diese Programme in anderen Sprachen zu schreiben, um zu sehen, wie sich die Lösungen von Rust unterscheiden.

Rust und den Code bekommen

Zunächst musst du Rust installieren. Einer meiner Lieblingsaspekte an Rust ist die einfache Verwendung des Tools rustup für die Installation, Aktualisierung und Verwaltung von Rust. Es funktioniert sowohl unter Windows als auch unter Unix-ähnlichen Betriebssystemen (OSs) wie Linux und macOS. Du musst die Installationsanweisungen für dein OS befolgen. Wenn du bereits rustup installiert hast, solltest du rustup update ausführen, um die neueste Version der Sprache und der Werkzeuge zu erhalten, da Rust etwa alle sechs Wochen aktualisiert wird. Führen Sie rustup doc aus, um die umfangreiche Dokumentation zu lesen. Du kannst deine Version des rustc Compilers mit dem folgenden Befehl überprüfen:

$ rustc --version
rustc 1.76.0 (07dca489a 2024-02-04)

Alle Tests, Daten und Lösungen für die Programme findest du im GitHub-Repository des Buches. Du kannst das Git-Quellcode-Verwaltungstool (das du eventuell installieren musst) verwenden, um es auf deinen Computer zu kopieren. Der folgende Befehl erstellt auf deinem Computer ein neues Verzeichnis namens command-line-rust mit dem Inhalt des Repository des Buches:

$ git clone https://github.com/kyclark/command-line-rust.git

Du solltest deinen Code nicht in dem Verzeichnis schreiben, das du im vorherigen Schritt geklont hast. Du solltest ein separates Verzeichnis für deine Projekte erstellen. Ich schlage vor, dass du dein eigenes Git-Repository erstellst, in dem du die Programme, die du schreibst, aufbewahrst. Wenn du zum Beispiel GitHub nutzt und es rust-solutions nennst, kannst du den folgenden Befehl verwenden, um dein Repository zu klonen. Achte darauf, dass du YOUR_GITHUB_ID durch deine tatsächliche GitHub-ID ersetzt:

$ git clone https://github.com/YOUR_GITHUB_ID/rust-solutions.git

Eines der ersten Werkzeuge, die du in Rust kennenlernen wirst, ist Cargo, das Build-Tool, der Paketmanager und der Testrunner. In jedem Kapitel wirst du angewiesen, ein neues Projekt mit Cargo zu erstellen, und ich empfehle dir, dies in deinem Lösungsverzeichnis zu tun. Du wirst das Testverzeichnis jedes Kapitels aus dem Repository des Buches in dein Projektverzeichnis kopieren, um deinen Code zu testen. Wenn du neugierig bist, wie das Testen von Code mit Cargo und Rust aussieht, kannst du die Tests für Kapitel 1 ausführen. Wechsle in das Verzeichnis 01_hello des Buches und führe die Tests mit cargo test:

$ cd command-line-rust/01_hello
$ cargo test

Wenn alles gut läuft, solltest du einige bestandene Tests sehen (in keiner bestimmten Reihenfolge):

running 3 tests
test false_not_ok ... ok
test true_ok ... ok
test runs ... ok
Hinweis

Ich habe alle Programme auf macOS, Linux, Windows 10/PowerShell und Ubuntu Linux/Windows Subsystem for Linux (WSL) getestet. Obwohl ich es toll finde, wie gut Rust sowohl auf Windows- als auch auf Unix-Betriebssystemen funktioniert, funktionieren zwei Programme (findr und lsr) unter Windows etwas anders, da sich das Betriebssystem grundlegend von Unix-Systemen unterscheidet. Ich empfehle Windows/PowerShell-Benutzern, auch die WSL zu installieren und die Programme in dieser Umgebung durchzuarbeiten.

Der gesamte Code in diesem Buch wurde mit rustfmt formatiert, einem praktischen Tool, mit dem du deinen Code hübsch und lesbar machen kannst. Du kannst es mit cargo fmt verwenden, um es auf den gesamten Quellcode eines Projekts anzuwenden, oder du kannst es in deinen Code-Editor integrieren, um es bei Bedarf auszuführen. Ich bevorzuge zum Beispiel den Text-Editor vim, den ich so konfiguriert habe, dass er jedes Mal, wenn ich meine Arbeit speichere, automatisch rustfmt ausführt. Ich finde, das macht es viel einfacher, meinen Code zu lesen und Fehler zu finden.

Ich empfehle dir Clippy, einen Linter für Rust-Code.Linting ist die automatische Überprüfung von Code auf häufige Fehler, und es scheint, dass die meisten Sprachen einen oder mehrere Linter anbieten. Sowohl rustfmt als auch clippy sollten standardmäßig installiert sein, aber du kannst sie auch mit rustup component add clippy Wenn du sie installieren musst, kannst du sie mit cargo clippy ausführen, um den Quellcode zu überprüfen und Empfehlungen auszusprechen. Keine Ausgabe von Clippy bedeutet, dass es keine Vorschläge hat.

März 2024 Update

Dieses Buch wurde ursprünglich 2022 veröffentlicht. Die Sprache Rust und die Crates haben sich in den folgenden zwei Jahren schnell weiterentwickelt, und ich bin O'Reilly dankbar, dass ich meine Codebeispiele aktualisieren durfte, um diese Änderungen widerzuspiegeln.Ich habe die Programme vereinfacht, um sie leichter unterrichten zu können, und die Testausgabe verbessert, indem ich diepretty_assertions Die bei weitem größte Änderung betrifft die Kiste clap (command-line argument parser), die in jedem Programm ab Kapitel 2 verwendet wird. Die Kiste clap war in der Version 2.33, als ich das Buch schrieb, und hatte nur eine Methode (builder) zum Parsen von Argumenten. Die Version sprang kurz nach der Veröffentlichung auf 4 und führte eine zweite Methode (derive) ein. Ich habe alle meine Programme so umgeschrieben, dass sie diese neuen Muster verwenden, wobei ich darauf geachtet habe, das Parsing zu isolieren, damit der Leser jeden beliebigen Code ersetzen kann. Die Codebeispiele in dieser Version des Buches finden sich unter git checkout in den Zweigen clap_v4 und clap_v4_derive für die Muster builderbzw. derive.

Jetzt bist du bereit, etwas Rust zu schreiben!

In diesem Buch verwendete Konventionen

In diesem Buch werden die folgenden typografischen Konventionen verwendet:

Kursiv

Weist auf neue Begriffe, URLs, E-Mail-Adressen, Dateinamen und Dateierweiterungen hin.

Constant width

Wird für Programmlistings sowie innerhalb von Absätzen verwendet, um auf Programmelemente wie Variablen- oder Funktionsnamen, Datenbanken, Datentypen, Umgebungsvariablen, Anweisungen und Schlüsselwörter hinzuweisen.

Constant width bold

In Codeblöcken macht dieser Stil, sofern nicht anders angegeben, besonders auf die Elemente aufmerksam, die in der umgebenden Diskussion beschrieben werden. In diskursiven Texten werden Befehle hervorgehoben, die der Leser verwenden kann, während er dem Text folgt.

Constant width italic

Zeigt Text an, der durch vom Benutzer eingegebene Werte oder durch kontextabhängige Werte ersetzt werden soll.

Tipp

Dieses Element steht für einen Tipp oder eine Anregung.

Hinweis

Dieses Element steht für einen allgemeinen Hinweis.

Warnung

Dieses Element weist auf eine Warnung oder einen Warnhinweis hin.

Code-Beispiele verwenden

Zusätzliches Material (Code-Beispiele, Übungen usw.) steht unter https://oreil.ly/commandlinerust_code zum Download bereit .

Wenn du eine technische Frage oder ein Problem mit den Codebeispielen hast, sende bitte eine E-Mail an

Dieses Buch soll dir helfen, deine Arbeit zu erledigen. Wenn in diesem Buch Beispielcode angeboten wird, darfst du ihn in deinen Programmen und deiner Dokumentation verwenden. Du musst uns nicht um Erlaubnis fragen, es sei denn, du reproduzierst einen großen Teil des Codes. Wenn du zum Beispiel ein Programm schreibst, das mehrere Teile des Codes aus diesem Buch verwendet, brauchst du keine Erlaubnis. Der Verkauf oder die Verbreitung von Beispielen aus O'Reilly-Büchern erfordert jedoch eine Genehmigung. Die Beantwortung einer Frage mit einem Zitat aus diesem Buch und einem Beispielcode erfordert keine Genehmigung. Wenn du einen großen Teil des Beispielcodes aus diesem Buch in die Dokumentation deines Produkts aufnimmst, ist eineGenehmigung erforderlich.

Wir freuen uns über eine Namensnennung, verlangen sie aber in der Regel nicht. Eine Quellenangabe umfasst normalerweise den Titel, den Autor, den Verlag und die ISBN. Zum Beispiel: "Command-Line Rust von Ken Youens-Clark (O'Reilly). Copyright 2022 Charles Kenneth Youens-Clark, 978-1-098-10943-1."

Wenn du der Meinung bist, dass die Verwendung von Code-Beispielen nicht unter die Fair-Use-Regelung oder die oben genannte Erlaubnis fällt, kannst du uns gerne unter kontaktieren

O'Reilly Online Learning

Hinweis

Seit mehr als 40 Jahren bietet O'Reilly Media Schulungen, Wissen und Einblicke in Technologie und Wirtschaft, um Unternehmen zum Erfolg zu verhelfen.

Unser einzigartiges Netzwerk von Experten und Innovatoren teilt sein Wissen und seine Erfahrung durch Bücher, Artikel und unsere Online-Lernplattform. Die Online-Lernplattform von O'Reilly bietet dir On-Demand-Zugang zu Live-Trainingskursen, ausführlichen Lernpfaden, interaktiven Programmierumgebungen und einer umfangreichen Text- und Videosammlung von O'Reilly und über 200 anderen Verlagen. Weitere Informationen erhältst du unter https://oreilly.com.

Wie du uns kontaktierst

Bitte richte Kommentare und Fragen zu diesem Buch an den Verlag:

Wir haben eine Webseite für dieses Buch, auf der wir Errata, Beispiele und zusätzliche Informationen auflisten. Du kannst diese Seite unter https://oreil.ly/commandLineRust aufrufen .

Schreib eine E-Mail an , um Kommentare oder technische Fragen zu diesem Buch zu stellen.

Neuigkeiten und Informationen über unsere Bücher und Kurse findest du unter https://oreilly.com.

Finde uns auf LinkedIn: https://linkedin.com/company/oreilly-media

Schau uns auf YouTube: https://www.youtube.com/oreillymedia

Danksagungen

Als ich anfing, Rust zu schreiben, lernte ich schnell, dass ich versuchen konnte, ein naives Programm zu schreiben und mir einfach vom Compiler sagen zu lassen, was ich verbessern sollte. Ich fügte blindlings & und * hinzu oder zog ab, klonte und borgte, bis mein Programm kompiliert war, und fand dann heraus, wie ich es besser machen konnte. Wenn ich nicht weiterkam, fand ich immer Hilfe unter https://users.rust-lang.org. Jeder, dem ich in Rust begegnet bin, von Twitter bis Reddit, war freundlich und hilfsbereit.

Ich möchte der BSD- und der GNU-Gemeinschaft für die Programme und die Dokumentation danken, auf denen die Projekte der einzelnen Kapitel beruhen. Ich bin dankbar für die großzügigen Lizenzen, die es mir erlauben, Teile der Hilfedokumentation ihrerProgramme zu verwenden:

Außerdem möchte ich meinen Entwicklungsredakteuren Corbin Collins und Rita Fernando und meinen Produktionsredakteuren Caitlin Ghegan, Greg Hyman und Kristen Brown danken. Ich bin den technischen Prüfern Carol Nichols, Brad Fulton, Erik Nordin und Jeremy Gailor zu großem Dank verpflichtet, die mich auf dem rechten Weg gehalten haben, sowie anderen, die ihre Zeit für Kommentare geopfert haben, darunter Joshua Lynch, Andrew Olson, Jasper Zanjani und William Evans. Mein Dank gilt auch meinen Chefs der letzten Jahre, Dr. Bonnie Hurwitz an der University of Arizona und Amanda Borens am Critical Path Institute, die es toleriert haben, dass ich im Rahmen meiner beruflichen Tätigkeit viel Zeit und Mühe in das Erlernen neuer Sprachen wie Rust investiert habe.

In meinem Privatleben hätte ich dieses Buch nicht ohne die Liebe und Unterstützung meiner Frau Lori Kindler und unserer drei äußerst interessanten Kinder schreiben können. Schließlich möchte ich auch meinem Freund Brian Castle danken, der in der High School so sehr versucht hat, meinen Musikgeschmack von hartem und progressivem Rock auf alternative Bands wie Depeche Mode, The Smiths und They Might Be Giants umzulenken, von denen nur die letzte wirklich funktioniert hat.

Get Befehlszeilen-Rost now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial