Intro to Hardware — from the cloud to the microcontroller

Every project runs on something. This path is a guided tour of the hardware a developer chooses between — from a few dollars of shared web hosting up through VPSes, dedicated and home servers, the desktops and laptops you build on, the phones and tablets you ship to, and down to single-board computers and the tiny microcontrollers like the Arduino and ESP32. For each one you'll learn what it's for, the programming languages it runs, and its real strengths and drawbacks. The final module turns all of that into a practical way to decide which platform — often several working together — is right for your project. Examples lean on GopherTrunk, the kind of software-defined-radio software that can live on anything from a laptop to a Raspberry Pi by the antenna.

Start lesson 1 →Jump to glossary

Every program runs on something — and “something” covers an enormous range, from a few dollars of shared web hosting to a chip the size of a fingernail soldered into a sensor. This path is a guided tour of that range. For each kind of hardware a developer is likely to use, you’ll learn what it’s for, the programming languages that run on it, and its honest strengths and drawbacks — then how to weigh all of that to pick the right platform for a project.

Who this is for. Complete newcomers are welcome — no electronics or sysadmin background required. If you already write code, use the module list to jump to the parts you’re missing: servers and hosting, single-board computers, microcontrollers, or the decision framework at the end. Every lesson is self-contained and cross-linked, so you can read straight through or hop around.

How the path works. Seven modules move from foundations to decision. We start with the ideas every later module leans on — what hardware is, the parts inside every computer, and the trade-offs that drive every choice. Then we walk the whole spectrum: servers and hosting, personal computers, mobile devices, single-board computers like the Raspberry Pi, and microcontrollers like the Arduino and ESP32. The final module turns it all into a practical, repeatable way to choose — usually a combination of platforms — for a real project. Examples lean on GopherTrunk, software-defined-radio software that can live on anything from a laptop to a Raspberry Pi by the antenna, so abstract trade-offs stay concrete. Mark lessons complete as you go; your progress is saved in your browser. New here? Start with lesson 1: What is computer hardware?

Module 1 — Hardware Foundations

The ideas every later module leans on: what hardware is, the parts inside every computer, the spectrum from cloud to microcontroller, and the trade-offs that drive every choice.

  1. What is computer hardware? Hardware vs. software, what counts as a computer, and why the same job can run on a server or a chip the size of a stamp — the one idea everything else builds on. beginner 8 min
  2. CPU, memory, storage & I/O The four building blocks inside every computer, from a data center to a microcontroller, and how their size and speed define what a device can do. beginner 9 min
  3. The hardware spectrum — cloud to microcontroller A single map of every platform in this path, ordered by power, cost, and how much of it you control, so the rest of the path has a frame to hang on. beginner 8 min
  4. Programming languages & where they run Why a web host runs PHP and Python while a microcontroller runs C — how hardware shapes which languages are practical, and what "runs on" really means. beginner 9 min
  5. Cost, power & performance trade-offs The handful of trade-offs — money, electricity, performance, control, and effort — that recur in every hardware decision you'll make. beginner 8 min

Module 2 — Servers & Hosting

Where software runs for other people: the ladder from cheap shared web hosting, through VPSes and dedicated servers, to a server humming in your own home.

  1. Web & shared hosting The cheapest way to put something online — what shared hosting gives you, what it hides, the languages it runs, and where it stops being enough. beginner 9 min
  2. Virtual private servers (VPS) Your own slice of a server with root access — how virtualization carves one machine into many, what you can run, and the responsibility that comes with it. intermediate 9 min
  3. Dedicated servers A whole physical machine that's yours alone — when raw, uncontended performance is worth the price, and what changes when nothing is shared. intermediate 8 min
  4. Home servers & self-hosting Running your own server on your own internet — the freedom, the costs nobody mentions, and why a Raspberry Pi or old PC can be a perfect first server. intermediate 9 min

Module 3 — Personal Computers

The machines you build software on: the trade between a fixed, powerful desktop and a portable laptop, and how to choose the one you'll work on every day.

  1. Desktop computers The most power per dollar, endlessly upgradable, and going nowhere — what desktops are for, what they run, and where they shine for a developer. beginner 8 min
  2. Laptops A whole computer you can carry — the portability-for-power trade, battery and thermal limits, and why most developers work on one anyway. beginner 8 min
  3. Choosing your development machine Desktop, laptop, or both — matching your machine to how and where you work, and the specs that actually matter for writing software. intermediate 8 min

Module 4 — Mobile Devices

The computers in everyone's pocket and bag: what smartphones and tablets are good at, what they're not, and what it takes to build software for them.

  1. Smartphones The most widespread computer on earth — its sensors and constraints, the platforms and languages behind apps, and why it's a target, not a dev machine. beginner 8 min
  2. Tablets The big-screen cousin of the phone — where the extra size pays off, where tablets sit between phone and laptop, and what runs on them. beginner 7 min
  3. Developing for mobile devices Native, cross-platform, or web — the ways to build a mobile app, the languages and toolchains each uses, and the trade-offs between them. intermediate 10 min

Module 5 — Single-Board Computers

A complete computer on one small board: what an SBC like the Raspberry Pi is, what it's brilliant at, how you program it, and where its limits begin.

  1. What is a single-board computer? A real, Linux-running computer the size of a credit card — how an SBC differs from both a PC and a microcontroller, and why GPIO pins change everything. beginner 8 min
  2. The Raspberry Pi & its alternatives The board that defined the category, plus the rivals worth knowing — Pi Zero to Pi 5, Jetson, Rock, and BeagleBone — and how to tell them apart. beginner 9 min
  3. Programming & running software on an SBC It's just Linux — Python, C, Go, and the same tools you use on a PC, plus talking to the physical world through the GPIO header. intermediate 9 min
  4. SBC use cases, strengths & drawbacks Home labs, media servers, robots, and edge sensors — where SBCs win, and the heat, power, storage, and reliability limits that decide when to reach for something else. intermediate 8 min

Module 6 — Microcontrollers

The tiny chips that run the physical world: what a microcontroller is, the Arduino that made them approachable, the wireless ESP32, and how you program them.

  1. What is a microcontroller? A whole computer on one cheap, low-power chip with no operating system — how it differs from an SBC, and why it boots in milliseconds and runs for years. beginner 9 min
  2. Arduino & the maker ecosystem The board and language that made microcontrollers approachable — what Arduino is, the sketch model, and the enormous ecosystem that grew around it. beginner 9 min
  3. ESP32 & wireless microcontrollers A microcontroller with Wi-Fi and Bluetooth built in for a couple of dollars — why it powers most DIY smart-home gadgets and the Internet of Things. intermediate 9 min
  4. Programming microcontrollers: languages, use cases & limits C/C++, MicroPython, and Rust on bare metal — the use cases microcontrollers own, and the tight memory, power, and tooling limits you design around. intermediate 9 min

Module 7 — Choosing the Right Hardware

Everything applied: turn a project's needs into the platform — or, more often, the combination of platforms — that fits it best, with a repeatable framework and worked examples.

  1. Start with your requirements Before you pick a board or a host, pin down what the project actually needs — performance, connectivity, power, budget, and where it has to live. beginner 8 min
  2. Matching hardware to the project type Websites, apps, data crunching, automation, sensors, and robots — the platforms each kind of project tends to reach for, and why. intermediate 9 min
  3. Combining tiers: device, server & cloud Real systems rarely live on one platform — how a microcontroller, an SBC, and a server team up, and where to draw the line between them. intermediate 9 min
  4. A practical decision framework A repeatable checklist for turning requirements into a hardware choice, including the questions that quickly rule platforms in or out. advanced 10 min
  5. Worked examples: picking hardware for real projects The framework applied end to end to several projects — a blog, a smart-home sensor, a home media server, and a GopherTrunk scanner — to make it concrete. advanced 10 min
  1. Glossary of hardware terms Plain-language definitions for every hardware term in the learning path, cross-linked to the lessons.