The Practical DeveloperModify

2026-01-21 11:49:19

At first, Docker feels like a magic fix.
Wrap your app in a container, run a few commands, and suddenly everything works.

But as you gain experience, you realize something important:

Docker is not just a tool.
It’s a way of thinking about software.
This article is not a Docker tutorial.
It’s a practical playbook — the kind of lessons you learn only after using Docker in real projects.
The Real Problem Docker Solves
Docker doesn’t exist to impress us with containers and images.
It exists to solve one simple problem:
Consistency.
Same app
Same dependencies
Same behavior
→ everywhere
Laptop.
CI pipeline.
Production server.
When environments behave differently, teams slow down.
Docker removes that friction.
Images vs Containers (Explained Simply)
This confuses almost everyone at the beginning.
Think of it like this:
Docker Image → A packaged recipe
Docker Container → The running dish
You build the image once.
You can run it many times.
Nothing magical — just disciplined packaging.
Docker Is Not About Complexity
One mistake I often see is treating Docker as a reason to over-engineer.
You don’t need:
20 services
Complex networking
Heavy tooling
on day one.
A senior approach is different:
Start simple. Let complexity earn its place.
If a single container works, use one.
If you need multiple services later, Docker makes that transition smoother.
The Hidden Power: Team Productivity
Docker’s biggest win is not technical.
It’s human.
New developer joins → setup in minutes
CI failures reduce
Fewer “works on my machine” discussions
Docker creates a shared contract between developers, QA, and operations.
Everyone runs the same thing.
Docker in Real Projects (What Actually Matters)
After the basics, these things start to matter more:

1. Smaller images Large images slow everything down — builds, pulls, deployments.
2. Clear responsibility One container should do one job.
3. Docker Compose for local development It turns complex systems into a single command: docker compose up That’s powerful.
4. Security basics Running everything as root inside containers is easy — and risky. Good enough security beats perfect security that never ships. Common Mistakes I’ve Seen (And Made) Using Docker without understanding what runs inside Treating Docker as a silver bullet Ignoring logs and monitoring Copy-pasting Dockerfiles without thinking Docker doesn’t replace engineering judgment. It amplifies it — good or bad. Docker Is a Career Skill Now At some point, Docker stops being optional. If you work with: Backend systems Microservices Cloud platforms CI/CD pipelines Docker becomes part of your daily language. Not knowing Docker today is like avoiding Git years ago. Final Thought Docker doesn’t guarantee success. But it removes a whole category of unnecessary problems. And that’s powerful. Good engineers don’t just write code that works. They make sure it runs reliably — everywhere. Docker helps you do exactly that. Thanks for reading 🙌 If you’re using Docker in your workflow, I’d love to hear: What helped you the most? What confused you early on? Let’s learn from each other.

2026-01-21 11:46:54

How memory leaks happen and how the Mark-and-Sweep algorithm works.

Timothy was staring at the dashboard he was building. It was getting slow. Sluggish.

"I don't understand," he said. "I am just creating objects. I'm not running heavy calculations. Why is the browser freezing?"

Margaret walked to the chalkboard and drew a large rectangle.

"Because you are running out of space, Timothy. This is the Heap."

The Heap (Memory is Finite)

"The Heap is where JavaScript stores objects, arrays, and functions," Margaret explained. "It is large, but it is not infinite. If you keep allocating memory without freeing it, you exhaust the available space. The browser freezes."

"But I don't free anything," Timothy said. "I just move to the next function."

"You don't have to free memory manually," Margaret corrected. "The Garbage Collector (GC) does it for you. But it follows very strict rules."

Reachability (Mark-and-Sweep)

Margaret drew a small circle at the top of the board and labeled it Root (Window).

"How does the GC know which objects to keep and which to destroy?" she asked.

"It checks if I'm using them?"

"No," Margaret said. "It checks if they are Reachable."

She drew arrows connecting the Root to various objects.

"This is the Mark-and-Sweep algorithm," she said.

1. The Roots: The GC starts at the "Roots" (The Global window object and the current Call Stack).
2. The References: It follows every reference (every variable, every property). If an object is connected to a Root, it is marked "Safe."
3. The Sweep: Any object that cannot be reached from a Root is considered garbage. It is marked for deletion and removed during the next GC cycle.

The Disconnect

Margaret erased a line on the board.

let user = { name: "Timothy" }; 
// 1. The 'user' variable is a Reference from the Root to the object.

user = null; 
// 2. The Reference is broken.

"When you set user = null," Margaret explained, "you didn't delete the object. You just broke the Reference."

"So the object is stranded?" Timothy asked.

"Exactly. The next time the GC runs, it will start at the Root, try to find that object, and fail. Since it is unreachable, the space is reclaimed."

The Memory Leak

Timothy looked at his slow code. "So if my app is slow, it means I am holding onto objects I don't need?"

"Yes," Margaret said. "You have a Memory Leak. You are accidentally keeping a Reference alive."

She wrote a common trap on the board:

function startDashboard() {
    const hugeData = new Array(100000).fill("Data");

    // The Trap:
    window.addEventListener('resize', () => {
        console.log(hugeData.length);
    });
}

"Trace the References," Margaret commanded.

Timothy looked at the diagram.

1. The Root (Window) has an Event Listener attached to it (resize).
2. The Listener is a function that uses hugeData.
3. Because of Closure, the Listener must hold a reference to hugeData.

"I see it," Timothy realized. "The Window holds the Listener. The Listener holds the Data."

"Correct," Margaret said. "Even if startDashboard finishes running, that connection remains. The GC sees a clear path from the Root to your massive array. It cannot delete it."

The Solution

"How do I fix it?" Timothy asked.

"You must break the reference," Margaret said.

She added the cleanup code:

window.removeEventListener('resize', myListener);

"Remove the listener," she said. "The connection breaks. The huge data becomes unreachable. The Garbage Collector sweeps it away, and your browser breathes again."

The Conclusion

"Memory management isn't about micromanaging every object," Margaret concluded, wiping the chalk dust from her hands. "It's about understanding the invisible connections that keep data alive. Break the connections you don't need, and let the garbage collector do its job."

Aaron Rose is a software engineer and technology writer at tech-reader.blog and the author of Think Like a Genius.

2026-01-21 11:39:56

👋 Short Intro (Why I’m Writing This)

I’m currently learning HTML and decided to learn in public by documenting my journey.

This blog is part of my HTML-101 series, where I’m learning HTML step by step from scratch.

This series is not written by an expert — it’s a beginner learning out loud, sharing:

• what I understand,
• what confuses me,
• and what I learn along the way.

The goal is to build consistency, clarity, and invite discussion.

📌 What This Blog Covers

In this post, I’ll cover:

1. Quick recap — what paths are (short)
2. Anchor tag basics (<a>) and anatomy
3. Types of href values (absolute, relative, fragment, mailto, tel)
4. Important attributes: target, rel, download, title
5. Link states, styling, accessibility & keyboard behavior
6. Mailto links: formats and extra parameters (subject, body)
7. Tel links: formatting and best practices
8. When to use links vs buttons
9. Common mistakes and tips

📂 GitHub Repository

All my notes, examples, and practice code live here:

👉 GitHub Repo:

https://github.com/dmz-v-x/html-101

This repo is updated as I continue learning.

📚 Learning Notes

1. Quick recap — What a path is (1 line)

A path tells the browser where to find a file (image, page, script, stylesheet).

Examples:

<img src="images/logo.png">
<a href="pages/about.html">About</a>
<link rel="stylesheet" href="css/style.css">

• Difference between src, href and rel

2. Anchor tag basics — what is <a>?

<a> (anchor) creates clickable links.

Basic example:

<a href="https://example.com">Visit Example</a>

• href = destination (required for a real link)
• Link text = what users see and click

If href is missing, <a> is not treated as a link by browsers and assistive tech.

3. Types of href values

3.1 Absolute URL (external)

Full web address with protocol:

<a href="https://youtube.com">YouTube</a>

Use when linking to another website or CDN.

3.2 Root-relative path

Starts from the site root (/):

<a href="/about">About</a>
<img src="/assets/images/logo.png">

Works reliably when the site is hosted at domain root.

3.3 Relative path

Relative to the current file’s folder:

<!-- current file: /project/index.html -->
<a href="pages/about.html">About</a>
<img src="images/logo.png">

Use for files inside the same project.

3.4 Fragment / Anchor (jump within page)

Jump to an element with a matching id:

<h2 id="projects">Projects</h2>
<a href="#projects">Go to Projects</a>

3.5 mailto: (email) and tel: (phone)

Special schemes that launch apps:

<a href="mailto:[email protected]">Email me</a>
<a href="tel:+911234567890">Call me</a>

4. Anchor tag anatomy (basic + attributes)

<a href="URL" target="_blank" rel="noopener noreferrer" title="Tooltip">
  Link Text
</a>

• href — destination (URL, path, mailto, tel, or fragment)
• target — where to open (_self, _blank, _parent, _top)
• rel — relationship / security (important with _blank)
  • noopener prevents the new page from getting window.opener
  • noreferrer prevents sending the referrer URL
• download — suggests downloading the resource instead of navigating
• title — tooltip (use sparingly; not always helpful for accessibility)

Safe new-tab pattern (always do this):

<a href="https://example.com" target="_blank" rel="noopener noreferrer">
  External site
</a>

5. Link states & basic styling

Browsers provide pseudo-classes for link states:

• a:link — unvisited link
• a:visited — visited link
• a:hover — mouse over
• a:active — pressed/clicking
• a:focus — focused via keyboard (Tab)

Order in CSS: :link, :visited, :hover, :active, :focus (LVHAF).

Basic styling example:

a {
  color: #1e90ff;
  text-decoration: none; /* remove underline */
}
a:hover {
  text-decoration: underline;
}
a:focus {
  outline: 3px solid #f59e0b;
  outline-offset: 2px;
}

Usability tip: If you remove underline, show a clear hover or focus indicator so users know it’s a link.

6. Accessibility & keyboard behavior

• Links are keyboard-focusable by default and activate with Enter.
• Never remove focus outline without replacing it with a visible focus style.
• Link text should be descriptive (avoid “click here”).

Good vs bad:

<!-- Bad -->
<a href="mailto:[email protected]">Click here</a>

<!-- Good -->
<a href="mailto:[email protected]">Email Support</a>

7. Anchor vs Button — When to use what?

• Use <a> for navigation (go to a new page, external link, fragment).
• Use <button> for actions on the current page (open modal, submit form, toggle UI).

Bad pattern:

<a href="#" onclick="submitForm()">Submit</a> <!-- ❌ -->

Better:

<button type="button" onclick="submitForm()">Submit</button> <!-- ✅ -->

8. download attribute (force download suggestion)

<a href="/files/resume.pdf" download>Download Resume</a>
<a href="/files/resume.pdf" download="Himanshu-Bhatt-Resume.pdf">Download</a>

Browser may still open the file depending on type & user settings, but download suggests saving.

9. Mailto links — more details & extras

Basic mailto:

<a href="mailto:[email protected]">Email me</a>

Multiple recipients:

<a href="mailto:[email protected],[email protected]">Email both</a>

Add subject and body (URL-encoded):

<a href="mailto:[email protected]?subject=Hello%20from%20site&body=Hi%20there%2C%0A%0AI%20found%20your%20site.">
  Email with subject
</a>

• Spaces → %20
• New lines → %0A or %0D%0A
• Use ? for first param, & for others

Note: mailto opens the user’s email client. Not all desktop users have a configured client.

10. Tel links — formatting & best practice

Basic:

<a href="tel:+911234567890">+91 12345 67890</a>

• Use international format (+ + country code) in href.
• Display can show spaces or local formatting for readability.
• tel: opens dialer on mobile; desktop behavior varies.

Good examples:

<!-- Display friendly, href machine-friendly -->
<a href="tel:+14155552671">+1 (415) 555-2671</a>
<a href="tel:+911234567890">+91 12345 67890</a>

11. Usability & accessibility tips for mail/tel links

• Make link text descriptive: Email Support or Call Support.
• For phone numbers, consider adding aria-label for clarity:

<a href="tel:+911234567890" aria-label="Call support at +91 12345 67890">
  +91 12345 67890
</a>

• Don’t rely on mailto: for forms that require structured data — prefer actual contact forms for reliability and spam protection.

12. Common mistakes (summary)

• Forgetting to add rel="noopener noreferrer" with target="_blank".
• Using links for actions that should be buttons (accessibility & semantics).
• Using href="#" — this is an anti-pattern (it changes the URL or scrolls).
• Poor link text like “click here” — not descriptive for screen reader users.
• Not testing mailto: / tel: behavior on mobile vs desktop.

⚠️ Challenges / Mistakes I Faced

When I started, I used links for things that should be buttons and I often forgot rel="noopener noreferrer" for target="_blank".

I also learned that mailto: and tel: work great on mobile but may behave differently on desktop.

If you faced any issues or have questions, feel free to let me know in the comments 🙂

💬 Feedback & Discussion

💡 I’d love your feedback!

If you notice:

• something incorrect,
• a better explanation,
• or have suggestions to improve my understanding,

please comment below. I’m happy to learn and correct mistakes.

⭐ Support the Learning Journey

If you find these notes useful:

⭐ Consider giving the GitHub repo a star —

it really motivates me to keep learning and sharing publicly.

🐦 Stay Updated (Twitter / X)

I share learning updates, notes, and progress regularly.

👉 Follow me on Twitter/X:

https://x.com/_himanshubhatt1

🔜 What’s Next

In the next post, I’ll be covering:

👉 Internal Page Navigation

I’ll also continue updating the GitHub repo as I progress.

🙌 Final Thoughts

Thanks for reading!

If you’re also learning HTML, feel free to:

• follow along,
• share your experience,
• or drop questions in the comments 👋

📘 Learning in public

📂 Repo: https://github.com/dmz-v-x/html-101
🐦 Twitter/X: https://x.com/_himanshubhatt1
💬 Feedback welcome — please comment if anything feels off
⭐ Star the repo if you find it useful

2026-01-21 11:20:39

Lab Information

The Nautilus DevOps team is strategizing the migration of a portion of their infrastructure to the AWS cloud. Recognizing the scale of this undertaking, they have opted to approach the migration in incremental steps rather than as a single massive transition. To achieve this, they have segmented large tasks into smaller, more manageable units. This granular approach enables the team to execute the migration in gradual phases, ensuring smoother implementation and minimizing disruption to ongoing operations. By breaking down the migration into smaller tasks, the Nautilus DevOps team can systematically progress through each stage, allowing for better control, risk mitigation, and optimization of resources throughout the migration process.

For this task, create an AWS EBS volume using Terraform with the following requirements:

Name of the volume should be nautilus-volume.

Volume type must be gp3.

Volume size must be 2 GiB.

Ensure the volume is created in us-east-1.

The Terraform working directory is /home/bob/terraform. Create the main.tf file (do not create a different .tf file) to accomplish this task.

Note: Right-click under the EXPLORER section in VS Code and select Open in Integrated Terminal to launch the terminal.

Lab Solutions

Create main.tf

# main.tf

# Get the default VPC in us-east-1
data "aws_vpc" "default" {
  default = true
}

# Get availability zones in us-east-1
data "aws_availability_zones" "available" {
  state = "available"
}

# Create EBS volume
resource "aws_ebs_volume" "nautilus_volume" {
  availability_zone = data.aws_availability_zones.available.names[0]
  size              = 2
  type              = "gp3"

  tags = {
    Name = "nautilus-volume"
  }
}

To deploy this configuration:

Navigate to the Terraform directory:

cd /home/bob/terraform

Initialize Terraform:

terraform init

Output

bob@iac-server ~/terraform via 💠 default ➜  terraform init
Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/aws versions matching "5.91.0"...
- Installing hashicorp/aws v5.91.0...
- Installed hashicorp/aws v5.91.0 (signed by HashiCorp)
Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Plan the deployment to verify the configuration:

terraform plan

Output

bob@iac-server ~/terraform via 💠 default ➜  terraform plan
data.aws_vpc.default: Reading...
data.aws_availability_zones.available: Reading...
data.aws_availability_zones.available: Read complete after 2s [id=us-east-1]
data.aws_vpc.default: Read complete after 2s [id=vpc-cef5c033f2482a228]

Terraform used the selected providers to generate the following execution plan. Resource
actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # aws_ebs_volume.nautilus_volume will be created
  + resource "aws_ebs_volume" "nautilus_volume" {
      + arn               = (known after apply)
      + availability_zone = "us-east-1a"
      + encrypted         = (known after apply)
      + final_snapshot    = false
      + id                = (known after apply)
      + iops              = (known after apply)
      + kms_key_id        = (known after apply)
      + size              = 2
      + snapshot_id       = (known after apply)
      + tags              = {
          + "Name" = "nautilus-volume"
        }
      + tags_all          = {
          + "Name" = "nautilus-volume"
        }
      + throughput        = (known after apply)
      + type              = "gp3"
    }

Plan: 1 to add, 0 to change, 0 to destroy.

─────────────────────────────────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to
take exactly these actions if you run "terraform apply" now.

Apply the configuration:

terraform apply

Then type yes when prompted to confirm the creation of the EBS volume.

Output

bob@iac-server ~/terraform via 💠 default ➜  terraform apply
data.aws_availability_zones.available: Reading...
data.aws_vpc.default: Reading...
data.aws_availability_zones.available: Read complete after 0s [id=us-east-1]
data.aws_vpc.default: Read complete after 0s [id=vpc-cef5c033f2482a228]

Terraform used the selected providers to generate the following execution plan. Resource
actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # aws_ebs_volume.nautilus_volume will be created
  + resource "aws_ebs_volume" "nautilus_volume" {
      + arn               = (known after apply)
      + availability_zone = "us-east-1a"
      + encrypted         = (known after apply)
      + final_snapshot    = false
      + id                = (known after apply)
      + iops              = (known after apply)
      + kms_key_id        = (known after apply)
      + size              = 2
      + snapshot_id       = (known after apply)
      + tags              = {
          + "Name" = "nautilus-volume"
        }
      + tags_all          = {
          + "Name" = "nautilus-volume"
        }
      + throughput        = (known after apply)
      + type              = "gp3"
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

aws_ebs_volume.nautilus_volume: Creating...
aws_ebs_volume.nautilus_volume: Still creating... [10s elapsed]
aws_ebs_volume.nautilus_volume: Creation complete after 10s [id=vol-3e6e15fb552e10e08]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Resources & Next Steps

📦 Full Code Repository: KodeKloud Learning Labs

📖 More Deep Dives: Whispering Cloud Insights - Read other technical articles

💬 Join Discussion: DEV Community - Share your thoughts and questions

💼 Let's Connect: LinkedIn - I'd love to connect with you

Credits

• All labs are from: KodeKloud

• I sincerely appreciate your provision of these valuable resources.

2026-01-21 11:14:39

Let me guess.

Last week, you finally understood something.
It clicked.
You felt smart. Dangerous, even.

Then this week… you opened your editor and thought:

“Wait. Why does none of this look familiar?”

Congratulations. You’re not broken.
You’re officially learning to code.

The Lie We’re All Told

Somewhere along the way, we’re made to believe that learning to code works like this:

Learn something → remember it forever → move on.

That might work for memorizing song lyrics.
It does not work for programming.

If forgetting code was a sign you’re bad at it, there would be approximately zero developers left on Earth.

Your Brain Is Not a USB Drive

This was a hard pill for me to swallow.

I used to think:

“If I forget this, it means I didn’t really learn it.”

No. It means your brain is doing what brains do.

Code isn’t facts.
It’s patterns, logic, and decisions.

If you don’t use it, your brain quietly says:

“Wow. Not important. Deleting.”

Ruthless. Efficient. Slightly rude.

Tutorials Make This Worse (Sorry)

Tutorials are great… until they aren’t.

When you follow along:

• The decisions are already made
• The structure is given
• The problems are pre-solved

Your brain is basically on passenger mode.

So when the tutorial ends and you try to build something alone, your brain panics:

“Wait, we were just watching. Why are we driving now?”

That’s why everything disappears.

Forgetting Is Not Failure. It’s a Signal

This part changed how I see learning.

Forgetting usually means:

• You didn’t struggle enough
• You didn’t make decisions
• You didn’t break anything

The things you remember best are the ones that:

• Took you forever
• Made you angry
• Broke three times before working

Pain = memory.
Sadly.

The Moment I Stopped Panicking

I remember opening a project and realizing I couldn’t remember how I did something I literally wrote.

Past me had betrayed present me.

Instead of panicking, I tried something new:
I reread my own code.

And suddenly it came back.

Not because I memorized it, but because I understood why it existed.

That’s when I realized:

The goal isn’t to remember code.
The goal is to remember how to figure it out again.

What Good Developers Actually Remember

Here’s a secret.

Good developers don’t remember:

• Exact syntax
• Every method name
• Every edge case

They remember:

• How to think
• How to break problems down
• Where to look when they forget

They Google. Constantly. Confidently. Shamelessly.

How to Forget Less (Without Trying Harder)

Here’s what actually helps:

1. Build Something Small After Learning

Even a tiny thing.
Especially a tiny thing.

Your brain remembers decisions, not explanations.

2. Revisit Old Code (Yes, It’s Ugly)

Reading your past code feels like reading old diary entries.

Cringe.
But powerful.

3. Explain It to an Imaginary Person

If you can explain it without code, you understand it.
If you can’t, that’s okay! Now you know what to revisit.

The Reframe That Saved Me

Now, when I forget something, I don’t think:

“I’m bad at this.”

I think:

“Okay. I’ve seen this before. Let’s reconnect the dots.”

Learning to code is not about building a perfect memory.

It’s about building familiarity.

And familiarity comes back faster every time.

Final Thought

If you’re forgetting code you learned last week, you’re not behind.

You’re not stupid.
You’re not failing.

You’re just doing something hard, and doing it honestly.

And that’s exactly how real developers are made.

If this article felt a little too real, you’re my people.

What’s the last thing you forgot that made you question everything? 😄

2026-01-21 11:03:12

🦬 YAKMESH™ v2.5.0 Released!

A new version of YAKMESH - the post-quantum secure P2P mesh network - has been published!

What is YAKMESH?

YAKMESH is a high-resiliency, decentralized networking layer with:

• 🔒 Post-Quantum Security - ML-DSA-65 (NIST FIPS 204) signatures
• 🔮 Self-Verifying Oracle - Code-as-authority trust model
• 🌐 Mesh Networking - P2P WebSocket with gossip protocol
• ⏱️ Precision Timing - Atomic clock, GPS, PTP support

Install

npm install [email protected]

Links

• 📖 Documentation
• 💻 GitHub
• 📦 npm
• 💬 Discord
• 📱 Telegram

Built with quantum principles. Secured by math.