ESP Wiki is looking for moderators and active contributors!

Difference between revisions of "Software does not make a computer a new machine"

(House: Reworded the analogy to make it clearer that we are contrasting the changing of hardware to form a new machine to the changing of software which never creates a new machine)
(House: Reworded.. but still a work in progress)
Line 36: Line 36:
 
=== House ===
 
=== House ===
  
A full working computer can be made from a house with a great many doors and door sensors, a central clock, lots of wires, and a motor per door to open and close that door. This house is the computer, made and patented once.
+
A house, whose components and behavior will be described, can be made to be a full working computer.
 +
 
 +
The house has doors, motors, sensors, wiring, and a clock. These tangible components are called "hardware". They are built once and their behavior is never changed afterward. Doors open and shut, clocks tick, etc, all according to design. The quality and construction of the doors, clock, sensors, etc, can be patented. These are all tangible things constructed.
 +
 
 +
Software is intangible. Software is information. "Creating" software does not create anything tangible. When we add software to the house, we simply rearrange some of the doors in the house (into the open position or else into the closed position). Creating software adjusts the position of components of the house. How can we represent a value of 1 vs 0? By opening a door rather than closing it. Similarly, we can raise our hand vs lowering it. Creating software does not create anything tangible. Creating software rearranges. We open a door or close it; we raise a hand or lower it. We open a pair of scissors or close them. We turn on a light or turn if off. We don't create a new house, person, scissors, or light when we add software to these things. Software is just information. The value in software depends on what we do with that information.
 +
 
 +
In more detail...
 +
 
 +
In the case of our house, sensors collectively interpret the software (the state of the doors) and then enable the motors to move doors. Software in a given state thus leads to software in a new state at each clock tick. Whether a given door is open or closed impacts if some other door will open or close. How one door affects another door (at the next clock tick) is defined by the wiring of the sensors and motors. What the software information means is defined by the hardware.
 +
 
 +
Human beings can perform the same behavior of this house. The doors are our arms. We can raise them or lower them. The clock ticking is one lead human shouting continually each second so that all can hear: "NEXT... NEXT... NEXT...." The sensors sensing doors open or closed are the eyes of the humans looking at the hands of other humans to see if they are up or down. Each set of human eyes if fixated on a particular set of arms. The motors are the arm muscles of the humans that will raise or lower the arms.
 +
 
 +
Instead of humans we can use light bulbs. Instead of bulbs we can use lots of paper and write or erase marks on associated portions of the papers.
 +
 
 +
Instead of using these bulky mechanisms, we can also use very small parts that work very fast.
 +
 
 +
OK, now let's talk about algorithms and brains. Let's look at "firmware" and how it differs from software.
 +
 
 +
There is one set of doors in the house that are set when the house is built and are possibly never changed again. These firm doors are called firmware. These doors serve as a simpleton brain for the house. These doors are wired in a particularly clever way and define a core basic set of "instructions" that the house will understand from its software. This little simple firmware brain has one job: to repeatedly look at the door configuration in a certain other place (software) and, based on the configuration it finds, interpret it as an instruction and instruction data. When done with one instruction, go to the next location and keep interpreting over and over the doors as instructions until you reach the "halt" instruction, at which point the house will seize computing. The location of the next instruction is defined by the size of the prior instruction and usually means right after it, unless we encountered the "jump" instruction, which tells the simple brain to look for the next instruction elsewhere. An instruction such as "add" is handled by looking at the two sets of doors that will be interpreted as numbers (eg, 128 could be the interpretation of eight doors set as open, closed, closed, closed, closed, closed, closed, closed, in that order). And instruction such as "move" might copy the following 8 doors into some other group of 8 doors. How do we know which set of doors to change? Every 8 doors has an address (eg, 1, 2, 3, 4 .. to designate the first set of 8 doors, the second set of 8 doors, etc). Thus, the simple brains first finds that the next 8 doors has the instruction "move" and it is followed by 8 doors that refer to a value (eg, 57:  ) and by another 8 doors with an address (eg, 12  ). So the simple brains moves 57 into the 12th set of doors.
 +
 
 +
This firmware magic is effected with the wiring of sensors and motors on one set of doors representing the firmware. This is a special location generally not accessible to software instructions. For example, we usually cannot try to "move" into doors that hold firmware some other value because the system is not wired up to enable that. The firmware addresses don't exist, so we cannot reference them. We can only reference other software doors. Firmware is thus almost an extension of the hardware. It is a simplified brains that defines the instructions the house will understand from when software is added.
 +
 
 +
We can forget about firmware and simply call it "wiring", but it shows that there are two brains in play. The first brain is very "simple-minded" and unchangeable. The second brain is the software we add to actually perform a useful computation. So in referring to brains, it helps to be aware that there are two levels. One level is hard-coded into the machine by the time you buy the machine, and it does something very important to the functioning of the machine but extremely useless to humans that want to effect a given computation. Meanwhile, the interesting stuff comes from the software algorithms humans create. This software will be limited and defined by that simple-minded instructions set the firmware enabled. From the computer software developer point of view, firmware doesn't exist or can be abstracted as hardware, but from the view of the engineer designing a new computing hardware, he or she might use very low level computing chips built by someone else that will require a new instruction set to be "programmed" into it in a way that will be consistent with the other hardware components being designed by the engineer. So to some hardware engineers, firmware is software.
 +
 
 +
To get back to the humans that were simulating the computing house, each human will always follow a piece of firmware, a simple, dumb algorithm. In contrast, software is the initial configuration of raised or lowered arms that will set everything in motion. While the humans each locally perform a simple-minded raising of arms based on simple (firmware) rules applied to a few things seen with the eyes, a complex (software) algorithm gets effected collectively by them all. Note that the software (ie, the configuration of hands) comes in a near infinite number of possibilities. The software developer does not change what each human does but does leverage that information to design a complex software algorithm.
 +
 
 +
Adding software does not create a new machine. Adding software is nothing but a writing of instructions and then handing it over to the "machine" that will execute those instructions.
 +
 
 +
 
 +
Rough notes:
 +
 
 +
These connections define many features of this house, such as whether the house will be 32 bits (meaning the sensors-motors collaborate to effect logical and mathematical operations on door values, 32 doors at a time).        as if it were one number) and which instructions the house will be able to perform.    make up the rest of the important components of this computer., and a motor per door to open and close that door. This house is the computer. It is hardware. It can be patented. The components of this house are never changed once we build the house. That is, the hardware is defined one time and remains fixed until the computer is destroyed.
 +
 
 +
Now we add software to this house. Adding software means reconfiguring the doors of the house. Each door can be open or otherwise closed; thus, the information contained in each door's state is binary: 1 or 0 are the only values possible for a single door.
 +
 
 +
A first group of doors in the house is configured once when the house is built, and that configuration is essentially kept fixed in place forever. These firm doors ("firmware") hold the mathematical information necessary to allow the house to work as a general purpose computer (to cycle repeatedly reading and interpreting "instructions" encoded in other doors).
 +
 
 +
Every other door might potentially be reset over time, either into the open position or into the closed position. The state of these doors is the software.
 +
 
 +
Software and firmware are simply information. The hardware, the house itself (doors, clock, wires, sensors, etc) is the hardware. The hardware is never changed once you build the machine. The firmware is sometimes designed to be changed periodically. The software is changed all the time. Again, hardware is tangible and refers to material components. Firmware and software are abstract things. They represent the collective open or closed state of doors. An analogy would be that if I raise my hand, I can represent a "1" value and if I lower my hand I can represent a "0" value. I do not change who I am by raising or lowering my hand; however, the information of whether my hand is raised or lowered can be used by other people to help them carry out an informational algorithm.
 +
 
 +
When we flip the switch to start up the clock, the algorithms encoded into the doors' open-or-closed state will be carried out. Here is what this means. At each clock tick, each sensor tests whether its door is open or closed and then helps potentially activate the motor controlling a different door to either open or close. In this way the current state of each door (open or closed) helps define the state the doors will enter at the next clock tick. This testing and activating happens at every tick until the "halt" state is reached or until the power is turned off. The state of groupings of doors can be used to represent any number, letter, or other symbol. The way the sensors and motors are wired together on these doors representing numbers (letters, etc) enables certain mathematical and logical operations to be performed on them. In this way, and as proven mathematically, we can carry out any discrete algorithm, any finite set of steps, possible. The starting state of all the doors when the clock first starts to tick will determine what algorithm gets performed. This will be the effect that this house will mimic until the next reconfiguration.
  
Now we add software to this house. Adding software means reconfiguring the doors of the house. One group of doors in the house is never changed because they represent the "firmware" that allows the house to work as a general purpose computer. But every other door might potentially be set, either into the open position or into the closed position. This second group of doors represents the new software information added to this computing house.
 
  
When we flip the switch to start up the clock, the algorithms encoded into the doors' open-close state will be carried out. For example, at each clock tick, a typical sensor testing whether its door is open or closed will help potentially activate the motor controlling a different door to either open or close it.
 
  
 
What defines the behavior of each door-sensor pair depends on the design of the house (how it was wired) and essentially defines the instructions the house understands, whether it looks at doors in groups of 32 (32-bit computing), etc. Each such distinct new house would constitute a new "computer" that potentially would be patentable, but **if we keep the house's wiring, capabilities, limitations, etc (its entire potential behavior) identical and then add new software (ie, change the configuration of the doors prior to turning it on again), we have not created a new machine but have simply come upon a new way to use the existing machine**.
 
What defines the behavior of each door-sensor pair depends on the design of the house (how it was wired) and essentially defines the instructions the house understands, whether it looks at doors in groups of 32 (32-bit computing), etc. Each such distinct new house would constitute a new "computer" that potentially would be patentable, but **if we keep the house's wiring, capabilities, limitations, etc (its entire potential behavior) identical and then add new software (ie, change the configuration of the doors prior to turning it on again), we have not created a new machine but have simply come upon a new way to use the existing machine**.

Revision as of 09:39, 24 November 2010

One method used to circumvent the limits of software patentability, is to claim not "software" but "software and a computer". The goal is to present one non-innovative object (the computer) and one non-patentable object (the software) and get a patent on the combination. The argument made is that, when the software is put on the computer, the computer becomes a "new machine".

One example of this logic being rejected by the US CAFC (appeals court), is the in re Alappat decision, which said:

As the player piano playing new music is not the stuff of patent law, neither is the mathematics that is Alappat’s “rasterizer.”

The point of these analogies

Our goal is to show how computers are the same as other things whose use cannot be patented. When you use a record player, you get music. The music might be technical, innovative, new, etc. but no one will ever get a patent on use of a record player. This page collects other examples to show why running software on a computer can't be considered patentable.

Brief analogies

Calculator

A basic calculator does not become a new calculator when you punch in a new calculation for it to perform.

Car

If we have patented an automobile which can drive anywhere, we cannot then come back and file patents for driving from Albequerque to San Diego, etc. -- the more general patent already applies.

Human

A human performing a set of steps does not become a different human when he or she changes to perform a new set of steps. The human is simply following a new configuration in his or her head.

Similarly, a computer system running different software is still the same (already patented) computer system.

Fingers v. fork

A human using his/her fingers to scoop up food does not become a fork. Similar effects can be achieved through completely different "machines".

Long analogies

House

A house, whose components and behavior will be described, can be made to be a full working computer.

The house has doors, motors, sensors, wiring, and a clock. These tangible components are called "hardware". They are built once and their behavior is never changed afterward. Doors open and shut, clocks tick, etc, all according to design. The quality and construction of the doors, clock, sensors, etc, can be patented. These are all tangible things constructed.

Software is intangible. Software is information. "Creating" software does not create anything tangible. When we add software to the house, we simply rearrange some of the doors in the house (into the open position or else into the closed position). Creating software adjusts the position of components of the house. How can we represent a value of 1 vs 0? By opening a door rather than closing it. Similarly, we can raise our hand vs lowering it. Creating software does not create anything tangible. Creating software rearranges. We open a door or close it; we raise a hand or lower it. We open a pair of scissors or close them. We turn on a light or turn if off. We don't create a new house, person, scissors, or light when we add software to these things. Software is just information. The value in software depends on what we do with that information.

In more detail...

In the case of our house, sensors collectively interpret the software (the state of the doors) and then enable the motors to move doors. Software in a given state thus leads to software in a new state at each clock tick. Whether a given door is open or closed impacts if some other door will open or close. How one door affects another door (at the next clock tick) is defined by the wiring of the sensors and motors. What the software information means is defined by the hardware.

Human beings can perform the same behavior of this house. The doors are our arms. We can raise them or lower them. The clock ticking is one lead human shouting continually each second so that all can hear: "NEXT... NEXT... NEXT...." The sensors sensing doors open or closed are the eyes of the humans looking at the hands of other humans to see if they are up or down. Each set of human eyes if fixated on a particular set of arms. The motors are the arm muscles of the humans that will raise or lower the arms.

Instead of humans we can use light bulbs. Instead of bulbs we can use lots of paper and write or erase marks on associated portions of the papers.

Instead of using these bulky mechanisms, we can also use very small parts that work very fast.

OK, now let's talk about algorithms and brains. Let's look at "firmware" and how it differs from software.

There is one set of doors in the house that are set when the house is built and are possibly never changed again. These firm doors are called firmware. These doors serve as a simpleton brain for the house. These doors are wired in a particularly clever way and define a core basic set of "instructions" that the house will understand from its software. This little simple firmware brain has one job: to repeatedly look at the door configuration in a certain other place (software) and, based on the configuration it finds, interpret it as an instruction and instruction data. When done with one instruction, go to the next location and keep interpreting over and over the doors as instructions until you reach the "halt" instruction, at which point the house will seize computing. The location of the next instruction is defined by the size of the prior instruction and usually means right after it, unless we encountered the "jump" instruction, which tells the simple brain to look for the next instruction elsewhere. An instruction such as "add" is handled by looking at the two sets of doors that will be interpreted as numbers (eg, 128 could be the interpretation of eight doors set as open, closed, closed, closed, closed, closed, closed, closed, in that order). And instruction such as "move" might copy the following 8 doors into some other group of 8 doors. How do we know which set of doors to change? Every 8 doors has an address (eg, 1, 2, 3, 4 .. to designate the first set of 8 doors, the second set of 8 doors, etc). Thus, the simple brains first finds that the next 8 doors has the instruction "move" and it is followed by 8 doors that refer to a value (eg, 57: ) and by another 8 doors with an address (eg, 12 ). So the simple brains moves 57 into the 12th set of doors.

This firmware magic is effected with the wiring of sensors and motors on one set of doors representing the firmware. This is a special location generally not accessible to software instructions. For example, we usually cannot try to "move" into doors that hold firmware some other value because the system is not wired up to enable that. The firmware addresses don't exist, so we cannot reference them. We can only reference other software doors. Firmware is thus almost an extension of the hardware. It is a simplified brains that defines the instructions the house will understand from when software is added.

We can forget about firmware and simply call it "wiring", but it shows that there are two brains in play. The first brain is very "simple-minded" and unchangeable. The second brain is the software we add to actually perform a useful computation. So in referring to brains, it helps to be aware that there are two levels. One level is hard-coded into the machine by the time you buy the machine, and it does something very important to the functioning of the machine but extremely useless to humans that want to effect a given computation. Meanwhile, the interesting stuff comes from the software algorithms humans create. This software will be limited and defined by that simple-minded instructions set the firmware enabled. From the computer software developer point of view, firmware doesn't exist or can be abstracted as hardware, but from the view of the engineer designing a new computing hardware, he or she might use very low level computing chips built by someone else that will require a new instruction set to be "programmed" into it in a way that will be consistent with the other hardware components being designed by the engineer. So to some hardware engineers, firmware is software.

To get back to the humans that were simulating the computing house, each human will always follow a piece of firmware, a simple, dumb algorithm. In contrast, software is the initial configuration of raised or lowered arms that will set everything in motion. While the humans each locally perform a simple-minded raising of arms based on simple (firmware) rules applied to a few things seen with the eyes, a complex (software) algorithm gets effected collectively by them all. Note that the software (ie, the configuration of hands) comes in a near infinite number of possibilities. The software developer does not change what each human does but does leverage that information to design a complex software algorithm.

Adding software does not create a new machine. Adding software is nothing but a writing of instructions and then handing it over to the "machine" that will execute those instructions.


Rough notes:

These connections define many features of this house, such as whether the house will be 32 bits (meaning the sensors-motors collaborate to effect logical and mathematical operations on door values, 32 doors at a time). as if it were one number) and which instructions the house will be able to perform. make up the rest of the important components of this computer., and a motor per door to open and close that door. This house is the computer. It is hardware. It can be patented. The components of this house are never changed once we build the house. That is, the hardware is defined one time and remains fixed until the computer is destroyed.

Now we add software to this house. Adding software means reconfiguring the doors of the house. Each door can be open or otherwise closed; thus, the information contained in each door's state is binary: 1 or 0 are the only values possible for a single door.

A first group of doors in the house is configured once when the house is built, and that configuration is essentially kept fixed in place forever. These firm doors ("firmware") hold the mathematical information necessary to allow the house to work as a general purpose computer (to cycle repeatedly reading and interpreting "instructions" encoded in other doors).

Every other door might potentially be reset over time, either into the open position or into the closed position. The state of these doors is the software.

Software and firmware are simply information. The hardware, the house itself (doors, clock, wires, sensors, etc) is the hardware. The hardware is never changed once you build the machine. The firmware is sometimes designed to be changed periodically. The software is changed all the time. Again, hardware is tangible and refers to material components. Firmware and software are abstract things. They represent the collective open or closed state of doors. An analogy would be that if I raise my hand, I can represent a "1" value and if I lower my hand I can represent a "0" value. I do not change who I am by raising or lowering my hand; however, the information of whether my hand is raised or lowered can be used by other people to help them carry out an informational algorithm.

When we flip the switch to start up the clock, the algorithms encoded into the doors' open-or-closed state will be carried out. Here is what this means. At each clock tick, each sensor tests whether its door is open or closed and then helps potentially activate the motor controlling a different door to either open or close. In this way the current state of each door (open or closed) helps define the state the doors will enter at the next clock tick. This testing and activating happens at every tick until the "halt" state is reached or until the power is turned off. The state of groupings of doors can be used to represent any number, letter, or other symbol. The way the sensors and motors are wired together on these doors representing numbers (letters, etc) enables certain mathematical and logical operations to be performed on them. In this way, and as proven mathematically, we can carry out any discrete algorithm, any finite set of steps, possible. The starting state of all the doors when the clock first starts to tick will determine what algorithm gets performed. This will be the effect that this house will mimic until the next reconfiguration.


What defines the behavior of each door-sensor pair depends on the design of the house (how it was wired) and essentially defines the instructions the house understands, whether it looks at doors in groups of 32 (32-bit computing), etc. Each such distinct new house would constitute a new "computer" that potentially would be patentable, but **if we keep the house's wiring, capabilities, limitations, etc (its entire potential behavior) identical and then add new software (ie, change the configuration of the doors prior to turning it on again), we have not created a new machine but have simply come upon a new way to use the existing machine**.

Maybe it takes creativity, luck, analysis, etc, to find a good set of doors to open and close (for example, mathematicians and physicists try to solve new problems by coming up with such a configuration), but we are most certainly not creating a new machine. We are reconfiguring the state of the machine, reconfiguring its doors to be either opened or closed. And, further, the machine, in any of its states, does nothing but process information in a way any human could by knowing the initial state of the doors. Since this is just information processing (digital in nature) coupled with ordinary conversion to (from) analog form through standard peripheral devices (see below), we do not need a slow human or a bulky house for the digital processing, but can instead use a modern digital calculator (the "computer") which uses very tiny parts that use up very little energy and have very little mass so can move very fast.

This modern computer already exists and can be bought very inexpensively in many stores around the US. It's just a glorified pocket calculator. That same modern computer can run essentially an infinite number of distinct algorithms. We just have to set the initial configuration of "open or closed doors" appropriately and the computer will do the rest automatically. We are not creating a new machine. We are configuring an existing machine's "doors" to the *exact* same opened or closed position as we would if we were dealing with a computing house.

To see the results and interact with the gigantic computing house more easily we take a standard display monitor, keyboard, mouse, etc, and attach it to the doors that are responsible for holding the values inputted into and outputted from these peripheral devices. We would use ordinary peripheral devices for this in the expected way and for the designed purpose. These all might have been patented. What goes in and out of them is just data in the proper understood format, eg, to be directly displayed on the screen as colors. Every image can be trivially digitized to be seen or vice-versa to be marked as door open/close configuration. At the time we built (and perhaps patent this computing house), we also create the adaptors that change the electrical signals of these peripheral devices to signals that drive the motors corresponding to the proper set of doors. We note that because the house will be very slow in comparison to a modern computer, the display screen will be updated very slowly (so we won't be able to watch a film except over a long time like perhaps months). We note as well that we would need to use at least about the number of doors as we might find inside all the houses that exist in the US today (and this would run only very crude programs with low resolution graphics).

Related pages on ESP Wiki

External links