DEV Community: Maksym

Your Terminal Deserves Better. Oh My Zsh Agrees.

Maksym — Thu, 02 Apr 2026 05:08:17 +0000

You wouldn't write code in Notepad. So why are you still using a bare-bones shell? Oh My Zsh transforms your terminal from a blinking cursor into a genuinely productive environment -- one that autocompletes intelligently, surfaces git context at a glance, and makes you wonder how you ever lived without it.

If you caught the earlier piece on Fish shell, welcome back. Fish is opinionated and batteries-included by design. Zsh with Oh My Zsh takes a different approach: more configurable, a deeper ecosystem, and fully POSIX-compatible. Two great shells, two different philosophies. This is the other side of the coin.

What is Oh My Zsh?

Oh My Zsh is an open-source, community-driven framework for managing your Zsh configuration. It was born in 2009 from a single developer's frustration with their .zshrc. Today it ships with over 300 plugins and 150 themes, maintained by a community that has been iterating on shell ergonomics for fifteen years.

Think of it as a package manager for your shell personality. One install unlocks tab completion that actually works, inline git status in your prompt, syntax highlighting as you type, autosuggestions from history, and enough theme options to lose an afternoon.

Installation

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

That is it. The installer backs up your existing .zshrc, installs Oh My Zsh, and drops you into a configured shell. No manual setup required.

Plugins worth enabling

Plugins are activated by editing the plugins array in your ~/.zshrc:

plugins=(git z docker zsh-autosuggestions zsh-syntax-highlighting)

Restart your shell (or run source ~/.zshrc) and the changes take effect immediately.

git

The most-used plugin. Provides over 50 aliases for common operations:

Alias	Expands to
`gst`	`git status`
`gco`	`git checkout`
`glog`	`git log --oneline --decorate --graph`
`gp`	`git push`
`gl`	`git pull`

Type alias | grep "^g" in your shell after enabling to see the full list.

z

Tracks the directories you visit and lets you jump to any of them by typing a fragment of the path. No more cd ../../projects/client-name/repo -- just z repo.

z proj      # jumps to ~/code/projects
z dot       # jumps to ~/.dotfiles

zsh-autosuggestions

Displays ghost-text suggestions based on your command history as you type. Press the right arrow key to accept a suggestion. This one plugin alone eliminates a large fraction of keystrokes in a typical session.

git clone https://github.com/zsh-users/zsh-autosuggestions \
  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

zsh-syntax-highlighting

Colors your command as you type it. Valid commands appear in green. Unrecognized commands and typos appear in red -- before you press Enter, so you catch mistakes immediately.

git clone https://github.com/zsh-users/zsh-syntax-highlighting \
  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

Both zsh-autosuggestions and zsh-syntax-highlighting require a manual clone step because they are third-party plugins not bundled with Oh My Zsh.

Themes

The active theme is set with a single line in ~/.zshrc:

ZSH_THEME="robbyrussell"

The default theme (robbyrussell) is clean and fast. It shows your current directory and git branch, nothing more. For most setups it is a sensible starting point.

If you want more information density in your prompt, the community has converged on Powerlevel10k as the gold standard.

Powerlevel10k

Powerlevel10k renders asynchronously, meaning your prompt stays responsive even when git or other tools are slow to respond. It surfaces git status, last exit code, command execution time, current time, and more -- all configurable through an interactive setup wizard.

# Install
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git \
  ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

# Activate in ~/.zshrc
ZSH_THEME="powerlevel10k/powerlevel10k"

The first time you open a new shell after enabling it, the configuration wizard launches automatically. It walks you through a series of visual tests and preference questions, then writes a ~/.p10k.zsh file. The whole process takes about five minutes.

Zsh vs Fish

Since Fish shell was covered in a previous piece, it is worth stating plainly: both are excellent tools, and the right choice depends on what you value.

Fish gives you smart features -- autosuggestions, syntax highlighting, web-based config -- out of the box with near-zero configuration. It is opinionated by design and works well as a result.

Zsh with Oh My Zsh is a different trade-off. It requires a little more initial setup, but gives you a deeper plugin ecosystem, full POSIX compatibility (meaning shell scripts written for bash will generally work), and a community that has been accumulating tooling for over a decade.

Many developers install both and choose based on the machine or context. There is no wrong answer.

A starter `~/.zshrc`

export ZSH="$HOME/.oh-my-zsh"

ZSH_THEME="powerlevel10k/powerlevel10k"

plugins=(
  git
  z
  docker
  zsh-autosuggestions
  zsh-syntax-highlighting
)

source $ZSH/oh-my-zsh.sh

# Personal aliases
alias ll="ls -lAh"
alias gs="git status"
alias reload="source ~/.zshrc"

After saving, run source ~/.zshrc to apply the changes without opening a new terminal window.

Where to go from here

The official plugin list lives at ~/.oh-my-zsh/plugins/ -- browse the folder to see what is available without any additional installs. For third-party plugins, the Awesome Zsh Plugins repository is a well-maintained directory.

Oh My Zsh is not magic. It is fifteen years of collective developer frustration turned into very good defaults. Install it once, spend an hour making it yours, and you will not look at a stock terminal the same way again.

Pause, Save, Resume: The Definitive Guide to Stashing

Maksym — Wed, 01 Apr 2026 07:06:08 +0000

Git stash is one of those commands that feels minor until the day you desperately need it — and then it becomes indispensable. It lets you temporarily shelve changes you've made to your working directory so you can switch context, pull updates, or work on something else, then come back and reapply those changes later.

What is Git Stash?

When you stash your work, Git takes all your uncommitted changes (both staged and unstaged) and saves them onto a stack of unfinished changes that you can reapply at any time. Your working directory is then cleaned up to match the HEAD commit.

Think of it like putting your work in a drawer so you can clean your desk — the work isn't gone, it's just tucked away.

Basic Usage

Stashing your changes

git stash

This stashes all tracked, modified files. Your working directory reverts to a clean state.

Stashing with a descriptive message

git stash push -m "WIP: refactoring auth middleware"

Always recommended. When you have multiple stashes, messages make it easy to identify which stash contains what.

Including untracked files

By default, git stash ignores untracked (new) files. Use -u to include them:

git stash push -u -m "feature work including new files"

To also include ignored files (e.g. .env overrides), use -a:

git stash push -a -m "everything including ignored files"

Viewing Your Stashes

git stash list

Output looks like this:

stash@{0}: On main: WIP: refactoring auth middleware
stash@{1}: On feature/login: half-done login form
stash@{2}: WIP on main: 3f1abc2 fix typo in readme

Stashes are indexed from 0 (most recent) upward. The index is important for targeting specific stashes.

Applying Stashes

Apply the most recent stash (keep it in the stash list)

git stash apply

Apply and remove from the stash list

git stash pop

pop is shorthand for apply + drop. Use it when you're done with the stash and don't need it anymore.

Apply a specific stash by index

git stash apply stash@{2}
git stash pop stash@{1}

Apply to a different branch

You can apply a stash to any branch — just switch to it first:

git checkout feature/new-branch
git stash pop

Inspecting a Stash

Before applying, you might want to see what's inside a stash:

# Summary of changed files
git stash show stash@{0}

# Full diff
git stash show -p stash@{0}

Deleting Stashes

Drop a specific stash

git stash drop stash@{1}

Clear all stashes

git stash clear

Warning: git stash clear is irreversible. All stashes are permanently deleted.

Creating a Branch from a Stash

If your stashed changes have grown into something bigger, you can create a new branch directly from the stash:

git stash branch feature/new-feature stash@{0}

This creates and checks out a new branch, applies the stash to it, and drops the stash if the apply succeeds. Very handy when you realize mid-stash that your changes deserve their own branch.

Partial Stashing

You can stash only specific files instead of everything:

git stash push -m "only stashing config changes" -- config/settings.py

Or stash changes interactively (patch by patch, like git add -p):

git stash push -p

Git will walk you through each hunk and ask whether to stash it.

Handling Conflicts

If applying a stash causes a merge conflict, Git will mark the conflicts in the affected files — just like a regular merge. Resolve them manually, then stage the resolved files:

git add path/to/resolved-file.py

Note: when conflicts occur during git stash pop, the stash is not automatically dropped. You'll need to drop it manually once you're done:

git stash drop stash@{0}

Quick Reference

Command	Description
`git stash`	Stash tracked changes
`git stash push -u -m "msg"`	Stash including untracked files with a message
`git stash list`	List all stashes
`git stash show -p stash@{n}`	Show full diff of a stash
`git stash apply stash@{n}`	Apply a stash (keep in list)
`git stash pop`	Apply most recent stash and remove it
`git stash drop stash@{n}`	Delete a specific stash
`git stash clear`	Delete all stashes
`git stash branch <name>`	Create a branch from a stash
`git stash push -p`	Interactive/partial stash

Tips and Gotchas

Stashes are local. They don't get pushed to a remote repository. Don't rely on them for backup or sharing work.
Don't let stashes pile up. It's easy to forget what's in old stashes. Treat them as short-lived temporary storage, not a long-term holding area.
Staged vs unstaged state is preserved. When you apply a stash, files that were staged before stashing will still be staged — unless you use git stash apply --index to explicitly restore that state.
Name your stashes. stash@{3}: WIP on main: 9b2f1a0 update readme tells you very little compared to stash@{3}: On main: WIP: OAuth token refresh logic.

Exploring Lua: The Invisible Powerhouse of Scripting

Maksym — Fri, 27 Mar 2026 06:59:52 +0000

If you’ve played Roblox, adjusted a UI mod in World of Warcraft, or used a high-performance web server like NGINX, you’ve encountered Lua. Developed in 1993 at the Pontifical Catholic University of Rio de Janeiro, Lua (Portuguese for "Moon") was designed as a lightweight, embeddable scripting language.

Today, it remains one of the fastest and most efficient tools in a developer's kit.

1. Why Developers Love Lua

Lua isn't usually the "main" language of an application; instead, it acts as the glue. Here is why it excels in that role:

Speed: Lua is consistently ranked among the fastest interpreted languages. When using LuaJIT (Just-In-Time compiler), its performance can rival compiled languages like C in certain tasks.
Portability: The entire Lua interpreter is written in ANSI C. This means it can run on everything from a high-end PC to a tiny microwave oven's microcontroller.
Small Footprint: A compiled Lua interpreter is roughly 200–300 KB. It doesn't bloat the software it lives inside.
Simple Syntax: It’s easy to read and learn. If you know the basics of programming, you can become productive in Lua in a single afternoon.

2. The "Everything is a Table" Philosophy

The most unique feature of Lua is its data structure. Unlike other languages that have arrays, lists, dictionaries, and objects, Lua has only one: the Table.

Tables are associative arrays that can be indexed with numbers, strings, or even other tables. This single structure is used to represent:

Arrays: myList = {10, 20, 30} (Note: Lua uses 1-based indexing!)
Dictionaries: myData = {name = "Gemini", type = "AI"}
Objects: By using "metatables," Lua can simulate complex Object-Oriented Programming (OOP) behaviors like inheritance.

3. Real-World Applications

Lua thrives where performance and customization meet.

Game Development

This is Lua's home turf. Engines like LÖVE use Lua for everything, while massive engines like CryEngine and Leadwerks use it for game logic. It allows designers to change how a weapon behaves or how an NPC moves without needing to recompile the entire game engine.

Embedded Systems

Because it’s so light, Lua is a favorite for the "Internet of Things" (IoT). Devices with limited memory use Lua to handle logic while the heavy lifting stays in C.

Neovim and Productivity

The developer community has seen a massive shift toward Lua lately, specifically with the text editor Neovim. Users now write their entire editor configurations in Lua because it's significantly faster and more powerful than the older VimScript.

4. A Quick Code Example

Here is what a basic function looks like in Lua:

-- Define a function to greet a user
local function celebrate(name)
    print("Hello, " .. name .. "!")

    for i = 1, 3 do
        print("Blast off in " .. (4 - i))
    end

    print("Lua is ready!")
end

celebrate("Developer")

Summary

Lua is the "silent partner" of the programming world. You might not use it to build an operating system, but if you need to add a flexible, fast, and lightweight scripting layer to a project, there is rarely a better choice.

Wazuh: Centralized Logging with Error Notifications

Maksym — Wed, 04 Mar 2026 07:51:15 +0000

Introduction

Wazuh is an open-source security and monitoring platform that provides intrusion detection, log management, vulnerability detection, and incident response. It centralizes logs from diverse systems and applications, analyzes them in real time, and notifies teams when errors or suspicious activity occur. By combining log collection, rule-based detection, and alerting, Wazuh helps organizations improve visibility, security, and operational efficiency.

Centralized Logging

Wazuh agents collect logs from endpoints and forward them to the Wazuh manager, where they are aggregated and indexed (often in Elasticsearch). This allows administrators to monitor all system activity from a single location.

Configuration Example (multiple files):

<localfile>
  <log_format>syslog</log_format>
  <location>/var/log/syslog</location>
</localfile>

<localfile>
  <log_format>apache</log_format>
  <location>/var/log/apache2/error.log</location>
</localfile>

<localfile>
  <log_format>json</log_format>
  <location>/var/log/myapp/app.log</location>
</localfile>

<localfile>
  <log_format>syslog</log_format>
  <location>/var/log/auth.log</location>
</localfile>

Handling Unknown or Dynamic Files

If you don’t know the exact file names in advance (e.g., rotating logs or dynamically generated files), Wazuh supports wildcards and directories:

<localfile>
  <log_format>syslog</log_format>
  <location>/var/log/*.log</location>
</localfile>

<localfile>
  <log_format>apache</log_format>
  <location>/var/log/apache2/*.log</location>
</localfile>

<localfile>
  <log_format>json</log_format>
  <location>/var/log/myapp/*.json</location>
</localfile>

This ensures that any new log file matching the pattern is automatically monitored.

Error Detection Rules

Logs are analyzed against rules to detect anomalies and errors. Wazuh’s ruleset can be customized to match specific error patterns.

Example: Apache error detection

<rule id="100100" level="5">
  <decoded_as>apache_error</decoded_as>
  <description>Apache server error detected</description>
  <group>apache,errors</group>
  <match>Internal Server Error</match>
</rule>

Generic error rule (for unknown files):

<rule id="100300" level="6">
  <description>Generic error detected in logs</description>
  <group>errors</group>
  <match>ERROR|FAIL|CRITICAL</match>
</rule>

Notifications

Wazuh can notify teams via email, Slack, or other platforms. For example:

Email notification setup:

<global>
  <email_notification>yes</email_notification>
  <email_to>ops-team@example.com</email_to>
  <smtp_server>mail.example.com</smtp_server>
</global>

Telegram Integration Example

Telegram is not built-in, but you can integrate it using a custom script in Wazuh’s integrations/ folder.

Python script (telegram.py):

#!/usr/bin/env python3
import sys
import json
import requests

# Replace with your bot token and chat_id
BOT_TOKEN = "123456789:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"
CHAT_ID = "-1001234567890"  # group/channel ID or user ID

TELEGRAM_API_URL = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"

def send_telegram_message(message):
    payload = {
        "chat_id": CHAT_ID,
        "text": message,
        "parse_mode": "Markdown"
    }
    try:
        response = requests.post(TELEGRAM_API_URL, json=payload)
        if response.status_code != 200:
            print(f"Error sending message: {response.text}")
    except Exception as e:
        print(f"Exception: {e}")

def main():
    # Wazuh passes alert data to the script via stdin
    alert_json = sys.stdin.read()
    try:
        alert = json.loads(alert_json)
        # Customize the message format
        message = f"*Wazuh Alert*\n\nRule: {alert.get('rule', {}).get('description', 'N/A')}\nLevel: {alert.get('rule', {}).get('level', 'N/A')}\nAgent: {alert.get('agent', {}).get('name', 'N/A')}\nLog: {alert.get('full_log', 'N/A')}"
        send_telegram_message(message)
    except Exception as e:
        print(f"Failed to parse alert: {e}")

if __name__ == "__main__":
    main()

Integration block in ossec.conf:

<integration>
  <name>telegram</name>
  <script>telegram.py</script>
  <alert_format>json</alert_format>
</integration>

Example Workflow

Wazuh agent monitors /var/log/*.log, /var/log/apache2/*.log, and /var/log/myapp/*.json.
A new file error-2026-03-04.log appears with the string CRITICAL.
The generic rule matches it.
Wazuh raises an alert with severity level 6.
The telegram.py script sends the alert to your Telegram group.
Notification appears instantly in Telegram, allowing the team to respond.

Benefits

Centralized visibility: All logs collected in one place.
Real-time detection: Errors and anomalies caught instantly.
Automated notifications: Teams are alerted via email, Slack, or Telegram.
Scalability: Works across thousands of endpoints with clustering.
Flexibility: Wildcards and generic rules handle unknown or dynamic log files.

With this setup, Wazuh becomes a powerful centralized logger with error notifications, capable of sending alerts to multiple platforms — including Telegram — ensuring your team never misses critical issues.

Hopefully you find this article helpful. As always don't hesitate to like, share, leave a comment and if you find any inconvenience please let me know. Cheers

Golden Rule: Composition Over Inheritance

Maksym — Tue, 10 Feb 2026 14:53:04 +0000

A practical guide to writing flexible, maintainable code

Introduction

Every object-oriented developer eventually faces the same dilemma: two classes share some behaviour, and the natural instinct is to create a parent class and have them both inherit from it. It feels clean. It feels right. But more often than not, a few months down the road, that hierarchy starts to crack under the weight of new requirements.

This article explores why favour composition over inheritance — one of the most important principles in software design — what it means in practice, and how to apply it in your everyday code.

What Is Inheritance?

Inheritance is a mechanism where one class (the child or subclass) derives behaviour and state from another class (the parent or superclass). The child extends the parent, inheriting its methods and fields, and can override or add to them.

A classic textbook example:

class Animal:
    def speak(self):
        raise NotImplementedError

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

This looks perfectly fine. And for simple taxonomies, it often is. The problem appears when real-world requirements stop behaving like a tidy class diagram.

The Problems with Deep Hierarchies

The Fragile Base Class Problem

When you change a base class, you risk breaking every subclass. Because subclasses depend on the internal implementation of the parent — not just its public interface — even a small refactor can have cascading, unexpected side effects.

The Gorilla–Banana Problem

"You wanted a banana but what you got was a gorilla holding the banana and the entire jungle." — Joe Armstrong

Inheritance forces you to take everything the parent offers, whether you need it or not. If a subclass only needs one method from a parent that has twenty, it still inherits all the state and behaviour — along with all the associated complexity and risk.

The Diamond Problem

What happens when a class needs to inherit behaviour from two different parents that both define the same method? Most languages either forbid this entirely or introduce complicated resolution rules. It is a symptom of a deeper design flaw.

Violation of Encapsulation

Subclasses are intimately coupled to their parents. They often need to know about protected internals, call super() in the right order, and respect implicit contracts that are never written down. This tight coupling makes code hard to understand and refactor independently.

What Is Composition?

Composition means building complex behaviour by combining simpler, focused objects — rather than by extending a class hierarchy. Instead of asking "what is this object?", you ask "what does this object do?"

Where inheritance models an is-a relationship, composition models a has-a relationship.

Approach	Relationship	Example
Inheritance	is-a	`Dog` is an `Animal`
Composition	has-a	`Robot` has a `Speaker`

A Side-by-Side Comparison

Imagine you are building a game with different types of characters. Some can fly, some can swim, some can fight — and some can do combinations of all three.

The Inheritance Approach (and its problems)

class Character:
    pass

class FlyingCharacter(Character):
    def fly(self): ...

class SwimmingCharacter(Character):
    def swim(self): ...

# What about a character that can BOTH fly and swim?
# Most languages won't allow this cleanly.
class FlyingSwimmingCharacter(FlyingCharacter, SwimmingCharacter):
    pass  # Multiple inheritance — this gets messy fast

Every new combination of abilities requires a new class. The hierarchy explodes in complexity.

The Composition Approach

class FlyBehaviour:
    def fly(self):
        print("Soaring through the sky!")

class SwimBehaviour:
    def swim(self):
        print("Gliding through the water!")

class FightBehaviour:
    def fight(self):
        print("Attacking!")

class Character:
    def __init__(self, behaviours):
        self.behaviours = behaviours

    def perform(self, action):
        behaviour = self.behaviours.get(action)
        if behaviour:
            getattr(behaviour, action)()

# Build any combination at will
hero = Character({
    "fly":   FlyBehaviour(),
    "swim":  SwimBehaviour(),
    "fight": FightBehaviour(),
})

hero.perform("fly")   # Soaring through the sky!
hero.perform("swim")  # Gliding through the water!

Adding a new ability now means writing one new class — not reshaping the entire hierarchy.

Composition in the Real World

Strategy Pattern

The Strategy pattern is composition in its most recognisable form. You define a family of algorithms, encapsulate each one, and make them interchangeable.

class JSONSerializer:
    def serialize(self, data):
        import json
        return json.dumps(data)

class XMLSerializer:
    def serialize(self, data):
        # ... XML serialization logic
        return f"<data>{data}</data>"

class DataExporter:
    def __init__(self, serializer):
        self.serializer = serializer  # composed, not inherited

    def export(self, data):
        return self.serializer.serialize(data)

exporter = DataExporter(JSONSerializer())
exporter.export({"name": "Alice"})

# Swap the strategy without touching DataExporter
exporter.serializer = XMLSerializer()
exporter.export({"name": "Alice"})

Dependency Injection

Dependency injection is composition by another name. Rather than a class constructing its own dependencies (or inheriting them), they are passed in from the outside. This keeps classes loosely coupled and trivially testable.

class EmailNotifier:
    def notify(self, message):
        print(f"Sending email: {message}")

class SMSNotifier:
    def notify(self, message):
        print(f"Sending SMS: {message}")

class OrderService:
    def __init__(self, notifier):
        self.notifier = notifier  # injected dependency

    def place_order(self, order):
        # ... process order
        self.notifier.notify(f"Order {order.id} confirmed.")

# In tests, swap for a mock — no subclassing needed
service = OrderService(EmailNotifier())

When Is Inheritance Actually Appropriate?

Composition over inheritance does not mean never use inheritance. Inheritance is a valid and useful tool when the relationship genuinely satisfies all of the following:

The is-a relationship is stable and true across all use cases — Square is a Shape, HTTPException is an Exception.
You want to share a genuine, semantic contract, not just re-use some code.
The hierarchy is shallow — ideally no more than two levels deep.
You are extending a framework or library that is specifically designed to be subclassed (e.g. Django's View classes, Python's unittest.TestCase).

A useful heuristic: if you would feel awkward saying "X is a kind of Y" out loud to a non-programmer, reach for composition instead.

The Liskov Substitution Principle

The Liskov Substitution Principle (LSP) — the L in SOLID — states that objects of a subclass should be substitutable for objects of their superclass without altering the correctness of the program.

The classic violation:

class Rectangle:
    def set_width(self, w): self.width = w
    def set_height(self, h): self.height = h
    def area(self): return self.width * self.height

class Square(Rectangle):
    def set_width(self, w):
        self.width = w
        self.height = w  # A square must keep sides equal

    def set_height(self, h):
        self.width = h   # This breaks Rectangle's contract!
        self.height = h

A Square seems like it should be a Rectangle, but the subclass breaks the parent's behavioural contract. Any code that relies on being able to set width and height independently will malfunction when handed a Square.

If your inheritance violates LSP, it is a strong signal that you need composition instead.

Summary

	Inheritance	Composition
Relationship	is-a	has-a
Coupling	Tight (shares internals)	Loose (uses interface)
Flexibility	Low (hierarchy is fixed)	High (swap behaviours at runtime)
Reuse unit	Entire class	Individual behaviours
Testability	Harder (must instantiate hierarchy)	Easier (inject mocks)
Risk of change	High (fragile base class)	Low (changes are localised)

Inheritance is a powerful tool, but it is one that is easy to misuse. The moment you find yourself creating a subclass primarily to re-use some code — rather than to express a genuine taxonomic relationship — it is time to reach for composition.

Prefer composition. Build your objects from small, focused, interchangeable pieces. Your future self, and everyone else who reads the code, will thank you.

JavaScript vs Go: A Deep Dive into Syntax and Philosophy

Maksym — Sat, 27 Dec 2025 18:33:04 +0000

As developers, we often find ourselves jumping between languages, and the syntax differences can be jarring. JavaScript and Go represent two very different philosophies in programming language design. JavaScript evolved from a browser scripting language into a full-stack powerhouse, while Go was designed from scratch by Google to solve modern distributed systems problems.

Let's explore how these languages handle common programming tasks and what these differences reveal about their design philosophies.

Variable Declaration and Type Systems
Functions and Their Flavors
Error Handling: Exceptions vs Explicit Errors
Asynchronous Programming and Concurrency
Data Structures: Objects vs Structs
Control Flow and Conditionals
Loops and Iteration
Interfaces and Polymorphism
Package Management and Modules
Philosophy and Real-World Implications

1. Variable Declaration and Type Systems

JavaScript: Dynamic and Flexible

JavaScript's type system is dynamic—variables can hold any type of value and change types at runtime:

// Multiple ways to declare variables
let username = "Mephesto";        // Block-scoped, reassignable
const MAX_RETRIES = 3;            // Block-scoped, immutable binding
var legacy = "avoid this";        // Function-scoped (pre-ES6)

// Dynamic typing
let data = 42;                    // number
data = "now I'm a string";        // totally fine
data = { key: "value" };          // also fine
data = [1, 2, 3];                 // no problem

// Type coercion happens implicitly
console.log("5" + 5);             // "55" (string)
console.log("5" - 5);             // 0 (number)
console.log(true + 1);            // 2

Go: Explicit and Type-Safe

Go is statically typed—every variable has a specific type that's checked at compile time:

package main

import "fmt"

func main() {
    // Explicit type declaration
    var username string = "Mephesto"
    var count int = 42
    var isActive bool = true

    // Type inference with :=
    message := "Go infers this is a string"
    port := 8080  // inferred as int

    // Constants
    const MaxRetries = 3
    const Pi = 3.14159

    // Multiple declarations
    var (
        host string = "localhost"
        timeout int = 30
    )

    // This would be a compile error:
    // count = "string"  // cannot use "string" as int

    // Zero values (no undefined!)
    var emptyString string  // ""
    var emptyInt int        // 0
    var emptyBool bool      // false
    var emptySlice []int    // nil
}

Key Differences:

JavaScript lets you reassign variables to different types; Go doesn't
Go has zero values (default initialization), JavaScript has undefined
Go's := short declaration is convenient but only works inside functions
JavaScript has three declaration keywords (var, let, const); Go primarily uses var and :=

2. Functions and Their Flavors

JavaScript: First-Class and Flexible

JavaScript treats functions as first-class citizens—they're just values that can be passed around:

// Traditional function declaration
function calculateTotal(price, quantity) {
    return price * quantity;
}

// Function expression
const calculateDiscount = function(price, rate) {
    return price * (1 - rate);
};

// Arrow function (ES6+)
const calculateTax = (price, taxRate) => price * taxRate;

// Arrow function with block body
const processOrder = (order) => {
    const total = order.price * order.quantity;
    const tax = total * 0.2;
    return { total, tax };
};

// Default parameters
function greet(name = "Guest", greeting = "Hello") {
    return `${greeting}, ${name}!`;
}

// Rest parameters
function sum(...numbers) {
    return numbers.reduce((acc, n) => acc + n, 0);
}

// Destructuring parameters
function createUser({ name, email, age = 18 }) {
    return { name, email, age, createdAt: new Date() };
}

// Higher-order functions
function withLogging(fn) {
    return function(...args) {
        console.log(`Calling with:`, args);
        const result = fn(...args);
        console.log(`Result:`, result);
        return result;
    };
}

const loggedSum = withLogging(sum);
loggedSum(1, 2, 3); // Logs inputs and output

Go: Typed and Structured

Go functions are more rigid but offer unique features like multiple return values:

package main

import (
    "errors"
    "fmt"
)

// Basic function with typed parameters and return
func calculateTotal(price float64, quantity int) float64 {
    return price * float64(quantity)
}

// Multiple return values (idiomatic for error handling)
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// Named return values
func calculateStats(numbers []int) (sum int, avg float64, count int) {
    count = len(numbers)
    for _, n := range numbers {
        sum += n
    }
    if count > 0 {
        avg = float64(sum) / float64(count)
    }
    return // naked return uses named values
}

// Variadic functions (like JavaScript's rest parameters)
func sum(numbers ...int) int {
    total := 0
    for _, n := range numbers {
        total += n
    }
    return total
}

// Functions as values
func applyOperation(a, b int, op func(int, int) int) int {
    return op(a, b)
}

// Closures
func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

// Methods (functions with receivers)
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Pointer receivers for mutation
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

func main() {
    // Using multiple return values
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)

    // Variadic function
    total := sum(1, 2, 3, 4, 5)

    // Function as value
    multiply := func(a, b int) int { return a * b }
    result = applyOperation(5, 3, multiply)
}

Key Differences:

Go requires explicit types for all parameters and return values
Go's multiple return values eliminate the need for objects/tuples in many cases
JavaScript has more syntactic sugar (arrow functions, default params, destructuring)
Go's receiver functions replace JavaScript's method syntax
Both support closures and first-class functions, but Go's are more verbose

3. Error Handling: Exceptions vs Explicit Errors

This is where the philosophies diverge most dramatically.

JavaScript: Try-Catch Exceptions

JavaScript uses exceptions that can bubble up the call stack:

// Traditional try-catch
function readConfig(filename) {
    try {
        const data = fs.readFileSync(filename, 'utf8');
        return JSON.parse(data);
    } catch (error) {
        console.error(`Failed to read config: ${error.message}`);
        throw error; // Re-throw or handle
    } finally {
        console.log('Cleanup code runs regardless');
    }
}

// Async error handling with promises
async function fetchUserData(userId) {
    try {
        const response = await fetch(`/api/users/${userId}`);

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;
    } catch (error) {
        if (error.name === 'NetworkError') {
            console.error('Network error:', error);
        } else if (error.name === 'SyntaxError') {
            console.error('Invalid JSON:', error);
        } else {
            console.error('Unknown error:', error);
        }
        throw error;
    }
}

// Promise-based error handling
fetchUserData(123)
    .then(user => console.log(user))
    .catch(error => console.error(error))
    .finally(() => console.log('Done'));

// Custom error types
class ValidationError extends Error {
    constructor(field, message) {
        super(message);
        this.name = 'ValidationError';
        this.field = field;
    }
}

function validateUser(user) {
    if (!user.email) {
        throw new ValidationError('email', 'Email is required');
    }
    if (user.age < 0) {
        throw new ValidationError('age', 'Age must be positive');
    }
}

Go: Explicit Error Values

Go treats errors as values that must be explicitly checked:

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "os"
)

// Errors are just values
func readConfig(filename string) (map[string]interface{}, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return nil, fmt.Errorf("failed to read config: %w", err)
    }

    var config map[string]interface{}
    if err := json.Unmarshal(data, &config); err != nil {
        return nil, fmt.Errorf("failed to parse JSON: %w", err)
    }

    return config, nil
}

// Multiple error checking
func processUser(userID int) error {
    user, err := fetchUser(userID)
    if err != nil {
        return fmt.Errorf("fetch failed: %w", err)
    }

    if err := validateUser(user); err != nil {
        return fmt.Errorf("validation failed: %w", err)
    }

    if err := saveUser(user); err != nil {
        return fmt.Errorf("save failed: %w", err)
    }

    return nil
}

// Custom error types
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation error on %s: %s", e.Field, e.Message)
}

func validateUser(user *User) error {
    if user.Email == "" {
        return &ValidationError{
            Field:   "email",
            Message: "email is required",
        }
    }

    if user.Age < 0 {
        return &ValidationError{
            Field:   "age",
            Message: "age must be positive",
        }
    }

    return nil
}

// Error wrapping and unwrapping (Go 1.13+)
func fetchAndProcess(id int) error {
    data, err := fetchFromAPI(id)
    if err != nil {
        // Wrap error with context
        return fmt.Errorf("processing user %d: %w", id, err)
    }

    return processData(data)
}

// Checking for specific errors
func handleError(err error) {
    var validationErr *ValidationError
    if errors.As(err, &validationErr) {
        fmt.Printf("Validation failed on field: %s\n", validationErr.Field)
        return
    }

    if errors.Is(err, os.ErrNotExist) {
        fmt.Println("File not found")
        return
    }

    fmt.Println("Unknown error:", err)
}

// Defer for cleanup (like finally)
func processFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close() // Guaranteed to run

    // Process file...
    return nil
}

Key Differences:

JavaScript errors bubble up automatically; Go errors must be explicitly returned and checked
Go's if err != nil pattern is ubiquitous—critics call it verbose, advocates call it explicit
Go's defer provides cleanup guarantees similar to JavaScript's finally
JavaScript can throw any value; Go errors implement the error interface
Go 1.13+ added error wrapping with %w, similar to error causes in JavaScript

The Great Debate:

This is perhaps the most controversial difference. JavaScript developers often find Go's error handling repetitive. Go developers argue it makes error paths visible and forces you to think about failure cases. Coming from Django/Python, you'll recognize this as the "explicit is better than implicit" philosophy taken to an extreme.

4. Asynchronous Programming and Concurrency

JavaScript: Async/Await and Promises

JavaScript is single-threaded with an event loop, using async/await for non-blocking operations:

// Promises
function fetchUser(id) {
    return fetch(`/api/users/${id}`)
        .then(response => response.json())
        .then(data => {
            console.log('User:', data);
            return data;
        })
        .catch(error => {
            console.error('Error:', error);
            throw error;
        });
}

// Async/await (syntactic sugar over promises)
async function getUserProfile(userId) {
    try {
        const user = await fetchUser(userId);
        const posts = await fetchUserPosts(userId);
        const followers = await fetchFollowers(userId);

        return {
            user,
            posts,
            followers
        };
    } catch (error) {
        console.error('Failed to get profile:', error);
        throw error;
    }
}

// Parallel execution
async function getMultipleUsers(ids) {
    // Sequential (slow)
    const users = [];
    for (const id of ids) {
        users.push(await fetchUser(id));
    }

    // Parallel (fast)
    const promises = ids.map(id => fetchUser(id));
    const usersParallel = await Promise.all(promises);

    return usersParallel;
}

// Race conditions
async function fetchWithTimeout(url, timeout = 5000) {
    const timeoutPromise = new Promise((_, reject) => {
        setTimeout(() => reject(new Error('Timeout')), timeout);
    });

    return Promise.race([
        fetch(url),
        timeoutPromise
    ]);
}

// Promise combinators
async function complexFlow() {
    // All must succeed
    const [user, config, stats] = await Promise.all([
        fetchUser(1),
        fetchConfig(),
        fetchStats()
    ]);

    // First to succeed
    const fastestServer = await Promise.race([
        fetch('https://server1.com/data'),
        fetch('https://server2.com/data')
    ]);

    // All must settle (succeed or fail)
    const results = await Promise.allSettled([
        riskyOperation1(),
        riskyOperation2(),
        riskyOperation3()
    ]);

    results.forEach((result, index) => {
        if (result.status === 'fulfilled') {
            console.log(`Op ${index} succeeded:`, result.value);
        } else {
            console.log(`Op ${index} failed:`, result.reason);
        }
    });
}

Go: Goroutines and Channels

Go has built-in concurrency primitives—goroutines (lightweight threads) and channels:

package main

import (
    "fmt"
    "sync"
    "time"
)

// Basic goroutine
func sayHello() {
    fmt.Println("Hello from goroutine")
}

func basicGoroutine() {
    go sayHello() // Runs concurrently

    time.Sleep(time.Second) // Wait for goroutine (bad practice, use sync)
}

// Channels for communication
func fetchUser(id int, ch chan<- User) {
    // Simulate API call
    time.Sleep(100 * time.Millisecond)
    user := User{ID: id, Name: fmt.Sprintf("User%d", id)}
    ch <- user // Send to channel
}

func useChannels() {
    userChan := make(chan User)

    go fetchUser(1, userChan)

    user := <-userChan // Receive from channel (blocks until data available)
    fmt.Println("Received:", user)
}

// Concurrent fetching (like Promise.all)
func fetchMultipleUsers(ids []int) []User {
    users := make([]User, len(ids))
    var wg sync.WaitGroup

    for i, id := range ids {
        wg.Add(1)
        go func(index, userID int) {
            defer wg.Done()
            users[index] = fetchUserSync(userID)
        }(i, id)
    }

    wg.Wait() // Wait for all goroutines
    return users
}

// Channel patterns
func channelPatterns() {
    // Buffered channel
    ch := make(chan int, 3) // Can hold 3 items without blocking
    ch <- 1
    ch <- 2
    ch <- 3
    // ch <- 4 // Would block until something is received

    // Select for multiple channels (like Promise.race)
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(100 * time.Millisecond)
        ch1 <- "from ch1"
    }()

    go func() {
        time.Sleep(200 * time.Millisecond)
        ch2 <- "from ch2"
    }()

    select {
    case msg1 := <-ch1:
        fmt.Println("Received:", msg1)
    case msg2 := <-ch2:
        fmt.Println("Received:", msg2)
    case <-time.After(500 * time.Millisecond):
        fmt.Println("Timeout")
    }
}

// Worker pool pattern
func workerPool() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // Start workers
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // Send jobs
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    // Collect results
    for a := 1; a <= 9; a++ {
        <-results
    }
}

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

// Context for cancellation (like AbortController)
import "context"

func fetchWithContext(ctx context.Context, id int) (User, error) {
    resultChan := make(chan User)
    errChan := make(chan error)

    go func() {
        // Simulate long operation
        time.Sleep(2 * time.Second)
        resultChan <- User{ID: id}
    }()

    select {
    case user := <-resultChan:
        return user, nil
    case err := <-errChan:
        return User{}, err
    case <-ctx.Done():
        return User{}, ctx.Err() // Cancelled or timed out
    }
}

func useContext() {
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()

    user, err := fetchWithContext(ctx, 1)
    if err != nil {
        fmt.Println("Error:", err) // Will timeout
    }
}

// Mutex for shared state
type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

Key Differences:

JavaScript: single-threaded with async I/O; Go: multi-threaded with goroutines
JavaScript uses promises/async-await; Go uses channels and goroutines
Go's select is more powerful than Promise.race for complex coordination
JavaScript's event loop handles concurrency implicitly; Go makes it explicit
Go has built-in primitives (channels, mutexes); JavaScript relies on the event loop

Real-World Impact:

For CPU-bound tasks, Go's goroutines can utilize multiple cores natively. JavaScript would need worker threads (which are clunky) or child processes. For I/O-bound tasks (like your Django REST Framework apps), both work well, but Go's approach scales better for high-concurrency scenarios like handling thousands of WebSocket connections.

5. Data Structures: Objects vs Structs

JavaScript: Prototypal Objects and Classes

JavaScript is object-oriented with prototypal inheritance:

// Object literals
const user = {
    name: "Mephesto",
    email: "mephesto@example.com",
    age: 25,
    greet() {
        return `Hello, I'm ${this.name}`;
    }
};

// Dynamic properties
user.location = "Ukraine";
delete user.age;

// ES6 Classes (syntactic sugar over prototypes)
class User {
    constructor(name, email) {
        this.name = name;
        this.email = email;
        this.createdAt = new Date();
    }

    greet() {
        return `Hello, I'm ${this.name}`;
    }

    static fromJSON(json) {
        const data = JSON.parse(json);
        return new User(data.name, data.email);
    }

    get displayName() {
        return this.name.toUpperCase();
    }

    set displayName(value) {
        this.name = value.toLowerCase();
    }
}

// Inheritance
class AdminUser extends User {
    constructor(name, email, permissions) {
        super(name, email);
        this.permissions = permissions;
    }

    greet() {
        return `Hello, I'm ${this.name} (Admin)`;
    }

    hasPermission(perm) {
        return this.permissions.includes(perm);
    }
}

// Private fields (ES2022)
class BankAccount {
    #balance = 0;

    deposit(amount) {
        this.#balance += amount;
    }

    getBalance() {
        return this.#balance;
    }
}

// Mixing concerns
const withLogging = (BaseClass) => {
    return class extends BaseClass {
        log(message) {
            console.log(`[${this.constructor.name}] ${message}`);
        }
    };
};

const LoggedUser = withLogging(User);

Go: Structs and Composition

Go uses structs with composition instead of inheritance:

package main

import (
    "encoding/json"
    "fmt"
    "strings"
    "time"
)

// Struct definition
type User struct {
    Name      string    `json:"name"`
    Email     string    `json:"email"`
    CreatedAt time.Time `json:"created_at"`
}

// Constructor pattern (not built-in)
func NewUser(name, email string) *User {
    return &User{
        Name:      name,
        Email:     email,
        CreatedAt: time.Now(),
    }
}

// Methods with receivers
func (u User) Greet() string {
    return fmt.Sprintf("Hello, I'm %s", u.Name)
}

// Pointer receivers for mutation
func (u *User) UpdateEmail(email string) {
    u.Email = email
}

// "Getters" (not idiomatic to call them GetX)
func (u User) DisplayName() string {
    return strings.ToUpper(u.Name)
}

// Embedded structs (composition, not inheritance)
type AdminUser struct {
    User                    // Embedded field
    Permissions []string
}

func NewAdminUser(name, email string, perms []string) *AdminUser {
    return &AdminUser{
        User:        *NewUser(name, email),
        Permissions: perms,
    }
}

// Method overriding through embedding
func (a AdminUser) Greet() string {
    return fmt.Sprintf("Hello, I'm %s (Admin)", a.Name)
}

func (a AdminUser) HasPermission(perm string) bool {
    for _, p := range a.Permissions {
        if p == perm {
            return true
        }
    }
    return false
}

// Unexported fields (private)
type bankAccount struct {
    balance int
}

func NewBankAccount() *bankAccount {
    return &bankAccount{balance: 0}
}

func (b *bankAccount) Deposit(amount int) {
    b.balance += amount
}

func (b *bankAccount) Balance() int {
    return b.balance
}

// JSON marshaling/unmarshaling
func jsonExample() {
    user := NewUser("Mephesto", "m@example.com")

    // Marshal to JSON
    data, err := json.Marshal(user)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))

    // Unmarshal from JSON
    var newUser User
    if err := json.Unmarshal(data, &newUser); err != nil {
        panic(err)
    }
}

// Struct tags for metadata
type APIUser struct {
    ID        int       `json:"id" db:"user_id"`
    Username  string    `json:"username" db:"username" validate:"required"`
    Email     string    `json:"email,omitempty" db:"email"`
    CreatedAt time.Time `json:"created_at" db:"created_at"`
    password  string    // unexported, won't be marshaled
}

// Anonymous structs for one-off use
func anonymousStructs() {
    config := struct {
        Host string
        Port int
    }{
        Host: "localhost",
        Port: 8080,
    }

    fmt.Printf("Server: %s:%d\n", config.Host, config.Port)
}

Key Differences:

JavaScript has prototypal inheritance; Go has composition via embedding
JavaScript classes are syntactic sugar; Go structs are data containers with attached methods
Go doesn't have constructors—use factory functions by convention
JavaScript properties can be added/removed dynamically; Go structs are fixed at compile time
Go uses struct tags for metadata (like Django model field options)
Privacy in JavaScript uses # or closures; Go uses capitalization (Upper = public, lower = private)

6. Control Flow and Conditionals

JavaScript

// If-else
if (user.age >= 18) {
    console.log("Adult");
} else if (user.age >= 13) {
    console.log("Teenager");
} else {
    console.log("Child");
}

// Ternary operator
const status = user.isActive ? "Active" : "Inactive";

// Switch
switch (user.role) {
    case "admin":
        grantAdminAccess();
        break;
    case "moderator":
        grantModeratorAccess();
        break;
    default:
        grantUserAccess();
}

// Truthy/falsy
if (user.email) { // truthy check
    sendEmail(user.email);
}

// Nullish coalescing
const port = config.port ?? 8080; // Only for null/undefined

// Optional chaining
const city = user?.address?.city; // Won't throw if undefined

// Short-circuit evaluation
const name = user.name || "Anonymous";
const value = user.value && user.value.trim();

Go

package main

import "fmt"

func controlFlow() {
    // If-else (no parentheses!)
    age := 25
    if age >= 18 {
        fmt.Println("Adult")
    } else if age >= 13 {
        fmt.Println("Teenager")
    } else {
        fmt.Println("Child")
    }

    // If with initialization
    if err := someOperation(); err != nil {
        fmt.Println("Error:", err)
        return
    }

    // No ternary operator! Use if-else
    var status string
    if user.IsActive {
        status = "Active"
    } else {
        status = "Inactive"
    }

    // Switch (no break needed!)
    switch role := user.Role; role {
    case "admin":
        grantAdminAccess()
    case "moderator":
        grantModeratorAccess()
    default:
        grantUserAccess()
    }

    // Switch without expression (like if-else chain)
    switch {
    case age < 13:
        fmt.Println("Child")
    case age < 18:
        fmt.Println("Teenager")
    default:
        fmt.Println("Adult")
    }

    // Switch with multiple cases
    switch day {
    case "Saturday", "Sunday":
        fmt.Println("Weekend")
    case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday":
        fmt.Println("Weekday")
    }

    // Fallthrough (explicit, unlike JavaScript)
    switch num {
    case 1:
        fmt.Println("One")
        fallthrough
    case 2:
        fmt.Println("Two or less")
    }

    // Type switch
    var i interface{} = "hello"
    switch v := i.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

Key Differences:

Go doesn't have ternary operators—use if-else
Go's switch doesn't fall through by default (needs explicit fallthrough)
Go's switch can operate on types and arbitrary conditions
JavaScript has truthy/falsy; Go requires explicit boolean expressions
Go's if can include an initialization statement

7. Loops and Iteration

JavaScript

// For loop
for (let i = 0; i < 10; i++) {
    console.log(i);
}

// For...of (values)
const numbers = [1, 2, 3, 4, 5];
for (const num of numbers) {
    console.log(num);
}

// For...in (keys/indices)
const user = { name: "John", age: 30 };
for (const key in user) {
    console.log(`${key}: ${user[key]}`);
}

// While
let count = 0;
while (count < 10) {
    console.log(count);
    count++;
}

// Do-while
do {
    console.log(count);
    count--;
} while (count > 0);

// Array methods (functional style)
const doubled = numbers.map(n => n * 2);
const evens = numbers.filter(n => n % 2 === 0);
const sum = numbers.reduce((acc, n) => acc + n, 0);

numbers.forEach((num, index) => {
    console.log(`${index}: ${num}`);
});

// Break and continue
for (let i = 0; i < 10; i++) {
    if (i === 3) continue;
    if (i === 7) break;
    console.log(i);
}

// Labeled loops
outer: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (i === 1 && j === 1) break outer;
        console.log(i, j);
    }
}

Go

package main

import "fmt"

func loops() {
    // For loop (only loop keyword in Go!)
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }

    // While-style loop
    count := 0
    for count < 10 {
        fmt.Println(count)
        count++
    }

    // Infinite loop
    for {
        // Must have break somewhere
        if someCondition {
            break
        }
    }

    // Range over slice (like for...of)
    numbers := []int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Printf("%d: %d\n", index, value)
    }

    // Ignore index with _
    for _, value := range numbers {
        fmt.Println(value)
    }

    // Only index
    for index := range numbers {
        fmt.Println(index)
    }

    // Range over map
    user := map[string]interface{}{
        "name": "John",
        "age":  30,
    }
    for key, value := range user {
        fmt.Printf("%s: %v\n", key, value)
    }

    // Range over string (iterates over runes/characters)
    for index, char := range "Привіт" {
        fmt.Printf("%d: %c\n", index, char)
    }

    // Range over channel
    ch := make(chan int, 5)
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
        }
        close(ch)
    }()

    for value := range ch {
        fmt.Println(value)
    }

    // Break and continue
    for i := 0; i < 10; i++ {
        if i == 3 {
            continue
        }
        if i == 7 {
            break
        }
        fmt.Println(i)
    }

    // Labeled loops
outer:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i == 1 && j == 1 {
                break outer
            }
            fmt.Println(i, j)
        }
    }
}

// No built-in map/filter/reduce, but easy to implement
func Map(slice []int, fn func(int) int) []int {
    result := make([]int, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

func Filter(slice []int, fn func(int) bool) []int {
    result := []int{}
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

func Reduce(slice []int, fn func(int, int) int, initial int) int {
    result := initial
    for _, v := range slice {
        result = fn(result, v)
    }
    return result
}

Key Differences:

Go has only for (replaces while, do-while, foreach)
Go's range is like JavaScript's for...of but more powerful
JavaScript has rich array methods; Go requires manual implementation or libraries
Both support labeled breaks for nested loops
Go's range over strings gives you runes (Unicode code points), not bytes

8. Interfaces and Polymorphism

JavaScript: Duck Typing

JavaScript uses structural typing—if it looks like a duck and quacks like a duck:

// No explicit interface, just conventions
class FileStorage {
    save(data) {
        // Save to file
    }

    load() {
        // Load from file
    }
}

class DatabaseStorage {
    save(data) {
        // Save to database
    }

    load() {
        // Load from database
    }
}

// Works with anything that has save/load
function backup(storage, data) {
    storage.save(data);
}

backup(new FileStorage(), data);
backup(new DatabaseStorage(), data);

// TypeScript interfaces (compile-time only)
interface Storage {
    save(data: any): void;
    load(): any;
}

class CloudStorage implements Storage {
    save(data: any) { /* ... */ }
    load() { /* ... */ }
}

Go: Implicit Interfaces

Go has interfaces, but they're satisfied implicitly (structural typing):

package main

import "fmt"

// Interface definition
type Storage interface {
    Save(data []byte) error
    Load() ([]byte, error)
}

// Types implement interfaces implicitly
type FileStorage struct {
    path string
}

func (f *FileStorage) Save(data []byte) error {
    // Save to file
    fmt.Println("Saving to file:", f.path)
    return nil
}

func (f *FileStorage) Load() ([]byte, error) {
    // Load from file
    return []byte("file data"), nil
}

type DatabaseStorage struct {
    connStr string
}

func (d *DatabaseStorage) Save(data []byte) error {
    // Save to database
    fmt.Println("Saving to database")
    return nil
}

func (d *DatabaseStorage) Load() ([]byte, error) {
    // Load from database
    return []byte("db data"), nil
}

// Function accepts interface
func Backup(storage Storage, data []byte) error {
    return storage.Save(data)
}

func main() {
    file := &FileStorage{path: "/tmp/data"}
    db := &DatabaseStorage{connStr: "postgres://..."}

    Backup(file, []byte("data"))    // Works
    Backup(db, []byte("data"))      // Works
}

// Multiple interfaces
type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

// Empty interface (like any in TypeScript)
func PrintAnything(v interface{}) {
    fmt.Println(v)
}

// Type assertions
func processValue(v interface{}) {
    // Type assertion
    if str, ok := v.(string); ok {
        fmt.Println("String:", str)
    }

    // Type switch
    switch val := v.(type) {
    case int:
        fmt.Println("Int:", val)
    case string:
        fmt.Println("String:", val)
    case Storage:
        fmt.Println("Storage implementation")
    default:
        fmt.Println("Unknown type")
    }
}

// Common standard interfaces
import "io"

// io.Reader is everywhere in Go
func ProcessReader(r io.Reader) {
    data := make([]byte, 100)
    n, err := r.Read(data)
    // Process data
}

// Works with files, network connections, buffers, etc.

Key Differences:

Both use structural typing (duck typing), but Go makes it explicit with the interface keyword
JavaScript has no runtime interfaces; TypeScript interfaces are compile-time only
Go's interface satisfaction is implicit—no implements keyword needed
Go's empty interface interface{} is like JavaScript's any
Go has powerful standard interfaces (io.Reader, io.Writer, etc.)

9. Package Management and Modules

JavaScript: NPM and ES Modules

// package.json
{
  "name": "my-app",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "express": "^4.18.0",
    "lodash": "^4.17.21"
  },
  "devDependencies": {
    "jest": "^29.0.0"
  }
}

// Importing
import express from 'express';
import { debounce } from 'lodash';
import * as utils from './utils.js';

// Named exports
export function helper() { }
export const CONSTANT = 42;

// Default export
export default class MyClass { }

// Re-exporting
export { something } from './other.js';
export * from './module.js';

// Dynamic imports
const module = await import('./dynamic.js');

// CommonJS (older style)
const fs = require('fs');
module.exports = { helper };

Go: Go Modules

// go.mod
module github.com/mephesto/myapp

go 1.21

require (
    github.com/gin-gonic/gin v1.9.0
    github.com/lib/pq v1.10.7
)

// Importing
package main

import (
    "fmt"                    // Standard library
    "net/http"              // Standard library

    "github.com/gin-gonic/gin"           // External package
    "github.com/mephesto/myapp/internal" // Internal package
)

// Exporting (capitalization!)
package utils

// Exported (public)
func Helper() {
    // ...
}

const PublicConstant = 42

type PublicStruct struct {
    PublicField  string
    privateField string  // Not exported
}

// Not exported (private)
func helper() {
    // ...
}

// Package initialization
func init() {
    // Runs when package is imported
    fmt.Println("Package initialized")
}

// Internal packages (Go specific)
// github.com/mephesto/myapp/internal can only be imported
// by packages under github.com/mephesto/myapp

Key Differences:

JavaScript uses package.json; Go uses go.mod
JavaScript has explicit export/import; Go uses capitalization for visibility
Go's import creates a namespace; JavaScript can destructure imports
Go has internal/ package convention for truly private code
JavaScript has dynamic imports; Go imports are static (compile-time)
Go's standard library is more comprehensive

10. Philosophy and Real-World Implications

JavaScript Philosophy

Flexibility and Expression

JavaScript embraces multiple paradigms—object-oriented, functional, imperative. You can solve problems in many ways:

// Object-oriented
class UserService {
    findUser(id) { }
}

// Functional
const findUser = (id) => fetch(`/users/${id}`);

// Prototype-based
function UserService() { }
UserService.prototype.findUser = function(id) { };

Dynamic and Forgiving

// Type coercion
"5" - 3;        // 2
"5" + 3;        // "53"
[] + {};        // "[object Object]"
{} + [];        // 0 (in some contexts)

// Undefined behavior
const obj = {};
obj.deeply.nested.property; // TypeError
obj?.deeply?.nested?.property; // undefined (with optional chaining)

Ecosystem: Fast-Moving

The JavaScript ecosystem moves quickly. New frameworks appear constantly. This is both a strength (innovation) and weakness (fatigue).

Go Philosophy

Simplicity and Clarity

Go deliberately limits features. There's often "one way" to do things:

// One loop construct
for i := 0; i < 10; i++ { }

// No ternary operator
// No generics (until Go 1.18)
// No inheritance
// No overloading

Explicit and Strict

// No implicit conversions
var i int = 42
var f float64 = i  // Compile error
var f float64 = float64(i)  // Must be explicit

// Unused imports are errors
import "fmt"  // If not used, won't compile

// All errors must be handled
result, err := doSomething()
// Ignoring err is bad practice

Ecosystem: Stability-Focused

Go values backwards compatibility. The language changes slowly. Standard library is comprehensive. Fewer but more stable third-party packages.

When to Choose Which?

Choose JavaScript when:

Building web frontends (React, Vue, Angular)
Rapid prototyping with flexibility
Rich ecosystem of libraries needed
Team familiar with dynamic typing
Quick iteration more important than compile-time safety

Choose Go when:

Building microservices or APIs
Performance and concurrency critical
System-level programming
Deployment simplicity matters (single binary)
Long-term maintainability priority
Team values explicit error handling

Practical Example: Web API

JavaScript (Express):

const express = require('express');
const app = express();

app.get('/users/:id', async (req, res) => {
    try {
        const user = await db.findUser(req.params.id);
        res.json(user);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

app.listen(3000);

Go (Gin):

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")

        user, err := db.FindUser(id)
        if err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{
                "error": err.Error(),
            })
            return
        }

        c.JSON(http.StatusOK, user)
    })

    r.Run(":3000")
}

Key Observations:

JavaScript: More concise, async/await cleaner, dynamic
Go: More verbose, explicit error handling, typed parameters
JavaScript: Dependency on framework conventions
Go: Strong standard library, explicit control flow

Conclusion

JavaScript and Go represent different philosophies:

JavaScript says: "Be flexible, move fast, express yourself freely." It's the language of rapid iteration, rich ecosystems, and creative solutions. Perfect for web development where requirements change rapidly.

Go says: "Be explicit, be simple, be maintainable." It's the language of clarity, performance, and long-term reliability. Perfect for backend services where stability matters.

Neither is "better"—they solve different problems. Coming from Django and Python, you'll appreciate Go's explicitness and find JavaScript's dynamism both liberating and occasionally frustrating.

The best developers understand both paradigms and choose the right tool for the job. JavaScript for dynamic, user-facing applications. Go for reliable, concurrent backend services.

What matters is understanding the trade-offs and using each language's strengths effectively.

Want to dive deeper? Check out my other posts on language comparisons, or follow along as I continue exploring "What's wrong with..." various programming paradigms.

Taming the Container Beast: A Developer's Guide to Debugging Django in Docker

Maksym — Wed, 03 Dec 2025 09:18:49 +0000

Debugging a Django application running inside a Docker container can feel like trying to fix a car engine while it's still running—challenging, but definitely not impossible. If you've ever found yourself staring at cryptic error messages with no stack trace, or wondering why your breakpoints never trigger, you're not alone. This guide will equip you with the tools and techniques to effectively debug Dockerized Django applications.

Why Docker Makes Debugging Tricky

Docker containers are designed to be isolated, lightweight, and production-like. While this is great for deployment, it creates some unique challenges for debugging:

Limited direct access to the running process
Logs can be scattered or hard to follow
Interactive debuggers require special configuration
File system isolation makes it harder to inspect state
Network isolation can complicate remote debugging

But don't worry—once you understand how to work with these constraints, debugging becomes straightforward.

Setting Up Your Environment for Success

Before diving into specific debugging techniques, let's ensure your Docker setup is debug-friendly.

Optimize Your Dockerfile for Development

Create a separate Dockerfile.dev for development that includes debugging tools:

FROM python:3.11-slim

# Install system dependencies
RUN apt-get update && apt-get install -y \
    postgresql-client \
    netcat-traditional \
    vim \
    curl \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Install Python dependencies
COPY requirements.txt requirements-dev.txt ./
RUN pip install --no-cache-dir -r requirements.txt -r requirements-dev.txt

# Copy application code
COPY . .

# Don't run as root
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Configure docker-compose.yml for Development

Your docker-compose.yml should make debugging easier:

version: '3.8'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      # Mount code for live reloading
      - .:/app
      # Preserve Python packages
      - python-packages:/usr/local/lib/python3.11/site-packages
    ports:
      - "8000:8000"
      # Expose debugger port
      - "5678:5678"
    environment:
      - DEBUG=True
      - PYTHONUNBUFFERED=1
      - DJANGO_SETTINGS_MODULE=myproject.settings.dev
    depends_on:
      - db
    stdin_open: true
    tty: true

  db:
    image: postgres:15
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_USER=myuser
      - POSTGRES_PASSWORD=mypassword
    volumes:
      - postgres-data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

volumes:
  postgres-data:
  python-packages:

Key settings explained:

stdin_open: true and tty: true enable interactive debugging
PYTHONUNBUFFERED=1 ensures logs appear in real-time
Volume mounting allows code changes without rebuilding
Exposed ports enable remote debugging

Technique 1: Mastering Docker Logs

The first line of defense is always logs. Docker provides powerful logging capabilities.

View Real-Time Logs

# Follow logs from all services
docker-compose logs -f

# Follow logs from specific service
docker-compose logs -f web

# Show last 100 lines and follow
docker-compose logs -f --tail=100 web

# View logs with timestamps
docker-compose logs -f -t web

Enhance Django Logging

Configure comprehensive logging in your Django settings:

# settings/dev.py
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '[{levelname}] {asctime} {module} {process:d} {thread:d} {message}',
            'style': '{',
        },
        'simple': {
            'format': '[{levelname}] {message}',
            'style': '{',
        },
    },
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
            'formatter': 'verbose',
        },
        'file': {
            'class': 'logging.FileHandler',
            'filename': '/app/logs/debug.log',
            'formatter': 'verbose',
        },
    },
    'root': {
        'handlers': ['console', 'file'],
        'level': 'INFO',
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'file'],
            'level': 'INFO',
            'propagate': False,
        },
        'django.db.backends': {
            'handlers': ['console'],
            'level': 'DEBUG',  # Shows SQL queries
            'propagate': False,
        },
        'myapp': {
            'handlers': ['console', 'file'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

Use logging strategically in your code:

import logging

logger = logging.getLogger(__name__)

def my_view(request):
    logger.info(f"Processing request: {request.method} {request.path}")
    logger.debug(f"Request data: {request.POST}")

    try:
        # Your code here
        result = perform_operation()
        logger.info(f"Operation successful: {result}")
    except Exception as e:
        logger.error(f"Operation failed: {str(e)}", exc_info=True)
        raise

    return response

Technique 2: Interactive Shell Access

Sometimes you need to poke around inside the container.

Access the Container Shell

# Start a bash shell in running container
docker-compose exec web bash

# Or use sh if bash isn't available
docker-compose exec web sh

# Run as root for system-level debugging
docker-compose exec -u root web bash

Use Django Shell Inside Container

# Django shell
docker-compose exec web python manage.py shell

# Django shell with IPython (if installed)
docker-compose exec web python manage.py shell -i ipython

# Run specific Django commands
docker-compose exec web python manage.py migrate
docker-compose exec web python manage.py createsuperuser

One-Liner Debugging Commands

# Check database connectivity
docker-compose exec web python manage.py dbshell

# Inspect database tables
docker-compose exec db psql -U myuser -d mydb -c "\dt"

# Check environment variables
docker-compose exec web env

# Test a specific view
docker-compose exec web python manage.py shell -c "
from django.test import Client
client = Client()
response = client.get('/api/endpoint/')
print(response.status_code)
print(response.content)
"

Technique 3: Remote Debugging with debugpy

For complex issues, nothing beats a proper debugger with breakpoints.

Install debugpy

Add to requirements-dev.txt:

debugpy==1.8.0

Configure Remote Debugging

Create a debugging wrapper script debug_server.py:

import os
import sys
import debugpy

# Allow other computers to attach to debugpy
debugpy.listen(("0.0.0.0", 5678))

# Pause execution until debugger attaches
if os.environ.get('WAIT_FOR_DEBUGGER', 'False') == 'True':
    print("⏳ Waiting for debugger to attach...")
    debugpy.wait_for_client()
    print("✅ Debugger attached!")

# Start Django
if __name__ == "__main__":
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
    from django.core.management import execute_from_command_line
    execute_from_command_line(sys.argv)

Update your docker-compose.yml command:

services:
  web:
    command: python debug_server.py runserver 0.0.0.0:8000
    environment:
      - WAIT_FOR_DEBUGGER=False  # Set to True to wait for debugger

Configure VS Code

Create .vscode/launch.json:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Django: Remote Attach",
            "type": "python",
            "request": "attach",
            "connect": {
                "host": "localhost",
                "port": 5678
            },
            "pathMappings": [
                {
                    "localRoot": "${workspaceFolder}",
                    "remoteRoot": "/app"
                }
            ],
            "django": true,
            "justMyCode": false
        }
    ]
}

Configure PyCharm

Go to Run → Edit Configurations
Click + → Python Remote Debug
Set Host: localhost, Port: 5678
Set Path mappings: <Project root>=/app
Click OK

Using the Debugger

# Start your containers
docker-compose up

# In VS Code: Press F5 or click "Run and Debug"
# Set breakpoints in your code
# Make a request to trigger your code

The debugger will pause at breakpoints, allowing you to:

Inspect variables
Step through code
Evaluate expressions
Examine the call stack

Technique 4: Using pdb for Quick Debugging

For quick debugging sessions, Python's built-in pdb works well.

Insert Breakpoints

def my_view(request):
    data = request.POST.get('data')

    # Insert breakpoint
    import pdb; pdb.set_trace()

    # Or use the modern way (Python 3.7+)
    breakpoint()

    result = process_data(data)
    return JsonResponse({'result': result})

Attach to Container with TTY

# Stop current containers
docker-compose down

# Start with attached terminal
docker-compose run --service-ports web

# Now when pdb breakpoint hits, you'll get an interactive prompt

Common pdb commands:

n (next) - Execute next line
s (step) - Step into function
c (continue) - Continue execution
l (list) - Show code context
p variable - Print variable value
pp variable - Pretty-print variable
w (where) - Show stack trace
q (quit) - Quit debugger

Technique 5: Debugging Database Issues

Database problems are common in Django applications.

Inspect Database State

# Access PostgreSQL directly
docker-compose exec db psql -U myuser -d mydb

# Run SQL queries
docker-compose exec db psql -U myuser -d mydb -c "
SELECT * FROM django_migrations ORDER BY applied DESC LIMIT 5;
"

# Check database size and connections
docker-compose exec db psql -U myuser -d mydb -c "
SELECT 
    datname,
    pg_size_pretty(pg_database_size(datname)) as size,
    numbackends as connections
FROM pg_stat_database
WHERE datname = 'mydb';
"

Debug SQL Queries

Enable SQL logging in Django settings:

LOGGING['loggers']['django.db.backends'] = {
    'handlers': ['console'],
    'level': 'DEBUG',
}

Or use Django Debug Toolbar:

# requirements-dev.txt
django-debug-toolbar==4.2.0

# settings/dev.py
INSTALLED_APPS += ['debug_toolbar']
MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']
INTERNAL_IPS = ['127.0.0.1', 'host.docker.internal']

# For Docker, you need this:
import socket
hostname, _, ips = socket.gethostbyname_ex(socket.gethostname())
INTERNAL_IPS += [ip[:-1] + '1' for ip in ips]

Use Django Shell Plus

# Install
pip install django-extensions ipython

# Add to settings
INSTALLED_APPS += ['django_extensions']

# Use it
docker-compose exec web python manage.py shell_plus --print-sql

This auto-imports models and shows SQL for all queries.

Technique 6: Network and Service Debugging

Container networking can be tricky.

Test Inter-Container Connectivity

# From web container, test database connection
docker-compose exec web nc -zv db 5432

# Test HTTP endpoint from another service
docker-compose exec web curl http://another_service:8000/health

# Check DNS resolution
docker-compose exec web nslookup db
docker-compose exec web ping -c 3 db

Inspect Docker Networks

# List networks
docker network ls

# Inspect specific network
docker network inspect myproject_default

# Check which containers are on network
docker network inspect myproject_default | grep -A 5 "Containers"

Debug External Network Issues

# Check if container can reach external services
docker-compose exec web curl -I https://api.example.com

# Check DNS resolution
docker-compose exec web nslookup google.com

# Test with specific DNS server
docker-compose exec web nslookup google.com 8.8.8.8

Technique 7: Performance Profiling

Identify performance bottlenecks in your containerized app.

Use Django Silk

# requirements-dev.txt
django-silk==5.0.4

# settings/dev.py
INSTALLED_APPS += ['silk']
MIDDLEWARE.insert(0, 'silk.middleware.SilkyMiddleware')

# urls.py
urlpatterns += [path('silk/', include('silk.urls', namespace='silk'))]

Access profiling data at http://localhost:8000/silk/

Use cProfile

# Create a management command: myapp/management/commands/profile_view.py
from django.core.management.base import BaseCommand
import cProfile
import pstats
from django.test import Client

class Command(BaseCommand):
    def handle(self, *args, **options):
        client = Client()
        profiler = cProfile.Profile()

        profiler.enable()
        response = client.get('/api/slow-endpoint/')
        profiler.disable()

        stats = pstats.Stats(profiler)
        stats.sort_stats('cumulative')
        stats.print_stats(20)  # Top 20 slowest functions

Run it:

docker-compose exec web python manage.py profile_view

Monitor Container Resources

# Real-time container stats
docker stats

# Stats for specific container
docker stats myproject_web_1

# Check container processes
docker-compose exec web ps aux

# Check memory usage inside container
docker-compose exec web free -h

# Check disk usage
docker-compose exec web df -h

Technique 8: Debugging Static Files and Media

Static file issues are common during development.

Verify Static File Configuration

# Collect static files
docker-compose exec web python manage.py collectstatic --noinput

# Check static files location
docker-compose exec web python manage.py findstatic admin/css/base.css

# List all static file locations
docker-compose exec web python manage.py findstatic --verbosity=2 admin/css/base.css

Debug Media File Uploads

# settings/dev.py
MEDIA_ROOT = '/app/media'
MEDIA_URL = '/media/'

# Check permissions
import os
import logging
logger = logging.getLogger(__name__)

def check_media_permissions():
    media_root = settings.MEDIA_ROOT
    if not os.path.exists(media_root):
        logger.warning(f"MEDIA_ROOT does not exist: {media_root}")
    elif not os.access(media_root, os.W_OK):
        logger.error(f"MEDIA_ROOT is not writable: {media_root}")
    else:
        logger.info(f"MEDIA_ROOT is configured correctly: {media_root}")

Technique 9: Environment and Configuration Debugging

Configuration issues are hard to spot but easy to fix once found.

Dump All Django Settings

# Create management command: myapp/management/commands/show_settings.py
from django.core.management.base import BaseCommand
from django.conf import settings
import pprint

class Command(BaseCommand):
    def handle(self, *args, **options):
        # Get all settings
        settings_dict = {
            key: getattr(settings, key)
            for key in dir(settings)
            if key.isupper()
        }
        pprint.pprint(settings_dict)

docker-compose exec web python manage.py show_settings

Check Environment Variables

# View all env vars
docker-compose exec web env

# Check specific variable
docker-compose exec web bash -c 'echo $DATABASE_URL'

# Verify Django can access them
docker-compose exec web python -c "
import os
from django.conf import settings
print('DEBUG:', settings.DEBUG)
print('DATABASE:', settings.DATABASES)
print('SECRET_KEY:', settings.SECRET_KEY[:10] + '...')
"

Validate Docker Compose Configuration

# Validate compose file syntax
docker-compose config

# View merged configuration
docker-compose config --services

# Check resolved environment variables
docker-compose config --resolve-image-digests

Technique 10: Debugging Migrations

Migration issues can break your entire application.

Check Migration Status

# Show migration status
docker-compose exec web python manage.py showmigrations

# Show unapplied migrations
docker-compose exec web python manage.py showmigrations --plan

# Check for conflicts
docker-compose exec web python manage.py makemigrations --dry-run --check

Debug Failed Migrations

# Run migrations with verbose output
docker-compose exec web python manage.py migrate --verbosity=3

# Fake a specific migration (if needed)
docker-compose exec web python manage.py migrate myapp 0004 --fake

# Roll back to specific migration
docker-compose exec web python manage.py migrate myapp 0003

# Start fresh (DANGEROUS - dev only!)
docker-compose down -v
docker-compose up -d db
docker-compose exec db psql -U myuser -d mydb -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"
docker-compose exec web python manage.py migrate

Generate SQL for Migration

# See SQL that will be executed
docker-compose exec web python manage.py sqlmigrate myapp 0005

# Show SQL for all pending migrations
docker-compose exec web python manage.py sqlmigrate --backwards myapp 0005

Pro Tips and Best Practices

Use Docker Compose Override Files

Create docker-compose.override.yml for personal debugging settings:

version: '3.8'

services:
  web:
    environment:
      - DEBUG=True
      - DJANGO_LOG_LEVEL=DEBUG
    volumes:
      - ./my_local_debugging:/app/debug
    ports:
      - "5678:5678"  # Debugger
      - "8001:8000"  # Alternative port

This file is automatically merged and git-ignored by default.

Create Debugging Shortcuts

Add aliases to your .bashrc or .zshrc:

# Docker compose shortcuts
alias dc='docker-compose'
alias dcup='docker-compose up -d'
alias dcdown='docker-compose down'
alias dclogs='docker-compose logs -f'
alias dcweb='docker-compose exec web'
alias dcdb='docker-compose exec db psql -U myuser -d mydb'
alias dcshell='docker-compose exec web python manage.py shell_plus'
alias dcbash='docker-compose exec web bash'

# Django shortcuts
alias djmigrate='docker-compose exec web python manage.py migrate'
alias djmakemigrations='docker-compose exec web python manage.py makemigrations'
alias djtest='docker-compose exec web python manage.py test'
alias djcollectstatic='docker-compose exec web python manage.py collectstatic --noinput'

Use Watchdog for Auto-Restart

# requirements-dev.txt
watchdog==3.0.0

# Start server with auto-reload
docker-compose exec web watchmedo auto-restart \
    --directory=/app \
    --pattern="*.py" \
    --recursive \
    -- python manage.py runserver 0.0.0.0:8000

Build a Debugging Checklist

When something goes wrong, systematically check:

✅ Are all containers running? (docker-compose ps)
✅ Any errors in logs? (docker-compose logs)
✅ Can containers communicate? (nc -zv service port)
✅ Are environment variables set correctly? (env)
✅ Are migrations applied? (showmigrations)
✅ Is database accessible? (dbshell)
✅ Are static files collected? (findstatic)
✅ Is DEBUG=True in development? (show_settings)
✅ Can you reproduce outside Docker? (Local testing)
✅ Is it a volume/permission issue? (ls -la)

Common Pitfalls and Solutions

Issue: Changes Not Reflected

Problem: Code changes don't appear when refreshing.

Solutions:

Check volume mounting: docker-compose config | grep volumes
Ensure PYTHONUNBUFFERED=1
Restart with fresh build: docker-compose up --build
Clear Python cache: docker-compose exec web find . -name "*.pyc" -delete

Issue: Database Connection Refused

Problem: Django can't connect to PostgreSQL.

Solutions:

Check if DB is ready: docker-compose exec db pg_isready
Verify service name matches: Use db not localhost
Add healthcheck to wait for DB:

services:
  web:
    depends_on:
      db:
        condition: service_healthy
  db:
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U myuser"]
      interval: 5s
      timeout: 5s
      retries: 5

Issue: Permission Denied Errors

Problem: Can't write to mounted volumes.

Solutions:

Match container user to host user UID
Use named volumes for sensitive data
Run container as root temporarily: docker-compose exec -u root web bash

Issue: Debugger Won't Attach

Problem: Remote debugger fails to connect.

Solutions:

Ensure port 5678 is exposed and mapped
Use 0.0.0.0 not localhost in debugpy.listen()
Check firewall settings
Verify path mappings match exactly

Conclusion

Debugging Django in Docker doesn't have to be painful. With the right setup and tools, you can have a debugging experience that rivals local development while enjoying Docker's benefits. The key is to:

Set up proper logging from day one
Use remote debugging tools like debugpy for complex issues
Master Docker commands for container inspection
Create debugging shortcuts to save time
Build systematic debugging habits with checklists

Remember that debugging is a skill that improves with practice. Start with simple techniques like logging and shell access, then graduate to more advanced methods like remote debugging as needed. Your future self will thank you for investing time in proper debugging infrastructure.

Happy debugging! 🐛🔍🐳

Squashing is so much fun, if you know how to do that

Maksym — Fri, 28 Nov 2025 12:25:09 +0000

During development I often get frustrated by how frequently I need to change the database schema and generate new migrations, which quickly clutters the project and slows things down; my staging environment adds another twist since it runs entirely in Docker without Python installed on the host, giving me more free space and isolation but also making it harder to manage migrations directly, so this guide is written to help developers like me — and you — keep migrations clean, squash them when needed, and stay sane while juggling schema changes in containerized setups.

🧩 Why squashing?

Squashing migrations reduces clutter. Instead of having many small migration files, you combine them into one. This makes your project cleaner and faster to migrate on fresh databases.

📖 Step‑by‑Step Guide

1. Check your current migrations

Run:

python manage.py showmigrations myapp

You’ll see something like:

[X] 0001_initial
[X] 0002_auto
[X] 0003_add_field
[X] 0004_auto
[X] 0005_auto

The [X] means they’ve already been applied.

2. Run squashmigrations

Tell Django to squash up to the latest migration:

python manage.py squashmigrations myapp 0005

This creates a new file, usually named:

myapp/migrations/0001_squashed_0005.py

3. Edit the `replaces` list

Open the new squashed migration file. You’ll see something like:

replaces = [
    ('myapp', '0001_initial'),
    ('myapp', '0002_auto'),
    ('myapp', '0003_add_field'),
    ('myapp', '0004_auto'),
    ('myapp', '0005_auto'),
]

Since you only want to squash 0004 and 0005, trim the list:

replaces = [
    ('myapp', '0004_auto'),
    ('myapp', '0005_auto'),
]

4. Keep old migrations temporarily

Do not delete 0004 and 0005 yet. Commit the squashed migration alongside them. Django will treat the squashed migration as equivalent to those two.

5. Test on a fresh database

Drop your local DB and recreate it, then run:

python manage.py migrate

Check that the squashed migration applies cleanly and the schema looks correct.

6. Clean up

Once you’re confident:

Delete 0004_auto.py and 0005_auto.py from your repo.
Keep 0001, 0002, 0003 (since they’re already applied in production).
Keep the new squashed migration file.

7. Push to Git

Commit the changes and push. Teammates who already applied 0004 and 0005 won’t break — Django knows the squashed migration replaces them.

🚀 Best Practices

Always test squashed migrations on a fresh database.
Never squash migrations that are already deployed unless you’re only squashing the latest ones.
Communicate with your team before removing old migration files.

Hopefully this article will help you in the development or extend your knowledge in field of database migrations in Django. As always if you have any thoughts, criticism or just want to clarify something, write a comment!

Encapsulate the application in a portable, reproducible environment

Maksym — Wed, 19 Nov 2025 11:29:59 +0000

In Part 3 of our Smart Commuter project, we turn our attention to deployment by creating a Dockerfile that encapsulates the application in a portable, reproducible environment, and explore different options for hosting it effectively.

Deployment Options

Option 1: Run Locally

# Keep running in terminal
python smart_commute.py

# Or run in background
nohup python smart_commute.py > commute.log 2>&1 &

Option 2: Systemd Service (Linux)

Create /etc/systemd/system/smart-commute.service:

[Unit]
Description=Smart Commute Assistant
After=network.target

[Service]
Type=simple
User=your_username
WorkingDirectory=/path/to/smart-commute
Environment="PATH=/path/to/smart-commute/venv/bin"
EnvironmentFile=/path/to/smart-commute/.env
ExecStart=/path/to/smart-commute/venv/bin/python smart_commute.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Enable and start:

sudo systemctl enable smart-commute
sudo systemctl start smart-commute
sudo systemctl status smart-commute

Option 3: Docker

Create Dockerfile:

FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY *.py .

# Run
CMD ["python", "-u", "smart_commute.py"]

Create docker-compose.yml:

version: '3.8'

services:
  commute-assistant:
    build: .
    container_name: smart-commute
    restart: unless-stopped
    env_file:
      - .env
    environment:
      - TZ=America/Los_Angeles
    volumes:
      - ./logs:/app/logs

Run:

docker-compose up -d

Option 4: Raspberry Pi

Perfect for 24/7 operation:

# SSH into Pi
ssh pi@raspberrypi.local

# Install dependencies
sudo apt update
sudo apt install python3-pip python3-venv

# Clone/copy your project
cd ~
mkdir smart-commute
cd smart-commute

# Setup virtual environment
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Configure .env
nano .env

# Test run
python smart_commute.py

# Setup systemd service (see Option 2)
# Enable auto-start on boot

Advanced Features

1. Multiple Profiles

Handle different routes for different days:

# In config.py
WEEKDAY_CONFIG = {
    'work_address': 'Office Address',
    'check_time': '17:00'
}

WEEKEND_CONFIG = {
    'work_address': 'Gym Address',
    'check_time': '10:00'
}

# In smart_commute.py
import datetime

def get_config():
    if datetime.datetime.now().weekday() < 5:
        return WEEKDAY_CONFIG
    return WEEKEND_CONFIG

2. Weather Integration

Add weather considerations:

import requests

def get_weather():
    """Get current weather from OpenWeather API"""
    api_key = os.getenv('OPENWEATHER_API_KEY')
    lat, lon = 37.7749, -122.4194  # Your location
    url = f"https://api.openweathermap.org/data/2.5/weather"
    params = {'lat': lat, 'lon': lon, 'appid': api_key}

    response = requests.get(url, params=params)
    data = response.json()
    return data['weather'][0]['main']

# In check_traffic_and_notify():
weather = get_weather()
if weather in ['Rain', 'Snow']:
    self.config.buffer_minutes += 5
    print(f"🌧️ Bad weather detected, adding extra buffer time")

3. Cost Tracking

Track toll roads and fuel costs:

def calculate_trip_cost(traffic_data):
    """Estimate trip cost"""
    distance_km = traffic_data['total_distance'] / 1000
    fuel_cost_per_km = 0.15  # Adjust for your vehicle
    fuel_cost = distance_km * fuel_cost_per_km

    # Add toll costs (would need additional API)
    toll_cost = 0  # Calculate from route

    total_cost = fuel_cost + toll_cost
    return f"${total_cost:.2f}"

4. Historical Analysis

Learn from patterns:

import json
from datetime import datetime

def log_commute(traffic_data):
    """Log commute data for analysis"""
    log_entry = {
        'timestamp': datetime.now().isoformat(),
        'day_of_week': datetime.now().strftime('%A'),
        'departure_time': datetime.now().strftime('%H:%M'),
        'duration': traffic_data['total_duration_traffic'],
        'traffic_ratio': traffic_data['traffic_ratio'],
        'route': traffic_data['summary']
    }

    with open('commute_history.json', 'a') as f:
        f.write(json.dumps(log_entry) + '\n')

def analyze_patterns():
    """Find optimal departure times"""
    # Load historical data
    # Calculate average durations by day/time
    # Suggest optimal times
    pass

5. Smart Waypoint Suggestions

Suggest convenient stops based on route:

def suggest_waypoints(origin, destination):
    """Suggest convenient stops along route"""
    # Use Google Places API to find:
    # - Gas stations
    # - Grocery stores
    # - Coffee shops
    # Along the route with minimal detour

    places_url = "https://maps.googleapis.com/maps/api/place/nearbysearch/json"
    # Implementation details...

Troubleshooting

Common Issues

1. Bot not receiving messages

# Test bot token
curl https://api.telegram.org/bot/getMe

# Check chat ID
curl https://api.telegram.org/bot/getUpdates

2. Google Maps API errors

# Verify API key
curl "https://maps.googleapis.com/maps/api/directions/json?origin=NYC&destination=Boston&key=YOUR_KEY"

# Check quota
# Visit: https://console.cloud.google.com/apis/dashboard

3. Notifications not sending

# Add debug logging
import logging
logging.basicConfig(level=logging.DEBUG)

# Test notification manually
asyncio.run(telegram_bot.send_notification(
    "Test",
    "This is a test message"
))

4. Wrong departure time calculation

# Add detailed logging
print(f"Current time: {datetime.now()}")
print(f"Travel duration: {traffic_data['total_duration_traffic']} seconds")
print(f"Buffer: {self.config.buffer_minutes} minutes")
print(f"Calculated departure: {departure_time}")

Performance Optimization

1. Reduce API calls

# Cache results for 5 minutes
from functools import lru_cache
from datetime import datetime

@lru_cache(maxsize=10)
def get_traffic_cached(origin, dest, time_bucket):
    # time_bucket rounded to 5 minutes
    return get_traffic_data(origin, dest)

2. Optimize check frequency

# Adaptive checking
if time_to_leave > 30:
    check_interval = 15  # minutes
elif time_to_leave > 10:
    check_interval = 5
else:
    check_interval = 2

Cost Analysis

Let's break down the actual costs:

Monthly API Usage

Assumptions:

Work 20 days per month
Check every 5 minutes for 2 hours (24 checks/day)
Total: 480 API calls/month

Google Maps API:

Free tier: $200 credit = ~40,000 requests
Your usage: 480 requests
Cost: $0/month ✅

Telegram:

Unlimited messages for bots
Cost: $0/month ✅

Hosting:

Raspberry Pi: $35 one-time, $0/month
Your computer: $0/month
Cloud VPS: $5/month (optional)

Total: $0-5/month 🎉

Security Best Practices

1. Protect Your API Keys

# Never commit .env file
echo ".env" >> .gitignore

# Set proper permissions
chmod 600 .env

# Use environment variables in production
export GOOGLE_MAPS_API_KEY="..."

2. Restrict API Keys

Google Cloud Console:

Go to API Key settings
Add API restrictions: Only Directions API
Add application restrictions: IP address or referrer

Telegram:

Only respond to your chat ID
Implement rate limiting
Validate all inputs

3. Secure Your Server

# If using cloud server
# Setup firewall
sudo ufw enable
sudo ufw allow ssh
sudo ufw allow https

# Keep system updated
sudo apt update && sudo apt upgrade

# Use SSH keys, not passwords
ssh-keygen -t ed25519

Real-World Usage Scenarios

Scenario 1: Standard Commute

User: Sarah, Software Engineer
Route: Office → Home (12 km)
Time: Leaves at 5 PM

Setup:

CHECK_TIME=16:45
DESIRED_ARRIVAL_TIME=17:30
BUFFER_MINUTES=5

Daily routine:

4:45 PM: System checks traffic
4:55 PM: Light traffic, continues monitoring
5:05 PM: "🟢 Time to head home! 25 min via Highway 101"
Sarah leaves, arrives home at 5:28 PM

Scenario 2: Gym + Groceries

User: Mike, Product Manager
Route: Office → Gym → Grocery Store → Home

Setup:

CHECK_TIME=17:30
DESIRED_ARRIVAL_TIME=19:00
BUFFER_MINUTES=10

Commands:

5:00 PM: "Stop at 24 Hour Fitness"
Bot: ✅ Added stop: 24 Hour Fitness

5:15 PM: "Add Trader Joe's"
Bot: ✅ Added stop: Trader Joe's

5:30 PM check: "⏱️ Travel time: 52 min (with 2 stops)"
5:50 PM: "🏠 Time to head home!"

Mike gets a workout, groceries, and arrives home by 7 PM!

Scenario 3: Heavy Traffic

User: Lisa, Consultant
Route: Client site → Home (20 km)

What happens:

4:30 PM check: 🔴 Heavy traffic (45 min vs normal 28 min)
Bot: "⚠️ Heavy Traffic! Consider leaving 15 min early"

4:45 PM check: Still heavy
Bot: "🚗 Time to leave! 43 min via alternate route"

Lisa leaves early, avoids worst traffic, arrives on time!

Extending the System

Add Voice Notifications

# Using Twilio
from twilio.rest import Client

def send_voice_call(message):
    client = Client(account_sid, auth_token)
    call = client.calls.create(
        twiml=f'{message}',
        to=your_phone,
        from_=twilio_number
    )

Calendar Integration

# Check Google Calendar for meetings
from googleapiclient.discovery import build

def get_next_meeting():
    service = build('calendar', 'v3', credentials=creds)
    now = datetime.utcnow().isoformat() + 'Z'

    events = service.events().list(
        calendarId='primary',
        timeMin=now,
        maxResults=1,
        singleEvents=True,
        orderBy='startTime'
    ).execute()

    return events.get('items', [])[0]

# Adjust arrival time based on first meeting
meeting = get_next_meeting()
if meeting:
    meeting_time = meeting['start']['dateTime']
    # Adjust config.desired_arrival_time

Machine Learning Predictions

# Train model on historical data
from sklearn.ensemble import RandomForestRegressor
import pandas as pd

def train_traffic_model():
    # Load historical commute data
    df = pd.read_json('commute_history.json', lines=True)

    # Features: day of week, time, weather
    # Target: actual duration

    model = RandomForestRegressor()
    model.fit(X_train, y_train)
    return model

def predict_traffic(day, time, weather):
    features = [day, time, weather]
    predicted_duration = model.predict([features])
    return predicted_duration

Conclusion

You now have a complete, production-ready smart commute assistant that:

✅ Monitors traffic automatically

✅ Calculates optimal departure times

✅ Sends Telegram notifications

✅ Supports multiple stops dynamically

✅ Adapts to heavy traffic

✅ Runs 24/7 reliably

✅ Costs $0/month to operate

What makes this system special:

Proactive, not reactive - It tells you when to leave, not just current conditions
Interactive - Manage stops via chat, no need to edit config files
Intelligent - Learns traffic patterns and adjusts timing
Reliable - Handles errors gracefully, runs continuously
Free - Both APIs have generous free tiers

Next steps:

Deploy the system and use it for a week
Track how much time it saves you
Customize notifications to your preferences
Add features that matter to you (weather, calendar, etc.)
Share with colleagues who hate traffic!

The code is modular and well-documented, making it easy to extend. Whether you want to add machine learning, integrate with smart home devices, or track carbon emissions, the architecture supports it.

Happy commuting! 🚗✨

Complete Project Structure

smart-commute/
├── .env                      # Your secrets (don't commit!)
├── .env.example              # Template
├── requirements.txt          # Dependencies
├── config.py                 # Configuration management
├── traffic_monitor.py        # Google Maps integration
├── telegram_bot.py           # Telegram bot handler
├── smart_commute.py          # Main application
├── Dockerfile                # Docker setup
├── docker-compose.yml        # Docker orchestration

Resources

About the Author

This system was built to solve a real problem - the daily stress of not knowing when to leave work. After months of use, it's saved countless hours and reduced commute stress significantly. I hope it does the same for you!

Feel free to reach out with questions, suggestions, or to share your customizations!

Traffic data and smart notifications

Maksym — Wed, 19 Nov 2025 11:16:14 +0000

As we advance the Smart Commuter implementation, we’ll integrate traffic data and smart notifications to refine the user experience. For previous step see first part.

3. Telegram Bot Handler

# telegram_bot.py
import os
from typing import Optional
from telegram import Update, Bot
from telegram.ext import (
    Application, 
    CommandHandler, 
    MessageHandler, 
    filters, 
    ContextTypes
)
import asyncio

class TelegramCommuteBot:
    """Telegram bot for commute notifications and commands"""

    def __init__(self, token: str, chat_id: str, config):
        self.token = token
        self.chat_id = chat_id
        self.config = config
        self.bot = Bot(token=token)
        self.application = None

    async def send_notification(self, title: str, message: str, parse_mode: str = 'Markdown'):
        """Send notification message"""
        try:
            full_message = f"*{title}*\n\n{message}"
            await self.bot.send_message(
                chat_id=self.chat_id,
                text=full_message,
                parse_mode=parse_mode
            )
            print(f"✅ Telegram notification sent: {title}")
            return True
        except Exception as e:
            print(f"❌ Telegram error: {e}")
            return False

    async def send_departure_alert(self, 
                                   travel_time: str,
                                   route_summary: str,
                                   traffic_status: str,
                                   waypoints: list):
        """Send main departure notification"""
        message = f"🏠 *Time to Head Home!*\n\n"
        message += f"⏱️ *Travel time:* {travel_time}\n"
        message += f"🚦 *Traffic:* {traffic_status}\n"
        message += f"🗺️ *Best route:* {route_summary}\n"

        if waypoints:
            message += f"\n📍 *Your stops:*\n"
            for i, stop in enumerate(waypoints, 1):
                message += f"   {i}. {stop['address']}\n"

        message += f"\n_Have a safe trip home!_ 🚗"

        await self.send_notification("Commute Alert", message)

    async def send_early_warning(self, 
                                travel_time: str,
                                minutes_early: int,
                                traffic_status: str):
        """Send early warning for heavy traffic"""
        message = f"⚠️ *Heavy Traffic Detected*\n\n"
        message += f"Consider leaving *{minutes_early} minutes early*\n\n"
        message += f"⏱️ *Current travel time:* {travel_time}\n"
        message += f"🚦 {traffic_status}\n\n"
        message += f"_I'll notify you again when it's time to leave._"

        await self.send_notification("Traffic Warning", message)

    def setup_commands(self):
        """Setup bot command handlers"""
        self.application = Application.builder().token(self.token).build()

        # Command handlers
        self.application.add_handler(CommandHandler("start", self.cmd_start))
        self.application.add_handler(CommandHandler("status", self.cmd_status))
        self.application.add_handler(CommandHandler("add", self.cmd_add_stop))
        self.application.add_handler(CommandHandler("remove", self.cmd_remove_stop))
        self.application.add_handler(CommandHandler("stops", self.cmd_list_stops))
        self.application.add_handler(CommandHandler("clear", self.cmd_clear_stops))
        self.application.add_handler(CommandHandler("check", self.cmd_check_now))

        # Message handler for natural language
        self.application.add_handler(
            MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_message)
        )

    async def cmd_start(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle /start command"""
        message = (
            "🏠 *Welcome to Your Commute Assistant!*\n\n"
            "I'll help you get home on time by monitoring traffic "
            "and notifying you when to leave.\n\n"
            "*Available Commands:*\n"
            "• `/status` - Current commute info\n"
            "• `/add ` - Add stop on your way\n"
            "• `/remove ` - Remove a stop\n"
            "• `/stops` - List all stops\n"
            "• `/clear` - Clear all stops\n"
            "• `/check` - Check traffic now\n\n"
            "*Natural Language:*\n"
            "You can also say:\n"
            "• 'Add gym'\n"
            "• 'Stop at grocery store'\n"
            "• 'Clear all stops'\n\n"
            f"I'll check traffic daily at *{self.config.check_time}* "
            f"and notify you when it's time to leave!"
        )
        await update.message.reply_text(message, parse_mode='Markdown')

    async def cmd_status(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle /status command"""
        message = f"📊 *Current Configuration*\n\n"
        message += f"🏢 *Work:* {self.config.work_address}\n"
        message += f"🏠 *Home:* {self.config.home_address}\n"
        message += f"⏰ *Check time:* {self.config.check_time}\n"
        message += f"🎯 *Target arrival:* {self.config.desired_arrival_time}\n"
        message += f"⏱️ *Buffer:* {self.config.buffer_minutes} min\n\n"

        if self.config.waypoints:
            message += f"📍 *Active stops:*\n"
            for i, stop in enumerate(self.config.waypoints, 1):
                message += f"   {i}. {stop}\n"
        else:
            message += f"📍 *No stops configured*\n"

        await update.message.reply_text(message, parse_mode='Markdown')

    async def cmd_add_stop(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle /add command"""
        if not context.args:
            await update.message.reply_text(
                "Please specify a location.\n"
                "Example: `/add Whole Foods Market`",
                parse_mode='Markdown'
            )
            return

        stop = ' '.join(context.args)
        if self.config.add_waypoint(stop):
            await update.message.reply_text(
                f"✅ Added stop: *{stop}*\n\n"
                f"You now have {len(self.config.waypoints)} stop(s).",
                parse_mode='Markdown'
            )
        else:
            await update.message.reply_text(
                f"⚠️ Stop *{stop}* already exists!",
                parse_mode='Markdown'
            )

    async def cmd_remove_stop(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle /remove command"""
        if not context.args:
            await update.message.reply_text(
                "Please specify which stop to remove.\n"
                "Use `/stops` to see your stops.",
                parse_mode='Markdown'
            )
            return

        stop = ' '.join(context.args)
        if self.config.remove_waypoint(stop):
            await update.message.reply_text(
                f"✅ Removed stop: *{stop}*",
                parse_mode='Markdown'
            )
        else:
            await update.message.reply_text(
                f"⚠️ Stop *{stop}* not found!",
                parse_mode='Markdown'
            )

    async def cmd_list_stops(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle /stops command"""
        if not self.config.waypoints:
            await update.message.reply_text("You have no stops configured.")
            return

        message = f"📍 *Your stops ({len(self.config.waypoints)}):*\n\n"
        for i, stop in enumerate(self.config.waypoints, 1):
            message += f"{i}. {stop}\n"

        await update.message.reply_text(message, parse_mode='Markdown')

    async def cmd_clear_stops(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle /clear command"""
        count = len(self.config.waypoints)
        self.config.clear_waypoints()
        await update.message.reply_text(
            f"✅ Cleared {count} stop(s).",
            parse_mode='Markdown'
        )

    async def cmd_check_now(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle /check command - trigger immediate traffic check"""
        await update.message.reply_text(
            "🔍 Checking traffic now...",
            parse_mode='Markdown'
        )
        # This will be called by the main app
        # Store the update context for callback
        context.user_data['check_requested'] = True

    async def handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        """Handle natural language messages"""
        text = update.message.text.lower()

        # Pattern matching for natural commands
        if any(word in text for word in ['add', 'stop at', 'stop by']):
            # Extract location (simple approach)
            for keyword in ['add', 'stop at', 'stop by']:
                if keyword in text:
                    location = text.split(keyword, 1)[1].strip()
                    if location:
                        self.config.add_waypoint(location)
                        await update.message.reply_text(
                            f"✅ Added: *{location}*",
                            parse_mode='Markdown'
                        )
                        return

        elif 'clear' in text and 'stop' in text:
            count = len(self.config.waypoints)
            self.config.clear_waypoints()
            await update.message.reply_text(
                f"✅ Cleared {count} stop(s)."
            )
            return

        elif 'status' in text or 'info' in text:
            await self.cmd_status(update, context)
            return

        # Default response
        await update.message.reply_text(
            "I'm not sure what you mean. Try:\n"
            "• `/status` - See your settings\n"
            "• `/add ` - Add a stop\n"
            "• `/help` - See all commands"
        )

    def run_bot(self):
        """Start the bot (blocking)"""
        self.setup_commands()
        print("🤖 Telegram bot started")
        self.application.run_polling()

Key features:

Interactive Telegram commands (/add, /remove, /status, etc.)
Natural language processing for casual commands
Real-time stop management
Beautiful formatted messages with emojis

4. Main Application

# smart_commute.py
import os
import schedule
import time
import asyncio
from datetime import datetime, timedelta
from config import CommuteConfig
from traffic_monitor import TrafficMonitor
from telegram_bot import TelegramCommuteBot

class SmartCommuteAssistant:
    """Main application orchestrating the commute assistant"""

    def __init__(self):
        # Load configuration
        self.config = CommuteConfig.from_env()

        # Initialize components
        self.traffic_monitor = TrafficMonitor(
            os.getenv('GOOGLE_MAPS_API_KEY')
        )
        self.telegram_bot = TelegramCommuteBot(
            token=os.getenv('TELEGRAM_BOT_TOKEN'),
            chat_id=os.getenv('TELEGRAM_CHAT_ID'),
            config=self.config
        )

        # State tracking
        self.last_notification_time = None
        self.notification_sent_today = False

    def check_traffic_and_notify(self):
        """Main logic: Check traffic and send notification if needed"""
        current_time = datetime.now()
        print(f"\n🕐 Checking traffic at {current_time.strftime('%H:%M:%S')}")

        # Get route with all waypoints
        route = self.config.get_full_route()
        origin = route[0]
        destination = route[-1]
        waypoints = route[1:-1] if len(route) > 2 else None

        print(f"📍 Route: {origin}")
        if waypoints:
            for wp in waypoints:
                print(f"   ↓ via {wp}")
        print(f"   → {destination}")

        # Get current traffic data
        traffic_data = self.traffic_monitor.get_route_with_traffic(
            origin=origin,
            destination=destination,
            waypoints=waypoints
        )

        if not traffic_data:
            print("❌ Could not retrieve traffic data")
            return

        # Calculate when to leave
        departure_time, travel_minutes = self.traffic_monitor.calculate_departure_time(
            traffic_data,
            self.config.desired_arrival_time,
            self.config.buffer_minutes
        )

        # Analyze traffic
        traffic_status = self.traffic_monitor.analyze_traffic(
            traffic_data,
            self.config.heavy_traffic_threshold
        )

        # Format travel time
        travel_time_str = self._format_duration(
            traffic_data['total_duration_traffic']
        )

        # Calculate time until departure
        time_until_departure = (departure_time - current_time).total_seconds() / 60

        # Print status
        print(f"⏱️  Travel time: {travel_time_str}")
        print(f"🚦 Traffic: {traffic_status}")
        print(f"🏁 Recommended departure: {departure_time.strftime('%H:%M')}")
        print(f"⏰ Minutes until departure: {int(time_until_departure)}")

        # Send notifications based on timing
        if 0 <= time_until_departure <= 5 and not self.notification_sent_today:
            # Time to leave!
            asyncio.run(self._send_departure_notification(
                travel_time_str,
                traffic_data,
                traffic_status
            ))
            self.notification_sent_today = True
            self.last_notification_time = current_time

        elif (traffic_data['traffic_ratio'] >= self.config.heavy_traffic_threshold 
              and 5 < time_until_departure <= 20
              and not self.notification_sent_today):
            # Heavy traffic - send early warning
            asyncio.run(self._send_early_warning(
                travel_time_str,
                int(time_until_departure),
                traffic_status
            ))
            # Don't set notification_sent_today yet, still need to send main alert

        elif time_until_departure > 30:
            print("⏳ Too early to leave, continuing to monitor...")

        elif time_until_departure < 0:
            print("⚠️  You should have already left!")
            if not self.notification_sent_today:
                asyncio.run(self._send_late_warning(travel_time_str))
                self.notification_sent_today = True

    async def _send_departure_notification(self, 
                                          travel_time: str,
                                          traffic_data: dict,
                                          traffic_status: str):
        """Send the main departure notification"""
        await self.telegram_bot.send_departure_alert(
            travel_time=travel_time,
            route_summary=traffic_data['summary'],
            traffic_status=traffic_status,
            waypoints=traffic_data.get('waypoints', [])
        )

    async def _send_early_warning(self, 
                                 travel_time: str,
                                 minutes_early: int,
                                 traffic_status: str):
        """Send early warning for heavy traffic"""
        await self.telegram_bot.send_early_warning(
            travel_time,
            minutes_early,
            traffic_status
        )

    async def _send_late_warning(self, travel_time: str):
        """Send warning if user is late"""
        message = f"⚠️ *You're Running Late!*\n\n"
        message += f"⏱️ *Travel time:* {travel_time}\n\n"
        message += f"_Leave now to minimize delay!_"
        await self.telegram_bot.send_notification("Late Alert", message)

    def _format_duration(self, seconds: int) -> str:
        """Format duration in seconds to readable string"""
        minutes = int(seconds / 60)
        if minutes < 60:
            return f"{minutes} min"
        else:
            hours = minutes // 60
            mins = minutes % 60
            return f"{hours}h {mins}min"

    def _check_if_in_monitoring_window(self):
        """Check if we're within the monitoring window"""
        now = datetime.now()

        # Reset daily flag at midnight
        if now.hour == 0 and now.minute < 5:
            self.notification_sent_today = False

        # Parse check time and arrival time
        check_hour, check_minute = map(int, self.config.check_time.split(':'))
        arrival_hour, arrival_minute = map(int, self.config.desired_arrival_time.split(':'))

        check_time = now.replace(hour=check_hour, minute=check_minute, second=0)
        arrival_time = now.replace(hour=arrival_hour, minute=arrival_minute, second=0)

        # Monitor from check_time until 30 minutes after arrival_time
        end_time = arrival_time + timedelta(minutes=30)

        if check_time <= now <= end_time:
            self.check_traffic_and_notify()

    def start(self):
        """Start the commute assistant"""
        print("\n" + "="*60)
        print("🚀 Smart Commute Assistant Started")
        print("="*60)
        print(f"\n📍 Work: {self.config.work_address}")
        print(f"📍 Home: {self.config.home_address}")
        print(f"⏰ Check time: {self.config.check_time}")
        print(f"🎯 Target arrival: {self.config.desired_arrival_time}")
        print(f"📊 Monitoring for traffic conditions...")

        # Schedule checks
        check_time = self.config.check_time

        # Main scheduled check
        schedule.every().day.at(check_time).do(self.check_traffic_and_notify)

        # Continuous monitoring during window (every 5 minutes)
        schedule.every(5).minutes.do(self._check_if_in_monitoring_window)

        # Run once immediately for testing
        print(f"\n🔍 Running initial check...")
        self.check_traffic_and_notify()

        # Start the scheduling loop
        print(f"\n✅ System is running. Press Ctrl+C to stop.")
        print("="*60 + "\n")

        try:
            while True:
                schedule.run_pending()
                time.sleep(30)  # Check every 30 seconds
        except KeyboardInterrupt:
            print("\n\n👋 Smart Commute Assistant stopped")

def main():
    """Entry point"""
    assistant = SmartCommuteAssistant()
    assistant.start()

if __name__ == "__main__":
    main()

Key features:

Intelligent scheduling with monitoring windows
Daily notification reset at midnight
Multiple notification types (departure, early warning, late alert)
Automatic waypoint handling
Continuous monitoring during commute window

Usage Examples

Basic Setup

Configure your .env file:

GOOGLE_MAPS_API_KEY=AIzaSyB...
TELEGRAM_BOT_TOKEN=123456789:ABC...
TELEGRAM_CHAT_ID=987654321

WORK_ADDRESS=1600 Amphitheatre Parkway, Mountain View, CA
HOME_ADDRESS=123 Main Street, Mountain View, CA

CHECK_TIME=17:00
DESIRED_ARRIVAL_TIME=18:00
BUFFER_MINUTES=10

Run the system:

python smart_commute.py

Interactive Commands

While the system is running, chat with your bot on Telegram:

Check current status:

You: /status

Bot: 📊 Current Configuration

🏢 Work: 1600 Amphitheatre Parkway...
🏠 Home: 123 Main Street...
⏰ Check time: 17:00
🎯 Target arrival: 18:00
⏱️ Buffer: 10 min

📍 No stops configured

Add a stop:

You: /add Whole Foods Market

Bot: ✅ Added stop: Whole Foods Market

You now have 1 stop(s).

Or use natural language:

You: Stop at the gym on my way home

Bot: ✅ Added: the gym on my way home

List your stops:

You: /stops

Bot: 📍 Your stops (2):

1. Whole Foods Market
2. the gym on my way home

Remove a stop:

You: /remove gym

Bot: ✅ Removed stop: the gym on my way home

Clear all stops:

You: /clear

Bot: ✅ Cleared 1 stop(s).

Notification Examples

Normal departure notification:

🏠 Time to Head Home!

⏱️ Travel time: 32 min
🚦 Traffic: 🟢 Light traffic
🗺️ Best route: I-280 S

📍 Your stops:
   1. Whole Foods Market

Have a safe trip home! 🚗

Heavy traffic warning:

⚠️ Heavy Traffic Detected

Consider leaving 15 minutes early

⏱️ Current travel time: 45 min
🚦 🔴 Heavy traffic

I'll notify you again when it's time to leave.

📂 Full source code and implementation details are available on Smart Commute

Initiate project and setup

Maksym — Wed, 19 Nov 2025 10:40:17 +0000

Introduction

We've all been there - sitting at the office, wondering "Should I leave now or wait a bit longer?" Traffic apps tell you the current conditions, but they don't tell you when to leave. What if you could have a personal assistant that monitors traffic for you and sends you a notification at exactly the right moment, telling you the best route home?

Even better - what if you need to pick up groceries or stop at the gym on your way home? Traditional route planners make you manually add stops every time. But with a smart system, you could simply send a message like "Add Whole Foods" and your assistant would recalculate the optimal departure time for your multi-stop journey.

In this article, I'll show you how to build exactly that - a smart commute assistant using Python, Google Maps API, and Telegram Bot. By the end, you'll have a system that:

Monitors traffic automatically at your specified time
Calculates when you should leave based on real-time conditions
Sends you Telegram notifications with the best route home
Supports dynamic waypoints - add stops on the fly via chat
Adapts to traffic - alerts you earlier when there's congestion
Runs 24/7 on a Raspberry Pi or cloud server

Why This Matters

The Problem: Most of us leave work at a fixed time, regardless of traffic. This means we either leave too early (wasting time at the office) or too late (sitting in traffic). And when we need to make stops, we're constantly checking our phone to see if we have time.

The Solution: A proactive system that:

Checks traffic conditions at your desired time
Calculates the optimal departure time
Notifies you when it's time to leave
Lets you add stops dynamically
Adjusts timing based on traffic patterns

Real-world impact:

Save 15-30 minutes daily by leaving at the optimal time
Reduce stress from traffic uncertainty
Never forget important stops on the way home
Better work-life balance with predictable commute times

Architecture Overview

Before diving into code, let's understand the system architecture:

┌─────────────────────────────────────────────────────────┐
│                  USER (You at work)                     │
│                                                         │
│  "Add gym on my way home"                               │
│            ↓                                            │
│     [Telegram App] ←→ [Telegram Bot API]                │
└────────────────────┬────────────────────────────────────┘
                     │
                     ↓
┌─────────────────────────────────────────────────────────┐
│            YOUR SERVER (Python Application)             │
│                                                         │
│  ┌───────────────────┐      ┌──────────────────┐        │
│  │  Schedule Manager │      │  Command Handler │        │
│  │  - Check at 5 PM  │      │  - Parse messages│        │
│  │  - Every 5 min    │      │  - Add waypoints │        │
│  └────────┬──────────┘      └────────┬─────────┘        │
│           │                          │                  │
│           ↓                          ↓                  │
│  ┌──────────────────────────────────────────┐           │
│  │        Traffic Analyzer                  │           │
│  │  - Query Google Maps API                 │           │
│  │  - Calculate optimal route               │           │
│  │  - Determine departure time              │           │
│  └────────────────┬─────────────────────────┘           │
│                   │                                     │
│                   ↓                                     │
│  ┌────────────────────────────────┐                     │
│  │   Notification Engine          │                     │
│  │   - Send Telegram message      │                     │
│  │   - Include route info         │                     │
│  │   - Show waypoints             │                     │
│  └────────────────────────────────┘                     │
└─────────────────────────────────────────────────────────┘
                     ↓
┌─────────────────────────────────────────────────────────┐
│              EXTERNAL SERVICES                          │
│                                                         │
│  [Google Maps API]     [Telegram Bot API]               │
│   - Traffic data        - Message delivery              │
│   - Route calculation   - Command processing            │
└─────────────────────────────────────────────────────────┘

Prerequisites

What You'll Need

1. Python Environment

Python 3.8 or higher
Basic knowledge of Python and async programming

2. API Credentials (Both Free!)

Google Maps API Key: For traffic data and routing
- Free tier: $200/month credit (≈40,000 requests)
- Your usage: ~600 requests/month
- Cost: $0/month
Telegram Bot Token: For notifications
- Completely free, no limits for personal use
- Cost: $0/month

3. Hosting (Optional)

Your computer (free)
Raspberry Pi ($35 one-time)
Cloud VPS like DigitalOcean ($5/month)

Getting Your API Keys

Google Maps API (5 minutes)

Go to Google Cloud Console
Create a new project or select existing
Enable these APIs:
- Directions API
- Distance Matrix API (optional, for multi-stop optimization)
Create credentials → API Key
Important: Restrict your API key:
- Go to API Key settings
- Add API restrictions: Only allow Directions API
- Save your key securely

Telegram Bot (2 minutes)

Open Telegram and search for @BotFather
Send /newbot command
Follow prompts to name your bot (e.g., "My Commute Assistant")
Save the bot token (looks like: 123456789:ABCdefGHIjklMNOpqrsTUVwxyz)
Get your Chat ID:
- Send a message to your bot
- Visit: https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates
- Find your chat_id in the JSON response

Pro tip: Save both tokens immediately to a password manager!

Building the System

Project Setup

Let's start by setting up our project structure:

# Create project directory
mkdir smart-commute
cd smart-commute

# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install requests python-telegram-bot schedule python-dotenv

Create a .env file for your secrets:

# .env
GOOGLE_MAPS_API_KEY=your_google_maps_api_key_here
TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here
TELEGRAM_CHAT_ID=your_telegram_chat_id_here

# Your locations
WORK_ADDRESS=456 Work Avenue, Your City, ST 12345
HOME_ADDRESS=123 Home Street, Your City, ST 12345

# Schedule settings
CHECK_TIME=17:00
DESIRED_ARRIVAL_TIME=18:00
BUFFER_MINUTES=10

Core Implementation

Now let's build the system. I'll break it down into logical components:

1. Configuration Manager

# config.py
import os
from dataclasses import dataclass, field
from typing import List, Optional
from dotenv import load_dotenv

load_dotenv()

@dataclass
class CommuteConfig:
    """Configuration for commute monitoring"""
    work_address: str
    home_address: str
    check_time: str  # HH:MM format
    desired_arrival_time: str  # HH:MM format
    buffer_minutes: int = 10
    heavy_traffic_threshold: float = 1.3
    waypoints: List[str] = field(default_factory=list)

    @classmethod
    def from_env(cls):
        """Load configuration from environment variables"""
        return cls(
            work_address=os.getenv('WORK_ADDRESS'),
            home_address=os.getenv('HOME_ADDRESS'),
            check_time=os.getenv('CHECK_TIME', '17:00'),
            desired_arrival_time=os.getenv('DESIRED_ARRIVAL_TIME', '18:00'),
            buffer_minutes=int(os.getenv('BUFFER_MINUTES', '10')),
            heavy_traffic_threshold=float(os.getenv('TRAFFIC_THRESHOLD', '1.3'))
        )

    def add_waypoint(self, address: str):
        """Add a stop on the way home"""
        if address not in self.waypoints:
            self.waypoints.append(address)
            return True
        return False

    def remove_waypoint(self, address: str):
        """Remove a stop"""
        if address in self.waypoints:
            self.waypoints.remove(address)
            return True
        return False

    def clear_waypoints(self):
        """Clear all waypoints"""
        self.waypoints.clear()

    def get_full_route(self) -> List[str]:
        """Get complete route: work → waypoints → home"""
        return [self.work_address] + self.waypoints + [self.home_address]

Key features:

Loads configuration from environment variables (secure!)
Dynamic waypoint management
Returns the full route including all stops

2. Traffic Monitor

# traffic_monitor.py
import requests
from typing import Dict, List, Optional, Tuple
from datetime import datetime, timedelta

class TrafficMonitor:
    """Handles traffic data retrieval and route analysis"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://maps.googleapis.com/maps/api/directions/json"

    def get_route_with_traffic(self, 
                               origin: str, 
                               destination: str,
                               waypoints: Optional[List[str]] = None) -> Optional[Dict]:
        """
        Get route information with traffic data

        Args:
            origin: Starting location
            destination: Final destination
            waypoints: Optional list of stops along the way

        Returns:
            Dictionary with route and traffic information
        """
        params = {
            'origin': origin,
            'destination': destination,
            'departure_time': 'now',
            'traffic_model': 'best_guess',
            'key': self.api_key
        }

        # Add waypoints if provided
        if waypoints:
            params['waypoints'] = 'optimize:false|' + '|'.join(waypoints)

        try:
            response = requests.get(self.base_url, params=params, timeout=10)
            response.raise_for_status()
            data = response.json()

            if data['status'] == 'OK':
                return self._parse_route_data(data, waypoints)
            else:
                print(f"❌ API Error: {data['status']} - {data.get('error_message', '')}")
                return None

        except requests.exceptions.RequestException as e:
            print(f"❌ Request failed: {e}")
            return None

    def _parse_route_data(self, data: Dict, waypoints: Optional[List[str]]) -> Dict:
        """Parse Google Maps API response"""
        route = data['routes'][0]
        legs = route['legs']

        # Calculate total duration and distance
        total_duration = sum(leg['duration']['value'] for leg in legs)
        total_duration_traffic = sum(
            leg.get('duration_in_traffic', leg['duration'])['value'] 
            for leg in legs
        )
        total_distance = sum(leg['distance']['value'] for leg in legs)

        # Parse waypoint information
        stops = []
        if waypoints:
            for i, leg in enumerate(legs[:-1]):  # All legs except the last
                stops.append({
                    'address': waypoints[i] if i < len(waypoints) else 'Unknown',
                    'duration_to_next': leg['duration']['value'],
                    'distance_to_next': leg['distance']['value']
                })

        return {
            'total_duration': total_duration,
            'total_duration_traffic': total_duration_traffic,
            'total_distance': total_distance,
            'distance_text': self._meters_to_text(total_distance),
            'summary': route['summary'],
            'waypoints': stops,
            'start_address': legs[0]['start_address'],
            'end_address': legs[-1]['end_address'],
            'traffic_ratio': total_duration_traffic / total_duration
        }

    def _meters_to_text(self, meters: int) -> str:
        """Convert meters to readable text"""
        if meters < 1000:
            return f"{meters} m"
        else:
            km = meters / 1000
            return f"{km:.1f} km"

    def calculate_departure_time(self, 
                                 traffic_data: Dict, 
                                 arrival_time: str,
                                 buffer_minutes: int) -> Tuple[datetime, int]:
        """
        Calculate when to leave based on traffic

        Returns:
            Tuple of (departure_time, travel_minutes)
        """
        # Parse desired arrival time
        arrival_hour, arrival_minute = map(int, arrival_time.split(':'))
        today = datetime.now().replace(
            hour=arrival_hour, 
            minute=arrival_minute, 
            second=0, 
            microsecond=0
        )

        # If arrival time has passed today, use tomorrow
        if today < datetime.now():
            today += timedelta(days=1)

        # Calculate travel time with buffer
        travel_seconds = traffic_data['total_duration_traffic']
        travel_minutes = (travel_seconds / 60) + buffer_minutes

        # Calculate departure time
        departure_time = today - timedelta(minutes=travel_minutes)

        return departure_time, int(travel_minutes)

    def analyze_traffic(self, traffic_data: Dict, threshold: float) -> str:
        """
        Analyze traffic conditions

        Returns:
            Traffic status emoji and text
        """
        ratio = traffic_data['traffic_ratio']

        if ratio >= threshold:
            return "🔴 Heavy traffic"
        elif ratio >= 1.1:
            return "🟡 Moderate traffic"
        else:
            return "🟢 Light traffic"

Key features:

Multi-stop route calculation
Real-time traffic analysis
Automatic departure time calculation
Traffic condition classification

📂 Full source code and implementation details are available on Smart Commute

🚀 Managing Media Files with MinIO and Podman

Maksym — Fri, 14 Nov 2025 12:29:28 +0000

Introduction

In one of my recent projects, I ran into a challenge: managing large volumes of media files efficiently. My team doesn’t rely on cloud platforms like AWS S3 or other managed bucket storage solutions — instead, we use dedicated services. That meant we needed a solution that could handle most use cases out of the box, without locking us into a specific vendor.

That’s when I discovered MinIO. It’s a high-performance, self-hosted object storage system that replicates the functionality of AWS S3. With MinIO, you get the familiar S3 API, but you can run it anywhere — on your own servers, in containers, or even on edge devices.

Here, I’ll walk you through how to deploy MinIO using Podman (though you can easily switch to Docker — most commands are identical).

⚙️ Step 1: Run MinIO with Port Mapping

When starting the container, you need to expose MinIO’s internal ports to your server’s public network.

By default, MinIO uses:

9000 → S3 API
9001 → WebUI (console)

Here’s the Podman command:

podman run -d \
  --name minio \
  -p 0.0.0.0:9000:9000 \
  -p 0.0.0.0:9001:9001 \
  -e MINIO_ROOT_USER=admin \
  -e MINIO_ROOT_PASSWORD=strongpassword \
  quay.io/minio/minio server /data --console-address ":9001"

This maps the container’s ports to your host machine and ensures MinIO listens on all interfaces (0.0.0.0).

🔍 Step 2: Verify the Container

Check that MinIO is running and ports are mapped correctly:

podman ps

You should see entries for 9000->9000 and 9001->9001.

🔒 Step 3: Open Firewall Ports

On Ubuntu, make sure the ports are accessible:

sudo ufw allow 9000/tcp
sudo ufw allow 9001/tcp

🌐 Step 4: Access the WebUI

For local testing, I’m using a Multipass Ubuntu server exposed on my LAN at http://192.168.2.2/.

You can find your server’s IP by running:

multipass list

Then open the MinIO console in your browser:

http://<your-server-ip>:9001

✅ Why MinIO?

S3-compatible API → Works with existing AWS SDKs and tools.
Lightweight & fast → Perfect for local development or edge deployments.
Self-hosted control → No vendor lock-in, full control over your data.
Scalable → Can grow from a single node to distributed clusters.

I hope this would help someone to

🎯 Conclusion

Setting up MinIO with Podman (or Docker) gives you a powerful, S3‑compatible storage solution without relying on external cloud providers. With just a few commands, you can spin up a fully functional object storage service, expose it securely on your network, and manage files through a clean WebUI.

For teams working with dedicated infrastructure, MinIO bridges the gap by offering the flexibility of AWS S3 while keeping full control over your data. Once deployed, you can integrate it seamlessly into your applications, automate workflows with the MinIO client (mc), and scale as your project grows.

Whether you’re experimenting locally or preparing for production, MinIO provides a reliable foundation for modern media and data management.

DEV Community: Maksym

Your Terminal Deserves Better. Oh My Zsh Agrees.

What is Oh My Zsh?

Installation

Plugins worth enabling

git

z

zsh-autosuggestions

zsh-syntax-highlighting

Themes

Powerlevel10k

Zsh vs Fish

A starter ~/.zshrc

Where to go from here

Pause, Save, Resume: The Definitive Guide to Stashing

What is Git Stash?

Basic Usage

Stashing your changes

Stashing with a descriptive message

Including untracked files

Viewing Your Stashes

Applying Stashes

Apply the most recent stash (keep it in the stash list)

Apply and remove from the stash list

Apply a specific stash by index

Apply to a different branch

Inspecting a Stash

Deleting Stashes

Drop a specific stash

Clear all stashes

Creating a Branch from a Stash

Partial Stashing

Handling Conflicts

Quick Reference

Tips and Gotchas

Exploring Lua: The Invisible Powerhouse of Scripting

1. Why Developers Love Lua

2. The "Everything is a Table" Philosophy

3. Real-World Applications

Game Development

Embedded Systems

Neovim and Productivity

4. A Quick Code Example

Summary

Wazuh: Centralized Logging with Error Notifications

Introduction

Centralized Logging

Handling Unknown or Dynamic Files

Error Detection Rules

Notifications

Telegram Integration Example

Example Workflow

Benefits

Golden Rule: Composition Over Inheritance

Introduction

What Is Inheritance?

The Problems with Deep Hierarchies

The Fragile Base Class Problem

The Gorilla–Banana Problem

The Diamond Problem

Violation of Encapsulation

What Is Composition?

A Side-by-Side Comparison

The Inheritance Approach (and its problems)

The Composition Approach

Composition in the Real World

Strategy Pattern

Dependency Injection

When Is Inheritance Actually Appropriate?

The Liskov Substitution Principle

Summary

JavaScript vs Go: A Deep Dive into Syntax and Philosophy

Table of Contents

1. Variable Declaration and Type Systems

JavaScript: Dynamic and Flexible

Go: Explicit and Type-Safe

2. Functions and Their Flavors

JavaScript: First-Class and Flexible

Go: Typed and Structured

3. Error Handling: Exceptions vs Explicit Errors

A starter `~/.zshrc`