DEV Community: Fjr

Episode 4: The Time Loop (Layers & Caching)

Fjr — Sat, 23 May 2026 11:06:07 +0000

So, Jack finally wrote his "Secret Scroll" (the Dockerfile). He changed one tiny typo in his code, hit build, and... he had to wait. And wait.
Docker started from the very beginning, downloading Python again, installing all the packages again, and basically rebuilding the entire apartment building just because Jack moved a chair in the living room.
"This isn't magic," Jack grumbled. "This is a time loop."

Union File System & Layering

To understand why your build is slow, you have to understand the Union File System (UnionFS).

When Docker builds an image, it isn't creating one single file. It is creating a stack of read-only layers. Each instruction in your Dockerfile (FROM, RUN, COPY) creates a new layer.

How Caching Works
Docker uses a "Layer Cache" to save time. When you run a build, Docker looks at each instruction and asks:

Have I run this exact command before?

Are the files involved in this command exactly the same as last time?

If the answer to both is YES, Docker skips the work and uses the Cache.

The "Chain Reaction" Problem

Here is the technical "gotcha": Layers are dependent on the ones below them. If you change a file that is used in Step 3, Docker cannot trust the cache for Step 4, Step 5, or Step 6 even if those steps didn't change! The "chain" is broken. Once a layer is invalidated (rebuilt), every subsequent layer must also be rebuilt from scratch.

Why Your Order Matters (The Tech Hack)
Because you change your code every 5 minutes, but you only change your requirements (packages) once a month!

The "Slow" Way:

COPY . .(Copies everything: code + requirements)

RUN pip install (Installs everything)

Result: Every time you change one line of code, Docker thinks the whole "Copy" step is new, so it runs pip install again. That’s 5 minutes wasted.

The "Pro" Way (The 2-Second Build):

COPY requirements.txt. (Copy only the list of packages)

RUN pip install(Install them)

COPY . . (Now copy the actual code)

Result: Since your requirements.txt didn't change, Docker skips the 5-minute install and jumps straight to copying your code. Boom. 2 seconds.

The Quest (The Time-Traveler's Challenge)

Your Mission: Go back to your Dockerfile from Episode 3. Look at where you put COPY . . and RUN pip install.

The Challenge:

Re-order your "Scroll" so that the pip install happens before you copy your main code folder.

Run docker build once (it will be slow this time).

Change a single comment in your main.py.

Run docker build again.

Did you see that? It should say ---> Using cache for almost every step.

So the Question is If Docker is so smart at caching, why do we still need to be careful? What happens if you add a new package to requirements.txt? Does the "Time Loop" start over?

If you've ever felt like your computer is punishing you for a small code change, welcome to the world of Layers and Caching.

Episode 3: The Secret Scroll (The Dockerfile)

Fjr — Sat, 23 May 2026 10:57:05 +0000

Jack was standing in front of his empty "Apartment Building." He knew about Namespaces and Cgroups, but he was frustrated. He had his App code sitting on his laptop, but he couldn't just "throw" the files into the building.

He needed a way to give Docker a precise, step-by-step Instruction Book.

"It’s like an ancient scroll," Jack realized. "If I write the instructions correctly, Docker will read it and build exactly what I need, every single time."

So, how do we write this "Instruction Book"? Jack realized that every Dockerfile is just a list of steps to turn an empty room into a working office for his code.

Here are the 5 core commands you need to know:
FROM python:3.9
FROM: The Foundation This is the very first step. Before you do anything, you need to decide what your "building" is made of. Does your app need Python? Node.js?

The Docker community is awesome they’ve already made "pre-made" environments for us. If you write FROM python:3.9, you are getting a room that already has a Linux Kernel and Python installed. You don't have to build the engine; you just start the car.

WORKDIR /code
WORKDIR: Making the Folder Your container is ready now, but it’s empty. What do you do on your local PC when you start a project? You make a folder, right?

WORKDIR /app tells Docker "Make a folder called 'app' and stay inside it." This is the 2nd layer. From now on, everything we do happens inside this specific room.

COPY . .

COPY: Moving Day Usually, we write our code on our laptops before we ever touch Docker. Now we need to get that code from our laptop into the container’s folder.

It’s pretty simple you use COPY . .. This just means "Take everything from my current folder on my laptop and paste it into the container’s folder."

RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

RUN: Installing the "Extras" Okay, we have the base Python and we have our code. But what if your code uses extra packages like fastapi or pandas? They aren't in the base room yet!

This is where we install our dependencies. You just tell Docker: RUN pip install fastapi. Now, your room has all the specific tools your app needs to breathe.
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

CMD: The Grand Opening Everything is in the container now: the OS, the Python, your code, and your packages. Is it running yet? No.

CMD is the final command. It’s like turning the key in the ignition. It tells the container: "Now that everything is set up, run this command to start the app!"

Why the weird --host 0.0.0.0?

Jack almost missed this! Remember our Namespaces from Episode 2?

If you run your app on 127.0.0.1 (localhost), the app thinks it’s only talking to itself inside its own "Secret Room."

By using 0.0.0.0, you are telling the app: "Listen to everyone in the building." This allows the "Apartment Building" (your laptop) to actually reach inside the room and see the app.

The Quest: Build Your First Image
Now that the scroll is written, it's time to turn it into a reality.

Your Task:

Create a folder on your PC.

Create a file named Dockerfile (no extension!) and paste the scroll above.

Open your terminal in that folder and type: docker build -t my-first-hero.

The Challenge: When you run that command, watch your terminal closely. You will see it saying "Step 1/6", "Step 2/6"...

Why does it go one by one? (Hint: Think back to our "Sandwich Layers" from the last episode!)

Episode 2: The Anatomy of a Hero (The Inner Workings)

Fjr — Tue, 05 May 2026 06:38:03 +0000

Jack had finally stepped into the world of Docker. It felt like magic, but Jack was never one to just believe in "magic spells." He was curious. He wanted to look under the hood and see what actually made Docker so powerful.
He had one big question: How could 50 different people live in the same "apartment building" (the Host OS) without accidentally reading each other's mail or eating each other's food? He needed to understand the mechanics of Isolation.
To truly master this world and, of course to impress Rose with his technical depth Jack decided to dive deep. He discovered that the entire Docker universe is built on Three Main Pillars.

Section 2: The Three Pillars of Docker

To understand how Docker works, you have to understand how it talks to the Linux Kernel (the brain of your computer). It uses three specific tools to create the "Apartment" environment.

Pillar 1: Security (Namespaces)
The Invisibility Cloak. Namespaces are what provide Isolation. When you run an app in Docker, the Kernel puts a "wrapper" around it called a Namespace.

How it works: It tricks the app into thinking it is the only process running on the whole computer. The app cannot see other apps, other files, or even the network of the main computer.

Why we need it: If App A doesn't know App B exists, it can’t interfere with it, steal its data, or crash it. It’s like being in a room with no windows or doors you don't even know there’s a building outside.

Pillar 2: Strength (Cgroups)
The Resource Police. Cgroups (Control Groups) manage the Strength and limits of your app.

How it works: In a normal PC, if one app gets "hungry," it can eat 100% of your RAM and CPU, making the rest of your computer lag or crash. Cgroups set strict rules: "You can only use 2GB of RAM and 10% of the CPU."

Why we need it: It prevents one "greedy" process from starving the others. It ensures that every container has exactly what it needs to survive, but not a drop more.

Pillar 3: Speed (UnionFS & Layers)
The Transparent Sandwich. This is where Docker gets its Speed.

How it works: Instead of copying a whole Operating System for every app, Docker uses Layers. Think of it like a sandwich: the bottom bread is "Ubuntu," the middle is "Python," and the top is "Your Code."

Why we need it: If you have 10 apps that all use "Ubuntu," Docker only stores that bottom layer once. When you start a new app, it just snaps a new "Top Layer" on. This makes starting an app take seconds instead of minutes.

The Form: Image vs. Container

If the 3 Pillars are the "Physics," how do we actually build something? This is where I have really struggled, so let’s break it down simply:

The Image is your Instruction Book. It isn’t "alive." It is a read-only set of instructions (Layers) on how to build a room.
Layer 1: Lay the foundation (Linux/Python).

Layer 2: Bring in the tools (FastAPI/Libraries).

Layer 3: Add your personal stuff (Your Code).

The Container: The Actual Room
The Container is the Actual Room built by following those instructions. When you "Run" the book, Docker follows the layers and opens the door. Now the room is active and isolated.If you dont get it now dont worry we will cover this more in detail in an incomming chapter.

The Final Quest: Jack’s "Ghost" Protocol

Jack stood in front of the terminal, sweating. He wanted to prove to Rose that he wasn't just "running commands" he was a Master of Dimensions.

"Watch this," he whispered. "I’m going to step into another world where your files don't even exist."

Now, it’s your turn to be Jack.

Your Mission(If you choose to accept it):
Open your terminal (Your "Teleportation Device").

Type:

docker run -it ubuntu bash

Once you’re in, try to find your "Downloads" folder or your "Pictures."

Typels(List files).

Type ps aux (See running processes).

The Moment of Truth: Do you see your Spotify playing? Do you see your Chrome tabs? No. You are a ghost. You are in a Namespace wrapper. You have the Security of a vault and the Strength of a Cgroup bodyguard.

If you successfully "teleported" without crashing your laptop, leave a comment below saying: "I'm in the Namespace, Jack!"

Next Episode: The Secret Scroll
Jack has explored the "Apartment," but now he wants to build his own. But he can't just wish it into existence he needs to write the Secret Scroll (The Dockerfile).

In Episode 3, we learn the ancient language of FROM, COPY, and RUN to build our very own world from scratch.

Don't let the Whale wait—see you in the next one!

Docker Chronicles Ep. 1: The Curse of the "Betrayed Friend"

Fjr — Fri, 01 May 2026 06:23:25 +0000

Long ago, the developer world lived in a state of constant distress. Hope was dimming under a legendary ancient curse: "But... It worked on my machine!"
This is the story of how that curse was broken by a hero. A hero that arrived in a flash of light to save our sanity. This is the story of The Great Docker.

The Tragedy of Jack and Rose

Jack spent weeks building a bombastic computer science project. It was perfect. It was beautiful. It worked like a charm on his laptop.

His best friend, Rose, was so excited to work together. Jack handed over the code, and Rose tried to run it on her system.

BOOM. 💥

Errors everywhere. Red text scrolling like a digital nightmare. Her system didn't just crash; it felt like it gave up on life.

Rose felt betrayed. "Jack, how could you do this to me? I thought we were partners! Why did you build something that won't work on my machine?"

Jack felt so sorry; he was emotional. He had given her all the requirements, but he realized one thing: his system environment was different. Their worlds were incompatible. There wasn't enough room on the "system boat" for both of them.

Just as Jack was about to give up, a hand touched his shoulder. A whale-shaped hero emerged from the mist: The Great Docker.

Step into the Docker World:

The "Apartment" Mystery When Jack first saw Docker, he scoffed. "Oh, so you’re just a Virtual Machine (VM)? Boring."

Docker just smirked. "Step forward into my world, kid. Let me show you the difference."

The Virtual Machine (The Separate Mansions)

Imagine a giant piece of land (your Hardware). A VM is like building three separate, massive mansions on that land. Each mansion has its own foundation, its own kitchen, and its own security guard (Guest OS/Kernel). It’s heavy. It’s slow. Each mansion takes up its own huge chunk of memory and CPU. To give your app to a friend, you have to give them the entire mansion.
The Docker Way (The Smart Apartment Complex)

Docker is different. Docker uses the Host Kernel (the "Main Infrastructure" of the city). Instead of building 3 mansions, Docker builds 3 Containers (Smart Apartments).They are Isolated—they don't contact each other—but they use the same city water and electricity (The Kernel). Because they don't need a separate Kernel for every container, they are lightweight and easy to share.

The Secret Sauce: Whether you are on Mac, Windows, or Linux, as long as you have the Linux kernel (or a way to talk to it), the container fits perfectly. You don't need a whole new computer you just need the container!

Why The Great Docker?

Docker looks at Jack and says, "Kid, I’m not just a box. I’m a lifestyle change. Here is why every developer in the world is looking for me:"

The 3 Superpowers of the Great Docker

1: The "It Works Everywhere" Shield
You know how Rose's system blasted? With me, that never happens. I package your code, your libraries, and your settings into a single Container. If it works on your laptop, it will work on Rose’s laptop, the production server, and even your grandma's old computer (if it runs Docker). No more environment drama!

2: The "Flash" Speed (Efficiency)
Virtual Machines are like old, heavy giants. They take minutes to wake up because they have to start a whole Operating System. But me? I'm a ninja. I start in seconds. Because I share the Host Kernel, I don’t waste your RAM or CPU. You can run dozens of me without your laptop turning into a heater!

3: The "Forbidden Room" (Isolation)
In the old days, if one project needed Python 2 and another needed Python 3, they would fight like cats and dogs until your system crashed. In the Docker world, each container is its own 'Forbidden Room.' What happens in Container A stays in Container A. No more 'Package Wars' on your main system!

Now that you’ve met the Hero, it’s time to see if you have what it takes to join the crew. Complete these three tasks to earn your Episode 1 Badge.

Task 1: The Summoning Ritual
You can’t fight the "It works on my machine" curse without the right weapon.

Your Mission: Install Docker and run this command in your terminal: docker run hello-world

The Goal: If you see a message saying "Hello from Docker!", the Hero has officially entered your system. If it fails... well, you might still be on the sinking ship.

Task 2: The "Betrayal" Confession
We’ve all been Jack or Rose at some point.

The Question: What was the most "bombastic" project you ever built that completely exploded when you gave it to a friend or a teacher?

Action: Tell your story in the comments. Let’s heal from our collective trauma together.

Task 3: The Brain Teaser
In our story, we said Docker is like an Apartment Complex and a VM is like a Mansion.

The Riddle: If you have a very tiny computer with very little RAM (electricity), which one would you choose to run 10 different apps? The Apartment or the Mansion? Why?
📢 The "Cliffhanger"
Stay tuned for Episode 2: The Secret Scroll (Dockerfile), where we learn how Jack writes the magical instructions to bottle up his project so it never sinks again!