IDEs do improve productivity

As time-to-market requirements for embedded applications become a source of competitive advantage, one of the critical challenges for embedded software vendors will be to equip their software developers with tools that significantly improve productivity.

The integrated development environment (IDE) product provides a seamless way for software developers to develop features in the most efficient manner. By combining the most relevant tools needed for software development in an integrated environment, IDEs can significantly shorten the time needed to design, implement, debug, test and deploy optimized applications in the embedded marketplace. It is clear that the IDE is an invaluable productivity tool in an embedded software developer's arsenal.

Embedded development in the early days involved several disparate components for the typical development cycle of "code, compile, execute, test and debug." The text editors were rudimentary and nonintuitive, forcing programmers to be experts at editor commands. Programs had to be compiled, executed and tested using command line interfaces that were error prone. The debugging of programs involved separate debuggers that did not involve graphical user interfaces. In addition to these constraints, the specifics of embedded development, which involved custom target hardware with minimal development support, often contributed to long development cycles. As the complexity of embedded applications grew, this approach to software development revealed several functional deficiencies creating significant bottlenecks for time-to-market requirements.

Specific intent

The IDE, which has been prevalent for the last several years, was created specifically to improve developer productivity and thus improve efficiency of software development. Starting with a basic feature set for edit, compile, test and debug, and a graphical user interface front-end, the IDE has consistently evolved to offer the capabilities for effective software development. Today, it is the centerpiece of a software developer's workbench with advanced features that offer superior insight into all aspects of software development. Today's commercial IDEs include significant features.

Almost all IDEs for embedded applications enable cross-development from a host operating system to an embedded hardware running a target embedded OS. Since the target hardware is usually unsuitable for development a significant percentage of embedded development is done using a cross-development environment. The most popular host development operating systems are Windows, Linux and Solaris.

All IDEs provide basic development tools that are involved in the development process. These are text editors, multiple language support, automated builder, execution and debugging of the compiled binary. However, the text editors provided with IDEs offer advanced features like syntax highlighting, auto indenting and better configurability. The most popular languages used for embedded development, C, C++ and Java, are also fully supported with advanced cross-compilers capable of generating highly optimized code. The automated build and execute component has significantly improved upon the "makefile" concept to create a seamless mechanism for creating large software programs involving thousands of files. The debuggers can provide source-level debugging as well as post-mortem debugging if applications crash.

One of the most remarkable advances in IDEs involves "project wizards," which create source file templates based on a developer's needs. For example, an application developer may need to create a program that involves independent threads of execution synchronized by semaphores. Based on this information a wizard can create a sample program with those capabilities that actually can be compiled and executed on a target OS. This concept has also been extended to creating sample device drivers in many IDEs. Using this capability, even software developers not familiar with an embedded OS API or its driver model can make significant progress in their development.

One of the most important phases of an embedded development cycle is the capability to create and execute an OS image along with embedded applications on the target hardware. The key requirements of an embedded application and its OS — like static size and memory usage — can be analyzed using these target tools. The IDE tools also allow the target image to be downloaded onto the hardware using a communication mechanism like serial line or Ethernet. Once these images have been downloaded, the IDE tools can also connect to the target to allow real-time debugging of applications or the OS during its execution.

The other recent inclusion into IDEs has been profiling and optimization tools. These tools allow analysis of the software program after basic development and debugging is complete to identify performance bottlenecks, tuning system behavior and even assist in comprehensive test analysis.

The profiling tools use instrumentation to provide insight into the execution of a software program. This can assist greatly in identifying the specific pieces of code that take the longest to execute or in tracing a specific code path. Event-tracing tools that provide a window into the overall system behavior can assist in tracking external interrupts into the system and their impact on application execution. The usage of these event-tracing tools can help optimize overall system behavior to a level that had been hard to achieve without these IDE tools.

Natural extension

The integration of configuration management tools into IDEs is a natural extension of the development environment. Any commercial software development that involves multiple versions of software requires appropriate configuration management, mainly to ensure that versions of a particular source file can be maintained in a repository, which assists in identifying specific files corresponding to different software releases. The configuration-management tools in an IDE allow for seamless storage and retrieval of a set of source files (typically called "Project"), thereby supporting seamless development of multiple software release.

The addition of these IDE features has greatly enhanced the effectiveness of software development. In fact, an organization that does not institutionalize the effective use of productivity tools is at a significant competitive disadvantage.

There are several commercial IDE offerings available from embedded operating system vendors. One such tool from LynuxWorks is VisualLynux, which is built on top of the Microsoft VisualStudio IDE and enables embedded software development for LynxOS and Bluecat Linux operating systems from a host PC running Windows. Another significant IDE is the Eclipse framework, which is an open-source IDE tool that has been written in Java and allows Java, C and C++ application development on Linux, Windows and Solaris. Other notable offerings include CodeWarrior from Metrowerks, Microsoft VisualStudio for Windows CE, Tornado from WindRiver Systems, Momentics from QNX Systems and Multi from GreenHills Software.

Arun Subbarao is the director of software engineering for LynuxWorks Inc. (San Jose, Calif.).