Imperative and Declarative Programming: Differences

Imperative programming describes how to obtain a result through instructions, while declarative programming expresses what result we want and leaves the concrete steps to another layer. These two approaches constantly coexist in software.

When we start programming, almost all of us learn by writing sequences of instructions that modify the computer’s memory step by step. It’s natural, because it resembles the hardware operation based on the von Neumann architecture.

As software grows, managing every detail of the how can be error-prone. This doesn’t mean abandoning the imperative, but rather using declarative abstractions when they better express the intention.

Today we will dissect these two approaches with a greater technical depth, analyzing how they manage state, flow control, and side effects.

Imperative Programming: Flow Control

Imperative programming focuses on describing how to achieve a result. The programmer dictates step by step the state changes needed to compute the solution.

Technically, it is based on three pillars:

It is the paradigm of C (original), C++ (classic), Java (pre-8), and the foundation of C#.

Imperative Example in C#

Suppose we want to filter a list of numbers to get only the even ones and then square them.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
List<int> results = new List<int>(); // 1. Mutable external state

// 2. Explicit control flow (How to iterate)
for (int i = 0; i < numbers.Count; i++)
{
    // 3. Conditional control flow (How to filter)
    if (numbers[i] % 2 == 0)
    {
        int square = numbers[i] * numbers[i];

        // 4. Side effect: Mutation of the results list
        results.Add(square);
    }
}

// results: { 4, 16, 36 }

Declarative Programming: Logical Abstraction

Declarative programming focuses on describing what we want to obtain, delegating flow control to the underlying language or framework.

Instead of specifying the traversal, we compose expressions that describe the transformation. Some declarative styles, such as functional programming, also favor:

These properties do not define all declarative programming. SQL, for example, is declarative even though a query can end up modifying data.

Declarative Example in C# (LINQ)

Let’s see the same problem solved declaratively using LINQ (Language Integrated Query).

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// "Tell me WHAT you want":
// You want numbers WHERE they are even, SELECTING their square.
var results = numbers
    .Where(n => n % 2 == 0)   // Filter (Declarative)
    .Select(n => n * n)       // Transformation (Projection)
    .ToList();                // Materialization

Technical Comparison

Why is the world moving towards declarative programming?

// Imperative (WinForms / Classic Android)
void OnButtonClick() {
    button.Text = "Loading..."; // We mutate the UI state manually
    label.Visible = true;
}

// Declarative (Concept like React/Blazor)
// We only define how the UI looks based on the state.
// The framework handles repainting whatever changes.
<Button Text="@(IsLoading ? "Loading..." : "Submit")" />
<Label Visible="@IsLoading" />