TT Rust: Unterschied zwischen den Versionen

Aus Wiki CCC Göttingen
Zur Navigation springen Zur Suche springen
KKeine Bearbeitungszusammenfassung
KKeine Bearbeitungszusammenfassung
 
(4 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 2: Zeile 2:


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 [https://en.wikipedia.org/wiki/System_programming_language 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.
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 [https://en.wikipedia.org/wiki/System_programming_language 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 [http://media.ccc.de/browse/conferences/hackover/2014/hackover14_-_6496_-_de_-_raum_1_7_-_201410251345_-_programmiersprache_rust_und_ihre_sicherheitsgarantien_-_esgeh.html Vortrag] wurde von demselben Autor später auf der Hackover2014 in Hannover gehalten.
=== Mitschnitt und Folien ===


{| class="wikitable"
{| class="wikitable"
Zeile 19: Zeile 23:
[https://dl.dropboxusercontent.com/u/46560320/docs/rust/sg-rust-intro-de.pdf Vortragsfolien] (pdf, 175 KB)
[https://dl.dropboxusercontent.com/u/46560320/docs/rust/sg-rust-intro-de.pdf Vortragsfolien] (pdf, 175 KB)
[https://dl.dropboxusercontent.com/u/46560320/docs/rust/sg-rust-intro-de.mp3 Audiospur] (mp3, 41 MB, 88 Minuten)
[https://dl.dropboxusercontent.com/u/46560320/docs/rust/sg-rust-intro-de.mp3 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 ===
=== Korrekturen ===


Auf einer Folie hatte ich "x++" im Code verwendet. So einen Operator gibt es allerdings nicht. Das könnte man z.B. "x+=1" ersetzen. Das kommt davon, wenn man sich bei sehr kleinen Code-Schnippseln denkt "Das passt schon so, muss ich nicht testen". :)
Auf einer Folie hatte ich <tt>x++</tt> im Code verwendet. So einen Operator gibt es allerdings nicht. Das könnte man z.B. durch <tt>x+=1</tt> 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 ===
=== Ergänzende Informationen zur Fehlerbehandlung ===

Aktuelle Version vom 3. November 2014, 15:37 Uhr

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]