Significance of the pillars of embedded software

Article By : Jacob Beningo

There are eight distinct software development areas. Let's examine each of these pillars and its role in embedded software development.

Successfully developing and launching an embedded system requires a wide range of skills in a variety of engineering disciplines. Every embedded systems development team needs knowledge in eight distinct software development areas. The degree to which developers have mastered these eight pillars of embedded software will directly affect development costs, code scalability, and system robustness among other critical development metrics.

Let's examine each pillar and its role in embedded software development.

__Pillar #1 – Architecture
The software architecture is the blueprint for the application. A well thought out blueprint provides developers with crucial understanding of 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 it will have, or even a 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. It's now 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 must appear to the users to be bug-free (even though a bug free system doesn't exist in reality). To achieve these attributes in development, 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 of useful techniques, but are only the tip of the analysis iceberg. A teams’ ability to analyze their code, discover flaws and bugs, and expose non-conformances can help ensure user safety and impact their company's 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. Similarly, 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, so mastering documentation can help decrease a project's total cost of ownership.

Pillar #5 – Programming language skills
Not all programming languages are equal. More than one language could potentially do the job, such as C, C++, Python, Ada, or perhaps another, so without an intimate understanding of a language's strengths and weaknesses developers could be asking for trouble. Certain C programming language areas, for instance, have ambiguous definitions where compilation using two different compilers could result in two distinct and different results. Likewise, certain constructs are fast and efficient while others bloat the code and slow it. If a developer doesn't know about 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. Industry standards such as MISRA, CERT, and IEC 61508 with its industry derivatives are full of great engineering practices. Development cycles contain too little time for developers to reinvent those wheels.

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 significant comfort level that the system behaves as expected under controlled conditions.

Pillar #8 – Tools
Professional embedded software developers need access to and should 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 forego their industry's tools, claiming the few-thousand-dollar investment isn't in the budget. The right tools for the right job, though, can pay for the tool ten times over through labor savings as well as have a huge impact on time to market.

Teams that master these eight pillars of embedded software will build their software upon a strong foundation. The majority of teams that I see fail lack expertise in at least one of these pillars. To ensure success, teams need to have expertise in each pillar and use a disciplined design approach.

About the author
Jacob Beningo is an embedded software consultant who currently works with clients in more than a dozen countries to dramatically transform their businesses by improving product quality, cost and time to market. He has published more than 200 articles on embedded software development techniques, is a sought-after speaker and technical trainer, and holds three degrees, which include a Masters of Engineering from the University of Michigan.

Leave a comment