Programming is one of the most powerful capabilities in the digital world. It allows people to transform ideas into software, websites, mobile applications, business systems, automation tools, and entirely new digital products.

But programming does not begin with memorizing a programming language.

It begins with learning how to solve problems precisely.

A person can memorize many lines of code without understanding how to design a solution. Another person can understand a problem, break it into manageable steps, and then learn the code needed to implement those steps.

The second person has developed a foundation for becoming a capable programmer.

This book will take you from the fundamentals of programming toward the ability to design, build, test, debug, and improve useful software. You will learn concepts that transfer across programming languages instead of depending entirely on one tool or platform.

You do not need previous programming experience to begin.

What You Will Learn in This Chapter

By the end of this chapter, you should be able to:

Explain what programming is and how it differs from simply using software.
Identify a problem that could be solved with a computer program.
Break a problem into inputs, processing steps, and outputs.
Understand algorithms, pseudocode, and computational thinking.
Write a simple algorithm in ordinary language.
Recognize why precision, testing, and logical reasoning matter.
Prepare a first programming exercise without committing to a particular language.

PART I — UNDERSTANDING PROGRAMMING

1. What Is Programming?

Programming is the process of designing and expressing instructions that a computer can execute to perform a task.

Those instructions are written using a programming language or another system that a computer can interpret or execute.

For example, a program could instruct a computer to:

Calculate the total cost of a customer's order.
Check whether a password meets specified requirements.
Sort a list of products by price.
Send an email when a form is submitted.
Retrieve information from a database.
Display a website that responds to user interactions.
Process environmental measurements and identify unusual readings.
Help a business track orders, payments, customers, and deliveries.

The common element is that each program translates a desired outcome into instructions and rules.

Consider a simple business problem.

A customer purchases three items:

Item	Price
Notebook	₦2,000
Pen	₦500
Folder	₦1,500
Total	₦4,000

A person can calculate this total manually. A program can perform the same calculation automatically.

The difference becomes important when a business has hundreds or thousands of orders, needs to calculate discounts, track inventory, and generate reports.

Programming allows us to describe a process once and have a computer carry it out repeatedly.

However, computers do not automatically understand what we mean. The programmer must define the required operations, rules, and expected outcomes.

2. Programming Is Different from Using Software

You probably already use software every day.

You might use a browser to access a website, a spreadsheet to calculate figures, or a mobile application to communicate with customers.

Using software means operating a system that someone has already built.

Programming means creating or modifying instructions that determine how software behaves.

These activities can overlap. For example, a spreadsheet user might begin by entering figures into existing formulas, then progress to writing formulas, and eventually develop scripts that automate repetitive tasks.

Consider three levels of capability:

Level 1 — Use

You use an existing application to calculate a business total.

Level 2 — Configure

You create spreadsheet formulas or automation rules that perform the calculation automatically.

Level 3 — Program

You write code for a custom application that calculates totals, validates orders, updates records, and produces reports.

Each level can be useful. You do not have to become a software engineer to benefit from programming concepts.

But learning to program expands what you can build and control.

3. What Can Programming Help You Build?

Programming is not limited to websites or games.

It can support several kinds of digital systems.

Application area	Example of what programming can do
Web development	Build interactive websites and web applications
Business	Track customers, orders, expenses, and inventory
Data analysis	Process datasets and calculate useful statistics
Networking	Automate configuration checks and network monitoring
Artificial intelligence	Integrate AI models into applications and workflows
Finance	Calculate transactions, analyze data, and enforce business rules
Environmental work	Process monitoring data and summarize measurements
Education	Create quizzes, learning tools, and student-management systems
E-commerce	Manage product listings, carts, orders, and payments
Publishing	Automate content processing and organize digital assets

These examples connect programming to other areas of the W3 NOTES learning library. A programmer who understands networking, data, security, business operations, or design can combine that knowledge with code to solve more specialized problems.

The goal is not simply to produce code.

The goal is to create a working solution to a meaningful problem.

PART II — HOW PROGRAMMERS THINK

4. Start with a Problem, Not a Programming Language

Beginners often start by asking which language they should learn first.

That question matters, but it is not the first question a programmer needs to answer.

Start with the problem.

Imagine that a small printing business receives customer orders through WhatsApp. The owner records the orders manually and calculates each order's total price.

The owner wants a tool that calculates the total automatically.

Before writing code, ask:

What problem are we solving?
Who will use the solution?
What information will the program receive?
What calculations or decisions must it perform?
What result should it produce?
How will we know the result is correct?

These questions help define the actual task.

Without them, you could spend time writing code that works technically but fails to solve the user's real problem.

Define the problem clearly

A vague requirement might be:

Build a program for a printing business.

That leaves many unanswered questions. Does the business need quotations, order tracking, payments, delivery management, or all of them?

A more precise requirement is:

Build a program that accepts the quantity and price per copy of a printing order, calculates the subtotal, adds an optional delivery charge, and displays the total amount due.

Now the task is specific enough to design a solution.

This is the first habit of a programmer: turn vague requests into clearly defined problems.

5. Break Problems into Smaller Parts

A large problem often becomes manageable when divided into smaller tasks. This approach is called decomposition.

Suppose you want to build an online ordering system for a printing business.

The complete system may eventually require:

Customer registration and sign-in.
A catalogue of printing services.
Price calculations.
Order submission.
Payment processing.
Order-status updates.
Delivery coordination.
Notifications.
Administrative tools.

Trying to design everything at once creates unnecessary complexity.

Instead, divide the work into smaller components.

For the first version, you might build only a quotation calculator.

That calculator could later become part of the larger ordering system.

The progression would look like this:

PRINTING BUSINESS SYSTEM
          |
          +-- Customer accounts
          |
          +-- Service catalogue
          |
          +-- Quotation calculator
          |
          +-- Order management
          |
          +-- Payments
          |
          +-- Delivery tracking

Each component has a defined responsibility. The components can eventually be connected into a complete system.

This principle applies whether you are building a simple script, a website, a mobile application, or a large enterprise platform.

6. Understand Inputs, Processing, and Outputs

One of the most useful models for understanding a program is:

INPUT
  |
  v
PROCESSING
  |
  v
OUTPUT

A program receives information, performs operations, and produces a result.

Let's examine each stage.

Input

Input is the information a program receives.

Examples include:

A customer's name.
The quantity of items ordered.
A product price.
A date.
A password entered into a login form.
Data received from an API or database.

For our printing calculator, the inputs might be:

Quantity: 100
Price per copy: ₦150
Delivery charge: ₦2,000

Processing

Processing is what the program does with the input.

For the printing calculator:

Multiply quantity by price per copy.
Add the delivery charge.
Prepare the total for display.

Output

Output is the result produced by the program.

For the example above:

Printing subtotal: ₦15,000
Delivery charge:   ₦2,000
Total amount due:  ₦17,000

The output is only correct if the input has been interpreted properly and the processing rules are correct.

This model is useful because it gives you a starting point when designing almost any program.

For a weather application, the input might be a location, the processing might involve retrieving and interpreting weather data, and the output might be a forecast.

For an inventory system, the input might be a new stock transaction, the processing might update the recorded quantity, and the output might be the current stock level.

7. What Is an Algorithm?

An algorithm is a defined sequence of steps for solving a problem or performing a computation.

An algorithm does not have to be written in a programming language. You can describe one using ordinary language, a diagram, a mathematical expression, or pseudocode.

Consider the task of calculating a printing order's total.

The algorithm is:

Receive the quantity.
Receive the price per copy.
Receive the delivery charge.
Multiply the quantity by the price per copy.
Add the delivery charge to the subtotal.
Display the total amount due.

In simplified form:

subtotal = quantity × price per copy
total = subtotal + delivery charge
display total

The algorithm describes the solution without committing to JavaScript, Python, PHP, C, or another language.

That separation is important.

You can design a solution first and then express it in the programming language appropriate for the project.

Algorithms must be sufficiently precise

Consider these instructions:

Receive the order.
Calculate the cost.
Show the result.

They are too vague for a reliable implementation. What information does the order contain? Which costs should be included? What happens if the quantity is zero or the price is missing?

A stronger algorithm specifies the necessary inputs, operations, and rules.

The more complex the problem, the more important this precision becomes.

8. What Is Computational Thinking?

Computational thinking is a way of approaching problems using ideas that help us develop solutions that can be carried out systematically.

It includes several useful techniques.

Decomposition

Break a complex problem into smaller parts.

Example: divide an online store into product browsing, cart management, checkout, and order tracking.

Pattern recognition

Identify similarities between problems or repeated tasks.

Example: different product types may use the same basic subtotal calculation.

Abstraction

Focus on the information relevant to the problem while setting aside details that do not matter to the current task.

Example: when calculating a basic order total, you may initially need only quantity, unit price, and delivery charge—not the customer's entire purchase history.

Algorithm design

Define the steps needed to solve the problem.

Example: calculate subtotal, add delivery charge, and display the amount due.

These techniques work together:

REAL-WORLD PROBLEM
        |
        v
   DECOMPOSE IT
        |
        v
  FIND PATTERNS
        |
        v
  IDENTIFY WHAT MATTERS
        |
        v
 DESIGN THE ALGORITHM
        |
        v
 IMPLEMENT AND TEST

Computational thinking does not replace programming. It helps you decide what the program should do before you concentrate on how to write it.

PART III — DESCRIBING SOLUTIONS BEFORE WRITING CODE

9. What Is Pseudocode?

Pseudocode is an informal way of expressing an algorithm using readable, structured instructions.

It resembles programming logic but does not have to follow the exact syntax of a particular language.

For example:

START

READ quantity
READ price_per_copy
READ delivery_charge

subtotal = quantity * price_per_copy
total = subtotal + delivery_charge

DISPLAY total

END

This example communicates the intended sequence of operations.

The words READ, DISPLAY, START, and END are being used descriptively. They are not presented here as executable commands from a particular programming language.

Pseudocode helps you:

Explain your proposed solution.
Check whether the steps are complete.
Identify missing decisions.
Discuss the design with another person.
Translate the algorithm into actual code later.

It is especially useful when you are learning because it allows you to concentrate on logic before dealing with language-specific syntax.

10. Express the Same Algorithm in Different Ways

There is often more than one way to communicate an algorithm.

For our calculator, we can use three representations.

Ordinary language

Multiply the quantity by the price per copy. Add the delivery charge. Display the result.

Pseudocode

subtotal = quantity * price_per_copy
total = subtotal + delivery_charge
DISPLAY total

Mathematical expression

[ \text{Total}=(\text{Quantity}\times\text{Unit Price})+\text{Delivery} ]

Each representation describes the same core calculation.

The programming language comes later. Its syntax tells the computer how to interpret the instructions, but the underlying logic remains recognizable.

This is one reason it is valuable to learn programming concepts instead of memorizing code examples alone.

PART IV — MAKING THE ALGORITHM MORE RELIABLE

11. What Happens When Something Goes Wrong?

A program can contain logically incorrect instructions even when those instructions are expressed in valid code.

Imagine a printing calculator that adds the delivery charge twice.

The program might run without a syntax error, but it would produce the wrong total.

Suppose:

Quantity = 100
Price per copy = ₦150
Delivery charge = ₦2,000

The correct calculation is:

[ (100\times150)+2{,}000=17{,}000 ]

If the program adds delivery twice, it calculates:

[ (100\times150)+2{,}000+2{,}000=19{,}000 ]

The program has produced an incorrect result.

This illustrates an important distinction:

Syntax error: the code violates the language's grammatical rules.
Logic error: the instructions do not produce the intended result.
Runtime error: an error occurs while the program is executing.

These are broad introductory definitions. The precise behavior and terminology can vary by language and environment.

A programmer needs to learn how to identify and correct all three types of problems.

12. Test More Than One Example

Testing means checking whether a program behaves as expected.

For the printing calculator, do not test only one ordinary order.

Use several cases.

Quantity	Price per copy	Delivery	Expected total
100	₦150	₦2,000	₦17,000
10	₦200	₦0	₦2,000
1	₦500	₦1,000	₦1,500
0	₦150	₦2,000	₦2,000 before applying any additional business rules

The last row highlights an important issue. Mathematically, zero copies plus a delivery charge produces ₦2,000. But should a real printing business allow an order with zero copies and a delivery charge?

That is a business-rule question, not merely a mathematical one.

You might decide that the program should reject an order when quantity is zero or less. You would then add a validation rule before calculating the total.

This is how real programming develops: define the requirement, design the logic, implement it, test it, and refine it.

13. Identify the Rules and Edge Cases

An edge case is a situation near the boundary of a system's expected inputs or behavior.

For a quotation calculator, useful questions include:

What happens if the quantity is zero?
What happens if the quantity is negative?
What happens if the price is missing?
What happens if the user enters text instead of a number?
Are decimal quantities allowed?
Can delivery be free?
Can discounts apply?
Should the program reject an order if any required field is incomplete?

You do not need to solve every possible business requirement in the first exercise. However, you should learn to recognize that these questions exist.

A program designed only for the easiest example may fail when a real user enters unexpected information.

Reliable programming means thinking beyond the example that first made the program work.

PART V — YOUR FIRST PROGRAMMING DESIGN EXERCISE

14. Build the Logic for a Simple Expense Calculator

Before choosing a programming language, let's design a second solution.

Imagine that you want a program to calculate the total cost of several business expenses.

The user will enter three expenses:

Internet subscription.
Transport.
Printing supplies.

The program must calculate the sum and display it.

Step 1: Define the problem

The program should add three expense amounts and display the total.

Step 2: Identify the inputs

internet_cost
transport_cost
printing_cost

Step 3: Define the processing

total = internet_cost + transport_cost + printing_cost

Step 4: Define the output

Display total

Step 5: Write the complete pseudocode

START

READ internet_cost
READ transport_cost
READ printing_cost

total = internet_cost + transport_cost + printing_cost

DISPLAY total

END

Step 6: Work through an example

Suppose the user enters:

Expense	Amount
Internet subscription	₦15,000
Transport	₦8,000
Printing supplies	₦12,500

The expected output is:

[ 15{,}000+8{,}000+12{,}500=35{,}500 ]

The total expense is ₦35,500.

You have now designed a small program without writing language-specific code.

That is a meaningful first step. The next stage will be learning how to express these instructions in an actual programming language and run them.

PART VI — HOW THIS CONNECTS TO THE REST OF YOUR LEARNING

15. Programming Is a Foundation, Not an Isolated Skill

As you progress, you will encounter several concepts that build on this chapter.

Variables allow programs to store and refer to values.

Data types describe different kinds of information, such as text, integers, and Boolean values.

Operators allow programs to perform calculations and comparisons.

Conditions allow a program to choose between different actions.

Loops allow a program to repeat operations.

Functions package reusable behavior.

Data structures organize related information.

Algorithms describe the steps used to solve computational problems.

Testing and debugging help you determine whether a program behaves correctly and fix problems.

Software engineering extends beyond writing code to include requirements, architecture, maintainability, teamwork, testing, security, and delivery.

These ideas will eventually connect to web development, mobile applications, databases, APIs, automation, cloud systems, and AI-powered software.

A useful way to think about the learning journey is:

PROBLEM SOLVING
       |
       v
ALGORITHMS AND LOGIC
       |
       v
PROGRAMMING FUNDAMENTALS
       |
       v
DATA AND PROGRAM STRUCTURE
       |
       v
SOFTWARE DESIGN AND TESTING
       |
       v
APPLICATION DEVELOPMENT
       |
       v
DEPLOYMENT AND MAINTENANCE
       |
       v
USEFUL DIGITAL SYSTEMS

This is a learning map, not a rigid rule that every topic must be mastered completely before encountering the next. In practice, learners revisit earlier concepts as projects become more complex.

16. A Note About Programming Languages

You may have heard of JavaScript, Python, PHP, C, C++, Java, and other programming languages.

Each has its own strengths, ecosystem, and appropriate uses.

This book begins with general programming concepts because the fundamentals transfer across languages. Later chapters can introduce language-specific syntax and practical development environments.

For web development, JavaScript is particularly relevant because browsers can execute it and it works alongside HTML and CSS. Python is also a useful language for general programming, automation, and data-related work.

The right language depends on the project and learning path.

For now, concentrate on understanding the problem, designing the solution, and checking the result.

CHAPTER REVIEW

What You Should Remember

Programming means expressing instructions a computer can execute to perform a task.
Good programming begins with a clearly defined problem.
Decomposition makes complex problems easier to manage.
Inputs, processing, and outputs provide a useful model for understanding programs.
An algorithm describes the steps used to solve a problem.
Pseudocode helps you design and communicate algorithms before writing language-specific code.
A program can run and still produce the wrong result.
Testing different cases helps reveal errors and missing rules.
Programming fundamentals connect to web development, data, automation, AI, and software engineering.

Practice Assignment

Design a program for a small business that sells three products.

Your program should accept the quantity and unit price for each product, calculate each line total, and display the grand total.

Complete the following tasks:

[ ] Write down the inputs.
[ ] Describe the calculations.
[ ] Identify the expected outputs.
[ ] Write the algorithm in ordinary language.
[ ] Convert the algorithm into pseudocode.
[ ] Work through at least three test cases.
[ ] Identify two invalid inputs the program should reject.
[ ] Explain how you would verify that the results are correct.

You do not need to write executable code yet. The purpose is to practise turning a real-world requirement into a clear, testable solution.

Self-Assessment

Before moving on, try answering these questions without looking back at the chapter.

What is the difference between using software and programming?
What are the three main parts of the input-processing-output model?
How does an algorithm differ from pseudocode?
Why should a programmer test more than one example?
What is the difference between a syntax error and a logic error?
Why is it useful to define a problem before choosing a programming language?

If you can answer these questions and complete the assignment, you have begun developing the problem-solving habits needed for the next stage.

WHAT COMES NEXT?

In Chapter 2, we will explore how algorithms make decisions and repeat actions. You will learn how to represent a solution using sequence, selection, and iteration—the foundations behind program flow, conditional statements, and loops.

From there, the book will build toward variables, data types, operators, functions, data structures, debugging, and practical programming projects.

The objective is not to memorize isolated code snippets. It is to understand how programs work so you can eventually design and build your own.

Further Learning

Harvard CS50x — Introduction to Computer Science: a free, open course covering computational thinking, algorithms, programming, data structures, and software development. Its introductory material emphasizes problem-solving before and alongside coding.
Harvard CS50x syllabus: a structured view of how programming concepts develop into practical computer-science skills.

These resources can supplement your study. You do not need to complete another course before continuing with this book.

W3 NOTES BLOG — The Internet Money Library

Learn the principles. Practise the reasoning. Build the capability. Use technology to solve real problems.

Image: CodeCademy

Pages

Friday, October 9, 2026

PROGRAMMING | Learn to Think Like a Programmer — Turn Real-World Problems into Instructions a Computer Can Execute