Lets Talk Declarative vs Imperative

Have you ever struggled to decipher a complex block of code? Or maybe you’ve written some code that feels overly long-winded. Understanding the difference between imperative and declarative code can be your secret weapon in tackling these challenges. This approach shapes how we instruct computers to achieve our programming goals, impacting both code readability and maintainability.

Over the years I’ve been gradually spending more time writing declarative code, and I’ve not only found it to be a more enjoyable experience but also a more maintainable one. I’ve been able to create more reusable and composable chunks of code that can be easily understood by others.

What’s the Difference?

In programming, we have two main approaches to achieve a desired outcome: imperative and declarative. The key distinction lies in how we instruct the computer to get there.

• Imperative code focuses on the “how” - it dictates the step-by-step instructions the computer needs to follow. Think of it as a recipe that meticulously details each action required to bake a cake.

• Declarative code, on the other hand, emphasizes the “what” - it specifies the desired end state without outlining the exact steps. It’s like telling someone you want a cake, and they handle the baking process.

Functional Programming vs Object-Oriented Programming

These two programming paradigms fall on opposite sides of the spectrum:

• Functional programming is inherently more declarative. It emphasizes functions that transform data without altering external state. Code tends to be cleaner, more concise, and easier to reason about.

• Object-oriented programming (OOP) leans towards the imperative side. OOP relies on objects that encapsulate data and behavior, often involving state changes. Code can become more verbose due to the focus on how objects interact.

Examples

Imperative (Step-by-Step) Approach:

// Create an empty array
const numbers = [];

// Add elements to the array one by one (imperative instructions)
numbers.push(5);
numbers.push(10);
numbers.push(15);

// Filter even numbers (imperative loop)
const evenNumbers = [];
for (let i = 0; i < numbers.length; i++) {
  if (numbers[i] % 2 === 0) {
    evenNumbers.push(numbers[i]);
  }
}

This code explicitly creates an empty array, adds elements one by one, and then uses a loop to filter even numbers with additional instructions.

Declarative (Desired State) Approach:

// Define an array of numbers
const numbers = [5, 10, 15, 20];

// Filter even numbers using declarative function (filter)
const evenNumbers = numbers.filter(number => number % 2 === 0);

Here, we define the array directly. Then, we use the built-in filter function to achieve the desired outcome (finding even numbers) in a single line. The function itself handles the logic of iterating through the array.

Choosing the Right Paradigm

The best approach depends on the specific problem you’re trying to solve. Imperative code can be advantageous when you need fine-grained control over program flow. Declarative code shines when you want to express the desired outcome clearly and leave the implementation details to the computer.

In essence, both paradigms have their place. Understanding the strengths and weaknesses of each will make you a more versatile programmer.

Next time you’re working through a complex problem thins about how you can leverage the power of declarative programming to simplify your solution.