In any system design, there are always trade-offs that need to be made. Unfortunately, there is rarely a time when you can get your cake and eat it, too! Modern embedded systems have exceptionally interesting trades that need to be made that often result in complex choices. Three essential trade-offs come to mind that every embedded systems developer needs to balance carefully.
Trade-off #1 – Power Consumption Versus System Performance in Embedded Systems
The IoT has been driving innovation within the embedded systems space for quite some time. With that innovation has come an explosion of features and capabilities that many embedded systems must support. For example, connectivity stacks, security, and graphic-rich interfaces, just to name a few. While adding a lot of value to a product, all these features also have unexpected consequences.
The need for more features results in more computing power to meet system performance expectations. However, more processing power means more power consumption. Power consumption is critical to battery-operated devices to maximize battery life and minimize product maintenance in the field. The faster the battery needs to be replaced, the higher the maintenance costs. Trading off performance and power consumption can be critical.
Now you might think you don’t have a battery, so power consumption is not a concern. However, in a society that sees the global impact our technology has on our environment, every device, battery-operated or connected to the grid, has an ethical responsibility to use the energy it needs and not waste it. Failing to optimize power consumption might result in market backlash from energy conscience consumers.
Trade-off #2 – Cost Versus Reliability
Cost is a significant driver in every product development cycle. Companies have a fixed budget to develop their innovative product and take it to market. While established and successful businesses may have wriggle room, start-ups and small businesses are particularly under pressure to deliver cost-effectively.
The dramatic increase in features and connectivity has resulted in a lot more work and cost that must go into designing and building an embedded product. Many teams are scrambling to use what budget they have just to get the basic features into their products. Reliability and robustness are viewed as nice to have, but the product must first get to market.
Reliability often comes at an extra cost to first put in place development and production processes. While potentially decreasing long-term costs, these processes are often put off in the hopes of short-term gain. The dynamic forces teams to trade off reliability and cost to achieve their system's needed level of reliability.
Trade-off #3 – Scalability Versus Complexity
When I started working in the embedded systems industry, embedded systems were “hot-rod” products. They were finely tuned, single-purpose devices designed and built once with short-term maintenance. They were not typically designed for reuse or portability. Today’s systems are very different. Many companies don’t view their embedded product as a one-off product but as a baseline platform that will be scaled and maintained and will result in numerous products being launched from the same code base.
Reusing existing platform code can result in a more complex software architecture. For example, a single-release product might leverage a monolithic architecture without issue. However, a platform that needs to scale to handle features and market changes for a decade might need to switch to a more complex microservices-based architecture. The microservices architecture allows great scalability but comes with increased complexity in design, deployment, maintenance, and even the ability to schedule tasks.
Modern embedded systems must carefully trade off and balance their need for scalability versus the complexity that results from scalability. An excellent place to start is to identify how much scalability your system needs and balance it with architectural decisions that can get you there without overly complicating your system.
Conclusions
Modern embedded systems are complex, which results in a wide variety of trade-offs that must be made. In this post, we explored the three most significant trade-offs facing many teams today:
- Power consumption versus system performance
- Cost versus reliability
- Scalability versus complexity
You might also face other trade-offs, but you’ll likely find that these three are driving many of the design decisions you make today. Successfully balancing them will determine whether you successfully launch a product or whether your product and company struggle to succeed.