Block I Illinois Library Illinois Open Publishing Network

Orange Unit: A Person-Centered Launch

3B: Computer Building Blocks

Background Knowledge Probe

In chapter one, “Introduction to Electronic Circuits,” the background knowledge probe had you create a list of the electronics you make use of on a regular basis. As you did so, you considered who designed it, what parts might have been used inside and out to build and use it, and what you did with any items that started to work less than optimally.

  • Now create a new list, this time documenting your daily-use computing devices such as laptops, tablet devices, and smartphones.
    • What external and internal electronic components, such as resistors, capacitors, diodes, transistors, switches, sensors, LEDs, copper wires, pins and clips, integrated circuits, and printed circuit boards, come to mind as you think about your computing devices?
    • What design choices and design objectives might have inspired the layout of the system and the various circuitry, mechanics, and artistry of its layout function, look, and feel?
    • What have you done with any components that started to work less than optimally?

Technical Introduction

In the technical chapter of session 1, we began deconstructing the components that make up our daily electronics, something we dug further into during chapter 2, “Electronic Components in Series.” We’ve also been expanding our fail-forward troubleshooting and innovation-in-use remixing as we further open up the hood of electronic systems and the social influences shaping, and being shaped by, these. Before launching the Raspberry Pi microcomputer, let’s spend a little time exploring how electronics, and often times code, are combined in a range of ways to create computers. In this chapter, we’ll:
  1. Explore the hardware building blocks that make up all computers.
  2. Examine the operating system building blocks that provide the major software package that supports the basic functions of a computer and other computing devices.

Computer Hardware Building Blocks

Electronic components like resistors, switches, LEDs, variable resistors, capacitors, other diodes, photocells, transistors, and integrated circuits combine to create many of the everyday devices around us. These can be prototyped using , ultimately leading to the creation of printed circuit boards. All computers are initially made using these prototyping tools as they evolve from innovation and design, to testing, to production and marketing, and distribution.

Inside the case of every computer, we will find one or more printed circuit boards. The is the main board connecting computer parts. It brings together the many different electronic components we have studied, as well as the connectors, sockets, and ports that provide internal and external connections to other electronics.

All computers are made up of the same basic building blocks. In addition to the motherboard, there are several key parts of a computer’s hardware:

  • The  the core integrated circuit controlling and executing operations.
  • , the integrated circuits that temporarily hold data until needed by the CPU or other processors.
  • , which includes devices like hard drives, optical media such as DVDs, solid state drives, and flash drives even when power is turned off, but that cannot share data fast enough to work directly with processors.
  • , the crossing guards that control the flow of data from inputs to processors, and from processors to outputs.
  • that you connect to the computer using Universal Serial Bus, or port, port, jack, audio jack, and others, such as the Raspberry Pi port.

Integrated Circuits

Processors: Do the thinking work

  • CPU: The main thinker and boss for the computer

Memory: Hold data until needed by processors; faster than storage but more expensive

  • RAM: The main system memory; it forgets when power is off
  • Flash: Changes circuits in a way that remembers even without power (USB stick, solid state drive)

Controllers: Move data from inputs to processors and from processors to outputs


Mechanical changes to media to store data even when power is turned off

  • Magnetic media: Uses positive and negative charges (e.g., hard drive)
  • Optical media: Uses lasers to detect presence or absence of reflected light (e.g., CD and DVD)

Printed Circuit Boards

System or Motherboard: Main highway connecting components; edge connectors and sockets provide for expansion

  • Memory module: Board with group of memory integrated circuits (e.g., DIMM)
  • Expansion cards: Board with controller and integrated circuits to add capability to computer (e.g., video card, network card)


  • Protects the building blocks from damage
  • Holds the power supply used to turn wall power into the power used by components (desktop)
  • Provides space for air to flow around and to cool components
  • Provides a surface to disperse heat away from components (laptop)

Input/Output Devices

  • Input devices let users control the computer (e.g., keyboard and mouse, touch-sensitive devices)
  • Output devices inform user what is happening (e.g., monitor, printer)

Computer Operating System Building Blocks

Operating systems are the software managing the various components of a computer’s basic functions, from coordination between the many applications that allow us to do our daily computer-based activities, to the used to span the boundary between programming code and the physical electronics. The building blocks of an operating system can be seen below:

Themes and Skins

  • Pre-set package containing graphical appearance details. Supported in some versions of Windows and Linux. Available as third-party applications in other cases.
  • Supported for many applications like web browsers.
  • Changes the look and feel of many features at once (e.g., background colors, text font and size, icons, mouse cursor, etc.).

Desktop Environment

  • The desktop environment is a collection of software that provides a predictable look and feel.
  • Includes a Window Manager that controls the placement and appearance of windows, support icons, menus, etc.
  • For some operating systems, such as Windows and macOS, the desktop environment is the branded look of the operating system and cannot be changed.

Window System

  • This is the part of the graphical user interface that communicates with the kernel.
  • Many operating systems allow remote interfacing with the window system, either directly or through third-party applications.

Bundled Software

  • Applications like , user managers, software managers.
  • Applications like web browsers, text editors, photo and movie editors.
  • Device and print drivers determine which hardware is “plug and play” ready.


  • As the heart of the operating system, it is the go-between from applications to input/output controllers, memory, the CPU, and storage devices.

When working with a computer, names bring things together, hiding from view many of the hardware and operating system building blocks. I’m working right now on a MacBook Air. This laptop has all of the key hardware building blocks pulled together into a single system board within a laptop case. It is installed with the macOS operating system. On my desk is a Motorola moto e5 play smartphone. This also has all the key hardware building blocks pulled together into a single system board, this time within a smartphone case. It is installed with the Android mobile operating system based on a modified version of the Linux operating system kernel and other open source software. My spouse uses a Lenovo laptop much like the MacBook Air but with a few more I/O ports and a larger laptop screen. It is installed with the Microsoft operating system.

We typically merge the hardware and software together as one device with a means for bringing in human input, using software to collect and respond to that input, and to provide output back to the human.

Image demonstrating the foundations of computer hardware, including 1) central processing unit time; 2) memory usage; 3) interfacing with peripheral hardware; and 4) program interactions. The kernel is the bottom of the operating system pyramid controlling interactions with this hardware. Bundled programs that come with the operating system are used to interact with the kernel, while shell and graphical user interfaces provide human interaction with the kernel and with computer programs.
We primarily interface with an operating system via the shell and graphical user interfaces. These connect us to the kernel of the operating system which interfaces with installed applications as well as with the computer hardware and other computer programs.

All modern operating systems include both a graphical user interface (GUI) and a text-based shell known as a command-line interface (CLI) or terminal window. For the most part, we spend our computer time using a keyboard, monitor, and mouse/touchpad to work within these GUIs without even knowing we’re in an operating system that controls each and every action we take on that computer. It’s just the computer and we’re just trying to do our work with a range of applications like web browsers, email clients, and word processors.

Sometimes, though, we need access from a distance, and so we use remote desktop software. In some cases, remote desktop software is operating system independent, as is the case with the Virtual Network Computing (VNC) server installed on the Raspberry Pi Operating System by default, and that can be installed on almost all different personal computers and smartphones. In other cases, it is designed for a specific operating system, as is the case for Apple Remote Desktop (Apple) and Remote Desktop Protocol (Microsoft).

For many server computers, including devices like routers and a range of open-source content management systems (CMS), these are designed to serve as a simple, responsive web interface to a computer that otherwise runs headless. Headless means the computer is run without a monitor, keyboard, and/or mouse connected to it. The content management system provides us with a remote interface device to access and use certain tasks that would otherwise be accessed using a GUI through a keyboard, mouse, and monitor or through a remote desktop application.

Another common way to work with headless devices is through a Universal Asynchronous Receive and Transmit (UART) serial connection or an Internet-based secure shell (SSH) connection. These serve to provide a simple, text-based shell, also sometimes called a console or terminal window. Indeed, the Raspberry Pi starter kit provides a default backup to connect a personal computer to a server or microcomputer using a USB (Universal Serial Bus) to TTL (Transistor Transistor Logic) cable to facilitate UART communications as a way to assure troubleshooting when all other means for user interface with a device has failed. This is how we’ll start our work with the Raspberry Pi.

Where Does the OS Live?

The operating system is installed and maintained using a storage device like a hard drive or MicroSD card. But storage devices are like our old paperwork that we store up in an attic. We can’t do anything with it beyond just storing it there. When a computer is turned on, those instruction sets in the operating system which are immediately needed are moved out of storage and into random access memory (RAM). We sometimes call this booting a computer, also called boot up or start up. This startup sequence first does a safety check of the system, then looks to one or more possible locations for the master boot record or boot manager, which then takes over control to bring forward the next modules of operating system code needed.

The reason we need to boot up is because RAM can only store information as long as it has power and ground to complete the circuits used to input, store, and output the memory. This is compared to the older long term storage devices like hard drives, and to newer storage devices like secure digital (SD) cards and other flash memory, all of which have means for permanently writing memory to spaces on them while also allowing reading, deleting, and rewriting to those spaces as needed, albeit more slowly. RAM is like paper files within an arm’s reach of a computer we’re working on at the moment.

But as is the case with many of the papers we may have sitting in close reach of the computer on our desk, they still can’t be actually read and processed. To do this, a computer next moves sequences of code from dynamic RAM (DRAM), which can store larger amounts of data at a more affordable rate but that still works a bit too slowly for static RAM (SRAM), which doesn’t need to be refreshed and that is faster than DRAM. SRAM serves as a system cache that works closely with the Central Processing Unit, or CPU. Consider SRAM as those files immediately at hand, and the CPU as your brain, now processing the information you just read from the file in front of you.

At any given moment, where a segment of the operating system is “living” depends on what modules, functions, variables, iterations, and sequences of code are needed. It is moving from attic to desk to hand to brain to hand to brain to desk to hand to brain to desk to attic over and over billions of times per second.

The Kernel: The Heart of the Operating System

The operating system is the underlying program that we generally don’t even know really exists. We hear about it, for instance when we buy a computer running Microsoft Windows 10, or an Apple MacBook running macOS Sierra. And once in a great while we’re encouraged or required to install a new version of the operating system.

But generally we just see lots of text and graphics on a monitor, and we type on our keyboard, move around a pointer from one place to another using a mouse or touchpad or even sometimes the monitor itself. That’s the user interface side. But the heart of the operating system lives in the kernel.

  • The kernel controls how applications get time on the CPU(s) of the computer. There was a day when the OS only allowed one application at a time to physically run on the computer. Imagine having to save your work in your text editor, exit, then open the spreadsheet to see your data, then exit, then reopen your text editor. Today operating systems are multi-tasking, allowing multiple applications to all “run” simultaneously. They do this using a very fast time sharing strategy, in which each application is allowed to submit threads, or small segments of programming code, to the operating system, requesting execution of that thread.
  • The kernel controls memory access at several levels:
    • Physical memory vs. virtual memory: Applications can easily eat up all available memory. To that extent, the OS must carefully control just how much memory is being used by a specific application. Further, when a user wants to do more than can be done with available memory, the operating system controls the movement of bits from physical memory to virtual memory or swap space, a special location on the hard drive configured to mimic, albeit very slowly, physical memory. Applications cannot directly access virtual memory, so when memory runs short, the OS spends a lot of time swapping bits between physical and virtual memory.
    • Shared vs. private address space: Some operating systems conserve physical memory allocation by only loading shared segments of code (for instance from a library file) once, then pointing all applications to this shared address space. The problem is that sometimes a badly behaving application can overwrite a critical shared code with corrupted data. In the worst cases, this can lead to a general protection fault (a type of system error). Many modern operating systems therefore decide to make greater use of private address space, always loading segments of code again even if they already exist in memory.
  • The kernel controls interactions with device controllers. Because there are many controllers manufactured for each type of input/output function (for instance, video controllers), an operating system cannot be expected to know how to interface with every one of them out of the box. Instead, each controller must come with its own device driver that can translate between the specific controller and the specific operating system. All hardware incompatibilities boil down to unavailable device drivers for the specific operating system.
  • The kernel of the operating system determines which types of file systems are supported.

In all cases, it is the kernel of the operating system that does the core work of communication between electronics and programming code.

A Brief History of Operating Systems

In Microsoft and Apple operating systems, they’ve put together a tightly intertwined, large set of applications to cover all main aspects of the operating system, from user interface, to bundled applications to configure the computer, store, delete, and access files, to install and update applications, to set up screensavers, accounts, and passwords, to disk and monitor management, and so much more. And the operating system has the essential instruction sets needed to interact with the electronics of the computer within the kernel, the most basic level of the operating system.

Before there was Microsoft or Apple, there was Unix, a family of multitasking, multiuser computer operating systems. Unix was first developed by AT&T at Bell Labs research center in the 1970s, but then was split into a few different Unix systems. All are commercial, at least at some level, although some have been made more widely available than others. For the most part, Unix provides a distinction between the kernel of the operating system, primary bundled applications, the user interface, and any networked information systems used to pass data back and forth with devices beyond the kernel.

Very early in its development, Unix developers created the X-Window system to provide the ability to create graphical user interfaces. The developers also set up Unix to work on the Internet. In this way, even back in the ’70s and ’80s, Unix was able to have a graphical user interface to a headless computer using simple (actually called ‘dumb’ at the time) computers that served primarily as a text and sometimes graphical human interface device to the Unix core computer.

One company that entered into a licensing contract to use and build their own iteration of Unix was Apple, leading to the macOS.

Microsoft wrote their own text-based operating system, called MS-DOS, or Microsoft Disk Operating System. It was meant to support a personal (that is, only one user working only with directly attached devices) computer, and included the kernel, basic bundled applications, and a text interface. They then later added their own Windows graphical user interface extension to MS-DOS. Later still, they created a new version of the operating system called Windows NT (New Technology) that integrated the kernel, bundled applications, and graphical user interface into one, while still also staying compatible with earlier versions of Windows. Ultimately, they made the break to create newer versions of the Windows operating system, and eventually also adding back a new and improved text-based terminal window. But throughout, their choices on select keyboard options, labels, and other essential communications have contrasted with those of Unix, and thereby with those of Apple as well.

Moving into the early 1990s, Unix computers were relatively expensive, and therefore were purchased by, and used in, research labs. Then in 1991 University of Helsinki student Linus Torvalds purchased an Intel 80386-based clone of the IBM PC mini-Unix called MINIX. Later that year, he made public his first prototype of a Unix-like kernel operating system he called Linux. On March 14, 1994, he released version 1.0. From the start, he released Linux using Richard Stallman’s General Public License. Stallman, a free software advocate, created the GNU Project, a software development initiative. By combining the GNU Project essential bundled applications with the Linux core, Torvalds built and released a fully functioning operating system.

Over the years, different groups have worked to create distributions of specific GNU applications, other applications, and a Linux core. The oldest surviving distribution of Linux is called Slackware, created by Patrick Volkerding in 1992. Slackware 1.0 came on 24 floppy disks and was built on top of Linux kernel version 0.99. I started working in the Neuronal Pattern Analysis Group of the Beckman Institute at the University of Illinois Urbana-Champaign in 1993 and soon after began using Slackware and Linux along with the newly developing X-Mosaic graphical web browser as part of a team seeking to use the Internet to make publicly available raw electrophysiology data which was collected as part of various research projects.

Two common distributions of Linux are used as the starting point for a rich variety of child distributions. One is called Fedora, and originated in 1995, under the name Red Hat Linux. In 2003, the Red Hat trademark was used to create two branches: Red Hat Enterprise, with a combination of free and open source applications and commercial applications, and Fedora, a community-oriented distribution designed for “hobbyists.” Commonly used distributions with Fedora at their core include CentOS and Scientific Linux.

Debian GNU/Linux was first announced in 1993 by its founder, Ian Murdock. It has been developed to every extent possible as a completely non-commercial project, through collaboration with over 1000 volunteer developers. Widely used Debian-based alternatives include the overall most widely used distribution, Ubuntu, and Raspberry Pi OS, the default Debian-based alternative for the Raspberry Pi microcomputer.

There are two widely used commercial operating systems based on the Linux kernel today as well. In September 2008, Google launched its Android operating system using a modified version of the Linux kernel and various open source software designed for touchscreen mobile devices, and subsequently developed for Android TV, Android Auto, and Wear OS. The Android Open Source Project is used for development of its core source code, and apps for Android can therefore be developed by anyone for virtually any purpose and installed and run on Android devices. In May 2011, Google released the first Chromebook, running the Chrome OS. It is only available preinstalled on hardware from Google manufacturing partners. Its open source equivalent, Chromium OS, can be freely installed.

Specific to Raspberry Pi OS, each major new release of Debian results in a major new release of Raspberry Pi OS. The code name used for each major release of Debian is taken from Toy Story characters. In 2013, this was Wheezy, the penguin character by that name. In 2015, this was Jessie, the cowgirl character. As of June 2017, this is Stretch, the rubber octopus from Toy Story 3. As noted in these code name release dates, Debian works to be stable through a conservative update process. The stable release is held for about two years, although test releases become available via the new code name during the interim for those wanting early access for use and testing of new designs.

Exercise: Reviewing Your Computer

Take some time to dig into the hardware, operating system, and major installed software applications of your primary computer. While it’s often more difficult, if even possible, to open up your computer to look at the system or motherboard of the computer than it used to be, if you can safely do that, do so. You may have received some default documentation with your computer, either in print or digital. There may be “About this Computer” links available on the computer or on a vendor’s website. Some resources are best accessed through applications that came with your computer and that provide current notes which can account for potential updates that have since replaced the defaults that came with the computer.

Using these resources, create your own list of the physical components and operating system of your computer:

  • Input/output devices, such as types of USB ports, Thunderbolt ports, audio, camera, Ethernet, Bluetooth, card readers, etc.
  • Type and amount of random access memory (RAM)
  • Storage devices
  • Central processing unit (CPU) and, if included, graphic processing unit (GPU)
  • Power source
  • Operating system (OS) type and version.subversion/edition
  • Windowing system, desktop environment, and themes/skins. For many computers today, these are highly integrated, so you may only see this as a singular graphical user interface system.

Take time to compare and contrast this with some of the other desktop and laptop computers that you or others around you use on a fairly regular basis.

Wrap Up

Computers, microcomputers, and microcontrollers are an everyday part of life. The core components of these devices have remained the same, even as the specifications, standards, and physical and software implementations have been shaped and reshaped repeatedly over the last 50+ years. Knowing at least a bit about the items within all devices is essential as we serve professional and personal roles in the selection, implementation, innovation-in-use, and support of these devices in our varying contexts.

Before we move on to examining the Raspberry Pi microcomputer, take a few moments to watch this “teardown” video from electronics repair company iFixit. A product teardown is a common method for identifying the component parts of an electronic device, in order to better refurbish or repair devices of that same model. However, take caution and browse the resources available from iFixit before tearing down your own device, as the manufacturer may claim that such actions void your warranty. Moreover, for many newer devices, components are glued — not screwed — together, requiring specialized equipment to get inside the device.

In this teardown video, a 2018 MacBook Air is disassembled and evaluated. As you watch, make note of any parts you recognize. For even more detail, read the full teardown guide.

Comprehension Check


Icon for the Creative Commons Attribution-ShareAlike 4.0 International License

A Person-Centered Guide to Demystifying Technology Copyright © 2020 by Copyright © 2020 Martin Wolske. Copyright “Ideating and Iterating Code: Scratch Example” © 2020 Betty Bayer and Stephanie Shallcross. Copyright “Introducing the Unix Command Line” © 2020 Martin Wolske, Dinesh Rathi, Henry Grob, and Vandana Singh. Copyright “Security and Privacy” © 2020 Sara Rasmussen. is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License, except where otherwise noted.

Share This Book