Veröffentlichung von Rust 1.53. Google finanziert die Unterstützung von Rust im Linux-Kernel

Die Veröffentlichung der Systemsprache Rust 1.53 wurde bekannt gegeben, die ursprünglich von Mozilla entwickelt wurde, inzwischen jedoch unter der Schirmherrschaft der unabhängigen gemeinnützigen Organisation Rust Foundation weiterentwickelt wird. Die Sprache konzentriert sich auf einen sicheren Umgang mit Speicher, bietet automatisches Speicher-Management und stellt Mittel zur Verfügung, um eine hohe Parallelität bei der Ausführung von Aufgaben zu erreichen, ohne auf einen Garbage Collector oder Runtime zurückgreifen zu müssen (die Runtime beschränkt sich auf die grundlegende Initialisierung und die Bereitstellung der Standardbibliothek).

Das automatische Speicher-Management in Rust befreit Entwickler von Fehlern beim Umgang mit Zeigern und schützt vor Problemen, die durch niedrige Arbeit mit Speicher entstehen, wie z. B. Zugriff auf Speicherbereiche nach deren Freigabe, Dereferenzierung von Nullzeigern, Bufferüberläufen usw. Zur Verteilung von Bibliotheken, zur Sicherstellung des Builds und zur Verwaltung von Abhängigkeiten wird der Paket-Manager Cargo entwickelt. Für das Hosting von Bibliotheken wird das Repository crates.io unterstützt.

Hauptneuheiten:

• Für Arrays wurde die Trait IntoIterator implementiert, die das Durchlaufen der Array-Elemente nach Werten ermöglicht: for i in [1, 2, 3] { .. }

  Es besteht jetzt auch die Möglichkeit, Arrays an Methoden zu übergeben, die Iteratoren akzeptieren, z. B.: let set = BTreeSet::from_iter([1, 2, 3]); for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) { .. }

  Früher wurde IntoIterator nur für Referenzen auf Arrays implementiert, d.h. um über Werte zu iterieren, mussten Referenzen verwendet werden („&[1, 2, 3]“) oder „[1, 2, 3].iter()“. Die Implementierungen von IntoIterator für Arrays wurden durch Kompatibilitätsprobleme behindert, die durch eine zuvor im Compiler hinzugefügte Umwandlung von array.into_iter() in (&array).into_iter() verursacht wurden. Diese Probleme konnten durch einen Umweg gelöst werden — der Compiler wird die Umwandlung von array.into_iter() in (&array).into_iter() fortsetzen, als ob die Implementierung des Traits IntoIterator nicht vorhanden wäre, jedoch nur bei einem Aufruf der Methode unter Verwendung der Syntax „.into_iter()“ und nicht bei Aufrufen in der Form „in [1, 2, 3]“, „iter.zip([1, 2, 3])“, „IntoIterator::into_iter([1, 2, 3])“.

• Die Möglichkeit, Ausdrücke „|“ (logische ODER-Operation) an jeder Stelle des Musters anzugeben, wurde bereitgestellt, z. B. anstelle von „Some(1) | Some(2)“ kann jetzt „Some(1 | 2)“ geschrieben werden: match result { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
• Die Verwendung von nicht-ASCII-Zeichen in Identifikatoren ist erlaubt, einschließlich aller nationalen Zeichen, die in der Unicode-Spezifikation UAX 31 definiert sind, jedoch ohne Emoji-Zeichen. Bei der Verwendung verschiedener, aber ähnlich gestalteter Zeichen gibt der Compiler eine Warnung aus. const BLÅHAJ: &str = «🦈»; struct 人 { 名字: String, } let α = 1; let ｓos = 2; warning: Identifier-Paar als verwirrbar betrachtet zwischen ‘ｓ’ und ‘s’
• Eine neue Reihe von APIs wurde in die stabile Kategorie überführt, darunter stabilisiert:
  • array::from_ref
  • array::from_mut
  • AtomicBool::fetch_update
  • AtomicPtr::fetch_update
  • BTreeSet::retain
  • BTreeMap::retain
  • BufReader::seek_relative
  • cmp::min_by
  • cmp::min_by_key
  • cmp::max_by
  • cmp::max_by_key
  • DebugStruct::finish_non_exhaustive
  • Duration::ZERO
  • Duration::MAX
  • Duration::is_zero
  • Duration::saturating_add
  • Duration::saturating_sub
  • Duration::saturating_mul
  • f32::is_subnormal
  • f64::is_subnormal
  • IntoIterator für Arrays
  • {integer}::BITS
  • io::Error::Unsupported
  • NonZero*::leading_zeros
  • NonZero*::trailing_zeros
  • Option::insert
  • Ordering::is_eq
  • Ordering::is_ne
  • Ordering::is_lt
  • Ordering::is_gt
  • Ordering::is_le
  • Ordering::is_ge
  • OsStr::make_ascii_lowercase
  • OsStr::make_ascii_uppercase
  • OsStr::to_ascii_lowercase
  • OsStr::to_ascii_uppercase
  • OsStr::is_ascii
  • OsStr::eq_ignore_ascii_case
  • Peekable::peek_mut
  • Rc::increment_strong_count
  • Rc::decrement_strong_count
  • slice::IterMut::as_slice
  • AsRef für slice::IterMut
  • impl SliceIndex für (Bound, Bound)
  • Vec::extend_from_within
• Eine dritte Stufe der Unterstützung für die Plattform wasm64-unknown-unknown wurde implementiert. Die dritte Stufe umfasst grundlegende Unterstützung, jedoch ohne automatisierte Tests, die Veröffentlichung offizieller Builds und die Überprüfung der Möglichkeit zur Code-Kompilierung.
• Der Paketmanager Cargo wurde standardmäßig so eingestellt, dass der Name „main“ für den Hauptbranch des Git-Repositorys (HEAD) verwendet wird. Für Abhängigkeiten, die in Repositories untergebracht sind, die den Namen main anstelle von master verwenden, ist es nicht mehr erforderlich, die Einstellung branch = „main“ anzugeben.
• Im Compiler wurden die Anforderungen an die minimale LLVM-Version auf LLVM 10 angehoben.

Zusätzlich kann man das Bereitstellen von Mitteln zur Entwicklung der Integration in den Linux-Kernel für die Entwicklung von Komponenten in der Programmiersprache Rust erwähnen. Die Arbeiten werden im Rahmen des Projekts Prossimo unter dem Dach der Organisation ISRG (Internet Security Research Group) durchgeführt, die das Projekt Let’s Encrypt ins Leben gerufen hat und die Förderung von HTTPS sowie die Entwicklung von Technologien zur Verbesserung der Internetsicherheit unterstützt. Die Mittel werden von Google bereitgestellt, das die Arbeiten von Miguel Ojeda, dem Schöpfer des Projekts Rust-for-Linux, finanziert. Zuvor hatten ISRG und Google bereits die Erstellung eines alternativen HTTP-Backends für das curl-Tool sowie die Entwicklung eines neuen TLS-Moduls für den Apache-Webserver finanziert.

Laut den Unternehmensangaben von Microsoft und Google sind etwa 70 % der Sicherheitsanfälligkeiten auf unsicheren Umgang mit Arbeitsspeicher zurückzuführen. Es wird angenommen, dass die Verwendung der Programmiersprache Rust zur Entwicklung von Kernelkomponenten, wie Gerätetreibern, das Risiko von durch unsicheren Umgang mit Arbeitsspeicher verursachten Sicherheitsanfälligkeiten verringern und die Entstehung solcher Fehler, wie z. B. den Zugriff auf den Speicherbereich nach dessen Freigabe und das Überschreiten von Puffergrenzen, ausschließen wird.

Die sichere Arbeit mit Speicher wird in Rust während der Kompilierung durch Überprüfung von Referenzen, Verfolgung des Eigentums an Objekten und Berücksichtigung der Lebensdauer von Objekten (Sichtbarkeitsbereich) sowie durch die Beurteilung der Korrektheit des Zugriffs auf den Speicher zur Laufzeit des Codes gewährleistet. Rust bietet auch Mittel zum Schutz vor ganzzahligen Überläufen, erfordert die zwingende Initialisierung von Variablen vor deren Verwendung, behandelt Fehler in der Standardbibliothek besser, wendet das Konzept der Immutabilität (unveränderlich) auf Referenzen und Variablen standardmäßig an und bietet eine starke statische Typisierung zur Minimierung logischer Fehler.

Quelle: opennet.ru