DEV Community: Millicodhiambo

Compilation 1.0

Millicodhiambo — Mon, 17 Aug 2026 14:09:58 +0000

You write some C++ code, hit compile, and—poof—an executable appears. Or maybe it doesn’t, and you’re drowning in errors you don’t understand. Here’s the thing: compilation isn’t magic. It’s a multi-step pipeline that transforms your human-readable code into binary your computer can run. Understanding this pipeline is like getting X-ray vision for debugging. You’ll know exactly where things go wrong—whether it’s a preprocessor hiccup, a compiler syntax error, or a linker meltdown.

In this series, we’re going to pull back the curtain. We’ll walk through every stage: preprocessing, compiling, assembling, and linking. We’ll write actual code, run real commands, and see what happens at each step. No hand-waving, no “it just works.” By the end, you’ll compile with confidence and debug like a pro, or try to.

Next up, we’ll try to build a simple project to see the pipeline in action.

The Big Picture: From Text to Binary
Let’s sketch out the journey your code takes. You start with a .cpp file—just text. That file goes through four main stages before becoming an executable:

Preprocessor: Handles directives like #include and #define. It’s basically a fancy copy-paste engine that runs before the real compiler kicks in.

Compiler: Parses your code, checks syntax, builds an internal tree (called an Abstract Syntax Tree or AST), and generates assembly language—a human-readable version of machine instructions.

Assembler: Converts that assembly text into binary object files (.o on Linux, .obj on Windows). These are chunks of machine code, but they’re not runnable yet.

Linker: Glues together all your object files and any libraries (like the C++ standard library) into a final executable. This stage handles both static linking (baking code into your binary) and dynamic linking (loading shared libraries at runtime, like .so files on Linux or .dll on Windows).

Here’s a visual:

Here’s a quick visual of how source code flows through the pipeline to become an executable.

Each stage can fail for different reasons. Preprocessor errors? Usually missing headers or typos in #include paths. Compiler errors? Syntax mistakes, type mismatches. Linker errors? Missing function definitions or libraries. Knowing where you are in the pipeline makes debugging way less painful.

Setting Up Our Test Project
Let’s build something simple to experiment with. We’ll create three files: a header (source.hpp), an implementation (source.cpp), and a main program (main.cpp). Our “library” will do one thing: add two integers. Riveting, I know—but it’s enough to see every stage in action.

source.hpp (the interface):

// source.hpp
// Declares a function that adds two numbers
int add(int a, int b);
source.cpp (the implementation):

// source.cpp
// Implements the add function
int add(int a, int b) {
return a + b;
}
main.cpp (the entry point):

// main.cpp

include "source.hpp"

int main() {
int result = add(2, 3);
return 0;
}
Save these in a folder. Now let’s try compiling. On Linux with g++ installed (Ubuntu/Debian users can sudo apt install g++), run:

g++ main.cpp source.cpp -o myprogram
./myprogram
If all goes well, it compiles silently and runs (though it doesn’t print anything yet—we’ll fix that later). But what if you only compile main.cpp?

g++ main.cpp -o myprogram
You’ll hit an error like:

undefined reference to `add(int, int)'
That’s the linker complaining. It knows add exists (the compiler saw the declaration in source.hpp), but it can’t find the actual code. That’s because source.cpp was never compiled and linked in. This is our first taste of how the pipeline stages interact.

Why This Matters
Understanding compilation isn’t just academic. Here’s what you get:

Faster debugging: When you see “undefined reference,” you’ll know it’s a linker issue, not a typo in your code.

Better build systems: Tools like Make, CMake, or Ninja automate this pipeline, but they’re just orchestrating these same steps under the hood.

Smarter optimization: Ever wonder what -O2 or -O3 flags do? They tweak the compiler and assembler stages. You’ll see that soon.

Plus, if you ever work on larger projects or dive into other compiled languages (C, Rust, D, even Java’s ahead-of-time compilation), this mental model transfers directly.

Wrapping It Up
We’ve mapped out the compilation pipeline: preprocessor → compiler → assembler → linker. We’ve set up a tiny project and seen how missing a file at link-time causes errors. Next time, we’ll crack open the preprocessor and see what #include really does (spoiler: it’s simpler than you think—and more dangerous if you’re not careful).

Try compiling the code above. Experiment: leave out source.cpp and watch the linker fail. Get comfortable with that error message—you’ll see it again.

I Was Basically Gaslighted Into Learning DNS... and I'm Glad I Was

Millicodhiambo — Sun, 12 Jul 2026 19:51:37 +0000

I have a confession.

I was strongly encouraged (read: lovingly gaslighted ) into writing this article. At first, I thought, "Why me? Can't someone else do it?"

But looking back... I might actually thank the people who pushed me.

Researching DNS and writing this article taught me far more than simply listening to the tech talk we had on Friday. It forced me to ask questions, connect the dots, and understand what actually happens every time I open a website.

So, if you've ever heard people throw around the term DNS and wondered what all the fuss is about, this one's for you.

What is DNS?

Imagine you want to visit your friend's house.

You probably remember their name, not their exact GPS coordinates. So you open Google Maps, type in their name or location, and your phone figures out where to take you.

The internet works almost exactly the same way.

DNS stands for Domain Name System. Think of it as the internet's phonebook—or even better, its contacts app.

Instead of remembering an IP address like 142.250.190.78, you simply type google.com.

DNS translates that easy-to-remember name into the numerical IP address that computers use to find each other.

Without DNS, we'd all be memorizing long strings of numbers just to visit our favorite websites. Imagine trying to remember the IP addresses for Google, GitHub, YouTube, Netflix... every single day.

No thanks.

So What Actually Happens?

Let's say you type github.com into your browser.

Here's what happens behind the scenes:

Your browser asks, "What's the IP address for github.com?"
It checks with a DNS resolver to see if the answer is already cached.
If it isn't, the resolver asks other DNS servers until it finds the correct IP address.
The IP address is sent back to your browser.
Your browser connects to GitHub's server and loads the website.

All of that usually happens in just a few milliseconds.

Pretty cool, right?

Why Does DNS Matter?

DNS makes the internet much more human-friendly.

It allows us to:

Remember names instead of complicated IP addresses.
Keep using the same website address even if the website moves to a different server.
Load websites faster through caching, where recently looked-up addresses are temporarily stored.

Without DNS, browsing the internet would be a lot slower and a lot more frustrating.

Another Way to Think About It

Think of your phone contacts.

Contact Name → google.com
Phone Number → IP Address
Tapping the Contact → Opening the website

You don't memorize everyone's phone number—you save their name and let your phone handle the rest.

DNS does exactly that for the internet.

Final Thoughts

DNS is one of those technologies that's quietly doing its job every single day.

Most of us never notice it, yet every website we visit depends on it.

This article started as an assignment I wasn't exactly excited about. But by the time I finished researching and writing it, I realized I'd learned far more than I expected.

Sometimes the things we're "forced" to learn end up becoming the things that make everything else in tech start to click.

If you're just starting your journey into networking or web development, understanding DNS is a great place to begin.

My First Day at a developer Bootcamp: What I Experienced as a Beginner

Millicodhiambo — Sun, 14 Jun 2026 19:52:58 +0000

Starting a developer bootcamp is both exciting and a bit overwhelming. On my first day, I didn’t expect to understand everything—but I was ready to learn how real developers think and work.

Even though I couldn’t fully follow all the sessions later in the week, my first day still gave me a strong introduction to the journey I’m stepping into.

What stood out for me

The biggest realization was that software development is not just about writing code—it’s about problem-solving, collaboration, and consistency.

I also noticed how important tools like Git, GitHub, and development environments are in keeping projects organized.

What I learned on day one

1.The importance of having a developer mindset (learning by doing)
2.How developers structure projects and workflows
3.That it’s okay not to understand everything immediately
4.The value of consistency over speed

My bigger motivation

Beyond the bootcamp, there’s a hackathon that marks its conclusion, where I get to work on a small idea called AfriPay—a concept aimed at improving cross-border payments in Africa by integrating the Bitcoin Lightning Network.

The Lightning Network is fascinating, but still quite challenging to fully grasp. I’m still learning how it works, and I see that as part of the journey.

This experience has made me realize how important software engineering is in solving real-world problems in my region.

Even though I’m still at the beginning of my learning journey, ideas like this keep me motivated to keep going and improving every day.

My biggest takeaway

Even a single day in a developer environment can change how you see technology. It made me realize that becoming a tech junkie isn’t just about passion—it’s about discipline and continuous learning.

What’s next for me

I’m continuing to learn on my own, building small projects, and improving step by step. This bootcamp experience is just the beginning of my journey into tech.

So yeah, this is just the beginning of my journey.