Is not the BIOS in most computers 'firmware'?
By my understanding, yes. The overall package could not function in any way without it, it has to be in place at power-up, and it is not user-alterable.
Having thought about it today, I think I can convince even the most sceptical of firmware as a separate entity (even if the exact boundary between firmware and software remains debatable):
Most electronics hardware today is designed using software tools - CAD, simulation, description languages which compile to produce logic definitions. I think anyone can accept that, once implemented, the hardware contains no software, even if it was designed using software.
Suppose the most efficient or effective way to design and implement the required functionality of the hardware is for it to execute instruction codes embedded in memory - apart from anything else, this is an effective strategy for de-risking design changes or corrections later in the design cycle than the hardware design freeze pre-manufacture. The hardware is still hardware, but memory accesses and the consequences thereof are an integral part of its design. The only distinction is that code is being executed from some kind of modifiable store - even if "modification" requires removal and replacement of a write-once ROM chip.
Now suppose the function of the ROM chip is replaced by a custom chip, designed (using software tools) to have the identical electrical and functional characteristics as the ROM chip - except instead of being implemented by programming the fuses of a ROM it is implemented purely as logic gates. Although designed using software, there is now nothing in the hardware which corresponds with a programmed element, but the hardware still operates identically. The programming is an intrinsic part of the hardware design, and that's firmware.
One definition I've seen places firmware in the area between software and hardware.
That is one way of looking at it. Firmware is generally needed in order for hardware to run software. The firmware designers generally need an intimate knowledge of the hardware, less so the software designers operating at a greater level of abstraction. For that reason, firmware design is generally within the hardware design department.
Probably known in my undergraduate days as microcode.
Microcode is a specific type of firmware. In the days before single-chip processors, a processor was constructed from simple logic elements, and the easiest way to do that was to build a very simple processor with just enough functionality that it could be programmed to emulate a more sophisticated processor - by running many simple instructions very quickly (which in those days was still very slow). In particular, the instruction word was very wide so that it had fields to directly control the source and destination of data, the arithmetic process to be done on it, any conditional test on the result, and the jump address to be executed if the condition is met. So, for example, in 48 bits might be encoded "fetch data from registers 16 and 31, subtract them, store the result in register 8, transfer execution to address 319 if the result was zero (continue if not)". Some might recognise this strategy as developing into RISC.
The point is that this microcode is used to implement the more familiar (and compact) instructions of macrocode (machine code), so that (say) a subroutine call is only one macro instruction, but may require many micro instructions to decode it and perform all the functions required by it (fetch the target address of the subroutine call from the next program memory locations by incrementing the macro program counter that indexes them, copy the macro program counter register to memory indexed by the stack pointer register, increment the stack pointer register, load the macro program counter register with the new value). The code implementing the functions to perform a "call" instruction is microcode, which ran at a few MHz and therefore the macro code ran at maybe 1 instruction per microsecond if you were lucky. I cut my professional design teeth on this stuff.
To speed things up, more sophisticated processor design implemented more of the functionality directly in hardware (made possible by increased integration shrinking everything), but then more sophistication was implemented in microcode... and then speeded up by integrating more of it directly in hardware... etc. I have no idea how much of an Intel Xeon processor (or whatever) is implemented in hardware or as microcode - it's irrelevant to the user, all that matters is what happens at the pins of the chip (or, in my early design career, at the contacts of the circuit board connector). If an instruction takes more than one clock cycle to execute though, you can be pretty sure there is some microcode coordinating it.
So what's the difference between microcode and firmware? Microcode is firmware, but so is the programming of programmable logic such as PLAs, FPGAs etc - devices which do not run code to implement a program but use embedded memory to directly control the flow of logic levels between logic gates and registers; programmable analogue arrays which implement a variety of amplifier, filter, etc functions on an analogue signal using standard hardware; any code embedded into single chip controllers such as run your washing machine or the electronic dashboard instrument panel in your car; etc etc. These are not microcode, but they
are firmware (embedded within the device to define its functionality, set by design, and not normally alterable by the end-user). Thus "firmware" has a wider definition than "microcode".
As mentioned above, firmware is typically closely tied to the hardware and is the preserve of the hardware design engineers (although the softies may well also have input), but it has an important distinction from hardware or software even from the end-user point of view: hardware can't be changed without getting out a soldering iron to make circuit modifications; firmware has the possibility of being altered post-manufacture by a formal update process to implement design corrections or changes; software is free to remove, change, modify, or add to at will. Humax's "software" update process (which started this discussion) supplies an image file for the user to apply by a specific procedure, as a complete unit, on a take-it-or-leave-it basis (or automatically with no choice at all), and it's essential to the operation of the equipment rather than loaded post-power-up. It's firmware, and erroneously calling it "software" does nothing to promote public understanding.
Hard: not alterable except by hammer and chisel
[fig.];
Soft: easily reshaped;
Firm: malleable, but with resistance.