The Embedded Systems Conference was held at the Moscone Center in San Francisco on April 9th through 13th. I attended along with Jim Marek. There was no single theme identified as the theme of the conference, but several featured technologies were represented by multiple classes and tutorials. The featured technologies were CORBA, Java, Linux, Wireless, and Security.
Among the special events at this conference were two keynote addresses and a panel discussion. The first address, Living in a Virtual World, was by the author of The Hitchhiker's Guide to the Galaxy, Douglas Adams. The second address, The Future of Real-Time Java was by two leaders in the Java community, James Gosling and Greg Bollella. A live demonstration of real-time Java in use was presented at the end of their talk by David Hardin. David presented a pair of robot arms which together played Chopsticks on an electronic keyboard. Each arm was independently controlled by a real-time Java application running on an aJile Java microprocessor. There was also a panel discussion on the first evening of the conference entitled Object-Oriented Programming: Method or Madness? More detailed notes on these talks may be found by following the links in the Annex to this report.
My personal interest presently is Java, which I am in the process of learning on my own, so I focused a bit more heavily on the Java courses. I was particularly interested in the Real Time Specification for Java, which is currently going through the standardization process within the Java Community. I also selected other courses that looked like they might be relevant to real-time systems or avionics. Following is a brief summary of the courses and tutorial that I did attend.
The printed slides from the classes (marked up with my notes), as well as the conference CD-ROM containing all the slides and submitted papers for every presentation, are available for check out from my personal library. Simply leave your drivers license, a crisp new $100 bill, or your right thumb as security deposit.
Everything You Ever Wanted to Know About Java, But Were Afraid to Ask (tutorial). This was actually a pretty good tutorial—largely because it did not endeavor to teach the Java programming language in one day-long tutorial. Instead, its focus was to provide a more general overview of the Java language and VM, "to prepare you to make Java-related decisions". The lecturer gave a no-nonsense look at the strengths, the weaknesses, the myths and the hype of Java. He also gave an overview of the important acronyms and technologies surrounding the present day use of Java, clarified some terminology that is widely but casually used, and described the evolution of Sun's approach to Java for embedded systems. He briefly described the major players in and efforts at providing for real-time programming in Java.
Architecture of Device I/O Drivers. A better title for this class would have been A Taxonomy of Device I/O Drivers. Dr. Kalinsky presented an overview, with examples, of different approaches to structuring device I/O drivers. He covered a range of approaches from simple Mutual Exclusion, to Synchronous I/O vs. Asynchronous I/O, to Double-Buffering, to Zero Copy DMA Input Spooler, and various points in between. He also discussed recent "advances" in automated device driver generation tools, clearing away some of the hype surrounding manufacturers' claims. The upshot: they are not really a "complete solution" as claimed by some of the manufacturers. Particularly they do not integrate with the application tasks. But they go a long way in getting the bit-banging control register configuration and manipulation details sorted out and properly into code.
Writing "Real" Java—Not Just C in Java. This was a pretty good introduction to the features of the Java programming language, presented by a practitioner who has heard too much Java spoken with a heavy "C" accent. The intended audience was those programmers who are making or who will soon be making the transition from C to Java. Through a series of small, sample code snippets, this talk presented a contrast between the old ways of doing things in C, and better ways to do them in Java. It covered such concerns as name space issues, constant declarations and usage, conditional compilation, classes, subclasses, and abstract classes, header files, exceptions, try blocks, and garbage collection vs destructors. The main shortcoming of the course was that the example code snippets were not included in the slide handouts, making it difficult to take notes about the examples. This was partly made up for by the author posting the slides on the web after the conference. Example annotated code snippets for the class may be found at http://www.x.wao.com/~esc2001.
Developing Embedded Software in Java. This was largely a ninety minute condensation of the material presented in the one-day tutorial. Michael Barr gave a no-hype overview of the strengths and weaknesses of Java, and related a personal success story in using Java for the first time. He also surveyed different places Java may be used in embedded applications, and illuminated some important terminological differences in what "embedded Java" means.
Real-Time Operating System Requirements for Use in Safety Critical Systems. This class started with a historical overview of approaches to real-time software, from cyclic processing on up to multiple multi-tasking applications of mixed criticality on a single processor. Issues of concern to real-time systems, especially to safety-critical applications were discussed: address space protection, guaranteed resource availability in space and time domains, kernel determinism and interrupt latency, high availability, and schedulability. The weakness of Rate Monotonic Scheduling over against Highest Locker Semaphore protocol was illustrated with regard to schedulability analysis and guarantee. Various standards relevant to safety-critical systems were surveyed, including DO-178B, ARINC 653, MoD OO-55/56, ISO 15408, and others. Also, an overview of a typical certification process was given. The class wrapped up with a survey of common defects in popular Real Time OSes that an engineer ought to be aware of and watch out for.
Effective Use Cases for Real-Time Design. This was a pretty good introduction to Use Case analysis. It assumes you are UML literate, or at least conversant, so it may be a bit challenging to follow if you are not. The author presented the Use Case as essentially a repository for requirements, a high-level organizational unit for requirements capture. The concepts were illustrated with a few simple example systems presented at different levels of concern and detail. The talk was sprinkled liberally throughout with practical advice on using Use Cases: dos and don'ts, rules of thumb, and a large section of Guidelines on when and where to use the different components and approaches. Two insightful cautions were that Use Cases should be employed for the requirements capture but not overused for detailed design decomposition, and one should not strive to be elegant in paring down Scenarios to the minimal set necessary to capture requirements. The author nicely related Use Cases to Object Oriented Analysis and Design, and also showed where their use fit in software life cycles, both in waterfall and spiral models. The author also cited some excellent references and touched lightly on a few advanced topics of Use Cases.
Real-Time CORBA and Its Applications to Embedded Systems. The first part of this talk presented an introduction to CORBA, with an overview of the CORBA architecture, and a description of the standards process. The overview of CORBA given in this talk was a particularly good introduction for anyone unfamiliar with CORBA. Following that, the particular needs that must be addressed for real-time applications were described. Essentially, what needs to be added to CORBA is predictability of ORB operations. This is addressed by the CORBA Real-Time Specification 1.0, which was developed by OMG as extensions to CORBA 2.2. The talk addressed the priority models, mutex mechanisms, threadpools, protocol selection, connection management, and better configuration specificity as the means for achieving Real-Time middleware.
Rolling Your Own Embedded Linux Distribution. This was a somewhat interesting nuts-and-bolts talk. The thrust of the class was to demonstrate a few really handy shoehorn techniques for generating a Linux system that will boot from a floppy. The author first put the discussion in context by overviewing when and why we might choose Linux for an embedded system (32 bit processor and 1M RAM is the "sweet spot" for embedded Linux), and observed that the Linux is "free" only if you don't value your time. You do have to configure it and pare it down for an embedded system. That said, he identified the C library as the largest portion of a bootable Linux image, and demonstrated a customizable, configurable replacement library product called uClibc. One can configure and compile this library so that it includes only those routines actually required by your installation. The other big payoff technique was to replace the entire set of shell utility binaries with a single "multi-call" binary image, built using a builder system called Busybox. This builder provides a fine-grained degree of customization, allowing the user to specify which utilities to include (awk, grep, ls, etc.) and which features to turn on or off. This single binary is invoked by each of the shell utility commands. It detects which utility name was used to invoke it, and then behaves like that utility. This way, one large binary contains all the code for all the utilities, and provides some additional space saving because of code sharing. At the end of the lecture the author configured, built and booted from a 1.44M floppy a small Linux system right before our very eyes.
Basics of Jini Technology and Java 2 Platform, Micro Edition (J2ME) for Embedded Development. This class gave a pretty nice introduction to two new technologies from Sun, Jini and J2ME. Jini is essentially a web-based service registration and lookup service. Characteristic of the Jini lookup service is that a server provides a Java applet referred to as Proxy Code when it registers its service, and the client is supplied this applet when it looks up the service in the Jini server. The Proxy Code runs on the client VM, and handles all the connection and interface between the server and the client from then on. Provisions are included for accommodating non-Java devices in the registry, by means of a registered Surrogate device. A Discovery Protocol permits devices to be quickly networked together and be able to easily discover the other devices and services on the network.
J2ME, the Java 2 Platform, Micro Edition, represents Sun's "regrouping" on its effort to define Java for embedded applications. The approach is divided into three focuses, the VM, Configurations, and Profiles. Two variants of the VM are defined to better accommodate the limited resources and device handling needs of embedded applications. A Configuration is essentially the minimum set of core Java classes necessary to support the VM. Two configurations are defined to delineate the two fundamental device classes that Sun perceives embedded devices to fall into. The CLDC devices are those that are severely resource limited, e.g. small memory, battery operation, low bandwidth connect. The CDC devices are those which are not. Profiles are essentially common sets of APIs to help developers write code for devices with similar characteristics, e.g. cell phone interface, TV set-top box, small LCD panel, etc.
Developing Applications in the Real-Time Specification for Java. This was the most interesting and stimulating class I attended all week. Greg Bollella, one of the principal developers of the RTSJ, gave a report on the current status of the Real-Time Specification, and presented a very informative overview of the specification, starting with the guiding principles in its design, and touching on the issues and features of memory management, threads and scheduling, asynchronous event handling, time and timers, asynchronous transfer of control, and physical memory access. What I found particularly exciting about this specification is that they accomplished all this without any syntactic extensions to the language, and without adding new semantics to the VM (two important guiding principles). The specification did tighten some of the semantics, e.g. where the VM spec used to say the VM must provide for "at least 10 priorities" the RTSJ says it must provide "at least 28 unique priorities." David Hardin covered the second half of the class, and presented code examples of how these RTSJ features are expressed. Although the features look a little cumbersome syntactically, they on first glance, look pretty easy to understand and use.
The Distributed Real-Time Specification for Java. This talk reported on early efforts on a Distributed Real-Time Specification for Java. This standard is currently under development through the Java Community Process (JSR-50), and the author gave a little overview of how that process works. The author then identified what "distributed real-time" means (to the Expert Group), discussed the concepts of characterization of distributed systems, time constraints and deadlines, collective timeliness, and end-to-end properties of multi-node applications. He presented the concept of a distributable thread as an end-to-end control flow abstraction that retains local semantics on remote invocations. Distributable threads were introduced to address the end-to-end needs of timeliness, integrity, control and event handling by sharing of timeliness information and data across nodes.
Supplemental notes on the keynote addresses and the panel discussion have been placed in separate documents. They may be reached by the following links. NOTE: I have handwritten notes from these sessions, and intend to write them up as time permits. If you have any desire to see one of these annexes, and do not find the notes online, ping me and I'll bump it up in priority, or let you look at my handwritten notes if you wish.
Douglas Adams was a captivating and entertaining keynote speaker. Whereas it is to be expected that the author of The Hitchhiker's Guide to the Galaxy would be entertaining, it was surprising and gratifying to find him also insightful and inspiring about technology itself—the path it has come, the problems we (yet) have with it, and where it ought to go. His talk was sprinkled liberally with humorous characterizations of the technological world in which we live. Here are a few of the observations and quips from his speech as well as some of the main points of his presentation [...]