26: Hardware Description Languages
Strictly speaking, hardware description languages (HDLs) are not programming languages, although it is easy to confuse the exact terminology. As the name suggests, HDLs are languages that primarily describe hardware, meaning any physical parts of a computer, and play a vital role in the development of any electronics.
Given the basic digital circuits we have constructed phenomenologically, these circuits grow in size to the point where our human minds cannot efficiently verify that they work as we have designed them. We need an effective way to verify them, deterministically, before we spend a lot of money on creating them. Given our digital logic posts from before, you will realize that a single misstep in any component, such as using a wrong gate or falsely connected multiplexer, will render the whole circuit useless or, worse, make it faulty in a hard-to-detect way.
Just like most special-purpose languages, HDLs were designed a long, long time after the first computers came to be, and only assisted hardware design after the hardware for it had been built. This meant that the first computers were not designed with the help of computers, but with paper and pencil. After the first computer began to emerge, many people had sought to create an HDL, hence why many different languages & computer programs were created in order to fill this need. Many of the languages described very specialized electronics, which mean that the world of electronics in the 1970s was plagued by a large assortment of software tools that checked/verified/created different hardware designs. Kinda like how cloud technology today is plagued by a multitude of vendors.
While the initial motivation of designing circuits using the computer (computer-aided design) had good intentions, the enthusiasm for the creation of new programs to verify hardware designs proved problematic for the industry. Many of the software tools built were incompatible with one another in addition to the fact that they needed to be run on specific machines, sold primarily from a single computer manufacturer. Vendor lock-in, a situation in which one cannot forego a vendor one has chosen to work with, was abound with computer-aided electronics design, which made designing electronics tiring and restricting.
If the computer holding the software data broke for example, it often meant that no more new electronics could be created, because companies likely didn’t have another machine with which to print the designs to send to manufacturers. If someone needed a replacement part for hard-earned designs in such a scenario, then one would need to go through the process of fixing a computer, which in would take time. The electronics industry was therefore reliant on computers, which created a linked industry, from computer manufacturing, to electronics design, to the radio/TV industry. In other words, if the computer broke, it had the potential to affect the entire population: if an adversarial country wanted to cripple the another nation, all they had to do was destroy computers.
Lack of working hardware could thus spell out a danger to fixing circuits controlling for safety, whether it be circuits inside nuclear power plants, or the power grids (some of which may be crucially connected to hospitals). The solution to this is have a single hardware language that works on all computers, so that one can transfer designs between them. Because no single vendor wanted to invest the money to create a unifying method, and because this problem was of national importance, the US Department of Defence (DoD) stepped in to solve this problem, initiating the development of a grand unifying hardware programming language in 1981.
The first version of this unifying language was released in 1983 and is still in use today. This language is known by its acronym VHDL, which stands for one of the longest acronyms I know by heart, Very High-Speed Integrated Circuit Hardware Description Language. The DoD initially kept the rights to this language, which invited due skepticism. Having a government entity that controlled the rights to the language and so, controlled the electronics industry (to a certain extent) meant that it was (non-engineer) government officials who would likely make uneducated decisions regarding the language. Regardless of the veracity of this statement, because Everyone knew that the language would have a significant influence on the entire electronics market, having the government control it was unpopular. And because it was unpopular, it wasn’t being adopted, thwarting the DoDs plans for a better future.
For this reason, the DoD gave all the rights to the language to the Institute of Electrical and Electronics Engineers (IEEE) in 1985 in hopes that they would adopt this standard across the whole industry. Lucky for everyone, past and present, this is exactly what happened.
Even today, VHDL is being used, because it gave us the first tools with which to standardize documentation for electrical circuits across all levels of abstraction, from the transistor level to digital gates and larger components, as well as standardize designs across the decades. Another HDL is Verilog, invented in 1983, at the same time as VHDL was released, but it was proprietary. Perhaps because it filled the circuit verification market, instead of the designing circuit one, the company owning Verilog survived for ten years without giving away their technology before they finally also gave it to the IEEE for free, without any restrictions on its use. The success of this event shows: Verilog is still being used alongside VHDL to this day.
As one an imagine, VHDL designs eventually ends up inside an integrated circuit, thus physicalizing the idea of design abstraction (i.e., fashioning many small parts into one unit) and making the computer a real thing. Of course, VHDL engineers don’t wake up every morning and design computers every day. Instead, they also build other types of components using either zero transistors, or more commonly, some number of transistors.
Because different circuits required hugely varying numbers of transistors, multiple levels of abstraction emerged in hardware design starting in the 1950s, which ended up having their own principles, ideas, and challenges:
Small Scale Integration (SSI): Circuits consisting of only around 1–10 transistors (1950s)
Medium Scale Integration (MSI): Circuits consisting of 10–500 transistors. Emerged with the advent of MOSFETs (1960s)
Large Scale Integration (LSI): Circuits consisting of 500–20’000 transistors. Emerged as a consequence of the squeezing together of MOSFETs on a single Integrated Circuit (1970s)
Very Large Scale Integration (VLSI): Circuits consisting of 20’000 to multiple millions of transistors in a single integrated circuit. Most computer components that we take for granted today use VLSI integrated circuits (1980s)
Whatever circuit one is building, HDLs attempt to unify the very lowest levels of these circuits (the transistor-level logic) up to the full electrical component that makes up a computer, even when millions of transistors are being used. This means that electrical/computer engineers working at any level of the design of a circuit, computer or otherwise, can use the same language to communicate or work together inside a common framework, exactly the intention of VHDL.
Such a tool is particularly useful if the people working in the same HDL don’t have the same background. Everyone using HDLs is an electrical engineer, but within electrical engineering, people use a variety of different transistor types and logics that have different physical characteristics that cannot be overlooked. Generally speaking, there are 3 circuit types that work with other types of transistors:
Transistor-to-transistor logic (TTL): Emerging as an improvement over the diode-transistor logic (DTL), TTL imagines circuits that consist mainly of transistors as opposed to other electronic components, such as Bipolar-junction transistors.
Emitter-coupled logic (ECL): This logic family mainly deals with circuits that amplify a voltage.
Complementary metal-oxide-semiconductor (CMOS): This logic family deals with circuits that are generally made of MOSFETs, or any other devices whose gates are made from metal-oxide and a semiconductor, but instead of the transistors being only one type (p vs. n), these circuits use both.
VHDL (and Verilog, I guess) therefore solved some long-standing problems in the industry, which was not only good for national security, but also for everyone working with the designs. Integrated circuit producers , for example, now only need to be able to know VHDL, instead of many different languages. Over time, given how well VHDL was, Vendors began to reject any designs that not coded up in VHDL, as this allowed for exact specifications with no room for misunderstandings. This trend continued, so that all other HDLs slowly died out.
Strangely enough, designing circuits with VHDL is a slightly restricted business since VHDL and Verilog have primarily been written for Windows machines*. Additional programs to support the language existed on machines other than Windows, although they were only a few, which in this respect, makes Windows more useful for electronics designers.
Now, we don’t particularly want to get into how VHDL and Verilog both work. They are, simply speaking, formal descriptions of software, which is a really boring way (although often the only way) to work with electronics across the whole supply chain. If one simply wants to play around to build a few circuits and see how they interact, there are better options.
In my opinion, the best way to start playing around with circuit design without having to buy actual electronics or use difficult-to-use professional tools, is the game Minecraft.
I am not joking. I know people who have learned circuitry through this game. In it, the game allows you to build digital circuits with redstone, a fictional resource that acts as wire. From this, the game allows you to build constructions that are, functionally speaking, transistors. From this, one can build universal gates, which means that you can now build any gate you want, and so (along with a few more clever uses of gameplay) you can construct computers.
You can build, and run a computer, within the computer program. People have done it as well, building circuits that work as entire computers into which one can load certain programs. Even crazier… because you can run anything on that fictional computer, you can run the game of Minecraft… inside Minecraft.
Obviously, they are nowhere close to as efficient or as fast as the computer it is running on, i.e. it has a much, much slower clock speed of 1Hz instead of a few billion Hz, which is what modern computers are capable of doing (1/1 billion computations per second. More on this in post 30). Nonetheless, it presents an excellent opportunity to gamify learning about digital circuits and to have more positive feedback from a program with balanced colors, calm sounds, and gentle piano keys, than ugly, difficult-to-understand VHDL or Verilog in- and output.
Besides, if you decide you’ve done enough circuit designing for the day, you can always switch to grabbing some tools and getting those diamonds. Just be careful not to dig straight down!
Footnotes
*While today, Windows operating systems are widespread, at the time, there was a significantly larger number of operating systems available, hence why it was restrictive at the time. If VHDL came around today, it would very quickly be recreated for other OSs.
BONUS: “Hello world” in VHDL
If you are reading this, and you don’t know how to program, can I perhaps interest you in potential party trick? Professional programmers don’t really deal with HDLs, so if you were to tell someone that you wrote your first program in VHDL, you will baffle them without end. You will likely only ever get two reactions: “What?” and “What the fuck?”
If you are on a mac like I am, then you can follow these steps to run your first program, the “Hello World” program, in VHDL:
1. Open your terminal (search bar: “terminal”)
2. You will need to install a software application called brew: The instructions for this can be found here. Alternatively, try running this command first:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"homebrew is an open source program that allows you to easily download many well-established programs in the computing world.
3. Once installed and the terminal is opened, type in brew install ghdl “install” tells brew that you want to download a new program. ghdl is an open-source simulator of the (Windows) VHDL language, which we will use to run the programs. This might take a while.
4. Type in ghdlto verify that it works.
(base) default-computer-name:~ 365days$ ghdl
ghdl:error: missing command, try ghdl 'help'
(base) default-computer-name:~ 365days$ Despite the seemingly negative response, the above means that ghdl is working, but it requires you to specify a file to run.
5. Create a new file titled hello.vhdl in your user folder. That is the folder where your Documents, Downloads, Pictures, etc. are. Inside this file, insert this code:
-- Hello world program.
use std.textio.all; -- Imports the standard textio package.
-- Defines a design entity, without any ports.
entity hello is
end hello;
architecture behaviour of hello is
begin
process
variable l : line;
begin
write (l, String'("Hello world!"));
writeline (output, l);
wait;
end process;
end behaviour;Traditionally, you would compile the code and either get a binary file or the code would run with just-in-time compilation. Because VHDL is not such a language, i.e. is an interpreted language, ghdl does not create binaries explicitly, but an intermediary code, which is then interpreted by ghdl. First, we translate the written code into the intermediary language:
6. Execute the command ghdl -a hello.vhdlin the terminal. This compiles the file into another file called work-obj93.cf
Instead of executing things with relation to the files from where the logic emerged, we are going to execute the code based off of the logic that’s contained within work-obj93.cf.
7. To run our program, we need to execute ghdl -r hello.vhdl You should get this output:
(base) default-computer-name:~ 365days$ ghdl -r hello
Hello world!
(base) default-computer-name:~ 365days$ Congratulations, you have written your first “Hello World!” program in VHDL!