We’re Using the Word Firmware Wrong

I had an interesting discussion the other day about code written for an embedded system. I was speaking with Voja Antonic about ‘firmware’. The conversation continued forward but I noticed that he was calling it ‘software’. We later discussed it and Voja told me he thought only the parts of the code directly interacting with the microcontroller were firmware; the rest falls under the more generic term of software. It really had me wondering where firmware stops being firmware and is merely software?

The topic has remained on my mind and I finally got around to doing some dictionary searches. I’m surprised that I’ve been using the word differently and I think most of the people I’ve heard use it are doing the same — at least as far as dictionary definitions are concerned. My go to sources are generally Merriam-Webster and Oxford English dictionaries and both indicate that firmware is a type of software that is indelible:

Permanent software programmed into a read-only memory.

computer programs contained permanently in a hardware device (such as a read-only memory)

According to this definition, I have never written a single bit of firmware. Everything I have written has been embedded software. But surely this is a term that must change with the times as technology progress so I kept digging.

Firmware Controls Hardware

Do I live my life by what the dictionary says? Honestly, I look up many words every day through the editing process here at Hackaday — so yes, I do largely follow the most widely selected definitions. At the same time, definitions change through their use in the vernacular. The fact that I’ve heard a large number of people in industry call their code firmware indicates that its definition is in flux. In these cases I like to see what the contributors at Wikipedia have come up with:

firmware is a type of computer program that provides the low-level program control for the device’s specific hardware.

There we are. I’ve still been using the term wrong but this fits what Voja put forth in our conversation. He asserted that the code directly accessing the microcontroller registers was firmware and anything built on top was software. This makes sense. But this gets pretty squishy as you being to think about it. A bootloader is obviously firmware, but the code you flash to a chip using that bootloader, is it part firmware, part software?

Evolution of a Term

The first EPROM could be erased with ultraviolet light.

Image by Poil CC-BY-SA 3.0

You can follow the evolution of the term by thinking back to the evolution of the technology. The earliest computers consisted of an ALU and registers (plus some way to interface with them). Once power was applied the computer did nothing until you fed it a series of instructions and data either by setting register values manually and shifting them in, or by a more automated method like using punch cards. But literally programming the computer every time you want to perform a task is a Sisyphean.

Enter read-only memory (ROM) whose earliest use was to store programs to run on general-purpose computers. This progressed forward with entire operating systems being stored as ROMs. Of course along the way, the indelible ROM became rewritable with advent of EPROM and EEPROM. The microprocessor was born and firmware started to be in devices all around us.

Today, we think of router firmware and bios firmware. Yes, these can be flashed through a special process, but they are the lowest level software running on the device and still obviously firmware. What we write for microcontrollers blurs that line.

As I said before, we’re writing embedded software which itself has firmware elements. Perhaps you will up your embedded game by look at the coding process in two distinct parts: writing the firmware that interacts at the hardware level (a hardware abstraction layer) and the rest of the software that uses that groundwork — menu systems, changing behaviors based on user inputs montiored by firmware, et cetera. But the process is by no means permanent. We rejoice in being able to flash code to a microcontroller thousands of times without issue, and even use on-chip debugging to alter code as it is running. We’ve come an amazingly long way since ‘firmware’ was originally coined in the 1960’s.

Through all of these justifications, if you flash the code to a microcontroller I still want to call it firmware. But I’m “wrong”. I’m really glad I stumbled up this topic in my conversation with Voja Antonic. He’s certainly someone who would understand the intricacies of this topic having worked as a computer engineer since the earliest days. One of my favorites from his is this EPROM emulator built in the 1990’s which replaces the older technology with the new hotness of a PIC microcontroller. Erasing EPROM took time, but this module could be left in-circuit and quickly reprogrammed for faster development cycles.

123 thoughts on “We’re Using the Word Firmware Wrong

    1. I agree, if its located on the chip, its firmware. If its loaded from an external device, its software/embedded. The real question is when does embedded software become just plain old software?

      1. I never see a firmware in opposition with software as I can see between a hardware and a software. Firmware is just a special case of software dedicated to run with a very specific hardware, wherever it may reside. “Firm” like not flexible software.

        1. …So, I use the .NET Microframework. My “firmware” is two things. First it’s a .NET interpreter/runtime and hardware drivers (written in C). Second it’s my .NET code which is interpreted dynamically (static classes and anything not GC’d directly from RAM). Furthermore, I do load “plugins” (DLLs) in runtime that are written by 3rd parties. My firmware knows nothing about these.

          Normally I target STM32F4/F7 chips.

        1. Depends, is that external flash-chip removable? We are stuck on a definition of RAM vs ROM. In the old days that line was clear. But really just because something is a flash-chip doesn’t make it any more user accessible. I would argue if it is loaded on a flash chip it is still firmware. If it is loaded from an SD card, it’s software.

          Think of it in terms of what a user would need to do.

      2. Firmware is an interpreter, it’s job is to take commands from software and interact with hardware. Most of us never have made firmware by definition. If we look at the Atmel chip from an arduino, there is a predefined instruction set. Could we not identify that as the firmware? Then there is the arduino bootloader, maybe this is a firmware? Well one thing we do know is the program we write can’t be… right?

        My understanding as the industry seems to identify a firmware as “the underlying software that enables an electronic device to do its job”. With that then software would be any program added on top of that layer. With that though, any arduino program would be firmware. And with that logic, on a computer the kernel would also classify as firmware.

        I would be curious what you all think about that?

        1. Even an EPROM can be erased with UV light and externally reprogrammed so I think the distinction is less about weather or not it can be re-programmed and more about weather or not he host system re-programs it.

          1. Even then there is no reason why you cannot add hardware in an embedded sort of way to erase a UV and re-programme it in circuit. Probably not sensible but certainly possible.

    2. The confusion comes from the modern differences between computers and embedded code.

      To find the defining difference you have to consider the difference in meaning between bootstrap, boot loader and boot code.

  1. It’s very simple, really. A piece of code becomes a computer program as soon as you can run it. It becomes software as soon as you package it so it can be sold as a product (hence -ware). It becomes firmware as soon as you put it in a product which you are selling.

      1. Well, if it can’t run Linux and is tied down to one OS (Looking at that secure-boot requirement from MS) then it is essentially firmware as that Macro-$haft OS is required to be “Flashed” onto a permanent storage… and if it gets corrupt: Hope the reinstall (re-flash) media is accepted!

        Heck, who’d thought the day when Microsoft tries to be more Firmware than OS!
        And who’d thought a spinning magnetic media would be treated the same as a Flash-rom!

        Only M$ could do it!

      2. Well, if it’s Linux on your router, you have no problems calling it “firmware”, so why not Windows on your laptop, if it comes pre-installed the same way, and might even be harder to remove or change? Because you don’t get “firmware updates” that you could install yourself?

    1. hmm, debatable. Most assembler programmers have stacks of software in the form of macros (functions in C, classes in java) That are used to make writing a programme much faster. They are all software but not of any use on their own.

      1. It’s code, but its not any kind of -ware until it’s an item you can distribute. Package it into a library or bundle it with a development kit, and you have software. Until then, it’s just code.

    1. If the purpose of language is communications then how effective is the word “firmware” in that goal? If I say “firmware” will the audience get an accurate picture of what is trying to be conveyed, or is there misunderstanding and my space probe veers off course, or the rocket explodes upon launch?

  2. IMO a firmware is a dependency of a particular piece of hardware, while software can be interchanged at will.

    An game console cartridge is software since the user can swap them out for different titles. But a game console’s BIOS is firmware since the hardware won’t function as designed with any other program in that memory device.

    Better yet, many hard disks have part of their firmware on the disk platter itself, alongside the host PC’s software and data on the rest of the disk. Again, the hard drive won’t work properly if someone replaces the firmware with a program that plays music over the voice coil.

    1. I thought about mentioning gaming cartridges because by the dictionary definition that is on a read-only memory which makes it firmware.

      As far as disk drives go, a previous revision of my article mentioned that solid state drives mean that all the software I install on my computer is being written to flash. But even with that bit of knowledge spelled out, it doesn’t really sway the argument.

  3. If I could coin a new term for this genesis of firmware and software and the transitory and evolutionary aspects of the technology, perhaps we could call it “Firstware” ? A blend of firmware and software – the stuff that, after ‘true’ firmware has gotten the CPU and associated hardware into a ready state, takes over – the starter fluid for our engine, if you will.

    Just don’t get surly about it, ok? :)

    1. Why not, “Bootware”
      Because, essentially the idea of most firmware is that it is long-term software designed to boot their target hardware in a state for use…

      Wifi, so the registers are in a sane/expected state and the RxTx on the PCIe are ready to transpose onto the internal Nth-bit-wide databus.

      HDD, prep the caches, check the heads’ continuity, check other stuff, spin up the motor, check current is still safe, read off S.M.A.R.T. software into cache/integrated-RAM, set up the internal ATA bus, set the serializer/de-serializer translation buses, run a DMA loop between the ATA bus and the head amplifiers.

      I-ME, set up encrypted environment, set MEBx software in Integrated micro-controller, do some questionable things, and on newer hardware: start the CPU x86-to-arm translator buses spinning, start the RAM spinning, and do other pre-startup stuff.

      IGP: sanitize the HW interface, dump all i2c EDID ROMs into a R/W table, gather number of rows from EDID (N), Count up to N rows for 60 times a second… connect DAC to EDID connected outputs, so forth…

      Essentially Firmware is to get hardware into a known state,
      So an arduino with an x86 emulator/virtual-machine would therefore be considered to have firmware on it to put it into a state of executing x86 instructions: A ready state…. however if said arduino then gets the weather and displays it… it is no longer code to put something in a ready state, instead it is in a busy state: including busy waiting for user input.

  4. My definition – Firmware is tied to specific hardware and will not run on other hardware. Although usually stored in non-volatile chip storage (eg, Flash, nvRAM, ROM) that isn’t absolutely required. Economics and practicality are such that for most products it makes no sense to do otherwise.

    Some vendors (eg IBM) use Microcode as a synonym for Firmware. My belief is that this is only true for a package containing code for a microprocessor, ie all microcodes are firmware, but not all firmwares are microcode. For example, I worked on a hydraulic controller that had three types of microprocessor (several DSPs for signal conditioning, a general purpose CPU for user interfacing, and DSPs for control loop outputs) in addition to programmable gate arrays to tie them all together. The code for all of them distributed as one firmware package

    1. I am under the impression that microcode is “hard wired” to a specific processor and its peripherals.
      In other words, a different processor in the same family won’t work, and the microcode also addresses specific families of peripherals, i.e. SATA, or SCSI, DRAM v. SRAM…

      1. Except for IBM (which invented Not Invented Here), I’ve only heard microcode used in reference to CPU instruction decoding.

        In fairness, sometimes there’s not a difference between the two. Many CPUs run thousand+ micro-op microcode instructions for certain tasks like power-on initialization. AMD Opterons would execute power-on microcode that would (among other things) fire up the clocks, start the HT links, probe the HT topology for the southbridge, and start fetching instructions from the BIOS on the southbridge if one is directly attached. This wasn’t in some embedded management processor, this was driven by one of the compute cores on each die by microcode in ROM.

      2. @[Ren]
        Have a look at Transport Triggered Architecture

        Your actually getting closer to the original meaning of firmware.

        Some very early computers did not have a fixed instruction set architecture. Instead they had microcode that defined the instruction set and of course software would NOT run unless the instruction set configured matched the instruction set in the software. That microcode was the original “firmware” because it bridged the co-dependency between hardware and software.

        Others here are talking about NV-RAM ROM SRAM RAM FLASH as if any of these are a defining factor but in reality today just as has historically been the case “firmware” can be run from a variety of sources even punched tape.

        Now days (in my opinion) firmware is better designated by it’s function rather than where it is stored.

        The first computers had to have the bootloader keyed in. Later computers had a small ROM like data source that was the bootstrap. In both cases the bootloader or bootstrap load in the boot code. The boot code then loads the operating system. In old computers the OS included all of the I/O functions as all OS’s were propriety to specific hardware.

        On a modern computer the bootloader executes at the end of the BIOS (which has done nothing yet) and will do something like load and execute the code from the boot sector of the hard drive. From there the OS loads but has one big difference to older computers.

        The OS’s are no longer propitiatory to specific hardware and the co-dependency code in the middle that has the function of matching the co-dependency between the OS and the hardware is the modern definition of firmware for a complex computer.

        Now with modern micro-controllers most of the delimiting points above fade away into a grey scale.

        Technically something like a Arduino appears to have firmware as the same code can run on various hardware. The problem is that it is pre-compiled in C and isn’t “firm” or firmware.

        Things like small SBC like the Raspberry Pi have firmware but most micro-controllers have hardware dependent code so they technically don’t have firmware by the functional definition.

        So I think we are asking the wrong question.

        We could ask “What *was* the definition of firmware” and this question I can answer.

        Or we could ask “What *is* the definition of firmware” and I have not a clue now because it is used in so many different ways today.

  5. We need to describe the middle of the continuum; hard -> firm -> ? -> soft -> vapor.
    Something between firm and soft, eh?
    Plastic? Pliable? Wax? Rubber? Middle? How about midware? Loadable? Maybeware?

    1. Well there is Mediumware,
      The tasks performed has to rhyme with the intended task so that it is a doing word that makes no sense when related… for example:
      Safely removing hardware becomes:
      Baitly improving mediumware!

  6. Surely all of this is silly.

    It is all software, but firmware is a specific sort of software. The exact definition you put on the word firmware is certainly variable. In the old days it was what was placed in ROM — and to most end users just seemed to be part of the hardware itself. These days with flash things get more muddy. You might call a boot loader in flash firmware, especially if you never intend to fiddle with it or change it. So that is the key aspect of things in –my– point of view. Firmware is software that the end user isn’t expected to change and seems like part of the gadget.

    But the definition changes as the concept of the end user changes. What is firmware to me as a developer might be the boot loader – at least in some cases. But the software I write and put in flash may be firmware to a person I give or sell the device to.

    A dictionary is the last place to go to try to sort this out. Go look up “hacker” in your favorite dictionary.

    And whatever you do, don’t call me Shirley.

    1. True… what is particularly misnamed is phone and router firmware, where it’s often the firmware OS and applications (configuration wizard or texting app for example.) that are the bulk of it…. sometimes it’s not even changing the true firmware when this is flashed.

    2. I’m with Shirley on this one. As time moves on, people will have different concepts of what words like this mean because the technology and methods of “programming” change. For those that are saying HDL is definitely NOT programming, I have to disagree. When you write code the get processed and changed by your computer to transform it in to some other form that is formatted for the target, then I would call that programming. Firmware to me is just code/programming that once you get it right, if ever, then the target will run that every time you power it on to perform the function it was designed for. Software, on the other hand, is something that is still programmed, but the end user has the option of installing it and changing the functionality of the device to make it do something that they desire and may not have even been something the designer of the hardware could imagine. Software refers to programs that have the ability to change the function of the device in unexpected and undefined ways. Firmware is intended to make a device function in a way that was probably defined by a contract between the engineer and client. I’m getting older though and I’m drinking whiskey now, so… I’m probably wrong.

      1. My view is a little different and no, I am not saying that you are wrong.

        To me programming is associated with a Turing complete machine. HDL can create combinational logic and finite state machines that are not Turing complete.

        1. I think we might be splitting hairs here, but I do agree that programming is *associated* with Turning’s complete machine. I’m just saying that to achieve that “combinational logic” and other things defined by Turing (that I haven’t really researched), you still have to program them to instantiate them into existence. I think this would still be true even if the FPGA vendors would give us some more information (like Lattice), so that we could know every bit that we could manually put into them for configuration (kind of like flipping switches). Then again, I’m still drinking whiskey, and I’m also being “being programmed” by the things I’m reading, looking at, and otherwise. I wish my brain was firmware sometimes (when it was in a really good state that is).

          1. LoL

            Yes, Probably slitting hairs. Keep drinking the whiskey.

            I am getting old so now I have DAM – delayed access memory.

            In the early days of CPLD we got see exactly what was in the chip and what flipping which bits did.

            We had a very standard macro that was used in CPLDs like the 22V10. The same macro cells were used even up to the XC9536/9572 which were like 4 or 8 22V10s in one chip with extra interconnect.

            Altera then split the macro in half and came up with logic equivalents LEs.

            So now we have many metrics: gates, Macros, LEs LUTs.

            At least with macros you knew you had 1 register bit per macro.

  7. We may as well take a stab at defining “embedded software” while we are at it. In some devices the embedded software and firmware could be one and the same. But given that we run entire operating systems (linux, android) on phones and things like BBB and RasPi’s — do we want to call that firmware? Maybe. But what is interesting is that linux can be embedded software (or at least part of embedded software) on my phone let’s say, but I wouldn’t call it embedded software and certainly not firmware on the desktop I am typing on right now. Again I would argue that it depends on the purpose of the device and whether the end user is expected to change the software as part of using the device. Most end users don’t expect to change the software on their phones (nor do the phone companies expect them to). Different situation on a RasPi and different yet on a desktop. But what about a secretary or your grandma using a computer for word processing or to get on the internet. Maybe we start calling software on a desktop “embedded” then?

    The human mind, and especially certain human minds insist on clear black and white definitions. It is great fun when situations arise that make neat definitions difficult or even impossible.

    1. I rather have people taking a stab at defining [real-time].

      I’m working in the embedded field, and there are little problems with what is embedded and what is firmware (but there is a huge grey area), but those terms get their specific use within any company pretty quick.

      Real-time however, that’s the one that’s miss used and abused all the time for “really really fast”.

      1. Most of my career has been “real time” programming. And you might be surprised how much has been embedded and how little has been “real time”. But here you go. Real time is all relative to the deadlines in the project. If the project has deadlines and you miss one then the software is broken. That is real time. Fast is not really the crucial issue. Scheduling policies in a kernel can make real time impossible no matter how fast the processor.

      2. The AI folks managed to rebrand the field to “machine learning”, and I think “RTOS” needs a similar rebranding.

        How about “Highly Determinstic Operating System”?

        Hopefully those that paid any attention in first year CS classes can make sense of the term.

    2. I would say that “embedded software” is a misnomer. There is embedded hardware. Software that runs on it is just software like any other. It runs from NAND/SD/M.2 SDD/eMMC, a CFII HD, etc. just like it would from a hard drive on a PC.

      If it runs from ROM/PROM you might call it firmware, though some will say firmware is the internal boot code, like Steppingstone in an ARM processor, which can pull in what is needed for U-Boot or uC/OS-III, FreeRTOS or whatever.

  8. All firmware is software, but not all software is firmware. Even the dictionary definition says that firmware is “permanent software”. The distinction between firm and soft in this case is that the firmware isn’t intended to be replaced, is distributed with the hardware as a part of the hardware, and “firm” in a sense.

    The distinction between software and hardware is much clearer — hardware is the physical chips, platters, circuit boards etc that are physically “hard”. Think of hardware as the brass drum with pins protruding, that vibrate the reeds in a music box. Then think of the software as the specific way the pins are arranged to produce a tune. Firmware is then the mostly permanent fixation of those pins to the drum. The easiest way to change out the tune in a music box is to replace the drum — you can’t easily reconfigure it. Thus it’s “firm”.

    1. As usual, “…except for when it’s not”.

      Many peripherals have their firmware in a blob that’s part of the driver on the host. Part of loading the driver involves copying the firmware into the device’s RAM, and usually re-enumerating the device after the firmware has had time to execute.

      The esp8089 driver does this, as do many other wireless chipsets.

      The Cypress EzUSB microcontroller is another example. EzUSB has only on-chip SRAM for code which gets loaded over USB from the host PC on power-up. The difference between a Saleae logic analyzer and an M-Audio Keystation USB-MIDI keyboard is which firmware the driver sends to the embedded EzUSB device down the USB pipe. Although the EzUSB SoC itself will execute either firmware, neither product will function correctly.

  9. Interesting. I first came across the phrase firmware in the Personal Computer World review of the ZX Spectrum in June 1982, and I’ve never thought to question the reviewer Peter Rodwell’s rough definition of something in between hardware and software.

    There are flaws with all definitions. People referred to microcode as being firmware, but… what about the Pentium Pro and similar Intel CPUs of the era? At least some of their microcode could be uploaded from the BIOS couldn’t it? But that’s not new; the pdp-11/60 made a big deal of its Writable Control Store: microcode you could load into the system at run-time from disk via the OS. I’m sure a number of computers used front-end computers or devices to load all the microcode: didn’t IBM invent the 8″ floppy drive for precisely that purpose. Cray super-computers did something similar (check out the hunt for the red boot code blog).

    I still think that the best definition is the ease at which you can modify it, which basically means if it’s in RAM it’s not firmware. If it’s loaded from disk it’s not firmware. Consider the Mac Classic from 1990. It had a minimal version of Mac OS 6.0.8 (called System 6.0.8) in the ROM itself. Now, that code went way beyond code that just interacted with the hardware, but it was most certainly firmware, given that it was impossible to modify it.

    This means that software held on flash is not firmware if you can easily change it: so smartphone apps aren’t firmware, but the whole of iOS or the android OS is, because you can’t easily change it (though with some effort you could downgrade or customise it). However, Mac OS X on a SSD is still software, because you can easily whip the boot drive out and replace it with another, or even mount another SSD drive as a boot disk.

    In any of these more subtle areas, defining firmware in terms of its ease of modification appears to work.

    1. In my yoot, in school we used a Univac, and the FORTRAN compiler was loaded as a stack of cards, then our programs were loaded from stacks of cards – twice I think. Two pass compiler. From the definitions here so far, that would all be firmware. You can’t write to punch cards and you can’t edit either, unless adding characters to the end of a line.

      1. My definition isn’t based on the media they’re stored on, but the media they’re run on. In the case of the UNIVAC all the programs would be running from Core though in the computer: the Core state is easily changed (just halt the UNIVAC and toggle some bogus instructions in).

        Though in your example, even if we considered the program media, it’d still be software because it’s easily changed. You could grab the FORTRAN compiler card which provides error messages (or even where there’s a write command for text) and replace the text just by punching another card. You could remove a line of code from your fortran stack by removing the card – or switch cards around, thus editing the code to do something else.

        It’s a bit dodgy having the compiler actually on cards though isn’t it? Won’t it wear out relatively quickly? I imagine the normal run would be to load the compiler (in this case you really are loading the program, since the stack of cards might be quite heavy) then put the job lot of source programs through the hopper to produce the intermediate representation. Then load the second pass of the compiler and run the intermediate stack through the hopper producing object code (a much smaller subset, since most programs would fail with syntax or other compilation errors). Finally you’d delete the compiler and run the set of object programs.

        In any case, the cards would get reloaded every day, surely a major problem?

          1. The different manufacturers used different units over different periods to describe their devices.

            The Xilinx XC9536 has 36 macros
            The Xilinx XC9572 has 72 macros
            The Xilinx Spartan 3-500 has 500,000 gates
            The Altera EPM240 has 240 Logic Equivalents (LEs) which is roughly 190 macros
            Other manufacturers use Look Up Tables (LUTs) or other units that make it hard to compare competing products because there is no easy or accurate way to compare the different units.

  10. Alan Kay: Remember, it’s all software, it just depends on when you crystallize it.

    So I think firmware is sometimes “should I have crystallized that?”, and sometimes it is “I was going to crystallize it, but I need 10 more products from this die.” but that’s just me.

  11. The terms software and hardware clearly designate “things” (albeit virtual, in case of software).
    The term firmware -IMO- is more on the line of roles a particular chunk of software has, as are the terms operating system, application.
    So it becomes unimportant on which media -ROchips, RWchips, punched cards, paper or magnetic tapes,magnetic or optical platters a particular chunk of software resides.

    Firmware is software in charge of “waking up” a device or gadget to the point “it can breathe” and fetch a small or large operating system with possibly one or more application (which in turn may or may not be deliberately and arbitrarily be choosen )nd/or changed from one instant to the next).

    Dictionary writers and editors are scientist, but they have a long tradition of also sometimes being a bit short minded when it comes to terms of domains near theyr horizons.
    That said, I accept that back then when the term firmware was “fixed”, all firmware was in chip-ROMs and no variation of this was in sight. Implied, such SW-in-a-chip was deemed to not be changed, at least not easily, and thus would hardly contain more than “bootloader and BIOS functionality”.
    Some decades flew by and technology progresses allow us today to store software with ANY role (FW, OS, Apps) on ANY media (chips or others).

    Yes, the dictionaries shall think about rewording (refining!) theyr definition of the term firmware. But at the end of the day this would not really change the original spirit of the term firmware, just the “depicting” and explaining words around it.

    IFF the DICTionary-makers absolutely cannot reword/complement this definition, THEN DICTionaries also are ROM FIRMware and theyr makers DICTators :^)

  12. Honestly, just because fuse proms, rope memory and even early eproms led to devices that were easier to program like FLASH memory, doesn’t mean we need to change the purpose or intent of what the word firmware means. While some might argue that because legacy magnetic core memory held its contents even after the power was removed made it non-volatile, it is certainly where your software “runs” and not like the firmware needed to make sure the system knows how to boot up. Firmware is basically that… the stuff that needs to be there for normal operation and while it shouldn’t change under normal conditions… it can be changed if required. In embedded systems, the firmware, to me, is the full contents of what gets installed during a “program upload” process. If the device also uses an SDcard for additional software or personality… its software.

  13. When it comes to certification all code is software. Even Verilog and VHDL. There was even a move to make any predefined data as software. Removes any wasted time over terminology since the certification was the same.

  14. I’ve been using firmware to describe Verilog & VHDL in recent years, as it isn’t software – and the eprom heritage seemed to also describe the nature of the Flash data that configures the hardware instantiation. The ‘firm’ aspect of the word doubly describing both the storage and use. Not correct perhaps, but seemed quite fitting.

    1. It’s probably fitting when you are explaining a Hardware Definition Language (HDL) in simple terms to those who don’t understand what a HDL is.

      Though technically the “firm” is part of “firmware” that like “software” is a programing language and a HDL is NOT a programming language.

  15. ___ Test: Is It Firmware? ____

    1.) Is it FIRM, meaning, not intended for someone to be altering it often?
    2.) Does it remain, as intended, on the hardware when the device is off and become active when the device is on?
    3.) Is it NOT an operating system?
    4.) Is it on a piece of hardware designed to be firm (like ROM)?

    If “yes” to the questions covers 90% or more of what everyone agrees is firmware, the test is “good enough” for me.

    There will always be grey areas and my inner INTP would love to disect it further…but why? Guess I’m not the hacker most people here are.

  16. How does the song go again???

    You like potato and I like potahto,
    You like tomato and I like tomahto;
    Potato, potahto, tomato, tomahto!
    Let’s call the whole thing off!

    You say software and I say firmware;
    You say wetware and I say hardware,
    Software, firmware, wetware, hardware,
    Let’s call the whole thing off!

  17. It doesn’t matter, does it? It’s executed programming running on an electronic system. If you call it firmware and I call it flexware, it still means the same thing to me. I KNOW what we are talking about, and differentiating the proper word for the programming between working minds doesn’t make a bit of difference.

  18. Firmware. Executable code in ROM.
    Very useful as a BOOTSTRAP program at powerup so you don’t have to single-step the address bus to hand key 2048 8 bit bytes of program code in by hand WITHOUT A SINGLE ERROR to get your computer up and running after power up. aka Monitor. See Also: Basic-in-ROM. Often used to enable other storage devices to load a larger operating system or language.

    Some want to change the definition. (find your own word then, eh? Globzikillions available, just make one up. )

  19. Firmware; code that runs on hardware, whose primary function is not to run other software.
    OS; code that runs on hardware, whose primary function is running of other software
    Software; code that runs on an OS
    Storage type does not matter. Basically how I see it anyway

  20. I thought about this at great length and decide that we need to abandon the word “firmware” and start using an entirely different word. I would like to suggest “underware”. Note the spelling. Any software that lies “under” whatever you are doing (such as BIOS, bootloaders, and such) should be called “underware”.

    This should reduce confusion.

  21. In the past the term firmware has been used to describe that code written for a specific processor and board hardware. Boot code that brings up the board from reset vector to C environment. It initializes memory mapping, interrupts, board ethernet etc. VxWorks has used the term Board Support Packge (BSP) in the past. Usually a software and hardware team effort that can figure out hundreds of register settings on more advanced processors.

    Since the firmware isn’t running to program itself into flash it usually relies on hardware programming using JTAG or ICE protocols. The boot code on an Arduino uses hardware programming.

    Wetware that does this type of code often feels it is superior to mere application wetware.

  22. If it runs on a CPU then it’s software.

    If it configures some programmable hardware (FPGA/CPLD) and is written in a register-transfer language (VHDL, Verilog), then it’s firmware.

  23. Dictionary definitions?!? Bah, humbug! I reject your reality and substitute my own. And in my book, “software” is what you run on general-purpose computing hardware that isn’t meant to do anything specific without appropriate software, and “firmware” is what instructs appropriate hardware how to behave like a single, specific, defined appliance, with a particular role and functionality. Full stop. Software is what you use to process information. Firmware is what you use to animate a dead object. And sure, there are always overlaps and border cases – to a degree each of the two is also the other one, but that’s not the point. I’m not interested in which square foot of the grey area is light grey and which is dark grey – I’m interested in where I plant my pole flags, and I just told you that.

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.