Patterns in the Machine: A Software Engineering Guide to Embedded Development

Table of Contents
About the Authors
About the Technical Reviewer
Acknowledgments
Preface
Chapter 1: Introduction
	Patterns in the Machine
	What Is Software Engineering?
	Software Engineering Best Practices
	What PIM Is Not
	What You’ll Need to Know
Chapter 2: Core Concepts
	Software Architecture
	Automated Unit Testing
	Functional Simulator
	Continuous Integration
	Data Model
	Finite State Machines
	Documentation
Chapter 3: Design Theory for Embedded Programming
	SOLID
		Single Responsibility Principle
		Open-Closed Principle
			Using ifndef
			Using Model Points
			Using Abstract Interfaces
			OCP Flexibility
		Liskov Substitution Principle
		Interface Segregation Principle
		Dependency Inversion Principle
	Binding Time
		Source Time Binding
		Compile Time Binding
		Link Time Binding
		A SOLID Conclusion
Chapter 4: Persistent Storage Detailed Design Example
	Persistent Storage Example
		Software Requirements
		High-Level Design
		A Monolithic Detailed Design
		A PIM-Informed Detailed Design
		Benefits of the PIM Design
		Expanded Layering
	Example PIM Thermostat Application
		High-Level Design
		Detailed Design
			The PIM-ness in the Design
	The PIM Dilemma
Chapter 5: Software Architecture
	About the Software Architect
	About Software Architecture Documents
		Major Sub-systems
		Major Interface Semantics
		Threading and Processor Model
		Communications Mechanisms
		Memory Strategy or Rules
		Performance Requirements and Constraints
		Hardware Interfaces
		Operating System
		Third-Party Software
		Functional Simulator
		File Organization
		Localization and Internationalization
		Conventions
		Unit Test Strategy
		Build System
	Creating “Real” Architecture Documents
Chapter 6: Unit Testing
	What Is a Unit Test?
		Source Directories and Unit Tests
		Manual Unit Tests
		Automated Unit Tests
		Code Coverage Metrics
	About Testing Frameworks
	Continuous Integration
	Tips for Unit Testing
		Minimize Dependencies
		Use Abstract Interfaces
		Use the Data Model Pattern
		Test Early
		Develop and Test Incrementally
	The Dark Side of Unit Testing
	Unit Testing vs. Integration Testing vs. System Testing
Chapter 7: Functional Simulator
	Operating System Abstraction Layer
	Hardware Abstraction Layer
	Main Pattern
	Simulated Time
		How to Implement Simulated Time
	Platform Boundaries
		Mocked Simulation
		Simulated Devices
		Emulated Devices
	Simulated Use Cases
		A Simulated LCD
		An Algorithm with Simulated Time
		A Model Simulator with Simulated Time
		A Communication Channel
	The Functional Simulator for the Thermostat Example
Chapter 8: Continuous Integration
	Implementing Continuous Integration
	Continuous Integration and PIM
	About the Build Machine
		Maximizing Build Machine Performance
	About Software Configuration Management
		Implementing Branching Strategies
	About Formal Builds
	About the Build Automation Tool
	About Build Scripts
Chapter 9: The Data Model Architecture
	Additional Model Point Features
	Model Points vs. Global Variables
Chapter 10: Finite State Machines
	Example of a Thermostat FSM
	State Tables
	Design vs. Implementation
	Code Generation Is a Good Thing
	Tips, Hints, and Suggestions
Chapter 11: Documentation
	Documenting Header Files
	Document First, Then Implement
	Documenting Your Development Process
	Document Your Software Architecture and Design
	Document Your Team’s Best Practices
Chapter 12: File Organization and Naming
	Organizing Files by Namespace
	Organizing External Packages
	Naming
		Naming Recommendations for C++
		Naming Recommendations for C
Chapter 13: More About Late Binding
	LHeader
		Implementation Example
			Caveat Implementor
	LConfig
Chapter 14: Initialization and the Main Pattern
	Staged Initialization
		About Open/Close with Inter-thread Communication
	Main Pattern
		Main Minor
		Main Major
Chapter 15: More Best Practices
	Avoid Dynamic Memory Allocation
	Documenting Header Files
	Interfaces and More Interfaces
		Compile Time Binding
		Link Time Binding
		C++ Pure Virtual and Virtual Constructs
	Data Model
	Build System
Chapter 16: PIM Thermostat Example
	Features and Requirements
	Target Hardware
	Installation and Setup
		Linux Setup
		Windows Setup
	Building
		Building on Linux with the GCC Compiler
		Building on Windows with the Visual Studio Compiler
		Build Directory Naming Conventions
		PIM Thermostat Application Usage
			Running on the Target Hardware
			Functional Simulator
			Command-Line Interface (CLI)
			CLI—Basic Help
			CLI—Running Cooling
			Documentation
	About NQBP
		Installing NQBP
		NQBP Usage
		NQBP Build Model
		NQBP Object Files vs. Libraries
		NQBP Build Variants
		NQBP Build Scripts
		Selecting What to Build with NQBP
		NQBP Extras
	Colony.core
	Colony.Apps
	Colony.Arduino
	RATT
Chapter 17: The Tao of Development
	John’s Rules of Development
	Wayne’s Rules of Development
Appendix A:
Terminology
Appendix B:
State Machine Notation
Appendix C:
A UML Cheat Sheet
Appendix D:
Why C++
Appendix E:
About Package Management with Outcast
	Outcast
	Outcast Model
Appendix F:
Requirements vs. Design Statements
Index