Hardware Podcasts

438: There Is Nothing That Is True

Embedded.fm · 15 Dec 2022 · 56m · Episode 438

What this episode covers

John Taylor, principal software engineer at Avanos Medical and author of "Patterns in the Machine," explains his PIM framework, which emphasizes strategic software architecture over tactical coding. He details the "data model" pattern for type-safe, thread-safe data handling and the "open-closed principle" to ensure code is change-tolerant without modifying existing logic. Taylor also discusses the importance of platform-independent OSALs, functional simulators, and designing APIs that read like datasheets to decouple application logic from hardware drivers.

Most relevant to

early-stage companies

Topics

Mentioned

Companies
Avanos Medical, Carrier, ARM
Products
Ford Sync
Also
Patterns in the Machine, FreeRTOS, Zephyr, Rust

Related episodes from other shows

Other shows on the same ground, closest first.

  • The Pragmatic Embedded Podcast · 52m

    Patterns in the Machine with John and Wayne Taylor

    John and Wayne Taylor, authors of the book 'Patterns in the Machine', discuss strategies for creating reusable, decoupled code in embedded software development. They advocate for upfront architectural planning, including defining constraints and using functional simulators, to enable agile execution later in the project. The conversation covers specific patterns like the data model architecture for decoupling drivers from applications, and the importance of writing documentation that captures intent rather than just implementation details. They also address the cultural and logistical challenges of reusing code across different projects and organizations.

    Embedded firmwareCareers & education
    7 chapters

  • The Pragmatic Embedded Podcast · 30m

    Testing on the Host vs Target

    Jeff Gable and Luca discuss the strategy of testing embedded software on the host machine versus the target hardware, arguing that host testing catches the majority of bugs while target testing is reserved for hardware-specific interactions. They introduce architectural patterns like the Model-Hardware-Controller (MHC) and the Data Model pattern to decouple business logic from hardware, enabling effective unit testing. The conversation also covers handling resource-constrained systems by optimizing last and using special integration tests to uncover low-level bugs like interrupt priority issues.

    Embedded firmwareDebugging & failure analysis
    6 chapters

  • The Spark Gap · 34m

    The Spark Gap - Episode 19

    Hosts Carl and Corey discuss the architectural trade-offs of placing intelligence in embedded firmware versus host software. They analyze factors such as performance determinism, development speed, security risks, and the user experience of updates, citing Tesla's over-the-air updates as a key example of successful software-driven functionality changes.

    Embedded firmwareConnected products & IoT
    4 chapters

  • The Pragmatic Embedded Podcast · 48m

    Offensive Cybersecurity with Ryan Torvik

    Ryan Torvik, founder and CEO of Tulip Tree Technology, explains the offensive cybersecurity mindset and how it applies to securing embedded systems. He details techniques for extracting and analyzing firmware using tools like IDA Pro and Ghidra, and discusses the importance of designing security from the start, including using standard libraries and secure languages like Rust. Torvik also describes Tulip Tree's emulation technology, which models hardware behavior to allow developers to test firmware and detect vulnerabilities without physical hardware.

    Security & privacyEmbedded firmware
    10 chapters

  • The Pragmatic Embedded Podcast · 56m

    Modern Embedded Systems Programming with Miro Samek

    Miro Samek, founder and CEO of Quantum Leaps, explains why traditional embedded architectures like superloops and RTOS lead to 'spaghetti code' and concurrency bugs, advocating instead for event-driven active objects and hierarchical state machines. He details how this approach eliminates race conditions and mutexes by enforcing a 'no sharing' principle, thereby improving testability and development velocity. Samek also discusses the importance of using lightweight modeling tools to generate code from state diagrams, ensuring the model remains the source of truth in an agile workflow.

    Embedded firmwareDebugging & failure analysis
    8 chapters

The summary, chapters and topics are generated from the episode’s audio by this directory, not written by Embedded.fm. The episode itself belongs to its publisher.