DEV Community: Caelora

Why Every Developer Should Learn Docker (Even for Small Projects)

Caelora — Fri, 24 Jul 2026 07:17:26 +0000

Why Every Developer Should Learn Docker (Even for Small Projects)

If you've ever heard someone say, "It works on my machine," you've already encountered one of the biggest problems in software development.

Different operating systems, dependency versions, and local configurations can make the same project behave differently across computers.

That's exactly the problem Docker was built to solve.

What Is Docker?

Docker is a platform that packages your application together with everything it needs to run:

Programming language runtime
Dependencies
Libraries
Environment variables
System tools

Instead of telling someone how to set up your project, you simply share a Docker image or a Docker Compose file.

If Docker runs, your application runs too.

Why I Started Using Docker

When I first learned web development, setting up a new project was frustrating.

Sometimes I needed:

Node.js 18
PostgreSQL 15
Redis
MongoDB

Installing everything manually often caused version conflicts.

After switching to Docker, setting up a project became much easier.

Instead of spending 30 minutes configuring my environment, I could start everything with one command.

docker compose up

That's it.

A Simple Example

Imagine you're building a Node.js API.

Without Docker, every team member has to install:

Node.js
npm
PostgreSQL
Environment variables

With Docker, everyone uses the same environment.

A basic Dockerfile looks like this:

FROM node:20

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "start"]

Now anyone can run the application without worrying about different Node.js versions.

Docker Compose Makes It Better

Real applications usually need more than one service.

For example:

Backend API
Database
Redis cache

Docker Compose lets you start everything together.

services:
  app:
    build: .

  database:
    image: postgres:16

Instead of opening multiple terminals and starting services manually, one command launches the entire stack.

Benefits I've Noticed

After using Docker regularly, I noticed several improvements.

Faster onboarding

New developers can run a project within minutes.

Fewer environment issues

No more "works on my machine" conversations.

Cleaner computer

I don't have dozens of database installations and conflicting versions anymore.

Easier deployment

The same container used during development can often be deployed to production with minimal changes.

Is Docker Difficult?

At first, yes.

The documentation introduces many concepts:

Images
Containers
Volumes
Networks
Compose

It can feel overwhelming.

But once you understand the difference between an image and a container, everything starts to make sense.

You don't need to master every Docker feature on day one.

Learn the basics first.

Should Beginners Learn Docker?

Absolutely—but not immediately.

If you're just starting programming, focus on learning:

Variables
Functions
Loops
APIs
Databases

Once you've built a few projects, Docker becomes much easier to appreciate because you'll understand the problems it solves.

Final Thoughts

Docker isn't just for large companies or DevOps engineers.

Even small personal projects benefit from having a consistent development environment.

If you're tired of installation issues, dependency conflicts, or spending too much time configuring projects, Docker is worth learning.

It may have a learning curve, but it's one of the best investments you can make as a developer.

Are you already using Docker in your projects, or are you planning to learn it? I'd love to hear your experience in the comments.

5 Git Commands Every Developer Should Know

Caelora — Fri, 24 Jul 2026 07:13:49 +0000

5 Git Commands Every Developer Should Know

Git is one of the most important tools every developer uses, yet many people only know a few basic commands.

Learning a handful of additional Git commands can save time, reduce mistakes, and make collaboration much easier.

Here are five Git commands I use almost every day.

1. Check What Changed

Before committing anything, always check your changes.

git status

This command shows:

Modified files
New files
Deleted files
Files ready to commit

Running git status before every commit is a good habit.

2. View Your Commit History

Need to know what happened recently?

git log --oneline

Instead of showing long commit details, this command displays a clean, compact history.

Example:

f82d4f1 Fix login bug
1ab8c72 Update README
8ce44f0 Add authentication

It's much easier to read than the default output.

3. Create a New Branch

Never work directly on the main branch.

Create a feature branch instead.

git checkout -b feature/login

Or, with newer Git versions:

git switch -c feature/login

This keeps your work isolated until it's ready to merge.

4. Undo Staged Changes

Accidentally added the wrong file?

git restore --staged filename.js

This removes the file from the staging area without deleting your changes.

It's much safer than trying to fix mistakes later.

5. Pull Before You Push

Before pushing your code, make sure your local branch is up to date.

git pull origin main

This helps avoid unnecessary merge conflicts and ensures you're working with the latest code.

Bonus Tip

If you forget a command, Git has built-in help.

git help <command>

For example:

git help commit

The documentation is surprisingly helpful.

Final Thoughts

You don't need to memorize every Git command.

Mastering a small set of frequently used commands will make your daily workflow smoother and reduce common mistakes.

The five commands I recommend every beginner learns are:

git status
git log --oneline
git switch -c
git restore --staged
git pull

Once you're comfortable with these, learning more advanced Git features becomes much easier.

Which Git command do you use the most? Let me know in the comments!

Stop Using console.log Everywhere: Better Ways to Debug JavaScript

Caelora — Fri, 24 Jul 2026 07:03:37 +0000

Stop Using `console.log()` Everywhere: Better Ways to Debug JavaScript

If you're learning JavaScript, you've probably written something like this hundreds of times:

console.log(data);
console.log(user);
console.log(response);
console.log(error);

There's absolutely nothing wrong with using console.log(). Every developer starts there, and even experienced developers still use it.

However, as your application grows, relying only on console.log() can make debugging slower and your code harder to maintain.

Here are several debugging techniques that can save you time and make your development workflow much more efficient.

1. Use the Browser Debugger

Instead of printing every variable, use the built-in JavaScript debugger.

function calculateTotal(items) {
  debugger;

  return items.reduce((sum, item) => sum + item.price, 0);
}

When execution reaches the debugger statement, the browser pauses your application. You can inspect variables, check the call stack, and execute code step by step.

This is much more powerful than printing dozens of log statements.

2. Display Objects with `console.table()`

Large arrays of objects quickly become difficult to read.

Instead of:

console.log(users);

Use:

console.table(users);

The output becomes a clean table that's much easier to understand.

This works especially well for:

API responses
Product lists
User records
Database results

3. Organize Logs with `console.group()`

If your application produces many log messages, grouping them makes the console much cleaner.

console.group("Login Process");

console.log("Checking credentials...");
console.log("Loading user...");
console.log("Authentication successful");

console.groupEnd();

Now related messages stay together, making debugging much easier.

4. Measure Performance

Need to know how long a function takes?

console.time("fetchUsers");

await fetchUsers();

console.timeEnd("fetchUsers");

This instantly tells you how long an operation required without installing additional tools.

5. Take Advantage of Breakpoints

Modern browsers include excellent debugging tools.

Simply click beside a line number in Chrome or Firefox DevTools to create a breakpoint.

When execution stops, you can:

Inspect variables
View the call stack
Execute code manually
Step through your application line by line

For complex bugs, breakpoints are often much faster than adding dozens of log statements.

6. Read Error Messages Carefully

Many developers immediately search Google after seeing an error.

Instead, spend a few seconds reading it.

Most JavaScript errors already tell you:

Which file caused the problem
The line number
The type of error
The function where it happened

Understanding error messages is a skill that will dramatically improve your debugging speed.

7. Clean Up Before Deploying

We've all forgotten to remove debugging code.

console.log("HERE");
console.log("TEST");
console.log("WHY IS THIS UNDEFINED?");

Before pushing your code to production:

Remove unnecessary console.log() calls.
Delete forgotten debugger statements.
Keep only meaningful error logging where appropriate.

A clean codebase is much easier to maintain.

Final Thoughts

console.log() isn't bad—it remains one of the simplest and fastest debugging tools available.

But combining it with browser DevTools, breakpoints, console.table(), and performance timers can significantly improve your workflow.

As your projects become larger and more complex, learning these debugging techniques will save you hours of frustration.

What debugging technique do you use most often? Share your favorite tips in the comments!

7 VS Code Extensions I Install on Every New Computer

Caelora — Fri, 24 Jul 2026 06:57:51 +0000

7 VS Code Extensions I Install on Every New Computer

Every time I reinstall Windows or buy a new laptop, the first application I install is Visual Studio Code. But VS Code alone isn't enough. The real productivity boost comes from its extensions.

After years of web development, I've narrowed my list down to seven extensions that I install immediately. These extensions save time, improve code quality, and make development much more enjoyable.

1. Prettier

Nobody likes arguing about code formatting.

Prettier automatically formats your code every time you save, keeping your project clean and consistent.

Why I use it

Consistent formatting
Works with almost every language
Saves time during code reviews

"editor.formatOnSave": true

2. ESLint

ESLint catches mistakes before they become bugs.

Instead of discovering issues after deployment, you'll see warnings directly in your editor.

It also helps enforce coding standards across your team.

3. GitLens

GitLens makes Git much easier to understand.

With one hover, you can instantly see:

Who changed a line
When it was changed
Why it was changed

This is incredibly useful when working on large projects.

4. Error Lens

Normally, VS Code shows errors at the bottom of the screen.

Error Lens displays them directly beside your code, making debugging much faster.

Small extension, huge productivity boost.

5. Auto Rename Tag

If you're working with HTML, React, or Vue, this extension is a lifesaver.

Rename an opening tag...

<div>

...and the closing tag updates automatically.

</div>

No more broken markup.

6. Path Intellisense

Import paths can become annoying in large projects.

Instead of typing long file paths manually, this extension autocompletes them for you.

It's simple but saves countless keystrokes every day.

7. Thunder Client

Sometimes you don't want to open Postman just to test one API endpoint.

Thunder Client lives inside VS Code and lets you:

Send HTTP requests
Test REST APIs
Organize collections

Perfect for backend developers.

Final Thoughts

VS Code is already a fantastic editor, but the right extensions can dramatically improve your workflow.

If I had to choose only three, they would be:

Prettier
ESLint
GitLens

Those three alone eliminate many common development headaches.

What VS Code extension can't you live without? Let me know in the comments!

DEV Community: Caelora

Why Every Developer Should Learn Docker (Even for Small Projects)

Why Every Developer Should Learn Docker (Even for Small Projects)

What Is Docker?

Why I Started Using Docker

A Simple Example

Docker Compose Makes It Better

Benefits I've Noticed

Faster onboarding

Fewer environment issues

Cleaner computer

Easier deployment

Is Docker Difficult?

Should Beginners Learn Docker?

Final Thoughts

5 Git Commands Every Developer Should Know

5 Git Commands Every Developer Should Know

1. Check What Changed

2. View Your Commit History

3. Create a New Branch

4. Undo Staged Changes

5. Pull Before You Push

Bonus Tip

Final Thoughts

Stop Using console.log Everywhere: Better Ways to Debug JavaScript

Stop Using console.log() Everywhere: Better Ways to Debug JavaScript

1. Use the Browser Debugger

2. Display Objects with console.table()

3. Organize Logs with console.group()

4. Measure Performance

5. Take Advantage of Breakpoints

6. Read Error Messages Carefully

7. Clean Up Before Deploying

Final Thoughts

7 VS Code Extensions I Install on Every New Computer

7 VS Code Extensions I Install on Every New Computer

1. Prettier

2. ESLint

3. GitLens

4. Error Lens

5. Auto Rename Tag

6. Path Intellisense

7. Thunder Client

Final Thoughts

Stop Using `console.log()` Everywhere: Better Ways to Debug JavaScript

2. Display Objects with `console.table()`

3. Organize Logs with `console.group()`