Hardware Podcasts

354: Better Snowmen in Finland

Embedded.fm · 4 Dec 2020 · 1h 00m · Episode 354

What this episode covers

Becky Worledge of the Qt Company explains how to organize large C++ codebases using layered architectures and the PIMPL pattern to maintain binary compatibility, while Harrison Donahue discusses the new Qt for MCU offering. They detail the transition from qmake to cmake in Qt 6 and the use of Qt Safe Renderer for ASIL-D certified automotive instrument clusters. The conversation also covers career advice for moving into embedded systems and the cross-platform nature of the Qt framework.

Most relevant to

large enterprises

Topics

Mentioned

Companies
Qt Company, Mentor Graphics, KDAB
Products
Qt for MCU, Qt Safe Renderer, PySide
Tools
qmake, cmake

Related episodes from other shows

Other shows on the same ground, closest first.

  • The Pragmatic Embedded Podcast · 58m

    Modern C++ for Embedded with Niall Cooling

    Niall Cooling, director at Feabhas, explains how modern C++ (C++11 through C++23) enables safer, more agile embedded development by replacing C-style practices with compiler-enforced safety and modern tooling. He highlights 'quick wins' like `auto`, `constexpr`, and guaranteed copy elision, which improve code readability and performance without sacrificing the efficiency of C. Cooling argues that the true value of C++ lies in its ecosystem of header-only testing frameworks (like Doctest and Catch2), static analysis tools (Clang-tidy), and CI/CD integration, which allow teams to adopt Agile practices like Test-Driven Development (TDD) even in deeply embedded, safety-critical contexts. He contrasts this with the steep learning curve of Rust and emphasizes that successful adoption requires significant investment in training and process improvement rather than just language syntax changes.

    Embedded firmwareDebugging & failure analysis
    7 chapters

  • The Pragmatic Embedded Podcast · 35m

    Rust with Milica Kostic

    Milica Kostic, an embedded software architect with a background in electrical engineering and safety-critical industries like medical devices, discusses her journey from C/C++ to adopting Rust in production. She explains that the most successful adoption occurred in a greenfield embedded Linux project using a microservice architecture, which allowed for clean isolation of Rust code and minimized complex C/C++ interoperability challenges. Kostic highlights the benefits of Rust's tooling, such as Cargo and built-in static analysis, while noting current limitations in microcontroller support, IDE tooling, and certified stacks like BLE.

    Embedded firmwareMicrocontrollers & dev platforms
    8 chapters

  • The Pragmatic Embedded Podcast · 39m

    Christmas Special

    Hosts Jeff Gable and Luca share war stories from their careers in embedded systems, highlighting the pain of manual testing in helicopter avionics, the chaos of managing requirements with Word and Excel in Dropbox for medical devices, and the technical debt of massive #ifdef blocks in legacy machine tool software. They discuss the industry's slow adoption of modern software practices like version control and CI/CD, contrasting embedded development with web development standards. The episode concludes with book recommendations including 'The Phoenix Project' and 'Team Topologies', and reflections on the future of IoT security and agile adoption in hardware.

    Debugging & failure analysisEmbedded firmware
    6 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 Pragmatic Embedded Podcast · 44m

    QP framework with Mitch English

    Mitch English, a product development team lead at Inertia, discusses implementing the QP (Quantum Platform) framework for a medical device blood analyzer. He explains how QP's actor model and hierarchical state machines manage concurrency and complexity better than traditional RTOS approaches. The team shares lessons on testing strategies, using CppUTest for host-based unit tests, and the architectural decision to favor publish-subscribe patterns over direct posting to improve testability.

    Embedded firmwareDebugging & failure analysis
    7 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.