Successfully developing and launching an embedded system requires a wide skill range and engineering disciplines. Every embedded systems requires knowledge in eight distinct software development areas. The degree to which developers have mastered the 8 pillars of embedded software will directly affect development costs, code scalability, system robustness among other critical development metrics. Let’s examine each pillar and their role in embedded software development.
Pillar #1 – Architecture
The software architecture is the blueprint for the application. A well thought out blue print provides developers with a crucial understanding for the major software components, how they interact with each other and their environment. The architecture should provide scalability and give team members an understanding of the system being built. Lacking a software architecture is akin to constructing a building without knowing up front how tall it will be, how many floors and the general area that the building will take up. As one might imagine, constructing such a building would be doomed to failure before it ever started. Partway through the second decade of the twenty first century and I still encounter far too many teams that don’t understand software architecture fundamentals or even employ their use.
Pillar #2 – Code Analysis
Developing an embedded system isn’t just about cranking out code as quickly as possible. Many systems need to be robust and appear to be bug-free to the users (even though a bug free system doesn’t exist in reality). System developers need to have an understand modern code analysis techniques. Techniques such as static, dynamic and worst case stack analysis are just a few examples but only the tip of the analysis ice berg. A teams’ ability to analyze their code and discover flaws, bugs and expose non-conformances could ensure user safety or impact their companies brand.
Pillar #3 – Debugging
The greatest challenge facing embedded software teams today is debugging their systems. Embedded systems are becoming more complex every year and the more complex a system is, the more difficult, time consuming and costly debugging can be. In order to minimize debugging, developers need to be well versed in modern debugging techniques such as real-time tracing. Less time debugging can mean more time for adding innovative product features.
Pillar #4 – Documentation
Documentation is a necessary evil when developing an embedded system. A system can’t be built without some basic requirements definition describing what is being built. A developer can’t properly maintain code without a well documented code base. Regression tests are useLess if they aren’t testing valid product features. Documentation can be expensive to develop and take precious time if a team doesn’t have expertise in this area. Mastering documentation can help decrease total cost of ownership.
Pillar #5 – Language skills
Not all programming languages are equal. More than a single language could potentially do the job such as C, C++, Python, Ada or perhaps another. Without an intimate understanding of a languages strengths and weaknesses developers could be asking for trouble. Certain C programming language areas have ambiguous definitions where compilation using two different compilers could result in two distinct and different results. Certain constructs are fast and efficient while others bloat the code and slow it. If a developer doesn’t realize these problem areas then bad things are destined to happen.
Pillar #6 – Standards
Industry standards are a critical pillar that developers should follow carefully. Standards often contain developer insights and best practices that could only be learned otherwise through trial and error. Development cycles contain too little time for developers to reinvent the wheel and many industry standards such as MISRA, CERT and IEC 61508 with its industry derivatives are full of great engineering practices.
Pillar #7 – Testing
The ability to properly test and verify software even through regression testing is essential to a development team. Did the most recent change to fix a bug break anything else? Does the system meet the requirements? Has every code branch been properly executed through testing? Testing provides developers with a comfort level that the system behaves as expected under controlled conditions.
Pillar #8 – Tools
Professional embedded software developers need access to and know how to use the tools of their trade. An understanding of their tools and ecosystem can make the difference between a robust and polished system and a flakey, amateur product. Many teams ignore their industries tools, claiming the few thousand dollars investment isn’t in the budget. The right tools, for the right job though can pay for the tool ten times over and still have a huge impact on time to market.
Conclusions Teams that master these eight pillars of embedded software undoubtedly build their software upon a strong foundation. The majority of teams that I see fail lack expertise in at least one pillars. To ensure success, teams need to have expertise in each pillar and use a disciplined design approach. To learn more about how to improve in these areas, consider reading “Mastering the 8 pillars of embedded software“.