Hardware and Software
HARDWARE AND SOFTWARE
The invention of the computer hardware/software distinction is credited to computer scientist John Tukey (1915–2000), who also first used the term bit for memory capacity. Many think that the difference between hardware and software is obvious. One rule of thumb defines hardware as the computer stuff one can bump into. But others emphasize the logical equivalence of computer hardware and software: "Any operation performed by software can also be built directly into the hardware … any instruction executed by the hardware can also be simulated in software." (Tanenbaum 1999, p. 8)
Often computer hardware conjures up an image of a central processing unit (CPU) or a memory chip, not the wire that connects the mouse to a keyboard. But all physical entities that are part of a computer should be considered hardware, although some hardware is more directly involved with the symbol manipulation power of a computer than other hardware.
Tangibility and Functionality
Ruminations about the distinctions between hardware and software can lead to interesting contrasts. The hardware is a machine whose state changes as it operates, but whose form is difficult to change. (A light switch alternates between on and off positions, but one rarely changes its constituent parts.) As it executes, a software program remains static (except for self modifying programs, an exception that proves the rule), but the program causes changes in the hardware state (memory) and external devices (such as printers). And that same software that is static during execution is far easier to change between executions than the hardware that constantly changes its state during execution. To better understand the hardware/software distinction, it is useful to consider three distinct aspects of both: tangibility, functionality, and malleability.
Tangibility: If a computing entity is defined by its physical presence, it is hardware. If an entity is independent of any particular physical form, it is software. Notice that a tangible "hardware" can take many physical forms. The double helix spiral of DNA uses proteins as its hardware. The genetic patterns coded therein are software.
Functionality: If a computing entity has as its primary purpose a physical function, it is hardware. If the entity has as its primary purpose a logical function, it is software. Here "logic" is used to mean symbol manipulation, the transformation of bits according to syntactic and semantic rules. A particular set of bits could mean an integer or printable characters, depending on the rules in force. The bits themselves are represented by hardware, but the rules governing their interpretation are software.
Malleability: If a computing entity is relatively easy to change, it is software. If the entity is relatively hard to change, it is hardware. Of the three aspects, this is the one most in flux. The increasing range of options with respect to malleability has led to an intermediate designation, firmware.
Two early examples of computing illustrate the first two distinctions, tangibility and functionality. The first example is the Jacquard loom, the second a Turing machine.
In 1801 Joseph Jacquard invented a weaving loom using stiff pasteboard cards with holes that controlled rods for each step in the weave. These cards led to the punched cards used by Herman Hollerith for computing machines. Jacquard's physical loom, wood and metal, was hardware. The pasteboard of the punched cards was hardware. But the pattern of holes in the cards, and the desired pattern in the cloth, were software. Even in this ancient example of computing, there is an interplay between hardware and software. The software of the weaving pattern is realized in and by the loom hardware. In an almost mystical way, the cloth pattern is in, with, and under its hardware implementation. The threads that go through Jacquard's loom are tangible, and fall under the category hardware. But after the loom does its work, the threads become an embodiment of the software pattern represented (indirectly) by the punched holes in the pasteboard cards.
A Turing machine is a theoretical construct in computer science, and is composed of states, a recording tape, and a read/write head (Turing 1936). A computation proceeds by changing states and by reading and writing symbols to the tape. Turing machines are thought experiments, not physical objects, but could be manufactured. A recording head and its tape are tangible hardware with a primarily physical function, the recording of symbols. Whatever medium is used to represent different states inside the Turing machine would also be hardware. But the algorithm embodied in the states and the transitions between them is logical, and software. Note that whatever medium is used to embody an algorithm is tangible, but that the algorithm itself does not depend on the details of any particular medium. The same algorithm could simultaneously exist in a human brain, on a piece of paper, and in a Turing machine. Each manifestation would simultaneously be physically different and logically identical.
In the same way that a building embodies an architect's plans, a Turing machine embodies an algorithm. The Turing machine analog to an architectural plan is an algorithm; the Turing machine analog to a building is the Turing machine hardware. The architectural analogy is more apt for a Turning machine than for modern, multipurpose computers, because each Turing machine is customized to a single algorithm. Contemporary computers are far more complex than Jacquard's loom or a simple Turing machine. But the relationship between computer hardware and software is consistent with the relationship illustrated in these examples. In all computing machines, hardware implements software, and the software is embodied in the hardware. The software instructs the hardware, and the hardware manifests the actions described in the software.
Despite these examples, controversies remain. There is not much controversy about some hardware/software distinctions in modern computers. CPUs and memory chips are hardware. The algorithms implemented on that hardware are software. But not everyone agrees on other classifications. For example, some people label data as computer software, whereas others explicitly exclude data from being either computer software or hardware. But source code is a widely accepted example of software, and source code is data to the appropriate interpreter or compiler. If data is not software, then the same program is or is not software, depending on how one looks at it.
Some computing scientists and engineers include designs, user manuals, and online help as software, while others explicitly exclude such entities from consideration. It may be misleading to label all documents associated with a program as software. But designs and specification documents are closely related to algorithms. Some designs can be automatically transformed into machine language with minimal human intervention. It may thus be useful to classify as software documents directly related to program development.
Algorithms used when a computer is powered on are typically stored in special memory devices called read-only memory (ROM), that comes in various forms (PROM, EPROM, and EEPROM). These kinds of devices are easier to change than other hardware but harder to change than programs stored on a hard drive. The term firmware was coined to designate this intermediate form of malleability. Malleability (or its opposite, resistance to change) is the third criterion for hardware and software: If a computing entity is easy to change, it is software; if an entity is difficult to change, it is hardware; and if it is intermediate in this aspect, it is firmware. A closer argument is required here: The state of hardware may be easy to change (much computer hardware is a variation on the on/off switch); but the hardware itself (think of a light switch attached to a wall) is difficult to change. Thus an arithmetic/logic unit is hardware because it has permanently etched silicon algorithms for its calculations, and a C++ program residing on a hard drive is software because it can be more readily modified and recompiled. Although the use of firmware is commonplace, the ethical implications of the hardware/software distinction do not require this middle ground of malleability as a separate category.
Implications of the Hardware/Software Distinction
Some interest in the hardware/software distinction is associated with legal issues. Insofar as a computing entity is a mechanical device (hardware), it is subject to the same body of law that governs ladders and lawnmowers. Insofar as a computer entity functions as an algorithm (software), the laws of intellectual property and professional service are more germane. Hardware designs can be patented, software programs can be copyrighted.
The hardware/software distinction also has ethical implications. On an abstract level, algorithms are pure software. But to have a physical effect, an algorithm is embodied in some physical entity. The nature of the embodiment, the particular hardware chosen, has important ethical implications. For example, if an algorithm is embodied exclusively in a single brain, its ownership as a private thought is uncontroversial; but when the thought is shared as a written document, ethical issues of intellectual property instantly arise. Similarly an algorithmic thought has few consequences for others until it is implemented; when implemented, the algorithm can have important consequences.
When deciding how to embody an algorithm, one must select a location on the malleability continuum. Typically an emphasis on hardware implementation (for example, etched permanently in silicon) will encourage a more reliable implementation and less complex functionality than an implementation in software (such as using a high level programming language). Hardware implementations are more economically feasible when they are mass produced, so widely used algorithms for the many are more likely to be implemented in hardware, whereas customized algorithms for the few are more likely to be implemented in software. The questions of delivery schedules, how good is good enough, and a developer's obligations to customers are examples of the ethically charged issues inherent in any implementation decision. As the costs of fabricating hardware fall and the costs of writing software rise, judgments with regard to such issues may have to be reconsidered.
As computing becomes ubiquitous, software tends to replace hardware to deliver certain functionalities. Airplanes provide a dramatic example of this trend. First fighter jets and then commercial airliners have substituted complex computer algorithms for mechanical controls. The computer algorithms enable the newer airplanes to fly more efficiently and economically. But the redundancy of hardware is difficult to replicate in software (software defects tend to reoccur in a way that hardware defects do not), and this has consequences for the reliability of life-critical systems that rely increasingly on software for their safety. These differences result in ethically significant choices between more efficient operations using software and more expensive but safer hardware devices. As these tradeoffs becoming increasingly common, the different traditions of professionals in different engineering fields can become an ethical issue. For example, software engineers are rarely licensed (in the United States, only Texas issues a software engineering license, and corporate software engineers aren't required to obtain that license either), but other engineers in safety critical applications can be licensed. In this case, the hardware/software distinction may help determine the state's interest in certifying professional competence.
A final example of the ethical importance of the hardware/software distinction has less to do with computing professionals and more to do with the non-programming public and how they view problems with computing. Computers can be a handy scapegoat: "We can't help you with that right now; the computer's down." "Impossible. There's no way to type that into the computer." "I don't remember that email. I guess the computer ate it."
Most people know that software bugs are the responsibility of programmers. But organizations and individuals can sometimes hide behind the hardware of their machines. Emphasizing the hardware aspects of computers can help create an artificial distance between the general public and human errors in software. This deemphasis of human accountability is a danger lurking in the hardware/software distinction. The reality is that algorithms are human artifacts for which humans are responsible, no matter how they are implemented.
The ethical challenges lurking within the hardware/software distinction are reflected in legal and political controversies. There is freeware, shareware, and open source software; but there is no parallel movement to declare computer hardware free. The patent system has been, in the main, successful at protecting hardware innovations, but copyright, patent, trademark, and trade secrecy have each proven problematic in a different way when applied to computer software. Controversies over new laws that criminalize what was once considered legitimate reverse engineering of software have highlighted the importance of understanding the differences between hardware and software.
KEITH W. MILLER
Tanenbaum, Andrew S. (1999). Structured Computer Organization, 4th edition. Prentice-Hall, Upper Saddle River, NJ.
Turing, Alan. (1936). "On Computable Numbers, With an Application to the Entscheidungsproblem." Proceedings of the London Mathematical Society, Series 2, 42: 230–267.