LeanDog

TDD with Embedded C by James Grenning

Instructed by James Grenning

Test Driven Development is a powerful technique for building embedded software. This hands-on course teaches the practice of Test Driven Development in the challenging environment of C. In this course you will learn how TDD helps overcome some of the challenges embedded developers face including: unpredictable schedules, poor quality, and the problems that follow. In addition, embedded software developers must conquer the realities of concurrent hardware/software development, scarce target hardware availability, long download times, high deployment costs, as well as the challenges of testing embedded C.

TDD leads to better designs, towards more object oriented approaches to C. In this call you will also learn some of the design principles that can help to guide engineers to better designs.

Most of you have existing legacy code. In this class you will learn valuable techniques for dealing with legacy code. You will see incremental approaches to getting control of the legacy code with tests making improvements to the design less risky.

Test-Driven Development, a key agile practice, helps software developers improve schedule predictability and product quality and can do the same for embedded developers. TDD is valuable even outside of agile development methods.

This course describes the problems addressed by TDD, as well as the additional challenges and benefits of applying it to embedded software. You will learn the test driven techniques as well as specific design approaches to make your C code to testable today, maintainable tomorrow, and ready for a long useful life.

This course will get you and your team well on the way to applying TDD for Embedded C in your development efforts.

Instructor

James Grenning, founder of Renaissance Software Consulting, trains, coaches and consults worldwide. With more than thirty years of software development experience, both technical and managerial, James brings a wealth of knowledge, skill, and creativity to software development teams and their management. As his professional roots are in embedded software, he is leading the way to introduce Agile development practices to that challenging world. He is currently writing a book on applying Test Driven Development to embedded software. See James' articles for applying Agile to embedded software development.

James was doing Agile before it was called Agile. He is one of the original authors of the Manifesto for Agile Software Development. He is a seasoned extreme programming coach and trainer, coaching his first XP team in 1999. James has worked with Bob Martin, the author of many great books on software development, most of his professional career. They both share a passion for software and building it right. James learned from the guys that started it all: Kent Beck, Ron Jeffries, Martin Fowler, and Ken Schwaber.

James has made a significant contribution to Agile teams with his invention of Planning Poker. In a pragmatic moment, James restarted a stalled planning meeting. He had all the participants write their estimates secretly on a note card, cutting off seemingly endless debate and discussion. The meeting was no longer stalled. Soon, everyone around the table had a handful of cards and planning poker was born. That insight was the seed that has led to more fun, productive, and accurate planning sessions for Agile teams around the world. James can bring that kind of pragmatic action to your teams.

James has designed embedded applications for weather radar display, FAA control tower displays, distributed automatic testing systems, voice response systems, high-speed cut-sheet printing and communications systems. But, there is more to James than embedded software. Through his career he has worked in many domains and technologies. It positions him well to bring the knowledge and experience from main-stream software development back to his roots in embedded.

He has been training, coaching, and consulting since the mid-90s. His broad experience in design, requirements, management, planning, test automation, and process improvement makes him a well rounded resource for his clients adopting Agile techniques. His work has taken him to three continents.

Articles by James have been published in IEEE software, IEEE Test and Measurement, and C++ Report. James contributed a chapter to Robert Martin's newest book Clean Code. He also contributed a chapter to the upcoming book Beautiful Teams. He speaks regularly at Embedded Systems Conference and the Agile Development Conferences. He is one of the authors of CppUTest, an open source test harness for C and C++. Areas of interest are software process improvement, Object Oriented Design, programming, embedded systems, project management, Extreme Programming, Test Driven Development, test automation and Agile software development. James knows his way around Scrum, with Scrum Master and Product Owner certifications.

Course Specifics

• 3 days

• Embedded Software Developers
• Technical team leaders
• Managers that want to know the technology they manage

• Embedded C programming experience

• For embedded software engineers.
• For non-embedded software engineers.

• Test Driven Development
• Why Test Driven Development?
• What is Test Driven Development?
• The Microcycle
• Exercise
• Special Considerations for Embedded
• Leveraging the Development System
• Risks of Development System Unit Testing
• Embedded TDD Cycle
• Hardware/Platform Independence
• Testing with Printed Output
• Why is inspecting printed output manually is a loosing proposition?
• Spying on the printed output
• Using a dynamic spy
• Exercise
• Testable Designs
• Object Oriented Principles Applied to C
• TDD and Collaborating C Modules - testing the code in the middle
• Test Fakes, Stubs, Doubles, Mocks
• Spy
• Link time fake
• Exercise
• Breaking dependencies dynamically
• Dynamic fake
• Exercise
• Managing Hardware Dependencies
• Self-Verifying Mock Objects
• Exercise
• Intro to Refactoring
• Test Smells, Code Smells
• Critical Skills
• Incremental Improvement
• Exercise
• Object Oriented Design for Embedded Software
• Why OO for Embedded Software?
• Hardware Abstraction
• OO Design Model
• UML
• Design Exercise
• Agile Design
• Rules of Simple Design
• SOLID Design Principles
• DRY Principle
• Mind Your Own Business
• Architectural Vision
• The Big Picture
• Vertical Slices
• From Specific to General
• Evolution
• Exercise - Design Envisioning and Refinement
• Working with Legacy C
• Boy Scout Rule
• Incremental Improvement
• Legacy Change Algorithm
• Seams
• The first test, the next test
• Sprouting
• Convert Direct Function Call to Indirect Call
• Library substitution
• Generating Mocks
• Encapsulate Data Structure; Exercise
• Extract and Override; Exercise
• Crash to Pass Algorithm
• Learning Tests
• Legacy Code Test Addition Strategy
• TDD and Bug Fixes; Exercise
• Wrap up Discussion

This course will get you and your team well on the way to applying TDD for Embedded C in your development efforts.