Why Is Hardware So Easy and Software So Hard?

Perhaps I'm showing my hardware bias, but it seems to me that in the embedded world hardware design has been much easier than software design for many years. I'm talking primarily about digital hardware design, using blocks of logic with well-defined inputs and outputs. In ages past, you took a few LSI (large-scale integration) and MSI (medium-scale integration) devices, along with some memory, and connected them on a printed circuit board. It was (and still is) very easy.

Today you probably use an FPGA, along with memory and maybe even an MCU. You might even have a power module or two and connectors to other boards or a chassis. You might even have a wireless peripheral or an analog-to-digital converter.

These are very well-defined "blocks," with standard interface buses. Even on the FPGA, you are just using the same design technique -- except you are now connecting a "handful" of predefined functions (intellectual property cores) with standard buses, memory, and a few fixed-function peripherals.

The pattern here is fairly simple and has been successful for many decades. Just connect some well-defined high-level blocks (and they keep getting bigger as we integrate more functions onto a device or into an IP core) to create the system or subsystem you need.

MORE FROM DESIGN NEWS: The PCB Killer: Chip-Level Modules Are On Their Way

A good example of a typical printed circuit board with a mix of FPGA and standard components and connectors is Diligent Inc.'s Zybo development kit for the Xilinx Zynq SoC FPGA family. Coincidentally, I'm using this board to teach my next Design News Continuing Education Center (CEC) course, in July. Look for more information about this in my next post.

The tricky part starts when you need to write some software for the MCU or the FPGA. The hardware designer would approach the problem by asking, "Where are the well-defined modules I can use to build my software design?"

We expect common interfaces for high-level functions, predefined memory blocks to hold our various structures, tables, and initialization vectors. Many times hardware blocks are easily customized with parameters and initialization registers. Where are the customizable code blocks we can use for common algorithms and structures?

Now we might be lucky and find a motor control algorithm or some digital signal processing functions that is fairly high level. But what are the chances there is a common interface or memory buffer structure that seamlessly interfaces between the main blocks? There are probably plenty of drivers that help us connect to the interface components like a UART or Ethernet port, but these are usually only low-level functions that make it easy to control the actual hardware on the MCU or FPGA.

So I think that embedded software is hard because the common design "flow" is one of building up from the ground floor. It hasn't allowed us to design software with a hardware "flow." Give me a wide selection of standardized software "components" with common "buses" just like we have in the hardware world. I just want to code a few control sections and maybe a "special sauce" algorithm.

 The blocks approach works in the digital hardware world. Why can't we do it for software?

Warren Miller has more than 30 years of experience in electronics and has held a variety of positions in engineering, applications, strategic marketing, and product planning with large electronics companies like Advanced Micro Devices, Actel, and Avnet, as well as with a variety of smaller startups. He has in-depth experience of programmable devices (PLDs, FPGAs, MCUs, and ASICs) in industrial, networking, and consumer applications and holds several device patents.