DEV Community: Rdpfor Carzo

Stop Writing How, Start Writing What: Declarative vs Imperative Code

Rdpfor Carzo — Wed, 10 Jun 2026 08:02:09 +0000

Every developer remembers their first programming steps. You probably learned to write loops, modify variables, and instruct the computer step-by-step on exactly how to achieve a result. This style of programming is known as imperative programming.

But as codebases grow, this 'do this, then do that' approach can lead to spaghetti code, mutation bugs, and hard-to-read logic. Enter declarative programming, a paradigm where you describe what you want to achieve, leaving the underlying implementation details to the language.

In this post, we will explore the differences between these two approaches using real-world examples in JavaScript and Python, and see why shifting toward a declarative style can make your code cleaner, more readable, and easier to maintain.

JavaScript: Filtering and Transforming Arrays

Let's start with a common task: taking an array of numbers, filtering out the odd ones, and doubling the remaining even numbers.

The Imperative Way (The 'How')

In an imperative approach, we manually manage the iteration, state, and array mutations.

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const doubledEvens = [];

for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 === 0) {
        const doubled = numbers[i] * 2;
        doubledEvens.push(doubled);
    }
}

console.log(doubledEvens); // [4, 8, 12, 16, 20]

Why is this less than ideal?

State Mutation: We are continuously updating the doubledEvens array and changing the loop counter i.
Boilerplate: We have to handle loop boundaries, indices, and increments manually.
Cognitive Load: To understand what this code does, a reader has to step through the loop logic line-by-line.

The Declarative Way (The 'What')

Now, let's achieve the exact same result using JavaScript's built-in declarative array methods: filter and map.

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const doubledEvens = numbers
    .filter(num => num % 2 === 0)
    .map(num => num * 2);

console.log(doubledEvens); // [4, 8, 12, 16, 20]

Look at how much cleaner this is. We are not telling JavaScript how to loop over the array. Instead, we are declaring: 'Filter this array for even numbers, then map over those numbers to double them.' The state mutation is hidden away, and the code reads almost like English.

Python: Processing Complex Data Structures

Let's switch over to Python. Suppose we have a list of user dictionaries representing users in our system. We want to extract the usernames of all users who are marked as active.

The Imperative Way

Here is how we might write this using an imperative loop:

users = [
    {'username': 'alice', 'active': True},
    {'username': 'bob', 'active': False},
    {'username': 'charlie', 'active': True},
    {'username': 'david', 'active': False}
]

active_usernames = []

for user in users:
    if user['active']:
        active_usernames.append(user['username'])

print(active_usernames) # ['alice', 'charlie']

While this Python code is readable because of Python's clean syntax, it still suffers from imperative pitfalls: we are creating an empty list and manually appending to it inside a conditional loop.

The Declarative Way (List Comprehensions)

Python offers a powerful declarative construct called list comprehensions. It allows us to define the construction of a list in a single, expressive line.

users = [
    {'username': 'alice', 'active': True},
    {'username': 'bob', 'active': False},
    {'username': 'charlie', 'active': True},
    {'username': 'david', 'active': False}
]

active_usernames = [user['username'] for user in users if user['active']]

print(active_usernames) # ['alice', 'charlie']

This declarative approach does not require us to create an empty temporary list or call .append() repeatedly. We simply declare the structure of the data we want to produce.

Why Declarative Programming Wins

Why should you care about this shift? It comes down to three major pillars of software engineering: readability, predictability, and maintainability.

1. Less Shared State, Fewer Bugs

Imperative code relies heavily on keeping track of current state variables (like indices, temp arrays, or boolean flags). Every time you mutate a variable, you introduce a point of failure where another thread or asynchronous operation could read an inconsistent value. Declarative programming treats data as immutable, creating new collections instead of modifying existing ones.

2. Improved Code Readability

When you use functions like map, filter, and reduce (or Python's list comprehensions), your code communicates intent directly. A developer reading your code does not have to parse a loop to find out what it does; they can see the operations instantly.

3. Separation of Concerns

Declarative programming abstracts away the execution mechanism. If your language runtime updates its array processing implementation to run in parallel behind the scenes, your declarative code gains those performance benefits automatically without you changing a single line of your codebase.

When to Remain Imperative

While declarative programming is highly beneficial, it is not a silver bullet. There are times when an imperative approach is necessary:

Performance Hotspots: Low-level optimizations sometimes require precise manual memory management or tight loop controls that declarative abstractions obscure.
Complex Control Flow: If your loop needs to break early under complex conditions or needs to access neighboring elements in highly specific ways, a classic for loop might actually be cleaner than forcing a declarative structure.

Conclusion

Adopting a declarative mindset will change the way you approach problem-solving in code. Next time you start writing a manual loop or modifying state variables, take a pause. Ask yourself: 'Can I write this by describing what I want, rather than how to get it?' Your future self and your teammates will thank you.

Happy Coding!

Demystifying Async: A Comparative Guide to Python and JavaScript

Rdpfor Carzo — Wed, 10 Jun 2026 02:21:01 +0000

In the early days of software development, programs executed sequentially. Line A ran, then Line B, and if Line B requested a resource from a remote database, the entire application ground to a halt waiting for a response. This is synchronous, blocking execution.

Today, modern web applications handle thousands of concurrent requests. Waiting idle for I/O operations is no longer acceptable. Enter asynchronous programming: a paradigm that allows a program to start a long-running task and move on to other work before that task finishes.

In this article, we will demystify asynchronous programming by comparing how it is implemented in two of the world's most popular programming languages: JavaScript and Python.

The Asynchronous Paradigm: A Real-World Analogy

Imagine you are a chef in a busy kitchen. You need to toast bread and boil water for pasta.

Synchronous Approach: You put the bread in the toaster, stand still and stare at it until it pops up (blocking). Only then do you pour water into the pot and turn on the stove, standing idle again until it boils.
Asynchronous Approach: You put the bread in the toaster, turn on the stove for the water, and while both are heating up, you chop vegetables. You react when the toaster dings or the water boils.

Asynchronous programming is not necessarily parallel programming (running multiple tasks at the exact same split-second on different CPU cores). Instead, it is about efficient concurrency—cooperatively yielding control back to the system when waiting on external operations (like database queries, API calls, or file reads).

Asynchronous JavaScript: The Event Loop and Promises

JavaScript was designed for the web browser, where user interactions and network requests happen constantly. Because JavaScript is single-threaded, blocking the main thread means freezing the UI. To prevent this, JavaScript relies heavily on an Event Loop.

Modern JavaScript handles asynchronous actions using Promises and the async/await syntax. Here is a real-world example simulating a user dashboard load that fetches profile data and application configurations concurrently:

// Helper to simulate network latency
const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function fetchUserData(userId) {
    console.log(`[JS] Fetching data for user: ${userId}...`);
    await delay(1500); // Simulate a 1.5 second network delay
    return { id: userId, username: "dev_explorer", role: "admin" };
}

async function fetchSystemSettings() {
    console.log("[JS] Fetching system settings...");
    await delay(1000); // Simulate a 1 second network delay
    return { theme: "dark", notifications: true };
}

async function loadDashboard() {
    try {
        console.time("DashboardLoad");

        // Execute both tasks concurrently
        const [user, settings] = await Promise.all([
            fetchUserData(42),
            fetchSystemSettings()
        ]);

        console.log("[JS] Dashboard Loaded Successfully:");
        console.log("User Info:", user);
        console.log("Settings:", settings);

        console.timeEnd("DashboardLoad");
    } catch (error) {
        console.error("[JS] Error loading dashboard:", error);
    }
}

loadDashboard();

How it works in JavaScript:

Promise.all takes an array of promises and runs them concurrently.
When await Promise.all(...) is evaluated, the execution of loadDashboard is paused, yielding control back to the event loop.
Because both tasks run concurrently, the overall execution time is determined by the slowest task (1.5 seconds) rather than the sum of both tasks (2.5 seconds).

Asynchronous Python: Asyncio and Cooperative Multitasking

Historically, Python relied on threading or multiprocessing to handle concurrent operations. However, threads are resource-heavy and subject to the Global Interpreter Lock (GIL). Python 3.4 introduced the asyncio library, bringing cooperative multitasking to the language via coroutines.

Let’s write the exact same concurrent dashboard simulation in Python:

import asyncio
import time

async def fetch_user_data(user_id):
    print(f"[Python] Fetching data for user: {user_id}...")
    await asyncio.sleep(1.5)  # Simulate a 1.5 second network delay
    return {"id": user_id, "username": "dev_explorer", "role": "admin"}

async def fetch_system_settings():
    print("[Python] Fetching system settings...")
    await asyncio.sleep(1.0)  # Simulate a 1 second network delay
    return {"theme": "dark", "notifications": True}

async def load_dashboard():
    start_time = time.perf_counter()
    try:
        # Execute both tasks concurrently using asyncio.gather
        user, settings = await asyncio.gather(
            fetch_user_data(42),
            fetch_system_settings()
        )

        print("[Python] Dashboard Loaded Successfully:")
        print("User Info:", user)
        print("Settings:", settings)

        elapsed = time.perf_counter() - start_time
        print(f"[Python] Dashboard completed in {elapsed:.2f} seconds.")
    except Exception as e:
        print(f"[Python] Error loading dashboard: {e}")

# Run the asyncio event loop
if __name__ == "__main__":
    asyncio.run(load_dashboard())

How it works in Python:

The async def keyword declares a coroutine. Calling an async function does not run it immediately; it returns a coroutine object.
The asyncio.run(load_dashboard()) call acts as the entry point, establishing and managing the underlying event loop.
asyncio.gather acts like JavaScript's Promise.all, registering both coroutines with the event loop and resuming execution when both are completed.

Key Differences and Architectural Gotchas

While the syntaxes of Python and JavaScript look remarkably similar (both use async and await), their underlying mechanics and architectural histories differ significantly:

Feature	JavaScript (Node.js / Browser)	Python (asyncio)
Runtime Design	Asynchronous by default. Built around the Event Loop from day one.	Synchronous by default. Async support is added via libraries (`asyncio`).
Event Loop Management	Managed automatically by the runtime engine (V8, SpiderMonkey).	Must be explicitly managed using `asyncio.run()` or event loop APIs.
Concurrency Primitive	Promises	Futures / Tasks
Ecosystem Compatibility	Almost all web libraries are non-blocking by design.	Many legacy libraries (like `requests`) are synchronous and will block the loop if not run in executors.

The "Red Color vs. Blue Color" Function Problem

In both environments, asynchronous code is viral. You cannot easily call an asynchronous function inside a synchronous one without running into architectural roadblocks. Once a function is async, its callers usually need to be async too.

In JavaScript, synchronous code calling a promise will return the Promise object immediately instead of waiting for the resolved value. In Python, calling an async def function from a standard sync function returns a coroutine object without executing its contents, forcing you to use an event loop runner to resolve it.

Conclusion

Understanding asynchronous programming is vital for building performant, low-latency applications.

Use JavaScript's async features to build fast, non-blocking I/O web servers (Node.js) and responsive, high-fidelity user interfaces.
Use Python's asyncio when developing scraping engines, interacting with asynchronous web frameworks like FastAPI, or orchestrating microservices where high concurrency is required.

By mastering how both ecosystems leverage async and await, you can confidently write clean, non-blocking code that optimizes resource efficiency across the stack.