Stenobird

Episode

Rust at Work - conversation with Eli Shalom and Igal Tabachnik of Eureka Labs

Podcast
Rustacean Station
Published
Jun 14, 2025
Duration seconds
4729
Processing state
processed
Canonical source
https://rustacean-station.org/episode/eli-shalom-and-igal-tabachnik/
Audio
https://dts.podtrac.com/redirect.mp3/audio.rustacean-station.org/file/rustacean-station/2025-06-14-eli-shalom-and-igal-tabachnik.mp3
JSON
/v1/public/podcasts/rustacean-station/episodes/rust-at-work-conversation-with-eli-shalom-and-igal-tabachnik-of-eureka-labs
Markdown
/podcast/rustacean-station/rust-at-work-conversation-with-eli-shalom-and-igal-tabachnik-of-eureka-labs.md

Actions

  • POST https://stenobird.com/v1/public/podcasts/rustacean-station/episodes/rust-at-work-conversation-with-eli-shalom-and-igal-tabachnik-of-eureka-labs/transcription-requests
    Idempotently request low-priority transcript generation for this episode.
  • GET https://stenobird.com/podcast/rustacean-station/rust-at-work-conversation-with-eli-shalom-and-igal-tabachnik-of-eureka-labs.md
    Read the agent-friendly Markdown representation of this episode resource.

Summary

Engineers from Eureka Labs discuss leveraging Rust's type system to build high-throughput blockchain infrastructure. The conversation explores how Rust's functional programming influences and prevents common runtime errors in low-latency environments.

Topics

  • Rust
  • Blockchain
  • Software Engineering
  • Type Systems
  • Functional Programming
  • Infrastructure
  • Eureka Labs
  • Systems Programming

Highlights

  • Main idea: Rust's trait system allows for a clean separation of data (structs) and behavior (traits), mirroring functional programming patterns
  • Practical takeaway: Use Rust's compiler to catch logical errors, such as invalid equality comparisons for floating-point numbers, at compile time
  • Failure mode: Attempting to write Rust like Java or C without embracing ownership and error handling leads to frequent runtime panics
  • Main idea: The transition from JVM-based languages like Scala to Rust is facilitated by Rust's adoption of type class concepts
  • Practical takeaway: For standard web backend services, higher-level languages like Kotlin may be more efficient, but Rust is essential for performance-critical infrastructure

Chapters

  1. 1:00 Introductions: The host introduces the guests from Eureka Labs and discusses their backgrounds in code analysis and backend engineering.
  2. 7:00 Blockchain Fundamentals: An explanation of how blocks are added to a chain and the role of block builders.
  3. 13:00 The Role of Block Builders: Discussing the process of picking up transactions from the network and creating optimized blocks.
  4. 19:05 Rust's Type System and Safety: How Rust's type system ensures data integrity and prevents runtime errors through compile-time checks.
  5. 24:55 Design-Time Safety: The benefits of handling complex logic and payload parsing during compilation rather than at runtime.
  6. 36:55 Functional Programming Influences: Exploring how Rust borrows concepts like type classes from Haskell to manage data transformations.
  7. 49:10 Evaluating Ecosystem Dependencies: A discussion on the importance of vetting third-party crates for quality and security.
  8. 1:12:45 Choosing the Right Tool: Deciding when to use Rust versus JVM-based languages like Kotlin for different backend use cases.