TT Rust

Dies ist die Seite zum Thunder Talk über die Programmiersprache Rust, der am 3.6.2014 im Rahmen des OpenChaos gehalten wurde.

Der Vortrag fokussierte sich darauf, wie Rust Speichersicherheit garantieren kann, ohne dass das zu viel Overhead kostet. Die Sprache wird wie C und C++ zu den System-Programmiersprachen gezählt und stellt als solche eine der wenigen dar, die Dinge wie Speichersicherheit und Freiheit von Datenrennen garantieren kann. Außerdem wurde im Vortrag das Trait-System von Rust angerissen.

Ein ähnlicher Vortrag wurde von demselben Autor später auf der Hackover2014 in Hannover gehalten.

Mitschnitt und Folien

Zeit	Inhalt
00:00-43:05	Vortrag (Hauptteil zu Speichersicherheit)
43:05-53:50	Fragen und Diskussion Teil 1
53:50-65:04	Vortrag (Bonus-Folien zu Traits)
65:04-88:22	Fragen und Diskussion Teil 2

Vortragsfolien (pdf, 175 KB) Audiospur (mp3, 41 MB, 88 Minuten)

Alternativ könnt Ihr Euch, sofern Englischkenntnisse vorhanden sind, auch den Vortrag anschauen, der mich auch bei der Gestaltung meines Vortrags beeinflusst hatte: https://air.mozilla.org/guaranteeing-memory-safety-in-rust/ (ist gut!)

Korrekturen

Auf einer Folie hatte ich x++ im Code verwendet. So einen Operator gibt es allerdings nicht. Das könnte man z.B. durch x+=1 ersetzen. Das kommt davon, wenn man sich bei sehr kleinen Code-Schnippseln denkt "Das passt schon so, muss ich nicht testen". :)

In einem der Diskussionsteile habe ich ein Szenario beschrieben in dem "ausgeliehene Referenzen" an andere Tasks verteilt werden könnten. Im Allgemeinen sind solche Referenzen aber nicht versendbar -- es sei denn sie sind immutable und beziehen sich auf im statischen Speicher lebende Dinge und sind nicht.

Ergänzende Informationen zur Fehlerbehandlung

Wie im Vortrag erwähnt wurde, bietet Rust keine Ausnahmen (Exceptions). Ein "schwerwiegender" Fehler führt zu einem Abbruch eines Tasks. Viele Funktionen, die ihre Arbeit aufgrund von äußeren Einflüssen (fehlerhafte Eingaben oder ähnliches) aber nicht immer erledigen können, haben aber dementsprechende Rückgabetypen, worüber man Fehler signalisieren kann. Für eine Funktion, die im Erfolgsfall ein T zurück geben will, und sonst einen Fehlerwert des Typs E bietet sich da der Typ Result<T,E> an. Per Pattern Matching kann man zwischen diesen Fällen auch unterscheiden:

let r: Result<int,&'static str> = tue_was();
match r {
  Ok(i)  => { println!("Ich bekam einen int-Wert von {} zurück", i); }
  Err(e) => { println!("Da kam eine Fehlermeldung zurück: {}", e); }
}

Sonst gibt es auch Option<T>, wobei ein Wert dieses Typs entweder ein Some(T) oder ein None ist.

Ergänzende Informationen zu Konstanten und Type Casting

let s = 3i;       // int
let u = 3u;       // uint

let i = 3;        // generische Ganzzahl
let f = 3.0;      // 64-Bit Fließkommazahl, f64 Suffix ist optional
let p = 3.0f32;   // 32-Bit Fließkommazahl
let q: f32 = 3.0; // 32-Bit Fließkommazahl
let x: f64 = i as f64; // explizite Konvertierung mit "as" erforderlich
let y: int = f as int; // explizite Konvertierung mit "as" erforderlich

let m = "dings"        // &'static str (slice) bezieht sich auf den statischen Speicher
let o = m.to_string(); // String, besitzt eine Heap-allozierte und änderbare Zeichenkette

Weiterführende Links

• Homepage
• Rust-Wiki bei Github
• Sub-Reddit
• Rust by Example
• Rust-Spielwiese (Online Compiler mit Syntax Highlighting und Disassembler)
• Rust 'n Stuffs (Blog mit "This Week in Rust"-Serie)
• IRC Chat Logs für #rust