New game for GUIs
Those of us who recall DOS and other command interfaces appreciate the invention of graphical user interfaces (GUIs): Graphical controls and displays make us more efficient and productive because they are intuitive, with little or no learning required. GUIs make life easier, whether one is writing code or playing games.
Why? As the saying goes, a picture is worth a thousand words. But it’s actually worth a lot more when it comes to operating controls. Fast readers can proofread material at about 200 words – or about 900 bytes – a minute. By the same token, a video gamer manipulating images on a 1920 by 1080-pixel screen at 60 frames per second can comprehend about 22 gigabytes a minute. So moving controls via graphical versus textual information wins by a factor of more than 22 million.
People can assimilate a vast amount of sensory data almost instantaneously. Think of cars weaving in and out of high-speed traffic at night, which happens every day with relatively few accidents. However, if you blindfolded those drivers and gave them verbal commands about when to floor it, when to slam on the brakes, and where to turn, it would be a disaster scenario.
Challenges to visualization
It’s much easier to write code if each step in the process can be verified and tested visually rather than textually. If you know what the data should look like at certain points in the program, but the visualizations indicate the contrary, you can stop and fix the problems before they multiply. With GUIs, algorithms can be instrumented, simulated, and demonstrated as they are coded, reducing debug time. Yet although many GUI kits are available on the market, GUIs are not considered essential in the embedded world.
Programmers may not see the GUI cost/benefit since embedded software, such as a missile-tracking system or a radar-processing application, may not require graphics support. The target processor, for example, may not even feature a graphics chip. In addition, GUIs can drain processor cycles and create bottlenecks, both definitely unacceptable. Moreover, GUIs typically involve a lot of code, and the kits can entail extensive learning curves, as programmers familiarize themselves with hundreds or even thousands of application program interfaces (APIs).
What’s more, conventional GUIs – which emerged from the nondeterministic world – are difficult to adapt to the needs of embedded processing. For one thing, GUI software typically is intended for event-driven programming models in which many programming loops “sleep” in the background until triggered by an action such as a mouse click or a key press. The order in which components will execute will vary unpredictably, according to user inputs. This versatility is ideal for something like word processing. In contrast, real-time embedded processing applications, which require highly predictable performance, typically rely on a sequential programming model, where every step in the program is determined in advance and executes according to a rigorous schedule.
Developers of embedded software have been reluctant to develop GUIs because conventional GUIs increase development and maintenance costs, consume cycles, and appear to be unnecessary.
What if the embedded software world could reap the benefits of GUIs without incurring the costs? For starters, this would require easy-to-use GUI development kits that could quickly create no-frills interfaces. The GUIs also would need to be decoupled from the target code, so that visualizations could be run remotely, as needed.
Since these GUIs would be smaller and simpler than the systems found in the nonembedded world – no need for pull-down menus or pop-up dialog boxes – the kits would involve fewer APIs. The GUI would focus on the bare necessities of inputting and visualizing data. Application overhead would be limited to sending and receiving data when necessary over the TCP connections typically built into modern boards. Abaco Systems recently introduced AXIS DataView, a multiplatform, multi-operating system tool, which has only five APIs and is external to the application source code. (Figure 1.)
If GUIs can be set up quickly and allow developers to minimize coding and debug time, that is a winning scenario all around.