- How To
- About Us
- Contact Us
Agile and Test-Driven Embedded Development
James Grenning and Barr Group are teaming up for Agile and Test-Driven Embedded Development - an exciting one-week series of lectures and hands-on exercises designed to quickly get you up to speed in the technical and planning practices of Agile. The course is designed to give the working engineer, team leader, architect and manager a good foundation to build better embedded software faster using Agile techniques and principles. In this course, we will do programming, but that's not all; we will also explore and experience Agile and its planning practices.
The full-week program is ideal for Embedded Software/Firmware Engineers. For Engineering Managers and Product Managers, there are two options:
- Complete Five-Day Course: If you still like to keep your hands in the technology, you can join in for the full experience. We do C programming exercises in pairs so even if your coding is a bit rusty, you can still learn a lot so you can support your team through the transition to Agile.
- Planning for Agile One-Day Course: If you cannot spend the whole week, come on Thursday for a crash course in the adaptive planning practices of Agile.
What You'll Learn
Everyone who attends Agile and Test-Driven Embedded Development learns all sorts of useful info, including:
- What problems Agile is designed to solve
- How the Agile approach and practices can help reduce common development problems
- How to partition work into visible product stories
- How product stories drive incremental development
- How acceptance tests can be used as executable specifications
- How to estimate a product backlog
- How to track progress with velocity
- How to manage to a desired date or desired content
- What problems Test-Driven Development is designed to solve
- How to use an xUnit based open source test harness (CppUTest)
- How to write unit tests for C
- That testing is not tedious, it's fun when done the TDD way
- How to incrementally build well designed working code
- How to create a test list to guide your development
- How to perform the Test-Driven Development microcycle
- How to leverage your host development environment as a unit test bench
- How to adapt TDD to embedded development
- How to partition code that has dependencies on RTOS, hardware, and other modules
- How to test-drive code that has dependencies on RTOS, hardware, and other modules
- How to build test-fixtures with test-doubles (stubs, spies, fakes and mocks)
- How to decide how and when to use link-time, run-time, and pre-processor test-doubles
- How to avoid analysis paralysis during early stages of design
- How to partition a design using the SOLID design principles
- How to effectively pair program
- How to recognize code smells
- How to incrementally refactor problem code to better code
The Agile and Test-Driven Embedded Development course runs for 4-1/2 days and is broken up as follows:
Monday (morning) - Test-Driven Development (Part 1)
The day starts with an overview and demo of TDD, followed by a hands-on exercise that helps you get experience at creating useful code, driven by a series of tests, that works and stays working.
Monday (afternoon) - Test-Driven Development (Part 2)
After the morning's exercise we will debrief on the TDD experience, discuss how to adapt TDD to Embedded, introduce test-driving features that require interactions with hardware and RTOS. In the hands-on TDD exercise we'll use link-time test-doubles to test-drive code that interacts with the clock and the hardware.
Tuesday (morning) - Test-Driven Development (Part 3)
The hands-on exercise continues from day 1, followed by another debrief on the TDD experience.
Tuesday (afternoon) - Test-Driven Development (Part 4)
In this section we are going to get close to the silicon to test-drive a device driver showing how far you can go in unit testing embedded code off the target. In the exercise you will employ a mock object to model the the interaction between the driver and the silicon. We'll also see how to use function pointers to bind test doubles at run-time.
Wednesday (morning) - Design and Refactoring
Wednesday is all about keeping code clean, or cleaning it up after a mess is made. Refactoring involves transforming good designs into better designs and keeping the code working the whole time. We will look at a couple of the SOLID design principles as they provide design guidance and then you will start to put the three critical skills of refactoring to work in the refactoring exercises.
Wednesday (afternoon) - Refactoring and Legacy Code
We'll continue the exercise and then look at the strategy for improving Legacy code, code without tests.
Thursday - Planning Practices of Agile Development
The first three days of this class took a deep dive on several of the technical practices of Agile Development. Thursday is all about planning and flow of an Agile development release effort. We'll start by identifying the problems that Agile was designed to solve. Then we'll get everyone on the same page with an overview of Agile and how it attempts to keep work visible and reduce risk. You will experience the creation of Product Stories that name all the behaviors of the system, the definition of Acceptance Tests. You will practice a team estimation technique used to size and track the development effort. You will create an initial velocity estimate that allows you to lay out a rough release plan. We'll look at how Agile teams track their work in progress with in an iteration, as well as tracking and evolving an overall release plan.
Friday (half-day) - Attendee-Driven Content
Friday is driven by your needs. After experiencing the technical and planning practices of Agile development you will have questions; there will be topics you will want to know more about. We will use Agile planning to drive the morning's content. We will also do a closing TDD exercise to help you build skill so that the following Monday, you can put TDD to work for you.
James Grenning trains, coaches and consults worldwide. With more than thirty years of software development experience, both technical and managerial, James brings knowledge, skill, and creativity to software development teams and their management. As his professional roots are in embedded software, James’ mission is to bring state-of-the-art technical and management practices to embedded development teams. He is the author of Test-Driven Development for Embedded C. He is a co-author of CppUTest, a popular unit test harness for embedded C and C++, and he participated in the creation of the Manifesto for Agile Software Development.