© alonesdj / 123RF.com

Rust hat es zum offiziellen Werkzeug beim Erstellen des Linux-Kernels geschafft. Die Sprache ist inzwischen aber genauso in den Bereichen Anwendungsentwicklung, Web, Spiele oder Embedded zu Hause. Auf jeden Fall ist Rust mehr als einen Blick wert.

Da ich seit vielen Jahren im Bereich der C-, C#- und Python-Programmierung meine Brötchen verdiene, dachte ich irgendwann an meine Zukunft: Was wird denn die nächste Programmiersprache sein, die man als professioneller Entwickler können sollte? Ich sprach mit vielen Kolleginnen und Kollegen darüber.

Neben den üblichen Verdächtigen wie Go oder Exoten wie Haskell tauchte immer wieder der Name Rust auf, was mir damals nichts sagte. Dazu gab es immer Aussagen wie etwa, Rust sei “einfach wahnsinnig sicher”. Gemeint ist hier die Speichersicherheit – konkret, dass nicht das ganze Programm auseinanderfliegt, weil beispielsweise ein Array überläuft. Das war bei C nervig. C# und Python kümmern sich selbst darum, was aber die Performance senkt. Der Rust-Compiler garantiert dafür, dass keine Speicherfehler auftreten.

Ein anderer Hinweis lautete, unbedingt Rust zu lernen – es sei der Nachfolger von C++. Mich persönlich hat C++ nie so richtig begeistert. Hinter dieser Empfehlung steckt wahrscheinlich, dass Rust systemnah arbeitet. Man kann selbst genau bestimmen, was das Programm machen soll; zudem gibt es eine komfortable Abstraktionsebene. Die Sprache nimmt Entwicklern einige Aufgaben ab, sodass sie sich nicht ständig um jedes Bit kümmern müssen.

Tatsächlich fanden sich auch Stimmen, die mir eher von Rust abrieten: “Rust macht das viel zu kompliziert.” Nun liegt Komplexität immer im Auge des Betrachters, mit komplizierten Dingen hatte ich noch nie ein Problem. Außerdem hat sich Rust laut Umfragen zu einer der beliebtesten Programmiersprachen von Entwicklern gemausert. Wenn die Sprache zu kompliziert ist und Entwicklerinnen und Entwickler sie dennoch so schätzen, sind dann alle leicht masochistisch veranlagt?

Letztlich passten viele der Aussagen nicht zusammen. Das machte mich neugierig. Wie so oft im Leben gab es nur eine Möglichkeit, den Dingen auf den Grund zu gehen: es selbst ausprobieren.

Einsteigen, bitte!

In der Suchmaschine erschien nach dem Eintippen des Begriffs “Rust” in der Ergebnisliste die Seite https://www.rust-lang.org. Das ist die zentrale Anlaufstelle der Rust Foundation, die die Programmiersprache weiterentwickelt (Abbildung 1). Drücken Sie auf der Webseite den gelben Button Get Started, landen Sie auf eine Seite mit einem einzelnen Kopierbefehl, der den Compiler und alle anderen Werkzeuge auf den eignen Rechner bringt:

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

Abbildung 1: Die Seite Rust-lang.org bietet alle Werkzeuge und Dokumentationen für den Entstieg in Rust.

Sobald Sie den Befehl in einer Shell ausgeführt haben, holt das Werkzeug Rustup alle anderen für Rust notwendigen Programme auf den Rechner. Dazu gehören die aktuelle, stabile Version des Compilers Rustc und Cargo, das Werkzeug, das das Erstellen der Programme und Laden neuer Bibliotheken übernimmt. Cargo verbindet die Aufgaben klassischer Make-Tools mit denen von Paketmanagern wie PIP in Python oder NPM für Javascript.

Mit der Option »new« legt Cargo ein neues Projekt an, im Beispiel aus Listing 1 mit dem Namen »twentyone« (erste Zeile). Mit dem Befehl »tree« verschaffen Sie sich eine Übersicht über die Dateien und Verzeichnisse (zweite Zeile).

$ cargo new twentyone
$ tree --dirsfirst twentyone
twentyone
|-- src
|   `-- main.rs
`-- Cargo.toml
1 directory, 2 files

Die neue Datei »Cargo.toml« enthält alle Informationen, die Cargo benötigt, um ein lauffähiges Programm zu erzeugen (Abbildung 2). Der Abschnitt »[package]« der Datei beschreibt die neu zu erstellende Software inklusive ihrer Bezeichnung (»name«), Version (»version«) und des notwendigen Compiler-Releases (»edition«). Der nächste Abschnitt »[dependencies]« verweist auf alle Bibliotheken, die das Programm zusätzlich zur Standardbibliothek benötigt. Hier steht aktuell noch nichts. Im Verzeichnis »src/« hat Cargo ein minimales Hallo-Welt-Programm in der Datei »main.rs« generiert.

Abbildung 2: In der Datei »Cargo.toml« stehen der Name und die aktuelle Version des Programms sowie das benötigte Compiler-Release.

Die Funktion »(fn) main« markiert den Startpunkt jedes Rust-Programms. Mit geschweiften Klammern und einem Strichpunkt nach Befehlen lehnt sich die Rust-Syntax, zumindest auf den ersten Blick, an andere bekannte Programmiersprachen wie Java, Javascript oder C++ an. Der Befehl »println!« gibt schließlich den String »Hello, world!« auf dem Bildschirm aus (Abbildung 3).

Abbildung 3: Mit seinen geschweiften Klammern erinnert Rust zunächst an Sprachen wie Java, Javascript oder C++.

Übersetzen

Mit der Option »run« kümmert sich Cargo um alles, was zum Erstellen eines lauffähigen Programms aus dem Rust-Quellcode notwendig ist. Es kompiliert veränderte Quelldateien, lädt notwendige Bibliotheken aus dem Internet, linkt alles zum ausführbaren Programm »target/debug/twentyone« und führt es am Ende aus.

An dieser Stelle kann es passieren, dass auf Linux beim ersten Start von Cargo einiges fehlt. Der Rust-Installer übernimmt alles, was mit Rust zusammenhängt, prüft aber nicht, ob im Betriebssystem alle Dateien zur Programmerstellung vorliegen. Das Kommando »sudo apt install build-essential« lädt die wesentlichen Bestandteile auf den Rechner, sodass einem »cargo run« nichts mehr im Wege stehen sollte (Listing 2). Nebenbei erzeugt Cargo die Datei »Cargo.lock«, in der es Buch führt, welche Versionen der einzelnen Module erforderlich sind und welche Abhängigkeiten zwischen ihnen bestehen.

$ cargo run
$  Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
$   Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
$    Running `target/debug/hello_cargo`
$ Hello, world!

In Rust geschriebene Programme glänzen häufig mit einer ziemlich guten Performance. Starten Sie »cargo run« ohne zusätzliche Optionen, schleppt es einiges an Informationen für das Debugging und ähnliches mit. Mit dem Aufruf »cargo run –release« befreien Sie die finalen Programme davon, was sie häufig zehn bis hundert Mal schneller macht.

Eine Besonderheit: Konnte der Rust-Compiler ein Programm einmal fehlerfrei kompilieren, verspricht Rust, dass dies in zukünftigen Versionen der Programmiersprache genauso klappt. Weitere, ausführliche Informationen über die Installation und Werkzeuge wie Cargo finden Sie online im Buch “The Rust Programming Language” [1]. Es ist wie alle zentralen Werkzeuge von Rust kostenfrei. Darüber hinaus ist die Programmiersprache selbst quelloffen und soll es in Zukunft auch bleiben.

Orientierung

Als systemnahe Sprache stellt Rust vor allem eine gute Performance und eine optimale Speicherverwendung in den Fokus. Für das Rust-Entwicklungsteam ist es allerdings genauso wichtig, dass Nutzer die Programmiersprache möglichst einfach einsetzen können. Da die Sprache relativ jung ist, hat das Rust-Team beschlossen, erst einmal vier wichtige Themengebiete im Blick zu haben (Abbildung 4):

• Werkzeuge – Programme, die Sie in der Kommandozeile starten, die keine grafische Oberfläche besitzen und performant ihre Aufgaben erledigen,
• Webanwendungen – Programme, die im Browser laufen und mit Webpack oder WASM und Javascript zusammenarbeiten,
• Netzwerk – Programme, die auf Servern laufen, über ein Netzwerk ihre Dienste anbieten und sehr stabil sein müssen, sowie
• Embedded – Programme, die direkt auf Chips laufen, ohne viel Betriebssystem auskommen und wenig Ressourcen verbrauchen.

Abbildung 4: Auf der Webseite von Rust spiegeln sich vier wichtige Anwendungsgebiete.

Häufig kommt Rust in systemnahen Bereichen wie der Kernel-Programmierung von Linux zum Einsatz. Neuerdings entstehen aber immer mehr klassische Desktop-Anwendungen und Spiele mit der Programmiersprache.

Erste Schritte

Das erste Programm in Rust soll in diesem Artikel ein einfaches Siebzehn-und-Vier-Kartenspiel sein (siehe Kasten “Siebzehn und Vier”) – nur in der Kommandozeile, ohne große Oberfläche. Versuchen Sie, sich einfach durchzuwursteln, damit Sie sich selbst eine Meinung zu Rust bilden können. Das Beispielprogramm baut auf dem bereits erzeugten Projekt »twentyone« auf. Eine erste, minimale Version der Funktion »main()« sehen Sie in Listing 3.

fn main() {
  let mut sum_player:i32 = 0;
  let mut sum_bank = 0;
  println!("Player {} Bank {}", sum_player, sum_bank);
  // player draws cards
  // bank draws cards
  println!("Player win");
}

Die Funktion umfasst einige Variablendefinitionen, eine Ausgabe mit »println!« und Kommentare. Letztere beginnen in Rust mit »//« und gehen bis zum Zeilenende, zum Beispiel »// player draws cards«. Spezielle Klammern für Kommentare, wie in anderen Programmiersprachen üblich, gibt es in Rust nicht. Benötigen Sie für einen Kommentar mehrere Zeilen, beginnt Sie jede davon mit »//«.

Der Befehl »let mut sum_player:i32 = 0;« definiert eine neue Variable, hier mit dem Namen »sum_player«. Darin speichert das Programm den aktuellen Punktewert des Spielers. Der Rust-Compiler will genau wissen, welchen Typ diese Variable hat, damit er bereits beim Kompilieren möglichst viele Prüfungen für die Programmsicherheit ausführen kann. Daher schließt sich an den Variablennamen nach einem Doppelpunkt der Datentyp an, in diesem Fall eine 32-Bit-Integer-Variable (»i32«). Wäre es eine Gleitkommazahl (“floating point”), würde hier »f32« stehen (siehe Tabelle “Rust-Datentypen für Zahlen”).

Am Ende der Zeile folgt noch der Startwert der Variable. Mit dem Begriff »mut« (mutable) im Befehl »let« zeigt Rust an, dass Sie die Variable ändern können. Standardmäßig trifft das aber nicht zu. Normalerweise sind Variablen immer unveränderlich (immutable), außer Sie definieren das explizit anders. Der Rust-Compiler garantiert, dass sich das Programm dann auch daran hält.

Jede Variable besitzt in Rust grundsätzlich zur Zeit der Kompilierung einen festen Datentyp, den das Programm später nicht mehr ändern kann. Der Compiler versucht so weit wie möglich, die Typen abzuleiten, damit Sie sich eine explizite Angabe sparen können. Aus einem Startwert von »0« würde er ein 32-Bit-Integer (»i32«) ableiten, aus einem Startwert von »0.0« eine 32-Bit-Gleitkommazahl (»f32«). Falls der Compiler den Datentyp nicht erkennen kann, bekommen Sie beim Kompilieren eine Fehlermeldung und können dann eine explizite Typangabe einfügen.

Kommunikation

Die nächste Version des Siebzehn-und-Vier-Programms soll über die Tastatur einlesen, ob der Spieler oder die Spielerin eine weitere Karte will (Listing 4).

use std::io;
fn main() {
  let mut sum_player:i32 = 0;
  let mut sum_bank = 0;
  println!("Player {} Bank {}", sum_player, sum_bank);
  // player draws cards
  let mut answer = String::new();
  println!("Card? Y/[N]");
  io::stdin().read_line(&mut answer).expect("Failed to read line");
  // bank draws cards
  println!("Player win");
}

Die bisher verwendeten Funktionen und Datentypen gehören alle zu Rusts Standardbibliothek. Einen Teil davon (prelude) fügt Rust automatisch jedem Programm hinzu, um es zu vereinfachen. Das im Beispielprogramm benötigte Modul »std::io« gehört allerdings nicht dazu. Mit seiner Hilfe greifen Sie auf Ein- und Ausgabeschnittstellen zu. Der Befehl »use« am Anfang des Programms holt es an Bord (Zeile 1). Das »std« vor den zwei Doppelpunkten sagt aus, dass Rust das Modul in der Standardbibliothek findet.

Die vom Spieler zu erwartende Antwort ist eine Zeichenkette. Dazu erzeugt die Funktion »new()« in Zeile 7 einen neuen String. Die zwei Doppelpunkte »::« zwischen dem Datentyp »String« und der Funktion »new()« bedeuten nichts anderes, als dass es sich um eine Funktion handelt, die auf einen Datentyp angewendet wird. In Rust heißen nennt man diese assoziierte Funktionen (associated functions). Funktionen zum Erzeugen von Elementen heißen häufig »new()«, könnten aber ebenso gut einen ganz anderen Namen tragen. In anderen Programmiersprachen gibt es zum Erstellen neuer Elemente immer besondere Befehle oder Funktionen. In Rust dagegen ist »new()« eine Funktion wie jede andere.

Die Funktion »io::stdin<()« liefert den Zugriff auf die Standardeingabe (»std::io::Stdin«) zurück (Zeile 9). Bei Desktop-Rechnern ist das meist die Tastatur. Auf das, was hier zurückkommt, führt das Programm die Funktion »read_line()« aus. Da es sich hier um einen Wert statt um einen Datentyp handelt, verwendet Rust den Punkt ».« als Trennzeichen und kein »::« wie bei Datentypen. Etwas ausführlicher geschrieben, sähe das Konstrukt so aus:

let stdin_handle = io::stdin();
stdin_handle.read_line(&mut answer);

Im Parameter »&mut answer« speichert die Funktion »read_line()« den Wert, den sie von der Tastatur einliest. Die Bezeichnung »mut« (mutable) bedeutet wieder, dass Sie den Wert der Variable ändern können. Das Zeichen »&« definiert, dass Rust hier nicht den Wert der Variablen »answer« übergibt, sondern nur einen Verweis auf die Variable. Damit kann die aufgerufene Funktion den Wert ändern.

Die Funktion »read_line()« liefert nicht direkt die Eingabe zurück, sondern einen Wert des Datentyps »Result«. Er kann statt des Eingabewerts einen bei Lesen aufgetretenen Fehler enthalten. Rust verfügt über keinen gesonderten Fehlermechanismus wie andere Programmiersprachen, sondern verarbeitet Ausnahmen über Rückgabewerte. Die Funktion »expect()« (am Ende des Befehls in Zeile 9) analysiert das Ergebnis von »read_line«. Existiert ein Eingabewert, gibt sie ihn zurück. Im Fehlerfall liefert sie eine Warnung und bricht das gesamte Programm ab.

Entscheidungen

In der dritten Version des Beispielprogramms (Listing 5) kommt wieder einiges hinzu, sodass der Code auf den ersten Blick vielleicht etwas kompliziert wirkt. Manches ist bereits bekannt, anderes nicht. Wenn Sie die Anweisungen Schritt für Schritt durchgehen, klärt sich das meiste aber.

  use rand::Rng;
  use std::io;
  fn main() {
    let mut sum_player:i32 = 0;
    let mut sum_bank = 0;
    let mut player_win = true;
    println!("Player {} Bank {}", sum_player, sum_bank);
    let mut card_player = random_card();
    // player draws cards
    loop {
      println!("Card for Player {}", card_player);
      sum_player += card_player;
      println!("Player {} Bank {}", sum_player, sum_bank);
      let mut answer = String::new();
      println!("Card? Y/[N]");
      io::stdin().read_line(&mut answer).expect("Failed to read line");
      answer = answer.trim().to_string();
      if answer=="Y" || answer=="y"{
        card_player = random_card();
      } else {
          break;
      }
    }
    // bank draws cards
    println!("Player win");
  }
  fn random_card()->i32{
    let mut rng = rand::thread_rng();
    rng.gen_range(1..=11)
  }

Der Spieler oder die Spielerin kann jetzt nicht nur eine Karte ziehen, sondern beliebig viele. Deshalb braucht das Programm eine Schleife um das Einlesen der Tastatur herum. Neben den aus anderen Programmiersprachen bekannten For- und While-Schleifen kennt Rust die Endlosschleife »Loop«, die sich in unserem Fall anbietet (Listing 6).

loop {
  // mach irgendwas
  break; // Schleife wird beendet
}

»Loop« läuft immer wieder durch, bis Sie irgendwann den Befehl »break« absetzen. Dann geht es nach der Schleife weiter. Irgendwann heißt in unserem Fall, sobald der Spieler oder die Spielerin keine neue Karte mehr will (Listing 7).

loop {
  [...]
  answer = answer.trim().to_string();
  if answer=="Y" || answer=="y"{
    card_player = random_card();
  } else {
    break;
  }
}

Das If-Konstrukt gestaltet sich in Rust relativ einfach (Listing 8). In unserer Endlossschleife prüft diese Bedingung, ob der Spieler [Y] gedrückt hat – dann gibt es eine neue Karte.

if // Bedingung {
  // erfüllt
} else {
  // nicht erfüllt;
}

Da Rust systemnah viele Möglichkeiten bieten will, gibt es nicht nur einen Datentyp für Strings, sondern mehrere, für unterschiedliche Anwendungsfälle geeignete Varianten. Das wirkt gerade beim Einstieg in Rust etwas verwirrend. Ein Beispiel bietet die folgende Anweisung:

answer = answer.trim().to_string();

Hier schnippelt die Funktion »trim()« alles weg, was nicht zur eigentlichen Zeichenkette gehört, zum Beispiel Leerzeichen oder Zeilenumbrüche. Danach wandelt die Funktion »to_string()« alles in den Datentyp »String« um, den das Programm verwendet.

Eine Karte, bitte!

Wird eine weitere Karte gewünscht, liefert die Funktion »random_card« ein zufällig ausgewähltes Blatt zurück:

card_player = random_card();

Um es einfacher zu machen, kommt nicht wirklich eine Datenstruktur zurück, die einer Spielkarte entspricht, sondern ein zufälliger Integer-Wert zwischen 1 und 11. Den Umgang mit konkreten Spielkartenäquivalenten verschieben wir auf die nächste Folge dieser Reihe. Das Programm addiert mit »sum_player += card_player« den neuen Wert zur aktuellen Summe. Das ist lediglich eine verkürzte Schreibweise für »sum_player = sum_player + card_player«.

Jetzt fehlt noch die Definition der Funktion »random_card«. Das erfordert einen Zufallsgenerator, den die Standardbibliothek von Rust nicht mitbringt. Die meisten zusätzlichen Bibliotheken finden Sie im Web unter https://crates.io. Was in anderen Programmiersprachen Bibliotheken oder Pakete heißt, nennt Rust Crates. Das bedeutet im Englischen Kiste, Getränkekiste oder Versandbox. Die Idee für diesen Namen stammt wohl daher, dass der Name des Werkzeugs zur Programmerstellung Cargo (Fracht, Lieferung) lautet.

Damit heißt der englische Satz “You ship your crates to others with Cargo” (“Du versendest deine Kisten per Fracht”) für Rust-Programmierer “Du lieferst deine Bibliotheken mit dem Werkzeug Cargo aus”. Solche Begrifflichkeiten spielen eine wichtige Rolle, im Internet oder in Büchern stolpern Sie immer wieder darüber.

Zurück zur Bibliothek »rand« für Zufallszahlen: Zuerst müssen Sie dem Werkzeug »Cargo« in der Datei »Cargo.toml« mitteilen, dass Sie damit arbeiten wollen. Dazu fügen Sie im Abschnitt »dependencies« die gewünschte Library hinzu, unter Angabe der bevorzugten Versionsnummer:

[dependencies]
  rand = "*"

Der Stern »*« bedeutet in diesem Fall, dass Cargo immer die aktuellste Version verwendet. Im Programm selbst fehlt noch die Anweisung »use rand::Rng« zum Bekanntmachen der zusätzlichen Möglichkeiten. Nun erzeugt die Funktion »thread_rng()« einen neuen Zufallszahlengenerator (Listing 9, zweite Zeile), der Zahlen zwischen 1 und 11 liefert (dritte Zeile). Hier sehen Sie auch, wie Ausdrücke für Wertebereiche (range expression) in Rust aussehen: »1..11«. Allerdings wäre hier der letzte Wert nicht mit dabei, daher das zusätzliche Gleichheitszeichen in Zeile 3.

fn random_card()->i32{
 let mut rng = rand::thread_rng();
 rng.gen_range(1..=11)
}

Die Definition der Funktion »random_card()« in Listing 9 unterscheidet sich nicht groß von jener der bereits bekannten Funktion »main()«. An erster Stelle steht »fn« für Funktion, dann folgen der Name und runde Klammern. Der anschließende Pfeil »->« mit der Typangabe »i32« macht den Unterschied: Er signalisiert, dass es sich beim Rückgabewert um den Datentyp »i32« (32-Bit-Ganzzahl) handelt.

Jetzt die Quizfrage: Mit welchem Befehl gibt die Funktion einen Wert zurück? Wo ist das »return«? Wenn Sie ganz genau hinsehen, erkennen Sie, dass in der letzten Befehlszeile von Listing 9 der abschließende Strichpunkt fehlt: Genau das erzeugt in Rust den Rückgabewert. Das sieht erst einmal etwas knifflig aus. Mit der Zeit gewöhnt man sich aber daran und freut sich schon bald, nicht bei jeder Funktionsdefinition gebetsmühlenartig »return« tippen zu müssen.

Das gesamte Programm finden Sie in Listing 10, ergänzt um die Reaktion der Bank und die Abfrage, wer gewonnen hat. Jetzt können Sie mit »cargo run« selbst das Programm erstellen und einige Runden Siebzehn und Vier spielen.

use rand::Rng;
use std::io;
fn main() {
  let mut summe_player = random_card();
  let mut summe_bank = random_card();
  let mut player_win = true;
  println!("Player {} Bank {}", summe_player, summe_bank);
  let mut card_player = random_card();
  loop {
    println!("Card for Player {}", card_player);
    summe_player += card_player;
    println!("Player {} Bank {}", summe_player, summe_bank);
    if summe_player > 21 {
      player_win = false;
      break;
    }
    let mut answer = String::new();
    println!("Card? Y/[N]");
    io::stdin().read_line(&mut answer).expect("Failed to read line");
    answer = answer.trim().to_string();
    if answer=="Y" || answer=="y"{
      card_player = random_card();
    } else {
      break;
    }
  }
  let mut card_bank = random_card();
  loop {
    if player_win == false || summe_bank > 21 {
      break
    }
    println!("Card for Bank {}", card_bank);
    summe_bank += card_bank;
    println!("Player {} Bank {}", summe_player, summe_bank);
    if summe_bank < 17 {
      card_bank = random_card();
    } else {
      break;
    }
  }
  if summe_bank > 21 {
    player_win = true;
  } else if summe_bank > summe_player {
    player_win = false;
  }
  if player_win {
    println!("Player win")
  } else {
    println!("Bank win")
  }
}
fn random_card()->i32{
  let mut rng = rand::thread_rng();
  rng.gen_range(1..=11)
}

Ausblick

Als ich mein erstes Rust-Programm abgetippt hatte und es das gewünschte Ergebnis lieferte, lautete mein Fazit zunächst: Einfach ist Rust nicht, aber die Performance, der Compiler und vor allem die einprogrammierte Sicherheit machen Laune. Je mehr ich danach mit Rust arbeitete, desto begeisterter wurde ich. Meine Empfehlung lautet deswegen, nicht gleich nach dem ersten Programm aufzuhören. Machen Sie einfach weiter!

Einige Programme später hatte ich ein Gespräch mit der Redaktion des Linux-Magazins: “Was machst du so Neues?” “Rust.” “Wie wäre es mit einer Serie über Rust, vor allem für Einsteiger?” “Cool!” Das war die Geburtsstunde dieser Kolumne. Da das Programmieren in einer neuen Sprache für mich der Erforschung eines unbekannten Planeten ähnelt, stand auch schnell ein Name dafür fest: Planet Rust.

In der nächsten Folge von Planet Rust geht es darum, wie Sie für das Siebzehn-und-Vier-Spiel die Karten als Objekte abbilden und sie als Grafik auf den Bildschirm bringen. (csi/jlu)