Channel Title: Quantum Leaps, LLC Channel Description: Modern embedded systems programming Here, you can find the "missing curriculum" of real-time embedded programming. This channel's unique presentation style explains the main concepts by showing how they work at a low level. If you would like to support this channel, you can do the following: - Subscribe to the channel - Click the like button on the videos you like - Spread the word (e.g., by posting about the videos on other websites frequented by embedded folks) <video> Using QP/Spy Software Tracing with STM32Cube IDE Description: This video shows how to build a QP application with the QP/Spy software tracing system using the STM32Cube IDE. This will allow you to trace, troubleshoot, optimize, and monitor your QP applications. QP/Spy tracing is also a cornerstone of testing event-driven QP applications. This video is a continuation of our previous one, where we explored using the QP framework with STM32Cube IDE. --- Links to related software: - QP-bundle downloads https://www.state-machine.com/#Downloads - Quantum Leaps qpc-examples repo: https://github.com/QuantumLeaps/qpc-examples --- Links to related videos: - Using QP Framework with STM32 Cube IDE https://youtu.be/M05jMX3_wJk?si=gz2PGKTfUiVT0cTY - Software Tracing with printf https://youtu.be/i8lYMDcyLAM?si=hdOTQBughHH0_b7B - Software Tracing with Binary Protocols https://youtu.be/rwjV7LBOE8A?si=WCBcVhmXh39aftxO </video> <video> #51 Traceable Documentation with Doxygen & Spexygen Description: This lesson explains how to create traceable formal specifications, such as requirements, architecture, design, and many others, mandated by functional safety standards. The lesson starts with explaining the critical requirement for traceability, as mandated in the IEC 61508 standard. You learn how to use the Doxygen source code documentation system. Finally, you see the Doxygen extension, called Spexygen, which allows you to automate the creation of bidirectionally traceable documentation. End Notes: ---------- Companion web page to this video course https://www.state-machine.com/video-course/ Project download for this lesson: https://www.state-machine.com/course/lesson-51.zip GitHub repository for projects for this video course: https://github.com/QuantumLeaps/modern-embedded-programming-course Transcript of this lesson: https://www.state-machine.com/course/lesson-51.txt Referenced software: -------------------- Doxygen - Code Documentation. Automated. https://doxygen.nl Spexygen - Traceable specifications based on Doxygen https://github.com/QuantumLeaps/spexygen Music credits: -------------- The background music comes from: https://www.bensound.com/royalty-free-music/track/straight </video> <video> #47 Assertions and Design by Contract, Part-1 Description: In this lesson, you'll learn about software assertions and, more formally, the Design by Contract methodology in the context of embedded programming. This is part-1 of the two-part series on this subject. Contents with Timestamps: ------------------------- 1:25 What are software assertions? 1:46 Standard assertions in C 3:07 Demonstration of standard assertions on a desktop 4:37 Disabling standard assertions 5:49 Software Errors 6:38 Exceptional Conditions 7:17 Attempts to "handle" Errors as Exceptional Conditions 7:24 "Defensive Programming" 8:36 Fallacities of "Defensive Programming" 9:20 Design by Contract method 10:00 What assertions are NOT 11:02 The true purpose of assertions 11:24 Priorities for dealing with errors 11:49 Assertion handler as the last line of defense 12:00 Assertions as fuses End Notes: ---------- Companion web page to this video course https://www.state-machine.com/video-course/ Project download for this lesson: https://www.state-machine.com/course/lesson47.zip GitHub repository for projects for this video course: https://github.com/QuantumLeaps/modern-embedded-programming-course Transcript of this lesson: https://www.state-machine.com/course/lesson47.txt References resources: --------------------- Key Concepts: Design by Contract https://www.state-machine.com/dbc Bertrand Meyer, “Applying Design by Contract”, IEEE Computer, 1992 https://www.state-machine.com/doc/Mayer92.pdf Miro Samek, “An Exception or a Bug?”, C/C++ Users Journal, June 2003 https://www.state-machine.com/doc/Samek0308.pdf Quantum Leaps, Design By Contract (DBC) for Embedded C and C++, GitHub https://github.com/QuantumLeaps/DBC-for-embedded-C Music credits: -------------- The background music comes from: https://www.bensound.com/royalty-free-music/track/straight </video> <video> #52 Using low-power sleep modes in the "superloop" architecture Description: This lesson revisits the foreground background architecture, also known as the "superloop," but this time with the focus on incorporating the low-power sleep modes of the CPU. The subject is non-trivial, and many developers get it wrong. The need to explain these aspects arose while planning future lessons about the various ways of executing event-driven Active Objects, so this lesson lays some groundwork for the next one. However, the subject of this lesson is important in its own right, especially because the "bare metal" ("superloop") code structure is applied in such a wide range of products, many of them battery-operated. #embeddedprogramming #softwarearchitecture #lowpower #realtimesystems #eventdriven #education Resources for this lesson: -------------------------- Companion web page to this video course https://www.state-machine.com/video-course/ Project download for this lesson: https://www.state-machine.com/course/lesson-52.zip GitHub repository for projects for this video course: https://github.com/QuantumLeaps/modern-embedded-programming-course Transcript of this lesson: https://www.state-machine.com/course/lesson-52.txt References: ----------- STM32 Discussion Forum discussion thread: Best practices: How to work with interrupts and low power modes when using the HAL? https://community.st.com/t5/stm32-mcus-products/best-practices-how-to-work-with-interrupts-and-low-power-modes/td-p/620588 Texas Instruments, "Software Coding Techniques for MSP430 MCUs" TI document: SLAA294B (search with Google) Joseph Yiu, "Definitive Guide to ARM Cortex-M3 and AMR Cortex-M4 Processors, 3rd Edition" ISBN: 978-0124080829 Miro Samek, "Use an MCU’s low-power modes in foreground/background systems", https://www.state-machine.com/doc/Samek0710.pdf Music credits: -------------- The background music comes from: https://www.bensound.com/royalty-free-music/track/straight </video> <video> #0 Modern Embedded Systems Programming: Getting Started Description: This is an updated version of "lesson-zero" of the "Modern Embedded Systems Programming" video course. The updates include new development toolsets, new structure of the code projects, and new resources for the course. Timeline: 🕑 0:07 *Introduction:* In this course, you'll learn how to program embedded microcontrollers the modern way, from the basics all the way to the contemporary modern embedded programming practice. 🕑 0:23 *Teaching Approach:* The unique approach of this course is to step down to the machine level frequently and show you exactly what happens inside your embedded microcontroller. This deeper understanding will allow you to apply the concepts more efficiently and with greater confidence. If you are looking for a practical, hands-on, well-structured, and in-depth course explaining the essential concepts in embedded programming, this free course is right for you. 🕑 0:40 *Instructor:* The course is designed and taught by Miro Samek -- an embedded software expert with over 30 years of experience. Miro enjoys teaching, and this video course, his books, articles, and conference talks helped many developers improve their skills, pass tough job interviews, and get hired for embedded programming positions. 🕑1:00 *Relevance:* The course started already in 2013, so a legitimate question is: "Is it still relevant?" The answer is YES, perhaps even more so than in 2013, for two main reasons: 1️⃣ Fundamental Concepts: This course focuses on the essential and fundamental concepts in embedded programming, which never go out of style. 2️⃣ ARM Cortex-M Architecture: This course focuses on the prevalent ARM Cortex-M architecture, which over the past decade became unquestionably dominant in the embedded MCU market. Familiarity with ARM Cortex-M is the most sought-after skill that employers are looking for. 🕑1:37 *Prerequisites:* The course starts with the basics, but they focus on the embedded aspects. Therefore it is recommended to supplement this course with a general C programming book or course. Also, it would be good to know how CPU works (e.g., https://youtu.be/cNN_tTXABUA?si=UEXNelK-AoGHtOFp) 🕑2:16 *Embedded Boards:* You need one of the following embedded boards: 2:21 TivaC LaunchPad 2:47 STM32 NUCLEO-C031C6 3:11 Simulator 🕑3:25 *Installing USB Drivers:* 🕑4:54 *Embedded Development Toolsets:* You need one of the following embedded development toolsets: 5:03 IAR Embedded Workbench for ARM 6:18 KEIL MDK (Microcontroller Development Kit) 🕑7:57 *Installing Device Family Pack in KEIL MDK* The first time you open a project in KEIL MDK, you need to install the "Device Family Pack" for the microcontroller used in the project. 🕑8:19 *Requesting and Installing the License in KEIL MDK* 🕑8:42 *Installing Missing Stellaris ICDI in KEIL MDK* The newer KEIL MDK versions no longer support the hardware debugger called "Stellaris ICDI" on the TivaC LaunchPad. But you can add this support as an MDK extension. 🕑9:41 *Course Projects:* 9:56 How to download the code projects for the lessons 10:20 The hierarchical structure of the code projects (NOTE: updated from what is shown in the videos) ------ End Notes: Companion web page for this video course: https://www.state-machine.com/video-course GitHub repository for projects for this video course: https://github.com/QuantumLeaps/modern-embedded-programming-course Companion Miro Samek's blog on Embedded.com: https://www.embedded.com/?s=Miro+Samek --- Tiva LaunchPad board (a.k.a. EK-TM4C123GXL) https://www.ti.com/tool/EK-TM4C123GXL STM32 NUCLEO-C031C6: https://www.st.com/en/evaluation-tools/nucleo-c031c6.html ---- IAR EWARM: https://www.iar.com/ewarm KEIL MDK v6 Community Edition https://www.keil.arm.com/ --- YouTube playlist of the course: • Modern Embedded Systems Programming C... </video> <video> Guest video: TDD with cpputest-for-qpc Description: This video delivers a detailed overview of the cpputest-for-qpc library, designed to support PC-based unit testing of QP/C-based firmware projects. QP/C is a lightweight implementation of the Active Object model of computation specifically tailored for real-time embedded (RTE) systems. QP/C is both a software infrastructure for building applications consisting of event-driven, asynchronous Active Objects (Actors) and a runtime environment for executing the Active Objects in a deterministic, hard real-time fashion. Additionally, QP/C Framework supports Hierarchical State Machines to specify the behavior of Active Objects. The QP/C Framework can be viewed as a modern, event-driven, asynchronous real-time operating system (RTOS). #embeddedprogramming #testing #tdd #cpputest The GitHub repository for this video may be found at: - https://github.com/covemountainsoftware/video-tutorial-cpputest-for-qpc To learn more: - cpputest-for-qpc: https://github.com/covemountainsoftware/cpputest-for-qpc - QP/C GitHub repo: https://github.com/QuantumLeaps/qpc - TDD for firmware: https://wingman-sw.com/about - Matthew Eshleman Consulting: https://covemountainsoftware.com/ OUTLINE 0:00:00 - Introductions 0:02:48 - What is QP? 0:04:24 - What is TDD? 0:05:52 - Why cpputest-for-qpc? 0:11:54 - Example Active Object Requirements 0:13:50 - Environment Overview 0:14:29 - Starting Project Overview 0:16:00 - "C" Driver Clean Interface and mock 0:18:36 - More Project Overview 0:20:28 - Initial Unit Test Setup and Overview 0:23:39 - Unit Test of Service Startup 0:29:26 - Unit Test of Externally Published Event with Data 0:36:08 - Unit Test of Service Timer Behavior 0:43:29 - Unit Test of Externally Published Event without Data 0:45:30 - Unit Test of Published Events using Published Event Recorder 0:54:22 - Unit Test of Posting to another AO using Dummy Active Objects 1:02:54 - Unit Test of Q_ASSERT 1:07:49 - Summary of Unit Tests 1:09:23 - To Learn More and Conclusion </video> <video> #49 Embedded Unit Testing Description: This is the first lesson about embedded software testing and its central role in software development. You will also see some ways of testing embedded software on the host computer and embedded targets and how to obtain the necessary tools. #embedded_systems #embeddedsoftware #testing Contents with Timestamps: ------------------------- 🕑 0:45 Evolutionary principles for creating complex systems 🕑 2:00 On the Origin of Software by Artificial Selection :-) 🕑 3:00 Waterfall process and why it cannot work 🕑 4:00 Agile software development / Test-Driven Development (TDD) 🕑 5:20 Artificial selection 🕑 6:00 Software testing levels: Unit testing 🕑 6:30 Unit testing harness (a.k.a., Unit testing framework) 🕑 7:05 Embedded-Test (ET) unit testing harness 🕑 7:40 Downloading and installing ET 🕑 8:00 Testing embedded code on the host 🕑 8:30 ET basic example (on the host) 🕑 9:30 Obtaining the command-line tools for testing 🕑 10:00 QTools collection of tools for testing on Windows 🕑 11:38 Installing QTools on Windows 🕑 12:20 Explanation of the basic ET example (CUT and tests) 🕑 14:30 Testing assertions in ET 🕑 14:46 No need for "test runners" in ET 🕑 15:10 Overview of ET examples 🕑 15:35 James Grenning's "TDD for Embedded C" book and "dual-targeting" 🕑 16:22 Benefits of dual-targeting 🕑 17:00 Testing on embedded targets 🕑 17:32 Running tests on the TivaC LaunchPad 🕑 18:30 Running tests on the STM32 NUCLEO-C031 board 🕑 19:55 Adapting ET to run on embedded targets 🕑 21:20 The built-in ET adaptation for the host computers 🕑 21:44 Conclusions 🕑 22:23 Confusion about what is being tested 🕑 22:57 The need to discard less relevant tests End Notes: ---------- Companion web page to this video course https://www.state-machine.com/video-course/ Project download for this lesson: https://www.state-machine.com/course/lesson-49.zip GitHub repository for projects for this video course: https://github.com/QuantumLeaps/modern-embedded-programming-course Transcript of this lesson: https://www.state-machine.com/course/lesson-49.txt Referenced software: -------------------- 📥 QTools collection of open-source tools for embedded systems development on Windows, Linux, and macOS Quantum Leaps GitHub repository, 2023 https://github.com/QuantumLeaps/qtools 📥 Embedded-Test (ET) Embedded Test (ET) -- The Super-Simple Embedded Test Quantum Leaps GitHub repository, 2023 https://github.com/QuantumLeaps/Embedded-Test 📥 Unity unit testing framework Simple Unit Testing for C ThrowTheSwicth GitHub repository, 2023 https://github.com/ThrowTheSwitch/Unity 📥 CppUTest unit testing and mocking framework for C/C++ CppUtest GitHub repository, 2021 https://github.com/cpputest/cpputest 📥 GoogleTest - Google Testing and Mocking Framework Google GitHub repository, 2023 https://github.com/google/googletest ▶ Windows Subsystem for Linux (WSL) Tutorial & How To Gary Explains YouTube video, 2019 https://youtu.be/av0UQy6g2FA?si=CzmCQ5xItpft5obK Books and articles: ------------------- 📖 James W. Grenning, "Test Driven Development for Embedded C", The Pragmatic Programmers, 2011, https://pragprog.com/titles/jgade/test-driven-development-for-embedded-c/ 📖 John Gall, "Systemantics: How Systems Work and Especially How They Fail" Quadrangle; 1977, https://docdrop.org/download_annotation_doc/John-Gall---Systemantics_-How-Systems-Work-and-Especially-Ho-8qhgx.pdf 📖 Miro Samek, “On the Origin of Software by Means of Artificial Selection" Quantum Leaps Blog, 2011 https://www.state-machine.com/on-the-origin-of-software-by-means-of-artificial-selection Music credits: -------------- 🎵 The background music comes from: https://www.bensound.com/royalty-free-music/track/straight </video> <video> Super-Simple Tasker -- The Hardware RTOS for ARM Cortex-M, Part-2 Description: Super-Simple Tasker (SST) is a preemptive, priority-based RTOS kernel fully compatible with Rate Monotonic Analysis/Scheduling (RMA/RMS). It was initially published in 2006. This video presents a unique hardware implementation of a modern version of SST for ARM Cortex-M (M0, M0+, M3, M4, M7, etc.). This is Part-2 of the talk delivered at Embedded Online Conference 2023, see: https://embeddedonlineconference.com/session/Super_Simple_Tasker_Hardware_RTOS_for_ARM_Cortex_M In this second part, you will see how SST works internally and, specifically, how it maps to the hardware of ARM Cortex-M. You'll also see how SST compares to the FreeRTOS traditional kernel running the same "Blinky-Button" application on the same STM32 NUCLEO-L053 board. Resources All code presented in this video is available on GitHub in the SST repository: https://github.com/QuantumLeaps/Super-Simple-Tasker David M. Cummings, "Managing Concurrency in Complex Embedded Systems", https://www.state-machine.com/doc/Cummings2006.pdf Quantum Leaps, video: https://youtu.be/o3eyz1gEqGU Quantum Leaps, video: https://youtu.be/U1pHSkftzhw Quantum Leaps, video: https://youtu.be/qfPRHK5B62s Quantum Leaps, video: https://youtu.be/fLXxNe4YeJ4 #rtos #arm #embedded #realtime #programming </video> <video> Using QP Framework with STM32 Cube IDE Description: This video shows how to use the QP real-time embedded framework with the STM32Cube IDE. This will allow you to apply modern embedded programming with active objects, hierarchical state machines, modeling, and powerful software tracing in this popular STM32 development environment. Links to resources: - QuantumLeaps on GitHub: https://github.com/QuantumLeaps - cmsis-packs repo: https://github.com/QuantumLeaps/cmsis-packs - qpc-examples repo: https://github.com/QuantumLeaps/qpc-examples </video> <video> Super-Simple Tasker -- The Hardware RTOS for ARM Cortex-M, Part-1 Description: Super-Simple Tasker (SST) is a preemptive, priority-based RTOS kernel fully compatible with Rate Monotonic Analysis/Scheduling (RMA/RMS). It was initially published in 2006. This video presents a unique hardware implementation of a modern version of SST for ARM Cortex-M (M0, M0+, M3, M4, M7, etc.). This is Part-1 of the talk delivered at Embedded Online Conference 2023, see: https://embeddedonlineconference.com/session/Super_Simple_Tasker_Hardware_RTOS_for_ARM_Cortex_M The presentation begins with an introduction to preemptive but non-blocking multitasking with so-called basic tasks (as defined in the OSEK/VDX/AUTOSAR operating system). Such tasks are ideal for executing event-driven state machines (a.k.a. active objects), which are also non-blocking and handle events in a run-to-completion fashion. Next, you'll see an example application that demonstrates the various preemption scenarios in SST and shows how it complies with the requirements of Rate Monotonic Scheduling (RMS). Resources All code presented in this video is available on GitHub in the SST repository: https://github.com/QuantumLeaps/Super-Simple-Tasker David M. Cummings, "Managing Concurrency in Complex Embedded Systems", https://www.state-machine.com/doc/Cummings2006.pdf Quantum Leaps, video: https://youtu.be/o3eyz1gEqGU Quantum Leaps, video: https://youtu.be/U1pHSkftzhw Quantum Leaps, video: https://youtu.be/qfPRHK5B62s Quantum Leaps, video: https://youtu.be/fLXxNe4YeJ4 #rtos #arm #embedded #realtime #programming </video> <video> #50 To block or NOT to block, that is the question! Blocking as technical debt... Description: "To block or not to block?" is the single, most fundamental question determining the architecture of your embedded software. In fact, the issue of blocking is the most important discussion we can have in embedded programming, even though many embedded developers don't realize that. A traditional blocking RTOS is still the dominant approach, but this is changing. Concurrency experts increasingly see blocking as a *technical dept*, and therefore, non-blocking, asynchronous architectures are gaining more traction, especially in mission-critical systems. #embeddedprogramming #rtos #async #eventdriven Contents with Timestamps: ------------------------- 0:32 Blocking definition and types of blocking in embedded systems 0:42 Busy polling 1:17 Blocking in an RTOS (by context switching) 2:00 Why is blocking so important? 2:52 Software composability 3:18 State machine as an alternative to blocking 4:50 Input-driven state machine example 5:15 RTOS solution to non-composability of blocking code 5:58 Cost of blocking in RTOS: private stacks for all threads 6:10 Traditional embedded architectures classified by blocking/non-blocking 7:13 Changing landscape of embedded architectures 7:52 Event-driven programming (non-blocking) with traditional RTOS 8:00 Event-driven programming at NASA JPL 8:55 Event-driven state machines (e.g., UML statecharts) 9:25 Efficient non-blocking real-time kernels 10:05 Preemptive non-blocking kernel compatible with RMS/RMA 10:30 Summary: blocking as the defining characteristic of embedded architectures 10:45 Mission-critical architectures are predominantly non-blocking End Notes: ---------- NOTE: there is no specific project download for this lesson. Companion web page to this video course https://www.state-machine.com/video-course/ GitHub repository for projects for this video course: https://github.com/QuantumLeaps/modern-embedded-programming-course Transcript of this lesson: https://www.state-machine.com/course/lesson-50.txt Referenced articles: ------------------- PX5 RTOS, "PX5 RTOS User Guide Version 5.1.1," https://px5rtos.com/px5-rtos-user-guides/ (requires login to download) David M. Cummings, "Managing Concurrency in Complex Embedded Systems," Kelly Technology Group 2014 https://www.state-machine.com/doc/Cummings1006.pdf D. Kalinsky Associates, "Messages for Intertask Communication," 2010 https://www.state-machine.com/doc/Kalinsky2010.pdf D. Kalinsky Associates, "New Directions in RTOS Kernels," 2014 https://www.state-machine.com/doc/Kalinsky2014.pdf Herb Sutter, "Prefer Using Active Objects Instead of Naked Threads," Dr. Dobbs Journal, 2010 https://www.state-machine.com/doc/Sutter2010a.pdf Music credits: -------------- The background music comes from: https://www.bensound.com/royalty-free-music/track/straight </video> <video> Quick Demo: Automatic Host-Based Testing with QUTest Description: Host-based testing of embedded code can avoid the target-system bottleneck. This video shows how QUTest testing harness allows you to use the same test scripts (in Python) and test fixtures (in C or C++) on the host as on the embedded target. All tools and code shown in the video are provided in the QP-bundle download. #embedded #embeddedprogramming #testing </video> <video> Quick Demo: Automatic On-Target Testing with QUTest Description: Automatic testing embedded software on target has been notoriously difficult. This short video shows how to accomplish it with the QUTest testing harness specifically designed for on-target and host-based testing. All the host-based tools and embedded software shown in this video are included in the QP-bundle download ( https://www.state-machine.com/#Downloads ). #embeddedprogramming #testing #embedded #pythonprogramming </video> <video> Guest video: 5 Design and Coding Tips for QP-based Firmware Description: QP is a lightweight implementation of the Active Object model of computation specifically tailored for real-time embedded (RTE) systems. QP is both a software infrastructure for building applications consisting of event-driven, asynchronous Active Objects (Actors) and a runtime environment for executing the Active Objects in a deterministic, hard real-time fashion. Additionally, QP Framework supports Hierarchical State Machines to specify the behavior of Active Objects. The QP Framework can be viewed as a modern, event-driven, asynchronous real-time operating system (RTOS). The QP Framework is available in C (QP/C) and C++ (QP/C++). This video presents 5 design and coding tips for applying QP. You will learn: - How to select a particular real-time kernel to pair with your QP-based firmware project - How to design events (specifically, how to enumerate the event-signals) - How to define the basic software architecture based on Active Objects - How to review 3rd-party libraries and components to be used in your QP projects - How to design the internal state machines of Active Objects (specifically, the state entry and exit actions) #embeddedprogramming #statemachine #realtime #async To learn more: - QP: https://www.state-machine.com/products/qp - QP/C GitHub repo: https://github.com/QuantumLeaps/qpc - QP/C++ GitHub repo: https://github.com/QuantumLeaps/qpcpp Matthew Eshleman Consulting: - https://covemountainsoftware.com/ OUTLINE 0:00:00 - Introductions 0:00:53 - Tip #1 - RTFM 0:03:54 - Tip #2 - Use Distinct Signal Value Ranges for each Active Object 0:11:50 - Tip #3 - Define a Basic Software Architecture 0:16:45 - Tip #4 - Review 3rd party library requirements before selecting a kernel 0:23:30 - Tip #5 - Be wary of Exit-State Behavior 0:27:59 - Conclusion </video> <video> #48 Assertions and Design by Contract, Part-2 Description: In this second lesson about assertions and Design by Contract (DBC), you'll see how to practically apply them in embedded systems. Contents with Timestamps: ------------------------- 0:45 Agenda for the previous Part-1 and today's Part-2 1:00 Embedding assertions (the qassert.h header file) 1:45 qassert.h code review (using Doxygen documentation) 2:35 Q_ASSERT_ID() macro implementation 3:53 Q_ASSERT_ID() macro use 4:34 Q_DEFINE_THIS_MODULE() macro 4:52 no-return semantics of the Q_onAssert() handler 5:37 DBC elements: Preconditions, Postconditions, Invariants 6:57 Errors and the use of Q_ERROR_ID() macro 7:05 The Q_onAssert() assertion handler 8:12 Resetting the target in the assertion handler 8:37 Use of fault-injection for testing assertion failures 8:59 Assertions & Throwing Exceptions 9:48 Hardware assertions 10:28 Avoiding "denial of service" 11:06 Impact of Assertions 11:32 NASA JPL guidelines about assertion density 11:48 Microsoft Research study of assertions and code quality 12:25 Transformative impact of assertions on development 13:15 Demoralizing effects of "defensive programming" 13:32 Disabling assertions in the final product 14:45 Disabling assertions in the assertions-as-fuzes analogy 14:52 Disabling assertions in the assertions-as-guardrails analogy 15:08 Disabling assertions in the assertions-as-insurance analogy End Notes: ---------- Companion web page to this video course https://www.state-machine.com/video-course/ Project download for this lesson: https://www.state-machine.com/course/lesson-48.zip GitHub repository for projects for this video course: https://github.com/QuantumLeaps/modern-embedded-programming-course Transcript of this lesson: https://www.state-machine.com/course/lesson-48.txt References resources: --------------------- Key Concepts: Design by Contract https://www.state-machine.com/dbc Bertrand Meyer, “Applying Design by Contract”, IEEE Computer, 1992 https://www.state-machine.com/doc/Mayer92.pdf Miro Samek, “An Exception or a Bug?”, C/C++ Users Journal, June 2003 https://www.state-machine.com/doc/Samek0308.pdf Quantum Leaps, Design By Contract (DBC) for Embedded C and C++, GitHub https://github.com/QuantumLeaps/DBC-for-embedded-C Music credits: -------------- The background music comes from: https://www.bensound.com/royalty-free-music/track/straight </video>

Contacts and Links

Description

Modern embedded systems programming

Here, you can find the "missing curriculum" of real-time embedded programming. This channel's unique presentation style explains the main concepts by showing how they work at a low level.

If you would like to support this channel, you can do the following:
- Subscribe to the channel
- Click the like button on the videos you like
- Spread the word (e.g., by posting about the videos on other websites frequented by embedded folks)

Videos from channel