Rusts Compiler ist der meinungsstärkste Code-Reviewer, mit dem die meisten Entwickler je arbeiten werden. Sein Besitzmodell, der Borrow-Checker und die Lebenszyklus-Erzwingung eliminieren ganze Kategorien von Fehlern, die C- und C++-Codebasen plagen. Ein Compiler, der Speicherfehler verhindert, ist jedoch nicht dasselbe wie ein umfassendes Qualitätssicherungssystem. Logische Fehler, unsichere Abhängigkeitsketten, unsachgemäße Verwendung von Blöcken, Performance-Anti-Patterns und Stilabweichungen bleiben bestehen. rustcTeams, die zuverlässigen Rust-Code in großem Umfang bereitstellen, kombinieren den Compiler mit einem mehrschichtigen Satz statischer Analysetools, von denen jedes einen anderen Teil der Qualitätsoberfläche abdeckt.
Die falsche Kombination verschwendet CI-Zeit und erzeugt unnötigen Code, den Entwickler irgendwann ignorieren. Die richtige Kombination hingegen sorgt dafür, dass die Strenge des Compilers eher als Untergrenze denn als Obergrenze wahrgenommen wird. Die Tools in diesem Leitfaden sind nach ihrer Funktion und nicht alphabetisch geordnet, sodass Teams einen Stack aufbauen können, der alle drei Qualitätsebenen abdeckt: Linting und Idiome, Abhängigkeitssicherheit und tiefgehende Verifizierung für sicherheitskritischen oder sensiblen Code.
SMART TS XL
Die Aufrechterhaltung der Qualität in der modernen Rust-Entwicklung ist selbst mit den starken Sicherheitsgarantien der Sprache eine Herausforderung. SMART TS XL wurde entwickelt, um Teams bei der Entwicklung zuverlässiger, wartungsfreundlicher und sicherer Software zu unterstützen. Es bietet umfassende statische Analysefunktionen, die auf die einzigartigen Funktionen von Rust zugeschnitten sind. Es unterstützt professionelle Engineering-Workflows, indem es Probleme frühzeitig erkennt, Konsistenz sicherstellt und den manuellen Prüfaufwand reduziert.
Die drei Rostschichten – Statische Analyse
Das Verständnis dafür, welches Werkzeug wo eingesetzt werden sollte, verhindert den häufigen Fehler, einen formalen Verifizierer zu verwenden, wo ein Linter ausreichen würde, oder sich auf einen Linter zu verlassen, wo ein Sicherheitsscanner erforderlich ist. Jedes ausgereifte Rust-Projekt sollte alle drei Ebenen abdecken.
Schicht 1: Fussel und Stil Erkennt Verstöße gegen idiomatische Ausdrücke, häufige Fehler und Wartbarkeitsprobleme. Tools: Clippy, rustfmt, rust-analyzer.
Ebene 2: Abhängigkeiten und Lieferkettensicherheit Prüft Drittanbieter-Pakete auf bekannte Sicherheitslücken und Richtlinienverstöße. Tools: cargo-audit, cargo-deny, cargo-auditable.
Schicht 3: Tiefenverifizierung Findet Speichersicherheitsprobleme in unsicherem Code, undefiniertes Verhalten und beweist formal Eigenschaften kritischer Funktionen. Tools: Miri, Kani, MIRAI, Rudra, Creusot, Prusti.
Die folgende Tabelle ordnet jedes wichtige Werkzeug seiner Ebene, seinen Kosten, seiner Eignung für CI und seinem primären Anwendungsfall zu:
| Werkzeug | Schicht | Kosten | CI-geeignet | Primärer Anwendungsfall |
|---|---|---|---|---|
| Clippy | Flusen | Kostenlos / Open Source | Ja | Idiomatische Linting-Techniken, Stil, häufige Fehler |
| rustfmt | Flusen | Kostenlos / Open Source | Ja | Durchsetzung der Codeformatierung |
| Rost-Analysator | Linting / DX | Kostenlos / Open Source | Teilweise | IDE-Diagnostik, Inline-Analyse |
| Fracht-Audit | Abhängigkeitssicherheit | Kostenlos / Open Source | Ja | Bekannte CVEs in Kisten |
| Fracht verweigern | Abhängigkeitssicherheit | Kostenlos / Open Source | Ja | Lizenz, Duplikate, Hinweise |
| Frachtprüfbar | Abhängigkeitssicherheit | Kostenlos / Open Source | Ja | Abhängigkeitsdaten in Binärdateien einbetten |
| Miri | Tiefenprüfung | Kostenlos / Open Source | Ausgewähltes Personal | Undefiniertes Verhalten in unsicherem Code |
| Kani | Tiefenprüfung | Kostenlos / Open Source | Ausgewähltes Personal | Formale Verifikation, Modellprüfung |
| MIRAI | Tiefenprüfung | Kostenlos / Open Source | Ausgewähltes Personal | Abstrakte Interpretation, Taftanalyse |
| Rudra | Tiefenprüfung | Kostenlos / Open Source | Forschung | Speichersicherheitslücken in unsicherem Rust |
| Semgrep | Querschnitt | Kostenloses Angebot + kostenpflichtiges Angebot | Ja | Benutzerdefinierte Sicherheitsmuster, Mehrsprachigkeit |
| SonarCloud | Querschnitt | Kostenloses Angebot + kostenpflichtiges Angebot | Ja | Kontinuierliche Qualitätskontrolle, Dashboards |
Ebene 1: Linting, Stil und Entwicklererfahrung
Clippy
Clippy ist der ideale Ausgangspunkt für die statische Codeanalyse in Rust. Es ist Bestandteil der offiziellen Rust-Toolchain und bietet über 700 Lint-Tests, die Korrektheit, Performance, Stil, Komplexität und Einschränkungen abdecken. Es ist das Tool, das die meisten Rust-Teams täglich nutzen – und das aus gutem Grund: Es findet echte Fehler und nicht nur Stilfragen.
bash
# Run all lints including pedantic and nursery groups
cargo clippy -- -W clippy::all -W clippy::pedantic
# Fail CI on any warning
cargo clippy -- -D warnings
# Check specific lint group
cargo clippy -- -W clippy::correctness -W clippy::suspiciousEs lohnt sich, die Lint-Kategorien von Clippy genauer zu verstehen:
| Kategorie | Was es fängt |
|---|---|
correctness | Code, der mit ziemlicher Sicherheit falsch ist (immer ablehnen) |
suspicious | Code, der wahrscheinlich falsch oder sehr überraschend ist |
style | Nicht-idiomatische Muster mit einer deutlichen Verbesserung |
complexity | Unnötig komplexe Konstrukte |
performance | Code, der kompiliert, aber langsamer läuft als er sollte |
pedantic | Strenge Richtlinien, meinungsbetont (selektiv aktivieren) |
restriction | Regeln, die Sie in bestimmten Kontexten durchsetzen möchten. |
nursery | Neue Fussel können zu falsch positiven Ergebnissen führen. |
Frachtkontrolle vs. Clippy: cargo check Es validiert die Typkorrektheit und Kompilierung, ohne eine Binärdatei zu erzeugen. Es ist schnell und eignet sich zur Build-Verifizierung. cargo clippy läuft cargo check plus alle Lint-Analysen. Für CI ausführen cargo check für schnelles Kompilierungsfeedback und cargo clippy -- -D warnings als separates Qualitätsgate. Sie sind nicht austauschbar: cargo check wird idiomatische Probleme nicht erkennen, und cargo clippy ist langsamer.
Clippy konfigurieren clippy.toml oder Inline-Attribute geben Teams die Kontrolle über Störungen:
Toml
# clippy.toml
avoid-breaking-exported-api = false
msrv = "1.70"Rost
// Suppress a lint for one function with documented reason
#[allow(clippy::too_many_arguments)]
fn complex_setup(...) { ... }Was Clippy nicht abdeckt: tiefgreifende Datenflussanalysen über Module hinweg, Sicherheitslückenscans in Abhängigkeiten, formale Korrektheitsnachweise oder benutzerdefinierte, organisationsspezifische Regeln. Diese erfordern Werkzeuge in den anderen Schichten.
rustfmt
rustfmt erzwingt eine einheitliche Formatierung im gesamten Quellcode. cargo fmt. Der rustfmt.toml Die Konfigurationsdatei legt projektweite Stilregeln fest. In CI cargo fmt -- --check Gibt einen Fehlercode ungleich Null zurück, wenn eine Datei neu formatiert würde, wodurch ein sauberes Qualitätsgate ohne Konfigurationsaufwand entsteht:
bash
# Check formatting without modifying files (CI mode)
cargo fmt -- --check
# Apply formatting (developer mode)
cargo fmtIntegration von Rust-Analyzer und IDE
rust-analyzer ist die Implementierung des Language Server Protocol (LSP) für Rust und bietet Echtzeitdiagnose, Codevervollständigung, Sprung zur Definition und Inline-Clippy-Warnungen in jedem LSP-kompatiblen Editor. Es hat den veralteten Rust Language Server (RLS) ersetzt und sollte in neuen Projekten ausschließlich als Sprachserver verwendet werden.
Aus der Perspektive der statischen Analyse zeigt rust-analyzer Clippy-Lints direkt im Text an, während Entwickler tippen, und gibt so sofortiges Feedback zu Stil- und Korrektheitsproblemen direkt bei der Eingabe, anstatt einen separaten Terminallauf zu erfordern:
JSON
// VS Code settings.json: enable Clippy via rust-analyzer
{
"rust-analyzer.check.command": "clippy",
"rust-analyzer.check.extraArgs": [
"--", "-W", "clippy::all", "-W", "clippy::pedantic"
]
}rust-analyzer bietet außerdem Inlay-Hinweise für abgeleitete Typen, Ausleihlebensdauern und Parameternamen, die nützlich sind, um unbekannten Code zu überprüfen, ohne zu Definitionen navigieren zu müssen.
Schicht 2: Abhängigkeiten und Lieferkettensicherheit
Fracht-Audit
Die Frachtprüfung überprüft die Cargo.lock Die Datei wird mit der RustSec Advisory Database abgeglichen, um bekannte CVEs in direkten und transitiven Abhängigkeiten zu identifizieren. Sie ist das Mindestmaß an Abhängigkeitssicherheitsprüfung, das jedes Rust-Projekt in der CI-Pipeline durchführen sollte.
bash
# Install
cargo install cargo-audit
# Run audit
cargo audit
# Ignore a specific advisory (document the reason in comments)
cargo audit --ignore RUSTSEC-2024-0001
# JSON output for pipeline integration
cargo audit --json | jq '.vulnerabilities'cargo-audit erfasst ausschließlich bekannte, veröffentlichte Sicherheitswarnungen. Es kann weder Schwachstellen in Ihrem eigenen Code noch Probleme, die noch nicht in der RustSec-Datenbank erfasst sind, noch Richtlinienverstöße wie unerwünschte Lizenzen erkennen.
Fracht verweigern
cargo-deny erweitert das Abhängigkeitsmanagement über bekannte CVEs hinaus auf Lizenzkonformität, Erkennung doppelter Crates und benutzerdefinierte Sperr-/Zulassungsrichtlinien. Es ist das umfassendste Tool für Organisationen mit Compliance-Anforderungen:
Toml
# deny.toml
[advisories]
vulnerability = "deny"
unmaintained = "warn"
[licenses]
allow = ["MIT", "Apache-2.0", "ISC", "BSD-2-Clause", "BSD-3-Clause"]
deny = ["GPL-2.0"]
copyleft = "warn"
[bans]
multiple-versions = "warn"bash
cargo install cargo-deny
cargo deny checkFrachtprüfbar
cargo-auditable bettet den kompletten Abhängigkeitsbaum als strukturierte Metadaten in einem dedizierten Linker-Abschnitt in kompilierte Rust-Binärdateien ein. Dies ermöglicht die Überprüfung bereitgestellter Binärdateien ohne Zugriff auf den Quellcode, was für Sicherheitsüberprüfungen nach der Bereitstellung und Transparenz in der Lieferkette von großem Wert ist.
bash
cargo install cargo-auditable
cargo auditable build --release
# The binary now contains auditable dependency metadata
# Audit a binary directly:
cargo audit bin ./target/release/my-serviceSchicht 3: Tiefenverifizierung
Die Werkzeuge dieser Ebene erfordern mehr Einrichtungsaufwand, fundiertere Fachkenntnisse und längere Analysezeiten. Sie eignen sich nicht für jede Funktion in jeder Codebasis. Sie sind unerlässlich für unsicheren Code, kryptografische Implementierungen, Parserlogik zur Verarbeitung nicht vertrauenswürdiger Eingaben und jeden Code, bei dem die Korrektheit bewiesen und nicht nur getestet werden muss.
Miri: Erkennung von undefiniertem Verhalten
Miri ist ein Interpreter für Rusts Mid-Level Intermediate Representation (MIR), der Code so ausführt, dass er undefiniertes Verhalten erkennt, das der Compiler zwar zulässt, das aber gegen Rusts Sicherheitsgarantien verstößt: Speicherzugriffe außerhalb der Grenzen in unsicheren Blöcken, Use-After-Free, Dereferenzierungen von falsch ausgerichteten Zeigern, Datenkonflikte in unsicherem Multithread-Code und Verstöße gegen Rusts Aliasing-Modell.
bash
# Install Miri (requires nightly)
rustup +nightly component add miri
# Run tests under Miri
cargo +nightly miri test
# Enable strict aliasing validation
MIRIFLAGS="-Zmiri-strict-provenance" cargo +nightly miri testWas Miri erkennt: undefiniertes Verhalten in unsafe Blockierungen, Speicherzugriffsverletzungen, Use-After-Free-Fehler, nicht ausgerichtete Zugriffe, Integer-Überlauf in Debug-Builds, Datenkonflikte in unsicherem, nebenläufigem Code.
Was Miri nicht abdecktLogikfehler in sicherem Code, die kein undefiniertes Verhalten, Abhängigkeitsschwachstellen, Probleme mit dem Codestil oder Leistungsprobleme beinhalten.
CI-IntegrationMiri läuft 10- bis 50-mal langsamer als cargo testFühren Sie es selektiv auf Modulen aus, die Folgendes enthalten unsafe Code, oder zwar nächtlich anstatt bei jedem Commit:
YAML
- name: Miri on unsafe modules
run: |
rustup +nightly component add miri
cargo +nightly miri test --package my-unsafe-crateKani: Modellprüfung und formale Verifikation
Kani, entwickelt von Amazon Web Services, ist ein Modellprüfer, der Eigenschaften von Rust-Code formal verifiziert, indem er Ausführungspfade bis zu einer definierten Grenze vollständig untersucht. Während Miri konkrete Testfälle ausführt und spezifische Fehler findet, beweist oder widerlegt Kani, dass Eigenschaften für alle Eingaben innerhalb seines Analysebereichs gelten.
Kani erfordert das Schreiben von Verifizierungs-Frameworks: Funktionen, die den Eingaberaum und die zu überprüfenden Eigenschaften definieren:
Rost
#[cfg(kani)]
mod verification {
use super::*;
#[kani::proof]
fn verify_add_no_overflow() {
let a: u32 = kani::any();
let b: u32 = kani::any();
if a.checked_add(b).is_some() {
let result = safe_add(a, b);
assert!(result == a + b);
}
}
}bash
cargo install --locked kani-verifier
cargo kani setup
cargo kaniAm besten geeignet für: sicherheitskritische Funktionen, Protokollimplementierungen, Arithmetik in Finanz- oder kryptografischem Code und jede Funktion, bei der Sie eine Korrektheitseigenschaft beweisen und nicht nur testen müssen.
MIRAI: Abstrakte Interpretation und Fleckenanalyse
MIRAI, entwickelt von Facebook Research, nutzt abstrakte Interpretation zur Analyse des MIR-Systems von Rust. Es führt eine interprozedurale Analyse durch, die den Wertfluss durch Funktionsaufrufe verfolgt und potenzielle Panics, Vertragsverletzungen und die Weitergabe von Datenfehlern im Code erkennt.
Rost
use mirai_annotations::*;
fn divide(a: i32, b: i32) -> i32 {
precondition!(b != 0); // MIRAI verifies all callers satisfy this
a / b
}MIRAI benötigt einen nächtlichen Rust-Compiler und hat eine steile Einrichtungskurve, weshalb es sich am besten für Teams mit dedizierten Sicherheitsentwicklungskapazitäten oder forschungsorientierten Qualitätsanforderungen eignet.
Rudra: Speichersicherheit in unsicherem Bibliothekscode
Rudra analysiert ganze Programme über verschiedene Crates hinweg, um Speichersicherheitslücken aufzudecken, die spezifisch für Rusts Besitzmodell sind: Sicherheitsverletzungen der Send/Sync-Traits, Probleme mit höherwertigen Lebensdauern, die eine unzulässige Lebensdauerverlängerung ermöglichen, und Panic-Sicherheitslücken in unsicherem Code. Ursprünglich von Forschern entwickelt, läuft es als Compiler-Plugin und benötigt eine spezielle Nightly-Version. Es sollte regelmäßig für Bibliotheks-Crates mit unsicheren internen Abläufen ausgeführt werden, anstatt bei jedem Commit.
Creusot und Prusti: Deduktive Verifikation
Creusot und Prusti sind deduktive Verifikationswerkzeuge, die mathematische Eigenschaften von Rust-Programmen beweisen. Beide benötigen formale Spezifikationen (Vorbedingungen, Nachbedingungen, Schleifeninvarianten) und verwenden automatische Theorembeweiser, um Implementierungen anhand dieser Spezifikationen zu verifizieren. Sie zielen auf eine eingeschränkte Teilmenge von sicherem Rust ab und erfordern Fachkenntnisse in formalen Methoden. Sie eignen sich für regulierte Branchen, die Entwicklung kryptografischer Bibliotheken oder jeden Kontext, in dem ein mathematischer Korrektheitsnachweis vertraglich oder regulatorisch erforderlich ist.
Zusätzliche Tools, die es wert sind, einbezogen zu werden
Semgrep für benutzerdefinierte Sicherheitsmuster
Semgrep bietet musterbasierte statische Analyse, die sprachübergreifend gleichzeitig funktioniert. Für Rust ermöglicht es Teams, benutzerdefinierte Regeln zu schreiben, die organisatorische Sicherheitsrichtlinien und codespezifische Muster durchsetzen, die Clippy nicht abbilden kann:
YAML
# Custom rule: flag .unwrap() in production paths
rules:
- id: no-unwrap-in-production
pattern: $X.unwrap()
message: "Use proper error handling instead of .unwrap()"
languages: [rust]
severity: WARNINGSemgrep bietet außerdem eine verwaltete Regeldatenbank mit Rust-Sicherheitsregeln, die von der Community gepflegt werden.
SonarCloud / SonarQube für kontinuierliche Qualitätsgatter
SonarCloud bietet kontinuierliche Codequalitätsanalyse mit Dashboard, Trendverfolgung und Pull-Request-Dekoration. Die Rust-Unterstützung deckt häufige Fehlermuster, Sicherheitslücken und Code-Smells ab. Für Enterprise-Teams, die SonarCloud bereits für andere Sprachen nutzen, ermöglicht die Integration von Rust in dieselbe Pipeline eine einheitliche Qualitätsübersicht über den gesamten Stack.
Aufbau einer mehrschichtigen CI/CD-Pipeline
Der folgende GitHub Actions-Workflow stellt einen praktischen Ausgangspunkt für Teams dar, die eine umfassende Abdeckung der Rust-Qualität ohne übermäßigen Aufwand wünschen:
YAML
# .github/workflows/quality.yml
name: Code Quality and Security
on: [push, pull_request]
jobs:
lint:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
with:
components: clippy, rustfmt
- name: Check formatting
run: cargo fmt -- --check
- name: Clippy (treat warnings as errors)
run: cargo clippy -- -D warnings
security:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@stable
- name: Install security tools
run: |
cargo install cargo-audit
cargo install cargo-deny
- name: Dependency audit
run: cargo audit --deny warnings
- name: License and policy check
run: cargo deny check
verify:
runs-on: ubuntu-latest
# Scheduled or manually triggered, not on every push
if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
steps:
- uses: actions/checkout@v4
- uses: dtolnay/rust-toolchain@nightly
with:
components: miri
- name: Miri on unsafe modules
run: cargo +nightly miri test --package my-unsafe-crateWelches Tool sollten Sie verwenden? Entscheidungshilfe
Ein neues Rust-Projekt startenClippy + rustfmt + cargo-audit. In weniger als fünf Minuten konfigurierbar, erkennt es die meisten Qualitäts- und Sicherheitsprobleme, denen Teams begegnen.
Produktionsdienst mit externen Abhängigkeiten: Fügen Sie die Option „Fracht verweigern“ hinzu, um die Einhaltung von Lizenzbestimmungen und die Durchsetzung von Lieferkettenrichtlinien über CVEs hinaus zu verbessern.
Bibliothekskiste mit unsicheren InnenteilenFügen Sie Miri Ihrer Testsuite für Module mit unsicherem Code hinzu. Führen Sie Rudra regelmäßig aus.
Sicherheitskritischer oder kryptografischer CodeSchreiben Sie Kani-Verifikationsframeworks für die kritischsten Funktionen. Ziehen Sie Creusot oder Prusti in Betracht, falls das Team über Erfahrung mit formalen Verifikationsmethoden verfügt.
sicherheitsorientierte Organisation: Semgrep mit benutzerdefinierten Regeln für organisatorische Sicherheitsrichtlinien hinzufügen, plus cargo-auditable in Release-Builds.
Kontinuierliche Transparenz für ein größeres Team: SonarCloud für Trendverfolgung, Pull-Request-Dekoration und Qualitätskontrollmechanismen neben den Open-Source-Tools.
Polyglot-Unternehmensumgebung Wenn Rust mit COBOL, Java oder anderen älteren Sprachen interagiert, können die Rust-Tools, die nur eine Sprache verwenden, nicht über die Sprachgrenze hinwegsehen. SMART TS XL bietet die sprachübergreifende Analyse, die das gesamte System abdeckt.
Wenn die statische Analyse von Rust auf Unternehmenssysteme trifft
Rust wird zunehmend für neue Dienste in Unternehmen eingesetzt, die auch COBOL, Java, PL/I oder RPG auf Mainframe- oder Legacy-Plattformen betreiben. In diesen Umgebungen geht die statische Analyse über die Möglichkeiten von Rust-spezifischen Tools hinaus. Ein Rust-Mikrodienst kann ein COBOL-Programm aufrufen, in eine gemeinsam genutzte Datenbank schreiben oder Ereignisse eines Legacy-Batchsystems verarbeiten. Die für einen Enterprise-Architekten relevante Qualitäts- und Abhängigkeitsanalyse erstreckt sich über all diese Systeme gleichzeitig.
SMART TS XL Diese Lücke wird durch die Bereitstellung einer sprachübergreifenden Abhängigkeitsanalyse für das gesamte Anwendungsportfolio geschlossen. Während Clippy und cargo-audit nur Rust erkennen, SMART TS XL Es bildet ab, wie ein Rust-Dienst von gemeinsam genutzten Datenstrukturen, Legacy-Programmen und Unternehmens-APIs abhängt und welche Auswirkungen Änderungen an diesen Abhängigkeiten hätten. Dadurch ist es das bevorzugte Werkzeug für Wirkungsanalyse und Planung der Modernisierung bestehender Systeme in Umgebungen, in denen Rust eine von vielen Sprachen ist.
Für Teams, die Rust schrittweise innerhalb einer größeren Unternehmenscodebasis einführen, SMART TS XL statische Code-Analyse bietet die notwendige strukturelle Transparenz, um zu verstehen, wie Rust-Komponenten in das Gesamtsystem passen, bevor Änderungen vorgenommen werden, die sich auf Komponenten in anderen Sprachen auswirken könnten. Wie im Kontext von Abhängigkeitsgraphen und AnwendungsrisikoDie vollständige Abbildung der Abhängigkeitsstruktur vor der Erweiterung eines Systems ist das, was reibungslose Änderungen von solchen unterscheidet, die zu Fehlern in Komponenten führen, die niemand zu testen gedacht hat.
Der geschichtete Ansatz ist der Punkt
Statische Codeanalyse in Rust ist keine Frage der Werkzeugauswahl. Sie ist eine mehrschichtige Disziplin, die mit den vom Compiler bereitgestellten Tools beginnt und sich je nach Risikoprofil des Codes erweitert. Clippy und rustfmt bilden die Basis. cargo-audit ist für jedes Projekt mit externen Abhängigkeiten unerlässlich. Miri gehört in jedes Projekt mit unsicherem Code. Kani und die formalen Verifikationswerkzeuge sind für Funktionen gedacht, bei denen Fehler inakzeptabel sind.
Teams, die dies erfolgreich umsetzen, integrieren statische Codeanalyse in den Entwicklungsprozess: Clippy direkt im Editor, cargo-audit bei jedem CI-Lauf und Miri in einem nächtlichen Job, der Fehler aufdeckt, die Tests allein nicht erkennen. Das Ergebnis sind nicht nur weniger Fehler, sondern auch ein Vertrauen in die Codebasis, das es Teams ermöglicht, schnell Änderungen vorzunehmen, da sie wissen, dass die Analyseebenen zwischen Entwickler und Produktion korrekt funktionieren.
