DEV Community: Melody Mbewe

Want to Stand Out as a Junior Developer? Do it MORE.

Melody Mbewe — Fri, 23 May 2025 14:36:55 +0000

I remember the exact moment I realized I was doing it all wrong.

It was 2 AM, and I was deep in my third "Learn React in 30 Days" tutorial. My browser had seventeen tabs open with different coding courses, my notepad was filled with “best practices” I'd copied from various blogs, and my GitHub? Completely empty.

I felt productive. I felt like I was learning.

But I wasn't getting anywhere.

Then my friend, who started coding at the same time as I did—landed his first developer job. When I asked him for his secret, his answer floored me:

"I stopped watching tutorials and started building stuff. Lots of stuff. Ugly stuff. Broken stuff. But I kept building."

That night changed everything for me.

And if you're reading this, it might change everything for you, too.

💥 Forget Everything You Think You Know About "Talent"

Here’s the uncomfortable truth nobody wants to tell you: talent is overrated.

I’ve watched countless “naturally gifted” developers plateau while the “average” ones who just wouldn’t quit eventually lapped them.

The developer who seems impossibly smart?

They’ve just failed more times than you’ve tried.

The magic formula isn’t complicated:

Forget talent
Forget intelligence
Forget "natural ability"

🧠 The junior who writes more JavaScript becomes the senior who has mastered JavaScript.

It’s that simple.

And that's hard.

🔁 While You're Stuck in Tutorial Hell, Others Are Building

Right now, while you're reading this, another junior developer is building their 15th project.

It's probably not perfect.

It might not even work properly.

But they're building.

While others debate the “best” way to learn coding,

you should be coding.

While others wait for the perfect tutorial,

you should be building.

The harsh reality check I needed (and you probably need too):

✅ 3 projects built? You're still figuring out the basics
🔄 10 projects built? Now you're getting somewhere
🔥 30 projects built? You're outpacing 90% of other juniors
🏆 50+ projects built? You're not a junior anymore

📊 The Brutal Math of Standing Out

I applied to 47 companies.

Got rejected by 46.

The one that hired me?

They didn’t care about my bootcamp certificate or my perfect resume.

They cared about my GitHub.

"We can see you actually build things,"

the hiring manager said.

"Most candidates talk about what they want to build. You show us what you've already built."

That’s when it hit me:

You don’t need a fancy degree, the perfect mentor, or to be the smartest person in the room.

You just need to outwork everyone else.

🔥 The 20x Rule That Changes Everything

Want to become exceptional at React?

Build 20 React projects while others build 2.

Want to master algorithms?

Solve 500 problems while others solve 50.

Want to become invaluable as a junior?

Fix 100 bugs while others fix 10.

This isn’t motivational fluff.

This is how mastery works.

The senior developer who seems “gifted”?

They’ve simply logged more failures, more attempts, more reps.

😵 Why This Works (And Why It’s So Uncomfortable)

The difference between average and outstanding isn’t some hidden secret.

It’s repetition.

It’s volume.

It’s doing it MORE.

And here’s the truth:

Your 30th to-do app will feel boring
Your 200th algorithm will feel repetitive
Your 15th CRUD app won’t feel “new”

But that discomfort? That’s where the magic happens.

🧨 Your Competition Is Making a Fatal Mistake

While you could be building, your competition is:

Watching another tutorial
Reading another “How to Learn Coding” article
Waiting to feel “ready”
Debating which framework to learn first
Looking for the perfect project idea

They're stuck in preparation mode

while you could be in execution mode.

🚀 The 30-Day Challenge That Will Transform Your Career

Here’s my challenge to you:

What would happen if you doubled your output every week for the next month?

📅 Week Breakdown:

Week 1: Build 1 small project
Week 2: Build 2 projects
Week 3: Build 4 projects
Week 4: Build 8 projects

Yes, they’ll be simple.

Yes, some will be broken.

Yes, you’ll repeat yourself.

Do it anyway.

By the end of 30 days, you’ll have built 15 projects.

That’s more than most juniors build in a year.

🏃‍♀️ Stop Looking for Shortcuts — The Shortcut IS the Work

I wasted six months looking for the “best” way to learn to code.

I could have built 50 projects in that time.

The shortcut isn’t a better tutorial.

The shortcut is doing the work.

MORE of it
FASTER than others
MORE consistently

🔧 My Project Evolution (And Why Ugly Code Beats No Code)

Let me show you what this actually looks like:

Let me show you what this looks like in practice. My first project was a calculator that broke when you divided by zero. Embarrassing? Absolutely. But I built it.

Later, I made a weather app that only worked for one city. Still embarrassing, but slightly less broken.

Eventually, I built a task manager with user authentication. Not perfect, but actually useful.

And somewhere along the way, all that building led to my first developer job.

Each project wasn't a masterpiece. But each project made me better. The accumulated knowledge from building all those "mediocre" projects was more valuable than any single "perfect" project I could have spent months planning.The Reality Check You Need to Hear

If you've been coding for months but only have a few projects to show for it, you're not behind because you're not smart enough. You're behind because you haven't done enough repetitions.

The solution isn't to find a better resource or wait for inspiration. The solution is to build something today. And tomorrow. And the day after that.

Every line of code you write makes you better. Every bug you encounter teaches you something. Every project you finish builds confidence.

Each project wasn’t a masterpiece.

But each one made me better.

The cumulative knowledge of 35 “meh” projects?

More valuable than one “perfect” one.

🧠 The Reality Check You Need to Hear

If you've been coding for months but only have a few projects to show, you’re not behind because you’re not smart enough.

You’re behind because you haven’t done enough reps.

The solution isn’t more research.

The solution is to build something today.

Then do it again tomorrow.

Every line of code teaches you
Every bug helps you
Every project builds confidence

✅ Your Next Step Is Surprisingly Simple

Stop reading.

Start building.

Open your editor.

Create a new project.

It doesn’t matter what:

A random quote generator
A tip calculator
A color palette picker

Make it work.

Make it broken.

Make it ugly.

Just make it.

Then do it again tomorrow.

The junior developer who does this consistently

won’t stay junior for long.

💬 Let’s Discuss

What’s the first project you’re going to build after reading this?

Drop it in the comments. Let’s hold each other accountable.

The dev community is cheering you on. 🙌

Linux First: Your Step-by-Step DevOps Foundation Guide

Melody Mbewe — Wed, 23 Apr 2025 07:27:47 +0000

After my post about learning Linux before diving into Kubernetes, some of you asked for more specific guidance. Shout out to KC, who perfectly captured what many were thinking: "Can you detail those 5 steps? I've been using WSL but had no idea you could build a web server in it."

Challenge accepted! Let's break down how to build that Linux foundation that makes everything else in DevOps click—whether you're on Windows, macOS, or already running Linux.

Step 1: Install a Linux distro (and actually use it daily)

The goal here isn't just having Linux—it's making it part of your daily workflow until it becomes second nature.

Windows Users:

WSL (Windows Subsystem for Linux) is your best friend. Here's how to get started:

Open PowerShell as administrator and run:

   wsl --install

This installs Ubuntu by default, which is perfect for beginners.

After installation, create your Linux user and password when prompted.
Make WSL part of your daily routine:
- Set up Windows Terminal to open WSL by default
- Keep a terminal open while coding
- Challenge: Try doing your git operations from the WSL terminal instead of GUI tools for a week

macOS Users:

You're already on a Unix-based system, which is helpful, but I still recommend a Linux VM for the full experience:

Install UTM (free) or Parallels (paid) to run Linux VMs
Install Ubuntu or Debian and allocate at least 2GB RAM
Or if you prefer containers: brew install docker and run a Linux container

Linux Desktop Users:

You're already ahead! Just make sure you're:

Using the command line regularly instead of GUI tools
Learning your distro's package manager inside out
Managing your system via the terminal

Step 2: Learn Bash (it's your DevOps superpower)

I used to think Bash was just "that thing where I type commands." Now I know it's the secret weapon of productive DevOps engineers.

Bash Basics to Advanced:

Create a practice.sh file with:

   #!/bin/bash
   echo "Hello, $(whoami)! Today is $(date)"

Make it executable:

   chmod +x practice.sh
   ./practice.sh

Build a real automation script (start simple):

   #!/bin/bash

   # Simple backup script
   SOURCE_DIR="$HOME/projects"
   BACKUP_DIR="$HOME/backups"
   TIMESTAMP=$(date +"%Y%m%d_%H%M%S")

   # Create backup directory if it doesn't exist
   mkdir -p "$BACKUP_DIR"

   # Create the backup
   tar -czf "$BACKUP_DIR/backup_$TIMESTAMP.tar.gz" "$SOURCE_DIR"

   echo "Backup created at $BACKUP_DIR/backup_$TIMESTAMP.tar.gz"

Learn these bash concepts systematically:
- Variables and environment variables
- If/else conditionals
- Loops (for, while)
- Functions
- Processing command output
- Exit codes and error handling

I became comfortable with Bash by building small utility scripts for things I did repeatedly, like setting up development environments or cleaning up temp files.

Step 3: Build stuff manually (before automating)

This is the most transformative step. Before containerizing or automating, build it by hand.

Set Up a Basic Web Server in WSL/Linux:

Install Nginx:

   sudo apt update
   sudo apt install nginx

Start the service:

   sudo service nginx start

Create a custom HTML page:

   echo "<html><body><h1>My First Linux Web Server</h1></body></html>" | sudo tee /var/www/html/index.html

Access it:
- From WSL: curl localhost
- From Windows host with WSL: Open browser to http://localhost or http://[WSL-IP]

To find your WSL IP: ip addr show eth0 | grep "inet\b" | awk '{print $2}' | cut -d/ -f1

Other essentials to build manually:

Database server (MySQL/PostgreSQL)
SSH keys and secure server setup
Firewall configuration with ufw or iptables
Basic LAMP/LEMP stack
Cron jobs for scheduled tasks

When I first set up Nginx manually, I suddenly understood what all those Docker port mappings were doing—it wasn't magic anymore!

Step 4: Google like a pro (and understand what you're copying)

We all Google, but are you doing it effectively?

Sharpen your search skills:

Use specific error messages in quotes
Add your exact Linux distro to searches
Include version numbers
Try site-specific searches like site:stackoverflow.com nginx 403 forbidden

When reading solutions:

Break down each command:

   systemctl status nginx

What is systemctl? What does status do? What's the difference with service nginx status?

Use man pages and --help flags:

   man systemctl
   systemctl --help

Understand permissions and processes:

   ps aux | grep nginx
   ls -la /var/www/html

I keep a personal "command dictionary" where I document commands I've learned and what each flag does. It's become my most valuable resource.

Step 5: Document everything (your future self will thank you)

Documentation isn't just nice—it's necessary. Here's my system:

Set up a personal knowledge base:
- Use Markdown files in a git repo
- Try Obsidian or Notion
- Even a simple Google Doc works
Document even "obvious" things:

   # Setting up Nginx on Ubuntu 22.04

   1. Install: `sudo apt install nginx`
   2. Start service: `sudo service nginx start`
   3. Check status: `sudo service nginx status`
   4. Default config location: /etc/nginx/sites-available/default
   5. Web root: /var/www/html
   6. Logs: /var/log/nginx/

Include what didn't work (and why):

   Note: Initially tried using port 80 but got permission errors.
   Fixed by either:
   - Using port above 1024 (no sudo needed)
   - Or adding capability: `sudo setcap 'cap_net_bind_service=+ep' /usr/sbin/nginx`

I can't tell you how many times my documentation has saved me hours of frustration when revisiting something months later.

Bonus: Little-Known Linux Skills That Made Me Better

These smaller skills dramatically improved my Linux confidence:

1. Process and port management:

# Find what's using port 3000
sudo lsof -i :3000

# Kill a process
kill -9 <PID>

# Check resource usage
htop

2. System monitoring:

# Monitor logs in real-time
tail -f /var/log/nginx/error.log

# Check disk space
df -h

3. Network troubleshooting:

# Test connectivity
ping google.com

# Trace route
traceroute google.com

# DNS lookup
nslookup example.com

4. User and permission management:

# Add user to group
sudo usermod -aG docker $USER

# Change ownership
sudo chown -R user:group /path/to/directory

Putting It All Together

After getting comfortable with these steps, you'll find that:

Docker makes sense because you understand the Linux processes it's containerizing
Kubernetes feels logical because you know how networking and processes work
CI/CD is clearer because you understand the underlying shell commands
Configuration management tools like Ansible are intuitive because you've done the manual steps

Learning Linux first gave me something invaluable: confidence. Not the temporary confidence of following a tutorial, but the lasting confidence of understanding what's happening under the hood.

When things break in production (and they will), you won't freeze—you'll know exactly where to look and how to fix it.

So what are you waiting for? Open that terminal and start building your Linux foundation today. Your future DevOps self will thank you.

If this helped you, let me know what you build first! I'm always curious to see how others are starting their Linux journey. Drop a comment or DM me with your progress or questions.

The GitHub Chronicles: Your Contribution Graph Tells a Story (But Not the One You Think)

Melody Mbewe — Tue, 22 Apr 2025 09:01:50 +0000

Ever caught yourself staring at your GitHub contribution calendar, feeling a twinge of inadequacy as those gray squares stare back at you? I've been there too—my mouse hovering over someone else's perfectly manicured green grid, wondering what kind of coding superhuman I'm dealing with. That GitHub contribution graph, you keep staring at? It's not a scoreboard. It’s not a resume. It’s not a reflection of your worth. It’s just pixels.

But your journey? Now that’s the real masterpiece.

Let me confess something: I'm a "Just a Developer." My graph? A quiet sprinkle of commits here and there. It felt like standing in a gym next to a bodybuilder while you’re still trying to figure out how to use the treadmill.

But here's the twist: I’m still here. Still learning. Still building.

Because I’m not trying to be a GitHub wizard.
I’m just a developer.

The Seven GitHub Personalities: Where Do You Fit?

I recently stumbled on a hilarious, oddly accurate chart categorizing GitHub users that made me both laugh and reflect deeply. These patterns are eerily accurate:

1. Just a Developer (My Tribe)
Inconsistent but honest. Commits when it counts. Some days we ship features. Other days we battle bugs—or life. Our calendars show steady but inconsistent activity—commits sprinkled throughout the week with no particular pattern. Some days we're coding machines; other days we're debugging, researching, or simply thinking. It's authentic, it's messy, and it shows we have a life beyond the terminal.

What it really means: You're balancing coding with actual life. You commit when there's something worth committing, not for the sake of turning a square green.

2. The Weekender
No weekday commits, but weekends? All fire. The weekday grid? Empty my coffee cup by 10am. Likely juggling family, work, or a side hustle. Proof that coding isn’t a 9–5 for everyone.

What it really means: They're likely coding around other responsibilities—perhaps a non-tech day job or family commitments. Their focused weekend enthusiasm often produces some of the most interesting side projects.

3. The Unrealistic Expectations
Every. Single. Day. Green.
I don’t know if they sleep or if they've automated life itself. Looks impressive, but I worry they haven’t blinked since January. No holidays. No breaks. Just code, code, code.

What it really means: Either they've discovered the secret to never needing sleep, they're automating contributions, or more likely—they're optimizing for appearances rather than impact. Burnout waiting to happen.

4. The "Getting Ready to Search for a New Job"
Months of inactivity followed by a sudden explosion of green in October/November. It's the coding equivalent of crash-dieting before beach season.

What it really means: They understand the game. They know recruiters might peek at their profile, and they're strategically enhancing it. Smart? Yes. Authentic? Perhaps not entirely.

5. The GitHub Wizard
Their calendar forms deliberate patterns—names, shapes, or pixel-art hearts. Brilliant. Terrifying. Impressive and slightly concerning simultaneously. Do they eat?

What it really means: They're detail-oriented and have a flair for the creative. They also likely understand Git at a deeper level than most, scripting those perfect patterns.

6. The Mondrian
Named after the artist known for geometric paintings. Intense blocks of color, then total silence. They work in sprints, vanish to recharge, then come back swinging—creating an almost artistic composition.

What it really means: They work in focused project sprints with clear boundaries. They understand the power of deep work followed by genuine rest—a rhythm many of us aspire to.

7. The Cupid Shuffle
💖 Shaped commits? Hearts in your grid? Code meets poetry. Respect.

What it really means: They bring creativity to everything they do. Whether they're automating these patterns or meticulously planning them, they see coding as a form of self-expression.

💬 Real Talk: Your Green Squares Don’t Tell the Whole Story
After years of fluctuating between intense coding periods and quieter reflection times, I've come to a realization that transformed my relationship with those little green squares: The most important parts of a developer's journey leave no trace on GitHub.

Think about it:

The Saturday you spent reading docs instead of committing
The refactor that took 3 days and saved 30 bugs
The mental math that solved the logic problem in your head
The pair programming session that lit up someone else’s learning path
The late-night brainstorm that never made it to code—but shaped everything My most productive weeks? Often my emptiest GitHub weeks.

Why? Because growth doesn’t always leave digital fingerprints.

💡 What Really Makes You a Great Developer

Here's what I've learned about what truly matters in a developer's journey:

1. Impact Over Activity
A single, well-crafted PR that closes a nightmare bug is worth more than 40 commits that change variable names. Quality code speaks louder than a perfect contribution graph.

2. Sustainability Is the Real Metric
The "Unrealistic Expectations" type might win today’s race, but burnout is real. Your pace should be yours—slow, fast, paused, or passionate. The Unrealistic Expectation grid might look impressive, but is that pace sustainable for years? The most successful developers I know have found their rhythm—whether that's daily small commits or periodic deep dives.

3. Learning Happens in the Gray Squares = Growth Happens in the Quiet
Some of my biggest growth moments happened during periods where my GitHub activity was minimal. Thinking deeply about problems, reading a book. Watching a talk. Even resting. That’s growth. But GitHub doesn’t log naps or “Aha!” moments.

4. Coding ≠ Committing
You can build entire systems, lead a team, or mentor a junior dev—and not touch a repo for a week. Guess what? You’re still coding. You’re still building. You’re still valid. I've interviewed brilliant developers whose GitHub profiles were nearly empty—they had been working on proprietary code for years. And I've seen perfect green grids from developers who struggled with basic concepts.

🧭 Finding Peace in Your Pattern
It took me years to embrace my "Just a Developer" status. To stop chasing green squares and start chasing growth. Now I wear it as a badge of honor. It represents authenticity—showing up consistently but imperfectly, prioritizing impact over appearances. My graph shows chaos and calm. Focus and fatigue. Passion and pause. It shows I’m human. And honestly? That’s the kind of developer I want to work with.

Whatever pattern your calendar shows, ask yourself these questions:

Am I growing as a developer?
Is my code solving real problems?
Am I learning from both my active and quiet periods?
Does my current rhythm feel sustainable?

If you can answer yes to these, your GitHub pattern is perfect—whatever it looks like.

The Developers We Need

The tech industry doesn't need more developers obsessed with perfect contribution graphs. It needs:

Developers who solve real problems and prioritize users over green squares
Communicators who can explain complex code clearly
Mentors who help others grow
Thoughtful architects who consider the long view. The thinkers who zoom out before diving in
Sustainable coders who avoid burnout. Being the humans who code without losing themselves in the process

None of these qualities can be measured by a contribution graph.

Your Calendar, Your Story

I've made peace with my scattered constellation of commits. Some weeks I'm all in, pushing code daily. Other weeks I'm reading, thinking, or frankly, just living life away from the keyboard.

My GitHub contribution calendar doesn't tell my whole story—but it does tell a story. It shows I'm consistent over time, that I take breaks, that I have intense periods of focus and quieter times of reflection.

And that's exactly the developer I want to be.

📣 Final Word: What Does Your Pattern Say?
Look at your GitHub graph. Not with judgment. With curiosity.

Ask:

Did I grow this year?
Did I help someone?
Did I ship something that mattered?
Did I rest when I needed to?

If you answered yes to any of those, your graph is a masterpiece.

No matter what it looks like.

So which GitHub user are you? A Weekend Warrior? A GitHub Wizard? Or perhaps, like me, Just a Developer? Whichever pattern fits you, wear it proudly. Because the most important contributions you'll make won't be counted in green squares—they'll be measured in problems solved, knowledge shared, and systems improved.

And that's what really matters in the end.

Let’s normalize messy growth. Celebrate quiet progress. And stop glorifying burnout in green.

Because your greatest contributions?
They won’t be seen in a calendar.
But they’ll be felt in your code, your team, your users—and yourself.

Want to share your GitHub personality? Tag me.
Let’s build, laugh, and grow—square by square.

If You're Diving Into DevOps, Start Here (No, Not with Kubernetes)

Melody Mbewe — Fri, 18 Apr 2025 16:19:35 +0000

Let me tell you something I wish someone had drilled into my head sooner...

Before I touched a single kubectl command... Before I wrote my first docker-compose.yml... Before I even thought about spinning up an EC2 instance...

I should have learned Linux.

And now? I say it to anyone who'll listen (and even those who won't): Learn Linux before anything else.

I Made the Same Mistake You're Probably Making

When I got into tech, I did what most people do: I ran straight to Kubernetes because it sounded cool and everyone was talking about it. "It'll look great on my CV!" I thought. And sure, it does. But guess what?

I was completely lost.

Everything I did in Kubernetes felt like black magic. Something wouldn't work, I'd Google a fix, copy-paste a command, and pray. Spoiler: Sometimes it worked, but I had no idea why. That's a terrible way to build confidence.

It wasn't until I hit a wall (more like slammed into it full speed) that I realized the problem wasn't Kubernetes or Docker or the cloud provider.

The problem was... I didn't know how Linux worked. 🤦🏽‍♀️

Linux is the Foundation. Period.

We get so excited about flashy tools—K8s, AWS, Terraform, GitOps, MLOps, whateverOps—that we forget what they're all built on.

Yep. Good old Linux.

The container? It's a Linux process. Your cloud VM? It's a headless Linux server. CI/CD runners? You guessed it: Linux. Infrastructure as Code? You're automating Linux configuration.

So if you don't understand things like:

How to check which process is hogging port 80
Why a file is "not found" when it's right there
How to give your script execute permissions
What the heck /etc/fstab even does

...then you're going to struggle. And it's not your fault. But it is your responsibility to go back and fix that.

Real Talk: What Linux Teaches You

When you finally slow down and actually start using Linux daily, things will start to click. Here's what you will gain:

🛠️ Confidence to SSH into a server and troubleshoot

📦 Understanding of how packages, logs, and users are managed

🧠 The mental model for what happens when you deploy "infrastructure"

🧰 Superpowers with tools like Bash, cron, systemd, iptables, and more

And suddenly... Kubernetes will not be scary anymore. Docker willmake more sense. AWS EC2 feels familiar.

So What Should You Do?

Here's what I tell you now:

Install a Linux distro (even WSL works). Use it. Break it. Fix it.
Learn Bash. Seriously. Automate things. It's pure joy.
Build stuff manually first. Spin up a web server without Docker. Configure a firewall. Host a static site.
Google like a pro. But don't just copy-paste—read what you're doing.
Document everything. Your future self will thank you.

In DevOps, Cloud, GitOps, and MLOps — Linux Is Everywhere

I'm now deep into Kubernetes, Cloud, and Infrastructure as Code. I've built GitOps pipelines and helped teams ship ML models to GPU clusters.

But every time something breaks—and it will—where do I end up?

At a Linux shell.

Because at the heart of all this modern tech stack wizardry... It's still Linux doing the heavy lifting.

TL;DR?

If you want to thrive in this space, make Linux your home first.

Don't chase Kubernetes before you can grep. Don't run to Docker before you know what a PID is. Don't mess with AWS until you can manage a local Linux box.

Start small. Start right.

Linux isn't just another tool—it's the one that makes every other tool make sense.

If this hit home, or you're feeling stuck somewhere in your DevOps journey, drop a comment or DM me. I've been there. We all have. You're not alone. 🚀

Why Your ‘Productive’ Day Is Secretly Stunting Your Growth (And How to Fix It)

Melody Mbewe — Tue, 08 Apr 2025 16:33:13 +0000

Let me tell you a story you might recognize.

You wake up energized. Coffee in hand, you dive into a YouTube tutorial on system design. “This is it,” you think. “Today, I’ll level up!” An hour later, you’re nodding along to a Spring Boot course, building a to-do app (for the third time). Then, you skim a Kafka blog, scroll through a Redis thread, and bookmark “10 Must-Know Algorithms.” By bedtime, you feel like a coding wizard.

But here’s the kicker: Two weeks later, you remember nothing.

No code written. No projects shipped. Just a browser history full of tabs you’ll never reopen.

Sound familiar? Welcome to fake learning—the silent career killer for developers in their 20s.

Why Fake Learning Feels So Good (And Why It’s Toxic)

Fake learning is like eating candy for breakfast. It’s satisfying in the moment, but leaves you malnourished.

I fell into this trap hard early in my career. I’d binge tutorials, thinking “knowledge = progress.” Then, during a job interview, I froze when asked to explain how I’d actually design a real-time chat app. I’d watched 10 videos on it… but never built a single prototype.

That’s the problem: Your brain treats passive consumption as a checkbox. It tricks you into feeling productive, while your skills stay stagnant.

The Fix: Swap “I Watched” for “I Built”

Here’s the truth: Real growth happens when you’re frustrated, debugging at 2 AM, or scrapping a project that took weeks.

How do you escape the fake learning loop?

1️⃣ Learn With a Purpose

Instead of “I’ll watch a Docker tutorial,” try “I’ll containerize my side project this weekend.” Focused goals turn theory into muscle memory.

2️⃣ The 30-Minute Rule

After any tutorial, spend at least 30 minutes coding it yourself. Delete the instructor’s code. Rebuild it from scratch. Mess it up. Fix it. This is where learning sticks.

3️⃣ Embrace the “I Have No Idea” Journal

I started a Google Doc titled “Things I Pretend to Understand.” After every video, I’d jot down:

“What did I actually learn?”
“What’s still fuzzy?”
“How can I test this tomorrow?” Spoiler: The fuzzy list was always longer. And that’s okay.

Your 20s Are for Building Scars (Not Bookmarks)

This decade is your golden window to build a foundation that compounds over time. Every hour spent actually coding beats 10 hours of passive watching.

Yes, tutorials have their place. But they’re the appetizer—not the main course.

So next time you’re tempted to jump into another tutorial rabbit hole, ask:

“Will I remember this in 2 weeks… or just feel guilty for forgetting?”

Bottom line:

“Your GitHub commits are worth 100x your watch history.”

Stop collecting knowledge. Start creating proof.

Build something ugly. Break it. Fix it. Ship it. Repeat.

Your future senior-dev self is begging you. 💻

P.S. If you’re reading this instead of coding… close this tab. I’ll wait. 😉

I will use this in conjunction with habit formation technique from the book that I am reading, Atomic Habits by James Clear. Thank you Mercy

Melody Mbewe — Fri, 31 Jan 2025 11:18:48 +0000

How to trick your brain to be addicted to coding?

Mercy ・ Jan 31

#productivity #programming #career #careerdevelopment

How To Compare Characters in Java

Melody Mbewe — Wed, 18 Dec 2024 11:02:05 +0000

The knowledge of how to work with characters and their comparison in Java is something that every programmer must learn given the current trends in the ever-changing world of technology and software development. Text as we know it is composed of characters, and the skill to compare them gives one the chance to have more possibilities in text manipulation, sorting, and searching algorithms. If you are an experienced developer or even a novice, the ability to do character comparison is very critical. This article seeks to explain the various ways through which Java allows comparison between char types and character object types, which are indeed pointers to objects with a character value. You will learn this practically with examples provided in this article and build the confidence to use such tools in real-life situations, thus broadening your coding skills. There are several ways to compare two characters or strings in Java, and we will show you how you can implement them as a way to improve your programming skills, so keep reading.

1. Understanding Characters in Java
Before comparing two items, it is important that the item is clearly understood. For a good example, what is a character in Java? A character in Java is represented as char, which is a 16-bit data type intended to represent a single Unicode character. To uniquely identify each and every of the characters, symbols, and control characters within the Unicode space is a unique number code given by Unicode.

** For example:**

The ASCII code for 'A' is 65.
The ASCII code for 'a' is 97.
The ASCII code for space (' ') is 32.

In Java, the approximate char primitive is represented by a wrapper class called Character. It has features for dealing with characters, for example, methods and comparison constants.

2. Comparing Primitive Characters

2.1 Using Relational Operators
Other ways to do comparisons include For all the operations, there are variables for which their comparison can be complex routines. Direct comparisons of primitive characters can be made with relational operators(==,!=, <, >, <=, >=). With the use of relational operators, it is able to provide the basic logic needed for every operation which has the character's basic numerology built into it. For example, comparing with a grade.

Example: Comparing Grades

// Basic Grade Comparison Example
public class GradeComparison {
    public static void main(String[] args) {
character grade1 = 'A';
        char grade2 = 'B';

        // Compare grades
        if (grade1 < grade2) {
            System.out.println(grade1 + " comes before " + grade2);
        } else {
            System.out.println(grade2 + " comes before " + grade1);
        }
        // Equality check
        System.out.println("Are the grades equal? " + (grade1 == grade2));
    }
}

Output:

A comes before B
Are the grades equal? false

Relational operators are effective and easy but are limited to the simplest comparisons.

2.2 Using the **Character.compare() Method**
The Usage of Character.compare() Method If two characters are to be compared by its relevant character, Another method which can also perform that is, however, the Character.compare() method. It gives out logical representations of:

It returns:

0 if the characters are equal and it is understood as logically a neutral point.
A negative value if the first character is less than the second,
A positive value if the first character is greater than the second.

Example: Comparing Characters Numerically

public class CompareMethodExample {
    public static void main(String[] args) {
        char char1 = 'x';
        char char2 = 'y';
        int result = Character.compare(char1, char2);

        if (result == 0) {
            System.out.println(char1 + " is equal to " + char2);
        } else if (result < 0) {
            System.out.println(char1 + " comes before " + char2);
        } else {
            System.out.println(char1 + " comes after " + char2);
        }
    }
}

Output:

x comes before y

The final resonance is particularly useful and efficient in situations where you need to make a one-stop call for a lot of comparison functions in general.

3. Comparing Character Objects
When dealing with Character objects, the comparison methods differ slightly because Character is a reference type.

3.1 Using Character.compareTo()
The compareTo() method compares two character objects numerically. It works similarly to Character.compare() but is invoked on an instance of Character:

Example: Sorting Letters

import java.util.Arrays;

public class SortCharacters {
    public static void main(String[] args) {
        Character[] letters = {'z', 'a', 'm', 'k'};
        // Sort the characters using compareTo
        Arrays.sort(letters, (c1, c2) -> c1.compareTo(c2));
        System.out.println("Sorted letters: " + Arrays.toString(letters));
    }
}

Output:

Sorted letters: [a, k, m, z]

The compareTo() method is especially helpful when sorting or ordering character objects.

3.2 Using equals()
The equals() method checks if two character objects are equal. Unlike ==, which compares references for objects, equals() compares their values.

Example: Verifying Input

import java.util.Scanner;

public class PasswordCheck {
    public static void main(String[] args) {
        Character requiredChar = 'P';
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the required character: ");
        char input = scanner.next().charAt(0);

        if (requiredChar.equals(input)) {
            System.out.println("Correct input!");
        } else {
System.out.println("Incorrect input. Try again.");
        }

        scanner.close();
    }
}

Output: (Input: P)

Correct input!

Using equals() ensures type-safe and value-based comparisons.

3.3 Using Objects.equals()

The Objects.equals() method provides null-safe comparison for character objects. This is particularly useful when dealing with potential null values.

Example: Comparing Optional Characters

import java.util.Objects;

public class NullSafeComparison {
    public static void main(String[] args) {
        Character char1 = null;
        Character char2 = 'A';
        System.out.println("Are the characters equal? " + Objects.equals(char1, char2));
        char1 = 'A';
        System.out.println("Are the characters equal? " + Objects.equals(char1, char2));
    }
}

Output:

Are the characters equal? false
Are the characters equal? true

This method avoids NullPointerException when one or both characters are null.

4. Real-Life Scenarios

4.1 Validating User Input
In a user authentication system, you might compare characters for case sensitivity or specific requirements:

import java.util.Scanner;

public class CaseInsensitiveLogin {
    public static void main(String[] args) {
        char requiredChar = 'Y';
        Scanner scanner = new Scanner(System.in);
        System.out.print("Do you agree? (Y/N): ");
char input = scanner.next(). toUpperCase().charAt(0);
        if (requiredChar == input) {
            System.out.println("Thank you for agreeing!");
        } else {
            System.out.println("Action canceled.");
        }
        scanner.close();
    }
}

4.2 Sorting and Filtering Data
Suppose you're processing student grades and want to filter those with grades above a certain threshold:

import java.util.ArrayList;
import java.util.List;

public class FilterGrades {
    public static void main(String[] args) {
        List<Character> grades = List.of('A', 'B', 'C', 'D', 'F');
        List<Character> passingGrades = new ArrayList<>();
        for (char grade : grades) {
            if (grade <= 'C') {
                passingGrades.add(grade);
            }
        }
        System.out.println("Passing grades: " + passingGrades);
    }
}

Output:

Passing grades: [A, B, C]

5. Performance Considerations

Primitive vs. Wrapper
Comparing primitive char values is faster than comparing characterobjects since primitives avoid the overhead of object creation and method calls.

Null Safety
When working with character objects, consider null-safe methods like Objects.equals() to prevent runtime errors.

Readability and Maintainability
Choose methods that improve code readability. For instance, using Character.compare() or equals() makes the intent of the comparison explicit, which is beneficial in collaborative projects.

6. Conclusion
Analyzing character comparison in Java, we began with the simplest techniques for primitive types up to the Character compareTo method and the Objects equals for character objects. Such two operations were implemented in real life as well: filtering some data or validating user's inputs.
To handle text-based activities and improve the resilience of your applications, you must know how to compare characters efficiently. Select the approach that balances code clarity and performance for your use case.

You will be ready to tackle any Java character comparison task with this understanding!

If you found this information helpful, please like, follow, and share your thoughts in the comments below 👇! Your engagement helps us create more valuable content.

The Code to a Balanced Life: Finding Your Rhythm Between Work and Rest

Melody Mbewe — Tue, 17 Dec 2024 10:38:32 +0000

Introduction

Finding a perfect balance between life and work in the new world may be compared to a process of debugging a complex computer program. The same way an ideal computer code will have a start and stop command, so too does our life need its fair share of output and idle time. In this section, we will examine how certain ideas from programming can be implemented in an individual's life to achieve such a delicate balance.

Ideas from Programming Language that Apply to Life
Just as a program can be dissected into codes, a human being's life can also be said to have a sequence and basic structure. And just as we go about the day's work, there are some coding patterns that emerge and are surprisingly amusing when we analyze them from a programmer's perspective.

Function and Purpose

Every function has a goal in programming; similarly, every task performed in a day must work towards a goal. Each day there are certain functions that can be completed, which in turn leads towards the goal, and so the balance between the two needs to be maintained to prevent an overwhelming effect similar to a stack overflow.

Error handling

Life, more often than not, cannot be simplified into a piece of code. Regardless of the situation, the alternatives we have, or rather the backups we built into our lives in the first place—these determine how we react to the new conditions that arise. Such backups could be in the form of protecting highly sensitive work or even adjusting to the ‘alternatives’ life has to offer.

The Importance of Rest The Science of Breaks**

We exist in a society that praises work ethic above all else; however, as it is often overlooked, break time is crucial to the performance of a person. In this article, we aim to explore the working benefits breaks bring along and how vital they are.

According to research, a few major benefits are improvement in creative thinking, memory retention, problem-solving skills, and last but not least, an increase in productivity levels, which are all skills that can be vastly beneficial to a company as well as a person.

To further understand the reasoning behind these benefits, it is vital to understand the pomodoro technique, which consists of four focus sessions of twenty-five minutes followed by a five-minute break. This is a pretty standard norm that many people have started adapting to; the idea behind the technique is simple. It’s about working at a hyper-focused level for twenty-five minutes with an understanding that there is a break coming after each session layout, resulting in increased clarity and perspective.

In order to perform efficiently at any task repetition, consistency and a sense of routine are essential, which is as important in real-world situations as it’s equally important to approach consistently at work, rest, and personal life. A prime example of the significance of routine in a software engineer is proper versioning of your work to ensure maximum efficiency.

Making small incremental changes to your daily life, starting from your work regime, is a great way to see some major changes in the long run. It can be as simple as debugging in programming to see small changes in the final output.

While finding your peace is a great way of moving forward, setting in and following clear boundaries around working hours and meetings in addition to being calm and composed even during tense situations by setting extra time for ‘debugging’ unexpected scenarios all serve as building blocks for success.

Set up Environment

Establish zones for work and play.

Minimize distractions when doing deep work.

Provide cozy lounge spaces.

Keep your work area tidy and orderly.

Routine upkeep

Every week go through the timetable and make adjustments where necessary.

Track the cycles of their energy and productivity.

Personal targets related milestones set and do regular follow-ups.

Effective techniques of dealing with stress should be utilized.

Conclusion

Life, just like code, has to be structured, maintained, and tweaked on a regular basis. There are many aspects of my life that are unbalanced, but this has allowed me to be much more productive in the workplace. Remember that both a program and a person need time and rest to period, and then the two can work at maximum performance for a time.

“Work smarter and not harder” might be a cliche, but it does bring sense to striking a balance rather than working around the clock. By putting these techniques into practice and critically evaluating our own ‘life code’, we are instead more likely to lead a fulfilling and happy life. Let us start solving the problems and achieve self-optimization for the long term.

🎉 Don't spend another year in the same old routine. What bold moves are you planning to make for the coming year?

Melody Mbewe — Thu, 12 Dec 2024 10:10:47 +0000

8 Must-Learn Backend Development Tools for 2025: Your Ultimate Guide

Kudzai Murimi ・ Dec 11 '24

#backend #backenddevelopment #productivity #programming

Worth reading

Melody Mbewe — Wed, 11 Dec 2024 20:45:12 +0000

Understanding Java Multithreading: Part 1

Melody Mbewe ・ Dec 11 '24

#java #softwaredevelopment #coding #tutorial

Understanding Java Multithreading: Part 1

Melody Mbewe — Wed, 11 Dec 2024 13:56:27 +0000

In today’s software development landscape, the ability to run multiple tasks simultaneously is not just a luxury — it’s a necessity. Java’s multithreading capabilities empower developers to optimize performance and enhance user experience by executing multiple threads concurrently.

Key Takeaways

Learn the main ideas of Java multithreading and its significance in modern software development.
Discover essential aspects of thread management, including thread states, priority, and grouping.
Understand how to create and start threads using the Runnable interface and Thread class.

What is Java Multithreading and Why It Matters
Java multithreading allows developers to optimize resource utilization and performance in their applications. Here are several key reasons why multithreading is essential:

Improved Performance: By distributing tasks across threads, applications can better utilize CPU resources, resulting in faster execution times and reduced user wait times.
Enhanced Responsiveness: Multithreading ensures that applications remain interactive, even during intensive processing workloads, thereby providing a smoother user experience.
Efficient Resource Utilization: By leveraging system resources like CPU, memory, and I/O effectively, multithreaded applications achieve better overall performance and scalability.

Mastering Java multithreading opens up new possibilities for building high-quality, concurrent applications and is a critical skill for developers aiming to create responsive software in today’s competitive landscape.

Core Concepts of Thread Management in Java
Understanding the core concepts of thread management is essential for effectively utilizing Java’s multithreading capabilities. Key areas include:

1. Thread States and Lifecycle
Java threads transition through several states:

New: The thread is created but not started
Runnable: The thread is ready to execute but waiting for CPU time.
Running: The thread is actively executing.
Blocked/Waiting: The thread is paused while waiting for resources.
Terminated: The thread has completed execution.

Understanding these states helps manage thread behavior effectively.

public class ThreadLifecycleExample extends Thread {
 public void run() {
 System.out.println("Thread is running…");
 }
public static void main(String[] args) {
 ThreadLifecycleExample thread = new ThreadLifecycleExample();
 System.out.println("Thread state: " + thread.getState()); // NEW
 thread.start();
 System.out.println("Thread state after start: " + thread.getState()); // RUNNABLE
 }
}

2. Thread Priority and Scheduling
Java allows you to set thread priorities, influencing the order in which threads are scheduled for execution. Priorities range from 1 (MIN_PRIORITY) to 10 (MAX_PRIORITY). High-priority threads may receive more CPU time, but this does not guarantee execution order.

Thread thread1 = new Thread(() -> System.out.println("Thread 1"));
thread1.setPriority(Thread.MAX_PRIORITY);
Thread thread2 = new Thread(() -> System.out.println("Thread 2"));
thread2.setPriority(Thread.MIN_PRIORITY);
thread1.start();
thread2.start();

Thread Groups and Naming
Organizing threads into groups simplifies management, especially in complex applications. Naming threads and groups can improve code readability and debugging capabilities.

ThreadGroup group = new ThreadGroup("Group1");
Thread thread = new Thread(group, () -> System.out.println("Thread in group"), "Thread1");
thread.start();
System.out.println("Thread Group: " + group.getName());

“Understanding thread states, priority scheduling, and groups is crucial for creating efficient, robust multithreaded applications”

Creating and Starting Threads in Java

In Java, knowing how to create and start threads is key for performance optimization. There are two primary approaches to create threads: extending the Thread class or implementing the Runnable interface.Thread Creation and Instantiation

To create a thread in Java, you can either extend the Thread class or implement the Runnable interface.

1. Extending the Thread Class
You can create a new class that extends Thread and overrides the run() method. This is beneficial for threads needing specific tasks or access to Thread methods.

class MyThread extends Thread {  
    public void run() {  
        System.out.println("Running a thread by extending Thread!");  
    }  
}  

MyThread thread = new MyThread();  
thread.start();

2. Implementing the Runnable Interface
A better approach for larger applications is to implement the Runnable interface, allowing you to separate thread logic from thread management.

class MyRunnable implements Runnable {  
    public void run() {  
        System.out.println("Running a thread using Runnable!");  
    }  
}  

Thread thread = new Thread(new MyRunnable());  
thread.start();

Starting Threads
Once you create a thread, start it using the start() method on the thread object. This method allocates resources and schedules the thread’s execution.

“Understanding thread creation, instantiation, and starting is vital for leveraging Java’s multithreading capabilities effectively.”

**Implementing the Runnable Interface vs. Extending the Thread Class
**In Java, you can create threads either by using the Runnable interface or by extending the Thread class. Each method has unique benefits and use cases

Benefits of the Runnable Interface
Using the Runnable interface typically offers several advantages:

Code Reuse and Flexibility: You can pass a single Runnable object to multiple threads.
Separation of Concerns: The thread logic remains distinct from the thread creation and management code.
Ease of Testing and Debugging: Runnable implementations can be tested independently.When to Use Thread Class Extension

Extending the Thread class may be preferred in certain scenarios:

If you need to change the default behavior of the Thread class.
When direct access to Thread state and properties is required.
If you want to use the inheritance hierarchy to share common functionality.

Best Practices for Implementation
Regardless of which approach you choose, following best practices is important:

Avoid Excessive Thread Creation: Over-creating threads can lead to resource contention and reduced performance.
Manage Thread Lifecycle Events: Properly manage starting, stopping, and interrupting threads.
Safeguard Shared Resources: Synchronize access to shared resources and use concurrent data structures where necessary.
Leverage Java’s Concurrency Utilities: Use tools like ExecutorService and ThreadPool for more efficient thread management.

Thread Synchronization and Resource Management
In Java multithreading, coordinating threads to protect shared resources is essential. The synchronized keyword and lock objects are essential tools for managing access to critical sections of code, preventing race conditions and ensuring data integrity..

The synchronized keyword is a strong tool for methods or code blocks. It makes sure only one thread can run the synchronized code at once. This prevents race conditions, where threads fight for the same resource, causing data issues.

1. Synchronized methods
Java provides the synchronized keyword to enforce mutual exclusion on method calls. This ensures that only one thread executes a synchronized method at a time.

public class SynchronizedMethods {  
    private int counter = 0;  

    public synchronized void increment() {  
        counter++;  
    }  

    public synchronized int getCounter() {  
        return counter;  
    }  

    public static void main(String[] args) throws InterruptedException {  
        SynchronizedMethods counterObject = new SynchronizedMethods();  
        Thread thread1 = new Thread(() -> {  
            for (int i = 0; i < 10000; i++) {  
                counterObject.increment();  
            }  
        });  
        Thread thread2 = new Thread(() -> {  
            for (int i = 0; i < 10000; i++) {  
                counterObject.increment();  
            }  
        });  

        thread1.start();  
        thread2.start();  
        thread1.join();  
        thread2.join();  

        System.out.println("Final counter value: " + counterObject.getCounter());  
    }  
}

2. Synchronized blocks
Synchronized blocks allow you to control access to specific sections of code rather than entire methods, providing finer control over synchronization.

class Counter {  
    private int count = 0;  

    public synchronized void increment() {  
        count++;  
    }  

    public int getCount() {  
        return count;  
    }  
}  

Counter counter = new Counter();  
Thread t1 = new Thread(() -> {  
    for (int i = 0; i < 1000; i++) counter.increment();  
});  
Thread t2 = new Thread(() -> {  
    for (int i = 0; i < 1000; i++) counter.increment();  
});  
t1.start();  
t2.start();  
t1.join();  
t2.join();  
System.out.println("Final Count: " + counter.getCount());

Lock Objects
Java also provides more flexible synchronization options through lock objects. These offer better control over critical sections, allowing threads to acquire and release locks as needed.

“Proper thread synchronization is crucial in multithreaded applications to ensure the correct behavior and integrity of shared resources.”

Synchronization Mechanisms
Synchronization restricts access to shared resources to ensure thread safety. Java provides several synchronization constructs, including the synchronized keyword and ReentrantLock.

Familiarizing yourself with thread safety and concurrent collections is vital for creating Java applications that effectively utilize multithreading. Safe data structures, atomic operations, and proper synchronization can enhance application performance and reliability.

“Concurrent programming is all about managing access to shared resources.” — Brian Goetz, Java Concurrency in Practice

Common Multithreading Problems and Solutions
While multithreading enriches Java applications, several challenges may arise:

Race Conditions: Occur when two or more threads concurrently modify shared data. Use synchronization to prevent these.
Deadlocks: Happen when two threads wait for each other to release resources. Design carefully to avoid circular waits.
Starvation: Occurs when a thread is perpetually denied access to resources. Proper thread management can mitigate this issue.

Conclusion
Java multithreading empowers developers to build responsive, efficient applications. Understanding thread lifecycles, priorities, and synchronization lays a strong foundation for advanced concurrency.

Stay tuned for the next article, where we’ll delve into advanced multithreading concepts and performance optimization!

Amazon's $100M AWS Education Equity Initiative: Bridging the Tech Skills Gap

Melody Mbewe — Fri, 06 Dec 2024 14:17:11 +0000

Amazon's recent announcement of the AWS Education Equity Initiative marks a significant step towards addressing disparities in tech education. With a commitment of $100 million in cloud credits over the next five years, this initiative aims to empower organizations that serve underserved communities by providing access to essential cloud computing and artificial intelligence resources. This strategic investment not only targets the digital divide but also seeks to cultivate a diverse workforce equipped with critical digital skills necessary for the future job market.

Overview of the Initiative
The AWS Education Equity Initiative is designed to support a wide range of organizations, including non-profits, social enterprises, and educational institutions, in developing innovative digital learning solutions. By leveraging AWS technologies, these organizations can create tools that enhance educational access and quality for students from historically marginalized backgrounds.

Key Features of the Initiative:
- Financial Support:
The initiative provides up to $100 million in AWS credits, significantly reducing financial barriers for eligible organizations.

- Technical Advising: Recipients will receive guidance from AWS experts on building and scaling their educational solutions effectively.

- Focus on AI and Cloud Technologies:- Organizations are encouraged to incorporate AI-powered tools into their educational offerings, enhancing learning experiences and outcomes.
Impact on Education

The potential impact of this initiative is profound. For instance, partners like Code.org plan to utilize Amazon Bedrock to expand their AI-powered teaching assistants, which can automate assessments and free up educators' time for personalized instruction. This approach underscores the initiative’s goal of democratizing education by making high-quality learning resources accessible to all students, regardless of their socioeconomic status.

Importance of Computational Thinking
Beyond traditional technical skills such as programming and cloud computing, the initiative emphasizes the importance of computational thinking—a skill that is increasingly vital across various fields. This holistic approach aims to prepare students not just for specific jobs but for a rapidly evolving job market where adaptability and problem-solving are paramount.

Economic Implications
The demand for AI and tech skills is surging, with statistics indicating that workers with AI expertise can earn salaries up to 47% higher than their peers. Moreover, there is a projected shortage of qualified software developers, which highlights the urgent need for initiatives like this one that aim to build a more diverse talent pool.

Application Process
Organizations interested in participating in the AWS Education Equity Initiative can apply online. The application process requires them to demonstrate how their proposed solutions will benefit underserved communities, ensuring that the funding is directed towards projects with meaningful impact.

Conclusion
Amazon's AWS Education Equity Initiative serves as a powerful example of how corporate investment can drive social equity and economic growth. By bridging the tech skills gap through targeted support for underserved communities, this initiative not only addresses immediate educational needs but also lays the groundwork for a more inclusive future workforce.

What are your thoughts on the potential impact of this initiative? What other steps should be taken to bridge the digital divide?

DEV Community: Melody Mbewe

Want to Stand Out as a Junior Developer? Do it MORE.

💥 Forget Everything You Think You Know About "Talent"

🔁 While You're Stuck in Tutorial Hell, Others Are Building

📊 The Brutal Math of Standing Out

🔥 The 20x Rule That Changes Everything

😵 Why This Works (And Why It’s So Uncomfortable)

🧨 Your Competition Is Making a Fatal Mistake

🚀 The 30-Day Challenge That Will Transform Your Career

📅 Week Breakdown:

🏃‍♀️ Stop Looking for Shortcuts — The Shortcut IS the Work

🔧 My Project Evolution (And Why Ugly Code Beats No Code)

🧠 The Reality Check You Need to Hear

✅ Your Next Step Is Surprisingly Simple

💬 Let’s Discuss

Linux First: Your Step-by-Step DevOps Foundation Guide

Step 1: Install a Linux distro (and actually use it daily)

Windows Users:

macOS Users:

Linux Desktop Users:

Step 2: Learn Bash (it's your DevOps superpower)

Bash Basics to Advanced:

Step 3: Build stuff manually (before automating)

Set Up a Basic Web Server in WSL/Linux:

Other essentials to build manually:

Step 4: Google like a pro (and understand what you're copying)

Sharpen your search skills:

When reading solutions:

Step 5: Document everything (your future self will thank you)

Bonus: Little-Known Linux Skills That Made Me Better

1. Process and port management:

2. System monitoring:

3. Network troubleshooting:

4. User and permission management:

Putting It All Together

The GitHub Chronicles: Your Contribution Graph Tells a Story (But Not the One You Think)

The Seven GitHub Personalities: Where Do You Fit?

If You're Diving Into DevOps, Start Here (No, Not with Kubernetes)

I Made the Same Mistake You're Probably Making

Linux is the Foundation. Period.

Real Talk: What Linux Teaches You

So What Should You Do?

In DevOps, Cloud, GitOps, and MLOps — Linux Is Everywhere

TL;DR?

Why Your ‘Productive’ Day Is Secretly Stunting Your Growth (And How to Fix It)

Why Fake Learning Feels So Good (And Why It’s Toxic)

The Fix: Swap “I Watched” for “I Built”

Your 20s Are for Building Scars (Not Bookmarks)

I will use this in conjunction with habit formation technique from the book that I am reading, Atomic Habits by James Clear. Thank you Mercy

How to trick your brain to be addicted to coding?

Mercy ・ Jan 31

How To Compare Characters in Java

The Code to a Balanced Life: Finding Your Rhythm Between Work and Rest

The Importance of Rest ** The Science of Breaks

🎉 Don't spend another year in the same old routine. What bold moves are you planning to make for the coming year?

8 Must-Learn Backend Development Tools for 2025: Your Ultimate Guide

Kudzai Murimi ・ Dec 11 '24

Worth reading

Understanding Java Multithreading: Part 1

Melody Mbewe ・ Dec 11 '24

Understanding Java Multithreading: Part 1

Amazon's $100M AWS Education Equity Initiative: Bridging the Tech Skills Gap

The Importance of Rest The Science of Breaks**