Since the publication of the Agile Manifesto back in 2001, Agile practices have become mainstream in software development with processes such as Scrum and techniques such as Test-Driven Development (TDD) becoming common practice.
However, almost all current books and training on Agile ignore the challenges of applying it in an embedded C++ environment. Aspects such as aligning Agile with hardware and mechanical teams, testing on the target, hardware dependency and managing both host and cross-compiler toolchains are generally ignored or over-simplified.
The course attempts to provide a pragmatic introduction to both Agile practices, such as Scrum, and techniques, such as TDD, within the context of Embedded Systems. Attendees perform practical exercises using both host (Linux / g++) and cross-development (Cortex-M / arm-none-eabi-g++) toolchains supported by a modern build system (SCons) and configuration management (Git) tools.
The course also looks at modern Continuous Integration (CI) with Docker containers.
- To understand the principles of Agile Software Development
- To appreciate Agile for Embedded is different from Agile for non-Embedded
- To identify the required tools required to support Agile Software Development
- The gain practical experience of applying Agile principles to an Embedded system
- The challenges and pitfalls of applying TDD to an embedded system
Delegates will learn:
- How to cherry-pick appropriate Agile practices
- The principles of Scrum and Lean
- How to practice Test-Driven Development with version control (Git)
- How far Continuous Integration (CI) can be applied to embedded software development
- Why moving to ‘Agile’ can be difficult
- Attendees should have a good working knowledge of the C++ language
- Have experience of developing software for embedded systems
- Understand the build process (preprocessor-compiler-linker-executable)
Who should attend:
The course is designed for software engineers working on an embedded C++ project. The target audience is engineers working in, or looking to move to, an Agile project environment (e.g. Scrum) and who want a pragmatic introduction to Agile process and techniques in the context of writing software for embedded systems.
- Delegate manual
- Delegate workbook
- Delegate bootable Linux datakey with all tools installed
Attendees perform a mixture of hands-on programming for both host and embedded targets. Approximately 50% of the course is given over to practical work.
The host code is developed on Linux using g++ and Scons supported by Git versioning. The embedded code is targeted at an ARM Cortex-M based MCU using arm-none-eabi-g++.
As part of the course, students are introduced to Docker for build isolation and cloud-based build systems, such as Travis-CI.
This combination gives attendees a real sense of the challenges of applying Agile development to an embedded application.
Introduction to Agile
- The Agile Onion
Agile Assumptions and Embedded Systems
- Embedded System continuum
- New Product Development (NPD)
- Hardware/Software/Mechanical Teams
- Push vs Pull workflow
- Middle layer
- Outer layer
The Embedded Agile Toolset
- Dump the IDE
- Test framework
- Version control
- Make tools
- Build servers
- Build environment
- Target Download
- Debug tool
- Team workflow
- Problems / Issues
- Pairing variations
- Abstraction and encapsulation
TDD for C++
- TDD foundations
- Test construction
- Unit isolation
- Testing APIs
- Editor / IDE support
- From centralised to distributed
- Self-hosted vs. cloud-based repositories
- Isolation of application from platform
- Build systems
- Workflow and builds
Why is ‘Agile’ so difficult?
- Common Agile [Scrum] pitfalls
- Dark Scrum
- Flaccid Scrum