Stenobird

Episode

Malachite with Adi Seredinschi

Podcast
Rustacean Station
Published
Jun 20, 2025
Duration seconds
2571
Processing state
processed
Canonical source
https://rustacean-station.org/episode/adi-seredinschi/
Audio
https://dts.podtrac.com/redirect.mp3/audio.rustacean-station.org/file/rustacean-station/2025-06-20-adi-seredinschi.mp3
JSON
/v1/public/podcasts/rustacean-station/episodes/malachite-with-adi-seredinschi
Markdown
/podcast/rustacean-station/malachite-with-adi-seredinschi.md

Actions

  • POST https://stenobird.com/v1/public/podcasts/rustacean-station/episodes/malachite-with-adi-seredinschi/transcription-requests
    Idempotently request low-priority transcript generation for this episode.
  • GET https://stenobird.com/podcast/rustacean-station/malachite-with-adi-seredinschi.md
    Read the agent-friendly Markdown representation of this episode resource.

Summary

A deep dive into the engineering challenges of building Byzantine-fault tolerant (BFT) consensus engines. Adi Seredinschi explains why Rust's type system provides the necessary confidence for high-stakes distributed systems where Go's flexibility can lead to runtime surprises.

Topics

  • Rust
  • Byzantine Fault Tolerance
  • Distributed Systems
  • Formal Verification
  • Consensus Engines
  • Software Reliability
  • Model Checking
  • Blockchain Infrastructure

Highlights

  • Main idea: Rust's strong type system reduces the 'lack of confidence' often found in Go-based prototypes by catching errors at compile time
  • Practical takeaway: When building critical infrastructure like Malachite, the goal is to move beyond 'hacky' code that runs to code that is provably correct
  • Failure mode: Attempting to rewrite stable, reliable systems (like Tendermint) can fail if the primary goal is refactoring rather than solving a specific performance or business need
  • Main idea: Formal verification via tools like Quint and TLA+ is essential for ensuring distributed systems are resilient against Byzantine faults
  • Practical takeaway: The gap between Go and Rust development speed is closing, making Rust a viable choice even for rapid prototyping in modern workflows

Chapters

  1. 1:00 Introduction to Informal Systems: Adi introduces his background in PhD research on consensus and his role at Informal Systems.
  2. 4:25 The Challenge of Distributed Trust: A discussion on the fundamental problem of establishing trust between independent systems, such as in Bitcoin or Ethereum.
  3. 7:40 The Mission of Formal Verification: How Informal Systems uses formal methods and Rust to foster trust in complex software infrastructure.
  4. 10:50 Understanding BFT Consensus: An analogy comparing BFT consensus engines to replicated databases like PostgreSQL.
  5. 17:10 Rust vs. Go for Infrastructure: Comparing the developer experience and the 'confidence gap' between Rust and Go in the blockchain industry.
  6. 23:20 The Two Pillars: Quint and Malachite: Exploring how model checking and the Quint language serve as the foundation for verifying distributed protocols.
  7. 39:25 The Perils of Rewriting: Reflecting on the engineering difficulty of evolving legacy systems and the importance of pragmatic maintenance.