Engineering Mindset for Early-Career Developers by Moyinoluwalogo O. Mayowa - HTML preview

CHAPTER 2 — THINKING LIKE A PROBLEM

SOLVER

INTRODUCTION

At the heart of software engineering lies one essential skill: problem solving. Programming languages, frameworks, and development tools are all important, but they are ultimately just instruments used to solve problems.

A developer who can memorize syntax but cannot think through problems will struggle when faced with complex challenges. On the other hand, a developer with strong problem-solving abilities can adapt to new technologies quickly because they understand how to approach problems logically.

Thinking like a problem solver means learning how to analyze situations, break problems into smaller pieces, test possible solutions, and improve outcomes over time.

Early-career developers often assume that good engineers simply know the right answer immediately. In reality, experienced engineers usually arrive at solutions through structured thinking and careful analysis.

This chapter explores how developers can develop a systematic approach to solving technical problems. These skills apply not only to software development but also to many areas of professional and personal life.

UNDERSTANDING THE NATURE OF PROBLEMS IN

SOFTWARE DEVELOPMENT

Software problems come in many forms. Some are straightforward, while others involve complex systems with many interacting components.

Common types of problems developers encounter include:

• Implementing new features

• Fixing bugs

• Improving performance

• Designing system architecture

• Integrating external services

• Handling unexpected user behavior

Each of these challenges requires thoughtful analysis and a structured approach.

For example, imagine a web application where users report that the website loads slowly. The issue might be related to:

• inefficient database queries

• slow external APIs

• poorly optimized front-end code

• network latency

• server performance problems

Without structured thinking, a developer might randomly try different fixes. However, an engineer approaches the situation methodically, identifying possible causes and testing them systematically.

This disciplined approach is the essence of effective problem solving.

THE PROBLEM-SOLVING PROCESS

Successful engineers typically follow a series of steps when solving problems. Although the exact process may vary, the core stages usually include:

1. Understanding the problem

2. Breaking the problem into smaller parts

3. Designing possible solutions

4. Implementing the solution

5. Evaluating and improving the result

Let us examine each step in more detail.

STEP 1: UNDERSTANDING THE PROBLEM

Before attempting to solve any problem, engineers first ensure they fully understand it.

This may sound obvious, but many mistakes occur because developers rush into coding without clearly defining the issue.

Understanding the problem requires asking questions such as:

• What exactly is happening?

• What should be happening instead?

• When does the issue occur?

• Who is affected by the problem?

• What constraints exist?

For example, suppose users report that a login system sometimes fails. A developer should investigate details such as:

• Does the problem occur for all users or only some?

• Does it happen consistently or only occasionally?

• Does it occur on certain devices or browsers?

Collecting this information helps narrow down possible causes.

Experienced engineers often spend significant time gathering information before writing any code.

STEP 2: BREAKING THE PROBLEM INTO SMALLER

PARTS

Large problems can feel overwhelming. One of the most effective techniques engineers use is decomposition, which means breaking a problem into smaller, manageable components.

Consider the task of building an online shopping cart system.

Instead of attempting to implement everything at once, the problem can be divided into several parts:

• product listing

• product selection

• cart storage

• price calculation

• checkout process

• payment integration

Each of these components can then be developed separately.

Breaking problems into smaller pieces offers several advantages:

• it simplifies complex tasks

• it allows teams to divide work

• it reduces errors

• it makes debugging easier

This technique is fundamental to software engineering and appears in many areas such as system design, object-oriented programming, and microservices architecture.

STEP 3: DESIGNING POSSIBLE SOLUTIONS

Once a problem is understood and broken down, engineers begin thinking about possible solutions.

Good developers rarely start coding immediately. Instead, they explore different approaches and evaluate their advantages and disadvantages.

This stage may involve:

• sketching diagrams

• writing pseudocode

• discussing ideas with teammates

• reviewing similar solutions

For example, suppose a developer needs to store user data.

Several options may exist:

• relational databases (such as PostgreSQL or MySQL)

• NoSQL databases (such as MongoDB)

• in-memory storage (such as Redis)

Each option has strengths and limitations.

Relational databases provide strong data consistency and structured queries.

NoSQL databases may offer flexibility and horizontal scalability.

Choosing the right solution depends on the system's requirements.

Engineering decisions are rarely about finding a perfect solution. Instead, they involve selecting the best solution given the constraints.

STEP 4: IMPLEMENTING THE SOLUTION

After designing a solution, the next step is implementation.

This stage involves writing code and building the system according to the planned design.

However, implementation should follow good engineering practices such as:

• writing readable code

• using clear variable and function names

• following consistent coding standards

• documenting complex logic

• writing tests when possible