Windows® Embedded

Differences between hardware and software systems

by John Blyler

Hardware and software form a symbiotic relationship, yet the development process for each has some distinct differences. This has caused some economic and professional problems, especially when software is viewed as merely a component or subsystem of hardware development. Before one can appreciate the differences between the process of developing hardware and software, one must understand the differences between these two entities.

Complexity
One result of the flexibility of software is that it tends to be more complicated than hardware. Since the original goal of software was to extract greater functionality out of a given hardware design, one would expect software to be more complex, having more interfaces, dependencies and interactions between various sections of code. In this sense, hardware is usually much simpler than software. Consider the typical PC; if separated into its constituent parts, one would find much duplication. At the circuit level, active filter arrangement of resistors and capacitors are repeated for many sections of the motherboard. At the board level, there are several boards that perform similar functionality, such as parallel, serial and USB interface boards. Repetition is needed in most hardware designs because all of these parts are needed all of the time. But in software, a repeated function, e.g. a time function, is created once in code, then simply referred to as often as is needed. The main software program “calls” the requested time function subroutine when needed and it is executed at that time, returning the desired data value. This same subroutine can be called again and again, from any other code. Thus, there tends to be more unique parts of a software program than are found in a hardware system. The complexity of software results from all these unique programs interfacing with one another.

Defects
The flexibility that software brings to hardware systems comes at a price; the effective range of defects. Since a given subroutine can be used by an almost limitless number of other programs, and defects in that one section of code can potential affect all other interfacing programs. Consider the Y2K issue, for example, where a simple data function could affect systems from desktop PC to power utilities and even airlines. While hardware defects can be as devastating, they tend to be more localized and with a smaller set of interfaces. Design problem on a certain piece of hardware can affect all the hardware that uses that part, e.g., a faulty IC, out of tolerance O-ring on a space shuttle or an overstressed bolt on an aircraft engine. Typically, though, a hardware defect such is very limited in scope, effecting only the systems of which it is a part, such as a flat tire on your car. Software defects can have a much wider range of effects, since it effects all copies of the software. Also, as noted above, the complexity and number of interfacing programs make software defects much more far reaching in their effects. Finally, software defects are the result of the logic (or “design”) of the code, and are not the result of the medium on which the program is contained. Testing code to find defects is challenging, since the flexibility of software makes it almost impossible to test all the range of possible faults.

End life
Software does not wear out in the same way as hardware. Since hardware is directly related to physical materials, friction, interactions with the environment (rust, heat), and gravity, cause hardware to eventually wear out, rust or fall apart. The physical medium that contains software, e.g., memory stick, hard drive, CD or ZIP disk, does wear out in time. But since software is the embodiment of logic in code, it is analogous to the written word, which is not affected by the passage of time.

Maintenance
Most physical entities require maintenance. Hardware must be maintained to remain functional. Frictional affects between moving parts can be mitigated with oil and lubricants, rust can be prevent with annual applications of an exterior coating, heat dissipated from an CPU with metal fins or a cooling fan. Worn out parts are replaced with new ones and the hardware systems continues to operate as designed. In this hardware sense of replacing parts or compensating for environmental affects, software requires no maintenance.

But if this traditional and rather narrow definition of hardware is expanded to include correcting design flaws, converting to new systems and incrementally improving basic functionality, then software does need continual maintenance. In fact, software maintenance contacts comprise near half of the revenue for many software companies. The complexity of software, combined with the fact that programs can potentially be used on many different operating systems and hardware platforms (both PCs and networks), make it impossible to test programs for all potential defects. Hence, “bug” fixing forms a significant part of software maintenance work. This challenge is made more difficult by the fact that operating system programs are continually being improved, i.e., bugs are being fixed and enhancements made. So software applications, from word processors, to CAD systems and PCB assembly line programs must be continually tested on newer additions of the same operating system. Software maintenance is an endless process, despite the admonitions of the current software gurus.

pg_13