1. Module Introduction

Welcome to the very first module of Programming Logic for Web Developers. This is the start of an exciting journey. By the end, you will understand how programmers think. You will learn the secret behind every program, every app, and every website.

Have you ever followed a recipe to cook rice? Have you ever given directions to a stranger? Have you ever solved a maths problem step by step? If yes, then you already use logic. Logic is the art of thinking in clear, ordered steps.

Programming logic is simply using logic to tell a computer what to do. Computers are fast, but they are not clever. They cannot guess. They need clear steps. When you learn to give clear steps, you can control a computer.

In this module, you will learn what programming logic is. You will learn how to break a big problem into small steps. You will learn about algorithms, flowcharts, and pseudocode. Do not worry if these words sound strange. Every word will be explained in very simple language.

This module is written for beginners. You do not need to know any coding. You do not need a computer. You just need a curious mind. So grab a notebook, sit comfortably, and let us begin.

    YOUR LEARNING JOURNEY IN MODULE 1
    =================================

    [ Start ]
        |
        V
    What is Programming Logic?
        |
        V
    Thinking in Steps
        |
        V
    Algorithms
        |
        V
    Flowcharts
        |
        V
    Pseudocode
        |
        V
    Breaking Problems into Small Steps
        |
        V
    [ You can now think like a programmer! ]
    

Summary of the Introduction

This module introduces programming logic. You will learn how to think in clear steps. You will learn about algorithms, flowcharts, and pseudocode. Everything is explained in simple language with plenty of examples.

2. Learning Objectives

By the end of this module, you will be able to:

1. Explain what programming logic means in your own words.
2. Describe why computers need clear, ordered steps.
3. Explain what an algorithm is and give examples.
4. Draw a simple flowchart using basic symbols.
5. Write simple pseudocode for a daily task.
6. Break a big problem into small, easy steps.
7. Spot the correct order of steps in a task.
8. Identify mistakes when steps are out of order.
9. Give examples of algorithms from real life, school, home, and Nigeria.
10. Feel confident and curious to continue to Module 2.

Summary of Learning Objectives

You will learn what programming logic is, how to think in steps, how to write algorithms, how to draw flowcharts, and how to write pseudocode.

3. Warm-up Story — Tunde and the Robot Helper

Tunde is a 12-year-old boy who lives in Ibadan. For his birthday, his uncle sent him a small robot. The robot was called RB-1. It could walk, talk, and do simple tasks.

Tunde was very excited. "RB-1, please bring me a cup of water," he said.

The robot stood still. It did not move.

"RB-1, bring me water!" Tunde said again, louder this time.

The robot blinked its lights. "I do not understand. Please give clear steps."

Tunde's mother laughed. "Tunde, the robot cannot guess. You must tell it exactly what to do, step by step."

So Tunde thought carefully. Then he said:

1. Walk to the kitchen.
2. Find the cupboard.
3. Open the cupboard.
4. Take a clean cup.
5. Walk to the tap.
6. Turn on the tap.
7. Fill the cup with water.
8. Turn off the tap.
9. Walk back to me.
10. Hand me the cup.

The robot followed each step. It walked to the kitchen. It opened the cupboard. It took a cup. It filled it with water. It walked back. It handed Tunde the cup.

"You did it!" Tunde shouted.

"Thank you," said RB-1. "Next time, remember: clear steps make everything possible."

Tunde learned a big lesson that day. Computers and robots are not clever on their own. They need clear, ordered steps. That is what programming logic is all about.

    TUNDE AND THE ROBOT
    ===================

    [ Tunde says: "Bring water" ]
              |
              V
    [ Robot does not understand ]
              |
              V
    [ Tunde gives clear steps ]
              |
              V
    [ Robot follows each step ]
              |
              V
    [ Tunde gets his water! ]
    

Summary of the Warm-up Story

Tunde learned that robots and computers need clear, ordered steps. Without clear steps, they cannot do anything. This story introduces the whole module.

4. Main Lessons

In this section, you will go through 12 short lessons. Each lesson teaches one big idea. Each lesson ends with a mini summary. Read slowly. Think about the examples. Ask questions. That is how you learn.

    PROGRAMMING LOGIC
    =================

    [ Clear step 1 ]
          |
          V
    [ Clear step 2 ]
          |
          V
    [ Clear step 3 ]
          |
          V
    [ Task complete! ]
        

    CLEAR vs UNCLEAR STEPS
    ======================

    Unclear:  "Bring me a cup"
              |
              V
    Computer: ???? (confused)

    Clear:    "Walk to the kitchen.
               Open the cupboard.
               Take a clean cup."
              |
              V
    Computer: Does it perfectly!
        

    THINKING IN STEPS
    =================

    Big task: "Make tea"

    Steps:
      1. Boil water
      2. Put tea bag in cup
      3. Pour hot water
      4. Add sugar and milk
      5. Stir
      6. Serve
        

    WRONG ORDER vs RIGHT ORDER
    ==========================

    Wrong order:
      [ Put on shoes ]
              |
              V
      [ Put on socks ]
              |
              V
      Looks strange!

    Right order:
      [ Put on socks ]
              |
              V
      [ Put on shoes ]
              |
              V
      Looks perfect!
        

    ALGORITHM EXAMPLE
    =================

    Task: Brush your teeth

    Algorithm:
      1. Pick up toothbrush
      2. Put toothpaste on it
      3. Add water
      4. Brush for 2 minutes
      5. Rinse mouth
      6. Clean toothbrush
      7. Put toothbrush away
        

    ALGORITHMS EVERYWHERE
    =====================

    [ Making tea ]
    [ Getting ready for school ]
    [ Buying airtime ]
    [ Cooking jollof rice ]
    [ Charging a phone ]
    [ Sending a text message ]

    All of these have clear steps = algorithms!
        

    FLOWCHART SYMBOLS
    =================

    ( Start )         <- Oval

         |
         V
    [ Step 1 ]        <- Rectangle

         |
         V
    < Decision? >     <- Diamond
      /       \
    Yes        No
     |          |
     V          V
    [ Step 2 ] [ Step 3 ]

         |
         V
    ( End )           <- Oval
        

    FLOWCHART: MAKING TEA
    =====================

    ( Start )
        |
        V
    [ Boil water ]
        |
        V
    [ Put tea bag in cup ]
        |
        V
    [ Pour hot water ]
        |
        V
    [ Add sugar and milk ]
        |
        V
    [ Stir ]
        |
        V
    [ Serve ]
        |
        V
    ( End )
        

    START
      Boil water
      Put tea bag in cup
      Pour water into cup
      Add sugar
      Add milk
      Stir
      Serve tea
    END
        

    PSEUDOCODE EXAMPLE
    ==================

    START
      Wake up
      Brush teeth
      Take a bath
      Dress up
      Eat breakfast
      Pack bag
      If it is raining:
        Take umbrella
      Leave for school
    END
        

    BREAKING A BIG PROBLEM
    ======================

    Big problem: "Plan a birthday party"

    Break it down:
      -> Choose a date
      -> Choose a place
      -> Make a guest list
      -> Buy food and drinks
      -> Plan games
      -> Send invitations
      -> Set up
      -> Celebrate! 🎉
        

    FINDING MISTAKES
    ================

    Steps for making tea:
      1. Boil water
      2. Put tea bag in cup
      3. Pour hot water
      4. Add sugar and milk
      5. Drink
      6. Stir  <-- MISTAKE! This should come before drinking.

    Fix: Move "Stir" to step 5.
        

    THINKING LIKE A PROGRAMMER
    ==========================

    [ Understand the problem ]
              |
              V
    [ Break into small steps ]
              |
              V
    [ Put in order ]
              |
              V
    [ Check for mistakes ]
              |
              V
    [ Test the steps ]
              |
              V
    [ Improve ]
              |
              V
    [ Solve the problem! ]
        

Summary of Main Lessons

You have now learned the core ideas of Module 1: what programming logic is, why computers need clear steps, how to think in steps, why order matters, what algorithms are, how to draw flowcharts, how to write pseudocode, how to break big problems into small steps, how to find mistakes, and how to think like a programmer.

5. Key Vocabulary

Summary of Key Vocabulary

These words will help you understand programming logic. Use them often so they become easy.

6. Important Concepts

Concept 1 — Computers Need Clear Steps

Computers cannot guess. They need clear, ordered steps.

Concept 2 — Order Matters

Steps must happen in the right order. Wrong order causes wrong results.

Concept 3 — Algorithms Are Everywhere

Any task with clear steps is an algorithm. You use them every day.

Concept 4 — Plan Before You Build

Flowcharts and pseudocode help you plan before writing real code.

Concept 5 — Break Big Problems into Small Steps

Big problems are easy to solve when broken into small steps.

Summary of Important Concepts

These five concepts are the heart of Module 1. Read them again before moving on.

7. Step-by-step Explanations

Step-by-step: How to Write an Algorithm

1. Understand the task. What do you want to do?
2. List the steps. Write every action.
3. Put them in order. Make sure the order is correct.
4. Check for mistakes. Are any steps missing?
5. Simplify. Remove unnecessary steps.
6. Test. Follow the steps yourself.
7. Improve. Fix any problems.

    WRITING AN ALGORITHM
    ====================

    [ Understand task ]
          |
          V
    [ List steps ]
          |
          V
    [ Put in order ]
          |
          V
    [ Check for mistakes ]
          |
          V
    [ Simplify ]
          |
          V
    [ Test ]
          |
          V
    [ Improve ]
    

Step-by-step: How to Draw a Flowchart

1. Start with an oval. Write "Start".
2. Add a rectangle for the first step.
3. Draw an arrow to the next step.
4. Use a diamond if there is a decision.
5. Label arrows "Yes" and "No".
6. Continue with rectangles for more steps.
7. End with an oval. Write "End".

    DRAWING A FLOWCHART
    ===================

    ( Start )
        |
        V
    [ Step 1 ]
        |
        V
    < Decision? >
      /       \
    Yes        No
     |          |
     V          V
    [ Step 2 ] [ Step 3 ]
        |
        V
    ( End )
    

Summary of Step-by-step Explanations

Writing an algorithm and drawing a flowchart both follow clear steps. Following steps makes it easy.

8. Real-life Examples

Example 1 — Using an ATM

Steps: insert card, enter PIN, choose amount, collect cash, collect card.

Example 2 — Ordering Food Online

Steps: open app, choose restaurant, choose food, add to cart, pay, wait for delivery.

Example 3 — Booking a Flight

Steps: choose destination, choose date, choose airline, enter passenger details, pay, receive ticket.

Example 4 — Registering for School

Steps: fill form, submit documents, pay fees, receive admission letter.

Example 5 — Sending a Package

Steps: pack item, write address, pay postage, send, receive confirmation.

Summary of Real-life Examples

Algorithms are in ATMs, online shopping, flight booking, school registration, and package delivery.

9. Nigerian Examples

Example 1 — Buying Airtime

Steps: dial code, enter amount, enter PIN, receive confirmation.

Example 2 — Sending Money

Steps: open bank app, enter account number, enter amount, confirm, receive receipt.

Example 3 — Cooking Jollof Rice

Steps: blend pepper and tomatoes, fry, add stock, add rice, cook, serve.

Example 4 — Buying Fuel

Steps: drive to station, queue, pay, fill tank, pay again if needed, drive off.

Example 5 — Sending a Parcel

Steps: pack item, write address, go to park, pay driver, hand over parcel, call receiver.

Summary of Nigerian Examples

Nigeria has many examples of algorithms: buying airtime, sending money, cooking, buying fuel, and sending parcels.

10. Fun Examples Children Can Relate To

Example 1 — Playing a Video Game

Steps: start game, choose character, choose level, play, win or lose, restart or exit.

Example 2 — Making a Sandwich

Steps: take bread, add butter, add filling, close, cut, eat.

Example 3 — Flying a Kite

Steps: find open space, hold string, run, release kite, let it fly, pull gently.

Example 4 — Making a Paper Plane

Steps: take paper, fold in half, fold corners, fold again, fold wings, throw.

Example 5 — Building a Sandcastle

Steps: find sand, add water, fill bucket, turn over, pat, decorate.

Summary of Fun Examples

Algorithms are in video games, sandwich making, kite flying, paper planes, and sandcastles.

11. Everyday Examples

Summary of Everyday Examples

Even simple daily activities are algorithms. Now you can see them everywhere.

12. Parent Tips

1. Ask your child to explain steps. When they do a task, ask them to describe each step.
2. Point out algorithms in daily life. Cooking, dressing, and cleaning are all algorithms.
3. Draw flowcharts together. Use paper and pencil. Draw simple steps.
4. Practice pseudocode. Ask your child to write steps in plain English.
5. Play step games. Ask your child to give you steps to follow. Then follow them literally.
6. Praise clear thinking. When your child breaks a task into steps, praise them.
7. Encourage curiosity. When they ask how something works, help them break it down.
8. Be patient. Logical thinking takes practice. Encourage, do not pressure.

Summary of Parent Tips

Parents can help children develop logical thinking through daily activities and simple games.

13. Interesting Facts

1. The word "algorithm" comes from the name of a Persian mathematician, Al-Khwarizmi.
2. The first computer programs were written as step-by-step instructions on paper.
3. Flowcharts were invented in the 1920s, long before computers were common.
4. Pseudocode is used by professional programmers every day.
5. Algorithms can be very short or very long. Some have millions of steps.
6. The same task can have many different algorithms. Some are faster than others.
7. Many Nigerian tech companies start their projects by planning with flowcharts.
8. Even simple games like tic-tac-toe use algorithms.

Summary of Interesting Facts

Algorithms and flowcharts are old, powerful, and used everywhere.

14. Did You Know?

• Did you know that you use algorithms every day without knowing it?
• Did you know that the same algorithm can be written in many different programming languages?
• Did you know that programmers often plan on paper before typing any code?
• Did you know that flowcharts help teams understand a plan quickly?
• Did you know that pseudocode is not real code, but it looks like code?
• Did you know that many successful businesses start with a simple algorithm?

Summary of Did You Know?

Algorithms, flowcharts, and pseudocode are used by people all over the world every day.

15. Remember This

• Programming logic is thinking in clear, ordered steps.
• Computers cannot guess. They need clear steps.
• Order matters. Wrong order causes wrong results.
• An algorithm is a set of clear, ordered steps.
• Algorithms are everywhere in daily life.
• A flowchart is a picture of an algorithm.
• Pseudocode is fake code written in plain English.
• Break big problems into small steps.
• Find mistakes in steps before they cause problems.
• Thinking like a programmer helps in school, home, and life.

Summary of Remember This

These ten points are the heart of Module 1. Read them again before moving on.

16. Common Mistakes

1. Thinking computers can guess. They cannot. They need clear steps.
2. Leaving out steps. Missing steps cause confusion.
3. Putting steps in the wrong order. Wrong order causes wrong results.
4. Writing unclear instructions. The computer will not understand.
5. Trying to solve big problems at once. Break them into small steps.
6. Skipping planning. Planning saves time and mistakes.
7. Ignoring flowcharts and pseudocode. They help you think clearly.
8. Giving up too soon. Logical thinking takes practice.

Summary of Common Mistakes

Avoiding these mistakes will make you a better logical thinker than many adults.

17. Best Practices

1. Always understand the task before starting.
2. Break tasks into small steps.
3. Put steps in the correct order.
4. Write steps clearly and simply.
5. Draw flowcharts for tasks with decisions.
6. Write pseudocode before real code.
7. Check for mistakes.
8. Test your steps.
9. Improve your plan after testing.
10. Practice logical thinking every day.

Summary of Best Practices

These ten practices will help you become a strong logical thinker.

18. ASCII Illustrations, Diagrams, Flowcharts, and Timelines

Diagram 1 — Programming Logic

    PROGRAMMING LOGIC
    =================

    [ Clear step 1 ]
          |
          V
    [ Clear step 2 ]
          |
          V
    [ Clear step 3 ]
          |
          V
    [ Task complete! ]
    

Diagram 2 — Clear vs Unclear Steps

    CLEAR vs UNCLEAR STEPS
    ======================

    Unclear:  "Bring me a cup"
              |
              V
    Computer: ???? (confused)

    Clear:    "Walk to the kitchen.
               Open the cupboard.
               Take a clean cup."
              |
              V
    Computer: Does it perfectly!
    

Diagram 3 — Thinking in Steps

    THINKING IN STEPS
    =================

    Big task: "Make tea"

    Steps:
      1. Boil water
      2. Put tea bag in cup
      3. Pour hot water
      4. Add sugar and milk
      5. Stir
      6. Serve
    

Diagram 4 — Flowchart Symbols

    FLOWCHART SYMBOLS
    =================

    ( Start )         <- Oval

         |
         V
    [ Step 1 ]        <- Rectangle

         |
         V
    < Decision? >     <- Diamond
      /       \
    Yes        No
     |          |
     V          V
    [ Step 2 ] [ Step 3 ]

         |
         V
    ( End )           <- Oval
    

Diagram 5 — Breaking a Big Problem

    BREAKING A BIG PROBLEM
    ======================

    Big problem: "Plan a birthday party"

    Break it down:
      -> Choose a date
      -> Choose a place
      -> Make a guest list
      -> Buy food and drinks
      -> Plan games
      -> Send invitations
      -> Set up
      -> Celebrate! 🎉
    

Diagram 6 — Thinking Like a Programmer

    THINKING LIKE A PROGRAMMER
    ==========================

    [ Understand the problem ]
              |
              V
    [ Break into small steps ]
              |
              V
    [ Put in order ]
              |
              V
    [ Check for mistakes ]
              |
              V
    [ Test the steps ]
              |
              V
    [ Improve ]
              |
              V
    [ Solve the problem! ]
    

Summary of Illustrations

These diagrams help you see programming logic clearly. Draw them yourself to remember them better.

19. Comparison Tables

Table 1 — Algorithm vs Flowchart vs Pseudocode

Table 2 — Clear vs Unclear Steps

Table 3 — Real-life Tasks and Their Type

Summary of Comparison Tables

Comparing ideas side by side helps you remember the differences clearly.

20. Summary After Every Lesson (Consolidated)

21. End-of-Module Summary

Congratulations! You have completed Module 1. Let us review what you have learned.

You began by learning that programming logic is the skill of thinking in clear, ordered steps that a computer can follow.

You learned that computers cannot guess. They need clear steps. If the steps are unclear, the program fails.

You discovered how to think in steps. Big tasks become easy when broken into small actions.

You learned that order matters. Steps must happen in the right sequence.

You explored algorithms — sets of clear, ordered steps to solve a problem. You saw that algorithms are everywhere in daily life.

You discovered flowcharts — pictures that show the steps of an algorithm using shapes and arrows.

You learned about pseudocode — fake code written in plain English to plan steps before writing real code.

You practiced breaking big problems into small steps. This makes hard tasks easy.

You learned how to find mistakes in steps and fix them.

Finally, you learned how to think like a programmer. This skill helps you in school, home, and any job.

    MODULE 1 SUMMARY MAP
    ====================

    [ Programming Logic ]
              |
              V
    [ Thinking in Steps ] --> [ Order Matters ]
              |
              V
    [ Algorithms ] --> [ Flowcharts ] --> [ Pseudocode ]
              |
              V
    [ Breaking Problems ] --> [ Finding Mistakes ]
              |
              V
    [ Thinking Like a Programmer! ]
    

Well done! You now have a strong foundation. In Module 2, you will learn how programs make decisions and repeat tasks.

22. Frequently Asked Questions (10 Questions)

Question 1: What is programming logic in the simplest words?

Programming logic is thinking in clear, ordered steps that a computer can follow.

Question 2: Do I need to know coding to learn programming logic?

No. You can learn programming logic with just pen and paper.

Question 3: Why do computers need clear steps?

Because computers cannot guess. They only follow the instructions you give them.

Question 4: What is an algorithm?

An algorithm is a set of clear, ordered steps to solve a problem or complete a task.

Question 5: What is a flowchart?

A flowchart is a picture that shows the steps of an algorithm using shapes and arrows.

Question 6: What is pseudocode?

Pseudocode is fake code that uses plain English to describe steps.

Question 7: What is the difference between an algorithm and pseudocode?

An algorithm can be written in any form. Pseudocode is one way of writing an algorithm using simple, code-like words.

Question 8: Why does order matter in steps?

Because steps must happen in the right sequence. Wrong order causes wrong results.

Question 9: Can I use programming logic in daily life?

Yes! You already use it for cooking, dressing, doing homework, and many other tasks.

Question 10: What will I learn in Module 2?

You will learn how programs make decisions (if / else) and how they repeat tasks (loops).

23. Matching Exercises

Exercise 1 — Match the Word to the Meaning

Answers: 1-B, 2-A, 3-D, 4-C, 5-E

Exercise 2 — Match the Task to Its Type

Answers: 1-B, 2-A, 3-D, 4-C

Summary of Matching Exercises

Matching helps you connect words to meanings quickly.

24. Scenario-based Exercises

Scenario 1 — The Confused Robot

A girl tells her robot, "Bring me a book." The robot does not move.

Questions:

1. Why did the robot not move?
2. What should the girl do instead?
3. Write three clear steps she could give.

Scenario 2 — The Wrong Recipe

A boy wants to make tea. His steps are: pour water into cup, boil water, add tea bag, drink. The tea is cold and tasteless.

Questions:

1. What mistake did he make?
2. What is the correct order?
3. Why does order matter?

Scenario 3 — The Missing Step

A student writes steps for buying airtime: dial code, enter amount, receive confirmation. But the airtime is not added.

Questions:

1. What step is missing?
2. Why is this step important?
3. How can the student fix the algorithm?

Summary of Scenario-based Exercises

These scenarios help you apply what you have learned to real situations.

25. Group Activity

Activity: Write an Algorithm for a Daily Task

Group size: 3–5 students

Time: 30 minutes

Materials: Paper, pencil

Instructions:

1. Choose a daily task (e.g., making a sandwich, going to school).
2. Write the steps as an algorithm.
3. Draw a simple flowchart.
4. Check the order and fix any mistakes.
5. Present your algorithm to the class.

Goal: To practise writing algorithms and flowcharts as a team.

26. Individual Activity

Activity: My Morning Algorithm

Time: 20 minutes

Materials: Notebook, pencil

Instructions:

1. Write the steps you follow every morning.
2. Number each step in the correct order.
3. Draw a simple flowchart of your morning routine.
4. Check for any step you might have missed.

Goal: To connect algorithms to your own daily life.

27. Mini Project

Project: Design a Flowchart for a Simple Game

Time: 1–2 hours

Materials: Paper, pencil, ruler

Instructions:

1. Choose a simple game (e.g., guessing a number).
2. Write an algorithm for the game.
3. Draw a flowchart using shapes and arrows.
4. Include at least one decision (Yes/No).
5. Test your flowchart by following the steps.
6. Present your project to the class.

Goal: To practise designing algorithms and flowcharts.

28. Practical Assignment

Assignment: Interview Someone About Their Daily Routine

Time: 1 week

Materials: Notebook, pencil

Instructions:

1. Ask a family member or friend about a task they do often.
2. Write down the steps as an algorithm.
3. Draw a simple flowchart for the task.
4. Check if any steps are missing or out of order.
5. Write a one-page report on what you learned.

Goal: To see how algorithms appear in real life.

29. Key Takeaways

1. Programming logic is thinking in clear, ordered steps.
2. Computers cannot guess. They need clear steps.
3. Order matters. Wrong order causes wrong results.
4. An algorithm is a set of clear, ordered steps.
5. Algorithms are everywhere in daily life.
6. A flowchart is a picture of an algorithm.
7. Pseudocode is fake code written in plain English.
8. Break big problems into small steps.
9. Find mistakes in steps before they cause problems.
10. Thinking like a programmer helps in school, home, and life.

30. Classroom Discussion Questions

1. Why do you think computers need clear steps?
2. Can you give an example of an algorithm you use every day?
3. Why does order matter in steps?
4. What is the difference between an algorithm and pseudocode?
5. Why do you think flowcharts are useful?
6. What big problem would you like to break into small steps?
7. What happens if you skip a step in an algorithm?
8. Why is it important to find mistakes early?
9. How can programming logic help you in school?
10. What did you enjoy most in this module?

31. Preparation for the Next Module

You have finished Module 1. Well done! Here is how to prepare for Module 2, which is all about Making Decisions and Repeating Tasks.

1. Review your key words. Make sure you can explain algorithm, flowchart, pseudocode, and order in your own words.
2. Practise writing algorithms. Choose a daily task and write the steps.
3. Draw flowcharts. Practice using ovals, rectangles, diamonds, and arrows.
4. Look for decisions. Notice tasks where you must choose between options (like "if it rains, take an umbrella").
5. Look for repetition. Notice tasks where you repeat steps (like brushing each tooth).
6. Bring your curiosity. Module 2 will teach you about conditions, true and false, and loops.

    TRANSITION TO MODULE 2
    ======================

    [ Module 1: Thinking in Steps ]
              |
              V
    [ Module 2: Making Decisions and Repeating Tasks ]
              |
              V
    [ You will learn: if / else, true and false,
      comparisons, and loops ]
    

See you in Module 2. Keep thinking like a programmer!

1. Module Introduction

Welcome to Module 2. In Module 1, you learned how to think in steps. You learned what an algorithm is. You learned how to draw flowcharts and write pseudocode. Those are the foundations of programming logic.

Now we go one step further. Programs do not just follow steps in a straight line. They also make choices. They also repeat actions. Imagine a game that asks, "Do you want to play again?" If you say yes, it repeats. If you say no, it stops. That is a decision and a repetition.

In this module, you will learn how programs make decisions. You will learn about if, else, and else if. You will learn about true and false. You will also learn how programs repeat tasks using loops.

Do not worry if these words sound new. Every word will be explained in simple language. You will see examples from real life, from school, from home, and from Nigeria. You will also draw flowcharts and write pseudocode for decisions and loops.

This module is written for beginners. You do not need a computer. You just need your brain and a notebook. Let us begin.

    YOUR LEARNING JOURNEY IN MODULE 2
    =================================

    [ Start ]
        |
        V
    What is a Decision?
        |
        V
    True and False
        |
        V
    If Statements
        |
        V
    Else Statements
        |
        V
    What is a Loop?
        |
        V
    Repeat Loops
        |
        V
    While and For Loops
        |
        V
    [ You can now write programs that decide and repeat! ]
    

Summary of the Introduction

This module teaches you how programs make decisions and repeat tasks. You will learn about if, else, true and false, and loops. Everything is explained in simple language with examples.

2. Learning Objectives

By the end of this module, you will be able to:

1. Explain what a decision is in a program.
2. Describe what true and false mean.
3. Use simple comparisons like equal, greater than, and less than.
4. Write simple if statements in pseudocode.
5. Add else and else if to handle more options.
6. Draw a flowchart with a decision diamond.
7. Explain what a loop is and why loops are useful.
8. Write simple repeat loops in pseudocode.
9. Understand while loops and for loops.
10. Spot decisions and repetitions in daily life.

Summary of Learning Objectives

You will learn how to write decisions (if, else) and repetitions (loops). You will also learn true and false, comparisons, and how to draw flowcharts with decisions.

3. Warm-up Story — Chidi and the Smart Gate

Chidi is a 12-year-old boy who lives in Abuja. One day, his school installed a new gate. It was a smart gate. It opened by itself.

Chidi was curious. He watched the gate carefully.

When a teacher walked close, the gate opened. When a student walked close, the gate opened. But when a stranger walked close, the gate stayed closed.

"How does it know?" Chidi asked the security guard.

"It uses a sensor," the guard said. "If the person has a school ID card, the gate opens. Else, the gate stays closed."

Chidi thought about it. "So it makes a decision?"

"Yes," the guard said. "It checks: Is there an ID card? If yes, open. If no, stay closed."

Chidi was amazed. He noticed something else. The gate did not open just once. It opened for every person who had an ID card. It repeated the decision again and again.

"It also repeats!" Chidi said.

"Exactly," the guard said. "It makes a decision, then repeats. That is how most programs work."

From that day, Chidi understood. Programs make decisions and repeat tasks. That is what this module is all about.

    CHIDI AND THE SMART GATE
    ========================

    [ Person walks close ]
              |
              V
    [ Gate checks: Does person have ID? ]
       /                          \
     Yes                          No
      |                            |
      V                            V
    [ Open gate ]              [ Stay closed ]

    Then the gate repeats this for the next person.
    

Summary of the Warm-up Story

Chidi learned that the smart gate makes a decision (open or close) and repeats it for every person. This story introduces decisions and loops.

4. Main Lessons

In this section, you will go through 12 short lessons. Each lesson teaches one big idea. Each lesson ends with a mini summary. Read slowly. Think about the examples. Ask questions. That is how you learn.

    A SIMPLE DECISION
    =================

    [ Is it raining? ]
       /           \
     Yes            No
      |              |
      V              V
    [ Take        [ Do not
      umbrella ]    take umbrella ]
        

    TRUE AND FALSE
    ==============

    True:   [ YES ]  [ ON ]   [ Correct ]
    False:  [ NO ]   [ OFF ]  [ Wrong ]

    Every decision checks something: true or false?
        

    COMPARISONS
    ===========

    5 == 5   ->  True   (equal)
    5 != 3   ->  True   (not equal)
    10 > 5   ->  True   (greater)
    3 < 7    ->  True   (less)
    5 >= 5   ->  True   (greater or equal)
    3 <= 3   ->  True   (less or equal)
        

    IF it is raining THEN
      take an umbrella
    END IF
        

    IF STATEMENT
    ============

    [ Is the condition true? ]
       /                  \
     Yes                   No
      |                     |
      V                     V
    [ Do the action ]    [ Skip the action ]

    Example: IF it is raining, THEN take umbrella.
        

    IF it is raining THEN
      take an umbrella
    ELSE
      wear a hat
    END IF
        

    IF-ELSE STATEMENT
    =================

    [ Is the condition true? ]
       /                  \
     Yes                   No
      |                     |
      V                     V
    [ Do action A ]      [ Do action B ]

    Example: IF it is raining, THEN take umbrella.
             ELSE, wear a hat.
        

    IF score >= 70 THEN
      grade = A
    ELSE IF score >= 60 THEN
      grade = B
    ELSE IF score >= 50 THEN
      grade = C
    ELSE
      grade = F
    END IF
        

    ELSE IF CHAIN
    =============

    [ Score >= 70? ]
       /          \
     Yes           No
      |             |
      V             V
    [ Grade A ]  [ Score >= 60? ]
                    /         \
                  Yes          No
                   |            |
                   V            V
                [ Grade B ] [ Score >= 50? ]
                              /         \
                            Yes          No
                             |            |
                             V            V
                          [ Grade C ] [ Grade F ]
        

    LOOP CONCEPT
    ============

    [ Start ]
        |
        V
    [ Do the task ]
        |
        V
    [ More to do? ]
       /        \
     Yes         No
      |           |
      +--> repeat |
                  V
                [ End ]
        

    REPEAT 5 TIMES
      clap your hands
    END REPEAT
        

    REPEAT LOOP
    ===========

    [ Set count = 1 ]
          |
          V
    [ Do the task ]
          |
          V
    [ count = count + 1 ]
          |
          V
    [ Is count > 5? ]
       /          \
     No            Yes
      |              |
      +--> repeat    V
                   [ End ]

    Example: Clap 5 times.
        

    WHILE there is water in the bucket
      scoop water
    END WHILE
        

    WHILE LOOP
    ==========

    [ Check condition ]
          |
          V
    [ Is it true? ]
       /        \
     Yes         No
      |           |
      V           V
    [ Do task ]  [ End ]
      |
      +--> check condition again

    Example: WHILE water remains, scoop water.
        

    FOR number FROM 1 TO 10
      print number
    END FOR
        

    FOR LOOP
    ========

    FOR count FROM 1 TO 5
      print "Hello"
    NEXT count

    This prints "Hello" 5 times.

    Count:   1    2    3    4    5
           Hello Hello Hello Hello Hello
        

    DECISION vs LOOP
    ================

    Decision:                  Loop:
    [ Choose A or B ]          [ Repeat this task ]
        |                          |
        V                          V
    One action                 Many actions

    Sometimes you need both!
        

    FOR each student in the class
      IF student score >= 50 THEN
        mark student as passed
      ELSE
        mark student as failed
      END IF
    END FOR
        

    DECISION INSIDE A LOOP
    ======================

    FOR each item
        |
        V
    [ Check condition ]
       /          \
     Yes           No
      |             |
      V             V
    [ Action A ] [ Action B ]
      |             |
      +------+------+
             |
             V
    [ Next item ]
        

Summary of Main Lessons

You have now learned the core ideas of Module 2: what decisions are, true and false, comparisons, if statements, else and else if, what loops are, repeat loops, while loops, for loops, when to use decisions and loops, and how to combine them.

5. Key Vocabulary

Summary of Key Vocabulary

These words will help you understand decisions and loops. Use them often so they become easy.

6. Important Concepts

Concept 1 — Decisions Make Programs Smart

Decisions let programs react to different situations. Without them, programs would always do the same thing.

Concept 2 — True and False Are the Foundation

Every decision checks something that is either true or false.

Concept 3 — Loops Save Time

Loops repeat steps. They make programs shorter and easier to write.

Concept 4 — Choose the Right Loop

Use repeat loops when you know the count. Use while loops when you do not.

Concept 5 — Combine Decisions and Loops

Real programs often use decisions inside loops. This lets them handle complex tasks.

Summary of Important Concepts

These five concepts are the heart of Module 2. Read them again before moving on.

7. Step-by-step Explanations

Step-by-step: How to Write an If-Else in Pseudocode

1. Identify the condition. What are you checking?
2. Write the IF line. IF condition THEN.
3. Write the action. What to do if true.
4. Write the ELSE line. What to do if false.
5. End with END IF. Close the decision.
6. Test it. Try different conditions.

    WRITING AN IF-ELSE
    ==================

    IF score >= 50 THEN
      print "Passed"
    ELSE
      print "Failed"
    END IF
    

Step-by-step: How to Write a While Loop in Pseudocode

1. Identify the condition. What must be true to keep looping?
2. Write the WHILE line. WHILE condition.
3. Write the actions. What to do inside the loop.
4. Make sure something changes. Otherwise it will loop forever.
5. End with END WHILE. Close the loop.
6. Test it. Check if it stops at the right time.

    WRITING A WHILE LOOP
    ====================

    count = 1
    WHILE count <= 5
      print count
      count = count + 1
    END WHILE
    

Step-by-step: How to Draw a Decision Flowchart

1. Start with an oval. Write "Start".
2. Add a rectangle for the first step.
3. Add a diamond for the decision.
4. Label the arrows "Yes" and "No".
5. Add rectangles for actions after each arrow.
6. End with an oval. Write "End".

    DECISION FLOWCHART
    ==================

    ( Start )
        |
        V
    [ Read score ]
        |
        V
    < Score >= 50? >
      /          \
    Yes           No
     |             |
     V             V
    [ Print ]   [ Print ]
    [ Passed ]  [ Failed ]
     |             |
     +------+------+
            |
            V
         ( End )
    

Summary of Step-by-step Explanations

Writing decisions and loops, and drawing flowcharts, all follow clear steps. Following steps makes it easy.

8. Real-life Examples

Example 1 — Traffic Light

A traffic light uses decisions: If green, go. Else if yellow, slow down. Else, stop. It also loops through the colours repeatedly.

Example 2 — ATM

An ATM uses decisions: If PIN is correct, allow. Else, reject. It also loops: For each transaction, process it.

Example 3 — Washing Machine

A washing machine uses a loop: While there is water, keep washing. If the timer ends, stop.

Example 4 — Online Shopping Cart

An online cart uses a loop: For each item, add the price. It uses a decision: If the total is over ₦50,000, give free delivery.

Example 5 — Music Player

A music player uses a loop: For each song in the playlist, play it. If the user presses stop, stop.

Summary of Real-life Examples

Decisions and loops appear in traffic lights, ATMs, washing machines, shopping carts, and music players.

9. Nigerian Examples

Example 1 — Buying Airtime

Decision: If you entered the right PIN, airtime is added. Else, an error message appears.

Example 2 — Bank Transfer

Decision: If your balance is enough, the transfer goes through. Else, the transfer fails.

Example 3 — POS Payment

Loop: For each item, add the price. Decision: If the total is correct, confirm payment.

Example 4 — Fuel Station

Loop: For each customer, pump fuel. Decision: If the tank is empty, stop selling.

Example 5 — School Result Portal

Loop: For each subject, check the score. Decision: If the score is 50 or more, mark as pass.

Summary of Nigerian Examples

Nigeria has many examples of decisions and loops: airtime, bank transfers, POS, fuel stations, and school portals.

10. Fun Examples Children Can Relate To

Example 1 — Video Games

Decision: If the player touches an enemy, lose a life. Loop: For each level, load the level.

Example 2 — Choosing Clothes

Decision: If it is cold, wear a jacket. Else, wear a T-shirt.

Example 3 — Playing Hide and Seek

Loop: Count to 20. Decision: If you find everyone, the game ends.

Example 4 — Making a Sandwich

Decision: If you have cheese, add cheese. Else, skip it. Loop: For each slice, add filling.

Example 5 — Sharing Sweets

Loop: For each friend, give one sweet. Decision: If there are no sweets left, stop.

Summary of Fun Examples

Decisions and loops appear in video games, choosing clothes, hide and seek, sandwiches, and sharing sweets.

11. Everyday Examples

Summary of Everyday Examples

Even simple daily activities use decisions and loops. Now you can see them everywhere.

12. Parent Tips

1. Point out decisions in daily life. "If it rains, we take an umbrella."
2. Point out loops. "We wash each plate one by one."
3. Ask your child to spot decisions. In a game, in a movie, in a chore.
4. Play decision games. "If I say red, jump. If I say blue, sit."
5. Play loop games. "Clap 5 times. Now clap until I say stop."
6. Practise pseudocode. Ask your child to write "IF... ELSE" for a daily rule.
7. Praise clear thinking. When your child explains a decision, praise them.
8. Be patient. Logical thinking takes practice.

Summary of Parent Tips

Parents can help children learn decisions and loops through daily activities and simple games.

13. Interesting Facts

1. The if statement is one of the oldest ideas in programming.
2. Loops can repeat millions of times in a second.
3. Without loops, some programs would be millions of lines long.
4. Infinite loops are one of the most common programming mistakes.
5. Traffic lights use loops and decisions together.
6. Some computer games use thousands of loops every second.
7. The concept of true and false is called Boolean logic, named after a mathematician called George Boole.
8. In Nigeria, many tech companies teach if-statements and loops in their first coding lessons.

Summary of Interesting Facts

Decisions and loops are powerful, old, and used everywhere.

14. Did You Know?

• Did you know that every decision in a program uses true or false?
• Did you know that a single loop can save hundreds of lines of code?
• Did you know that the first computers had no loops, and programmers had to write every step by hand?
• Did you know that traffic lights, elevators, and washing machines all use decisions and loops?
• Did you know that an infinite loop can freeze a whole program?
• Did you know that "else if" is sometimes called "elif" in some programming languages?

Summary of Did You Know?

Decisions and loops are full of surprises. The more you learn, the more interesting they become.

15. Remember This

• A decision is a choice between options.
• Every decision uses true or false.
• Comparisons check relationships between values.
• An if statement runs when a condition is true.
• An else statement runs when a condition is false.
• An else if statement checks another condition.
• A loop repeats a set of steps.
• Repeat loops repeat a fixed number of times.
• While loops repeat as long as a condition is true.
• For loops repeat a specific number of times, often counting.

Summary of Remember This

These ten points are the heart of Module 2. Read them again before moving on.

16. Common Mistakes

1. Forgetting the else. Without else, the program does nothing when the condition is false.
2. Using the wrong comparison. Using "greater than" when you mean "greater than or equal to".
3. Writing an infinite loop. A loop that never stops.
4. Not changing the condition inside a while loop. This creates an infinite loop.
5. Using a loop when a decision is needed. They are different.
6. Forgetting to close loops or if statements. Use END IF and END LOOP.
7. Making conditions too complex. Keep them simple.
8. Giving up too soon. Logic takes practice.

Summary of Common Mistakes

Avoiding these mistakes will make you a better logical thinker than many adults.

17. Best Practices

1. Keep conditions simple and clear.
2. Always include an else when there is another option.
3. Use else if for multiple options.
4. Make sure loops change something, so they stop.
5. Choose the right loop for the task.
6. Test your code with different values.
7. Draw flowcharts for decisions and loops.
8. Write pseudocode before real code.
9. Look for loops and decisions in daily life.
10. Practice every day.

Summary of Best Practices

These ten practices will help you write better decisions and loops.

18. ASCII Illustrations, Diagrams, Flowcharts, and Timelines

Diagram 1 — A Simple Decision

    A SIMPLE DECISION
    =================

    [ Is it raining? ]
       /           \
     Yes            No
      |              |
      V              V
    [ Take        [ Do not
      umbrella ]    take umbrella ]
    

Diagram 2 — True and False

    TRUE AND FALSE
    ==============

    True:   [ YES ]  [ ON ]   [ Correct ]
    False:  [ NO ]   [ OFF ]  [ Wrong ]
    

Diagram 3 — If-Else Statement

    IF-ELSE STATEMENT
    =================

    [ Is the condition true? ]
       /                  \
     Yes                   No
      |                     |
      V                     V
    [ Do action A ]      [ Do action B ]
    

Diagram 4 — Else If Chain

    ELSE IF CHAIN
    =============

    [ Score >= 70? ]
       /          \
     Yes           No
      |             |
      V             V
    [ Grade A ]  [ Score >= 60? ]
                    /         \
                  Yes          No
                   |            |
                   V            V
                [ Grade B ] [ Score >= 50? ]
                              /         \
                            Yes          No
                             |            |
                             V            V
                          [ Grade C ] [ Grade F ]
    

Diagram 5 — While Loop

    WHILE LOOP
    ==========

    [ Check condition ]
          |
          V
    [ Is it true? ]
       /        \
     Yes         No
      |           |
      V           V
    [ Do task ]  [ End ]
      |
      +--> check condition again
    

Diagram 6 — Decision Inside a Loop

    DECISION INSIDE A LOOP
    ======================

    FOR each item
        |
        V
    [ Check condition ]
       /          \
     Yes           No
      |             |
      V             V
    [ Action A ] [ Action B ]
      |             |
      +------+------+
             |
             V
    [ Next item ]
    

Summary of Illustrations

These diagrams help you see decisions and loops clearly. Draw them yourself to remember them better.

19. Comparison Tables

Table 1 — If vs Else If vs Else

Table 2 — Repeat vs While vs For

Table 3 — Decision vs Loop

Summary of Comparison Tables

Comparing ideas side by side helps you remember the differences clearly.

20. Summary After Every Lesson (Consolidated)

21. End-of-Module Summary

Congratulations! You have completed Module 2. Let us review what you have learned.

You began by learning that a decision is a choice between options. Programs use decisions to react to different situations.

You learned about true and false, the two answers to a yes-or-no question. Every decision checks something that is either true or false.

You explored comparisons — equal, not equal, greater than, less than, and more.

You learned how to write if statements — "If this is true, do that."

You added else and else if to handle more options.

You discovered loops — ways to repeat steps. You learned about repeat loops, while loops, and for loops.

You learned when to use decisions and when to use loops. You also learned how to combine them.

    MODULE 2 SUMMARY MAP
    ====================

    [ Decision ] --> [ True / False ] --> [ Comparisons ]
              |
              V
    [ If ] --> [ Else ] --> [ Else If ]
              |
              V
    [ Loop ] --> [ Repeat ] --> [ While ] --> [ For ]
              |
              V
    [ Decision + Loop Together! ]
    

Well done! You now understand how programs make decisions and repeat tasks. In Module 3, you will learn how programs store and use information.

22. Frequently Asked Questions (10 Questions)

Question 1: What is a decision in programming?

A decision is a choice between two or more options. Programs use decisions to react to different situations.

Question 2: What is true and false?

True and false are the two answers to a yes-or-no question. They are the foundation of every decision.

Question 3: What is a comparison?

A comparison checks the relationship between two values. It asks: Are they equal? Is one greater? Is one smaller?

Question 4: What is an if statement?

An if statement tells the program: "If this is true, do that."

Question 5: What is an else statement?

An else statement tells the program what to do when the if condition is false.

Question 6: What is an else if statement?

An else if statement lets the program check more than one condition. It is used when there are more than two options.

Question 7: What is a loop?

A loop is a way to repeat a set of steps many times.

Question 8: What is the difference between a repeat loop and a while loop?

A repeat loop repeats a fixed number of times. A while loop repeats as long as a condition is true.

Question 9: What is an infinite loop?

An infinite loop is a loop that never stops. It happens when the condition never becomes false.

Question 10: Can I use decisions and loops in daily life?

Yes! You already use them for cooking, dressing, playing games, and many other tasks.

23. Matching Exercises

Exercise 1 — Match the Word to the Meaning

Answers: 1-B, 2-C, 3-E, 4-A, 5-D

Exercise 2 — Match the Task to Its Type

Answers: 1-C, 2-B, 3-A, 4-D

Summary of Matching Exercises

Matching helps you connect words to meanings quickly.

24. Scenario-based Exercises

Scenario 1 — The Silent ATM

A customer enters the wrong PIN at an ATM. The ATM does nothing. No message appears. The customer is confused.

Questions:

1. What is missing in the program?
2. What should the ATM do?
3. Write pseudocode for the correct behaviour.

Scenario 2 — The Endless Song

A music player keeps playing the same song forever. The user cannot stop it.

Questions:

1. What kind of mistake is this?
2. How could the programmer fix it?
3. What is the name of this mistake?

Scenario 3 — The Missed Decision

A shopping website always gives free delivery, even when the order is small. The company is losing money.

Questions:

1. What decision is missing?
2. How should the program check?
3. Write pseudocode for the correct decision.

Summary of Scenario-based Exercises

These scenarios help you apply what you have learned to real situations.

25. Group Activity

Activity: Design a Decision Flowchart for a Game

Group size: 3–5 students

Time: 40 minutes

Materials: Paper, pencil, ruler

Instructions:

1. Choose a simple game (e.g., guess the number, rock-paper-scissors).
2. Write the rules as decisions (if, else).
3. Include at least one loop (repeat until the game ends).
4. Draw a flowchart using ovals, rectangles, and diamonds.
5. Present your flowchart to the class.

Goal: To practise decisions and loops together.

26. Individual Activity

Activity: My Day in Decisions and Loops

Time: 20 minutes

Materials: Notebook, pencil

Instructions:

1. Write three decisions you made today (using if/else).
2. Write three loops you did today (like brushing each tooth).
3. Draw a simple flowchart for one decision.
4. Draw a simple flowchart for one loop.

Goal: To connect decisions and loops to your own daily life.

27. Mini Project

Project: Design a Simple Quiz Program on Paper

Time: 1–2 hours

Materials: Paper, pencil, ruler

Instructions:

1. Choose 5 simple questions (e.g., maths or general knowledge).
2. Write pseudocode that asks each question in a loop.
3. Inside the loop, use a decision: If the answer is correct, add 1 to the score.
4. After the loop, use a decision: If the score is 3 or more, say "Well done". Else, say "Try again".
5. Draw a flowchart of your program.
6. Present your project to the class.

Goal: To practise decisions and loops together.

28. Practical Assignment

Assignment: Observe Decisions and Loops in Real Life

Time: 1 week

Materials: Notebook, pencil

Instructions:

1. For one week, look for decisions and loops in daily life.
2. Write down at least 5 examples of each.
3. For one decision, write pseudocode using if/else.
4. For one loop, write pseudocode using while or for.
5. Write a short report on what you learned.

Goal: To see how decisions and loops appear in real life.

29. Key Takeaways

1. A decision is a choice between options.
2. Every decision uses true or false.
3. Comparisons check relationships between values.
4. If statements run when a condition is true.
5. Else statements run when a condition is false.
6. Else if statements check another condition.
7. Loops repeat a set of steps.
8. Repeat loops repeat a fixed number of times.
9. While loops repeat as long as a condition is true.
10. For loops repeat a specific number of times, often counting.

30. Classroom Discussion Questions

1. Why do programs need decisions?
2. What would happen if a program had no loops?
3. Can you give an example of a decision you made today?
4. Can you give an example of a loop you used today?
5. What is the difference between if and else?
6. When would you use else if?
7. What is the difference between a while loop and a for loop?
8. What happens if a loop never stops?
9. Why is it useful to combine decisions and loops?
10. What did you enjoy most in this module?

31. Preparation for the Next Module

You have finished Module 2. Well done! Here is how to prepare for Module 3, which is all about Storing and Using Information.

1. Review your key words. Make sure you can explain decision, if, else, loop, and while loop in your own words.
2. Practise writing pseudocode. Write if/else and loops for daily tasks.
3. Draw flowcharts. Use ovals, rectangles, diamonds, and arrows.
4. Look for information in daily life. Notice how you store and use information (names, numbers, lists).
5. Bring your curiosity. Module 3 will teach you about variables, data types, lists, and functions.

    TRANSITION TO MODULE 3
    ======================

    [ Module 2: Making Decisions and Repeating Tasks ]
              |
              V
    [ Module 3: Storing and Using Information ]
              |
              V
    [ You will learn: variables, data types,
      lists, functions, and input/output ]
    

See you in Module 3. Keep thinking like a programmer!

1. Module Introduction

Welcome to Module 3 — the final module of the Programming Logic for Web Developers course. You have come a long way. In Module 1, you learned how to think in steps. In Module 2, you learned how programs make decisions and repeat tasks.

Now we come to the last piece of the puzzle. Programs must remember things. They must store information. If a program cannot remember your name, your score, or your shopping list, it is not useful.

In this module, you will learn how programs store and use information. You will learn about variables — boxes that hold information. You will learn about data types — the different kinds of information. You will learn about lists and arrays — ways to store many things together. You will learn about functions — reusable blocks of steps. And you will learn about input and output — how programs receive and send information.

Do not worry if these words sound new. Every word will be explained in very simple language. Every idea will come with examples from real life, school, home, and Nigeria.

This is the last module. Take your time. Enjoy it. By the end, you will have all the logic skills you need to start learning HTML, CSS, and JavaScript.

    YOUR LEARNING JOURNEY IN MODULE 3
    =================================

    [ Start ]
        |
        V
    What are Variables?
        |
        V
    What are Data Types?
        |
        V
    Numbers, Text, and True/False
        |
        V
    What are Lists?
        |
        V
    What are Functions?
        |
        V
    What is Input and Output?
        |
        V
    [ You can now store and use information! ]
    

Summary of the Introduction

This module teaches you how programs store and use information. You will learn about variables, data types, lists, functions, and input/output.

2. Learning Objectives

By the end of this module, you will be able to:

1. Explain what a variable is in your own words.
2. Explain what a data type is and why it matters.
3. Describe the three main data types: numbers, text, and true/false.
4. Explain what a list or array is.
5. Explain what a function is and why functions are useful.
6. Explain what input and output mean.
7. Write simple pseudocode that stores and uses information.
8. Give examples of variables, lists, and functions in real life.
9. Draw a simple diagram showing how information flows in a program.
10. Feel confident and ready to start learning real programming languages.

Summary of Learning Objectives

You will learn how programs store information (variables, lists) and how they use it (functions, input/output). You will also learn about data types.

3. Warm-up Story — Amina's School Bag

Amina is a 13-year-old girl who lives in Kano. One morning, she packed her school bag for the day.

She put her Maths textbook in one pocket. She put her English textbook in another pocket. She put her pencil case in the front. She put her lunchbox in the side. She put her water bottle in the other side.

When she got to school, she knew exactly where everything was. When the teacher asked for Maths, she opened the Maths pocket. When she wanted lunch, she opened the lunch side.

Her friend, Fatima, was not so organised. She had thrown everything into one big bag. When the teacher asked for Maths, she spent five minutes searching. When she wanted water, she could not find it.

"Amina, how do you always know where everything is?" Fatima asked.

Amina smiled. "Each thing has its own place. I gave each item a name. When I need something, I just call its name."

Fatima thought about it. "So if I put Maths in a pocket called 'MathsBook', I just say, 'Open MathsBook', and I find it?"

"Exactly," Amina said. "That is how computers work too. Every piece of information gets a name. When the program needs it, it calls the name."

Fatima smiled. She had learned something important. Information needs a place and a name. That is what programming is all about.

    AMINA'S SCHOOL BAG
    ==================

    [ MathsBook ]     <- a variable holding a Maths book
    [ EnglishBook ]   <- a variable holding an English book
    [ PencilCase ]    <- a variable holding pencils
    [ LunchBox ]      <- a variable holding lunch
    [ WaterBottle ]   <- a variable holding water

    Each item has a name. You call the name to get the item.
    

Summary of the Warm-up Story

Amina organised her school bag by giving each item a name and a place. Computers do the same with variables. This story introduces the whole module.

4. Main Lessons

In this section, you will go through 12 short lessons. Each lesson teaches one big idea. Each lesson ends with a mini summary. Read slowly. Think about the examples. Ask questions. That is how you learn.

    VARIABLES ARE LIKE LABELLED JARS
    ================================

    [ Sugar ]   <- variable holding sugar
    [ Salt ]    <- variable holding salt
    [ Rice ]    <- variable holding rice

    In a program:
      score = 0
      name = "Amina"
      balance = 5000
    

    GOOD NAMES vs BAD NAMES
    =======================

    Bad:   x = 5000           (What is x?)

    Good:  accountBalance = 5000   (Clear!)

    Bad:   a = "Amina"        (What is a?)

    Good:  studentName = "Amina"   (Clear!)
    

    THREE DATA TYPES
    ================

    Number:      age = 13
                 balance = 5000
                 price = 250.50

    Text:        name = "Amina"
                 city = "Kano"
                 message = "Hello"

    True/False:  isRaining = true
                 isPassed = false
                 hasPaid = true
    

    NUMBERS IN ACTION
    =================

    price = 250
    quantity = 3
    total = price * quantity

    total is now 750.

    Numbers can be added, subtracted, multiplied, and divided.
    

    TEXT IN ACTION
    ==============

    name = "Amina Yusuf"
    city = "Kano"
    message = "Hello, how are you?"

    Text is always in quotes: "..."

    You can join text: "Hello, " + "Amina" = "Hello, Amina"
    

    TRUE / FALSE IN ACTION
    ======================

    isRaining = true
    isLoggedIn = false
    hasPaidFees = true

    If hasPaidFees is true, allow registration.
    If hasPaidFees is false, block registration.
    

    A LIST IS LIKE A SHOPPING LIST
    ==============================

    shoppingList = [ "Rice", "Beans", "Oil", "Salt" ]

    Item 1: "Rice"
    Item 2: "Beans"
    Item 3: "Oil"
    Item 4: "Salt"

    You can get any item by its position.
    

    USING A LIST
    ============

    shoppingList = [ "Rice", "Beans", "Oil", "Salt" ]

    FOR each item in shoppingList
      print item
    END FOR

    Output:
      Rice
      Beans
      Oil
      Salt
    

    A FUNCTION IS LIKE A RECIPE
    ===========================

    FUNCTION greet(name)
      print "Hello, " + name
    END FUNCTION

    greet("Amina")   -> "Hello, Amina"
    greet("Chidi")   -> "Hello, Chidi"

    Same steps, different inputs.
    

    INPUT AND OUTPUT
    ================

    [ Input ] --> [ Program ] --> [ Output ]

    Example:
    [ 2 + 3 ] --> [ Calculator ] --> [ 5 ]

    Another example:
    [ account number ] --> [ Bank app ] --> [ balance ]
    

    START

      shoppingList = [ "Rice", "Beans", "Oil" ]

      FUNCTION printList(list)
        FOR each item in list
          print item
        END FOR
      END FUNCTION

      printList(shoppingList)

      name = "Amina"
      print "Hello, " + name

    END
        

    PUTTING IT ALL TOGETHER
    =======================

    [ Variables ]  ->  [ Data Types ]  ->  [ Lists ]
          |                 |                  |
          V                 V                  V
    [ Functions ]  ->  [ Input/Output ]  ->  [ Complete Program! ]
        

    BECOMING A PROGRAMMER
    =====================

    [ Learn to think in steps ]
              |
              V
    [ Learn decisions and loops ]
              |
              V
    [ Learn variables and data ]
              |
              V
    [ Choose a language ]
              |
              V
    [ Build small projects ]
              |
              V
    [ Build bigger projects ]
              |
              V
    [ Celebrate! 🎉 ]
        

Summary of Main Lessons

You have now learned the core ideas of Module 3: variables, naming variables, data types, numbers, text, true/false, lists, using lists, functions, input/output, and how everything fits together.

5. Key Vocabulary

Summary of Key Vocabulary

These words will help you understand how programs store and use information. Use them often so they become easy.

6. Important Concepts

Concept 1 — Information Needs a Name

Variables give information a name so programs can find it later.

Concept 2 — Information Has a Type

Numbers, text, and true/false are different. Programs handle them differently.

Concept 3 — Lists Keep Things Together

Lists store many items in one place. They are perfect for going through items one by one.

Concept 4 — Functions Save Time

Functions are reusable blocks of steps. Write once, use many times.

Concept 5 — Programs Take Input and Give Output

Every useful program receives information and produces a result.

Summary of Important Concepts

These five concepts are the heart of Module 3. Read them again before moving on.

7. Step-by-step Explanations

Step-by-step: How to Use a Variable

1. Choose a name. Use a clear word, like "score".
2. Put a value inside. For example, score = 0.
3. Use the variable. Add to it, print it, or check it.
4. Change it if needed. score = score + 1.
5. Read it when needed. print score.

    USING A VARIABLE
    ================

    score = 0
    score = score + 1
    score = score + 1
    print score

    Output: 2
    

Step-by-step: How to Use a List

1. Create the list. Write items inside square brackets.
2. Read an item. Use its position number.
3. Add an item. Use "add" or "append".
4. Remove an item. Use "remove".
5. Loop through items. Use a for loop.

    USING A LIST
    ============

    fruits = [ "Mango", "Banana", "Orange" ]

    print fruits[0]     -> Mango
    print fruits[1]     -> Banana

    FOR each fruit in fruits
      print fruit
    END FOR
    

Step-by-step: How to Write a Function

1. Choose a name. Use a clear word, like "greet".
2. List the inputs. What does it need? For example, "name".
3. Write the steps. What should it do?
4. End the function. Use END FUNCTION.
5. Call the function. Use its name and pass inputs.

    WRITING A FUNCTION
    ==================

    FUNCTION greet(name)
      print "Hello, " + name
    END FUNCTION

    greet("Amina")
    greet("Chidi")

    Output:
      Hello, Amina
      Hello, Chidi
    

Summary of Step-by-step Explanations

Using variables, lists, and functions all follow clear steps. Following steps makes it easy.

8. Real-life Examples

Example 1 — A Shopping Cart

A shopping cart uses a list to store items. It uses a function to calculate the total. It uses input (the items you choose) and output (the receipt).

Example 2 — A Bank Account

A bank uses variables to store your name and balance. It uses a function to add or subtract money.

Example 3 — A Music Player

A music player stores songs in a list. It uses a function to play each song.

Example 4 — A School Portal

A school portal stores student names in a list. It uses a function to calculate the average score.

Example 5 — A Calculator

A calculator uses variables for numbers. It uses functions for addition and subtraction.

Summary of Real-life Examples

Variables, lists, and functions appear in shopping carts, banks, music players, school portals, and calculators.

9. Nigerian Examples

Example 1 — POS Machine

A POS machine stores items in a list. It uses a function to calculate the total. It shows the receipt as output.

Example 2 — Bank Transfer

A bank stores your balance in a variable. It uses a function to transfer money.

Example 3 — School Result Portal

A school portal stores each student's name and scores. It uses a function to calculate the grade.

Example 4 — Pure Water Seller

A pure water seller uses a variable to track bags sold. Each bag sold adds to the variable.

Example 5 — Jumia and Konga

These online stores use variables for prices, lists for products, and functions for calculating totals.

Summary of Nigerian Examples

Nigeria has many examples of variables, lists, and functions in POS machines, banks, schools, and shops.

10. Fun Examples Children Can Relate To

Example 1 — Video Game Score

A game stores your score in a variable. Every point adds to it.

Example 2 — A Playlist

A music playlist is a list of songs. The app plays each one.

Example 3 — A Pencil Case

A pencil case is like a list of items: pens, pencils, erasers.

Example 4 — A Recipe

A recipe is like a function. You follow the same steps each time.

Example 5 — A Sports Team

A team is a list of players. The coach uses a function to select the starting eleven.

Summary of Fun Examples

Variables, lists, and functions appear in video games, playlists, pencil cases, recipes, and sports teams.

11. Everyday Examples

Summary of Everyday Examples

Even simple daily activities use variables, lists, and functions.

12. Parent Tips

1. Point out variables in daily life. The score in a game, the price of an item.
2. Show lists. The shopping list, the class register, the timetable.
3. Explain functions. A recipe, a routine, a chore.
4. Play with numbers. Ask your child to calculate the total cost of items.
5. Encourage naming. Let your child name things clearly.
6. Use simple games. "Let's make a list of things to buy."
7. Praise good organisation. When your child organises things well, praise them.
8. Be patient. Learning takes time.

Summary of Parent Tips

Parents can help children understand variables, lists, and functions through daily activities.

13. Interesting Facts

1. The word "variable" comes from the Latin word "variabilis", meaning "changeable".
2. Lists can hold millions of items.
3. Functions can be reused thousands of times in one program.
4. The most common data types in programming are numbers, text, and true/false.
5. Some programming languages check data types automatically. Others do not.
6. Input and output are the two-way conversation between users and programs.
7. Even the simplest calculator uses variables and functions.
8. In Nigeria, many coding schools start with variables, lists, and functions.

Summary of Interesting Facts

Variables, lists, and functions are powerful, common, and used everywhere.

14. Did You Know?

• Did you know that every app you use stores information in variables?
• Did you know that a list can grow or shrink as the program runs?
• Did you know that functions make programs shorter and easier to fix?
• Did you know that input can come from a keyboard, a file, or even another program?
• Did you know that output can be text, images, sounds, or files?
• Did you know that learning variables is the first step to learning any programming language?

Summary of Did You Know?

Variables, lists, functions, and input/output are the foundation of every program.

15. Remember This

• A variable is a named box that stores information.
• Good variable names are clear and short.
• A data type tells the program what kind of information is stored.
• The three main data types are numbers, text, and true/false.
• A list stores many items in one variable.
• Using a list means adding, removing, reading, and looping.
• A function is a reusable block of steps.
• Input is information going into a program.
• Output is information coming out of a program.
• Real programs use variables, lists, and functions together.

Summary of Remember This

These ten points are the heart of Module 3. Read them again before finishing the course.

16. Common Mistakes

1. Using vague variable names. "x" and "a" are hard to understand.
2. Mixing data types. Trying to add a number to text.
3. Forgetting to put text in quotes. Text needs quotes: "Hello".
4. Using the wrong position in a list. Most lists start at position 0.
5. Forgetting to call a function. Defining it is not enough.
6. Not handling input. Programs should check what the user enters.
7. Making functions too long. Keep them short and clear.
8. Giving up too soon. Practice is the key.

Summary of Common Mistakes

Avoiding these mistakes will make you a better programmer than many adults.

17. Best Practices

1. Use clear variable names.
2. Choose the right data type for the job.
3. Keep lists organised.
4. Use functions for repeated steps.
5. Keep functions short and focused.
6. Always validate input.
7. Test your program with different inputs.
8. Write pseudocode before real code.
9. Comment your code so others understand.
10. Practice every day.

Summary of Best Practices

These ten practices will help you write better programs.

18. ASCII Illustrations, Diagrams, Flowcharts, and Timelines

Diagram 1 — Variables Are Like Labelled Jars

    VARIABLES ARE LIKE LABELLED JARS
    ================================

    [ Sugar ]   <- variable holding sugar
    [ Salt ]    <- variable holding salt
    [ Rice ]    <- variable holding rice
    

Diagram 2 — Three Data Types

    THREE DATA TYPES
    ================

    Number:      age = 13
                 balance = 5000

    Text:        name = "Amina"
                 city = "Kano"

    True/False:  isRaining = true
                 isPassed = false
    

Diagram 3 — A List

    A LIST IS LIKE A SHOPPING LIST
    ==============================

    shoppingList = [ "Rice", "Beans", "Oil", "Salt" ]

    Item 1: "Rice"
    Item 2: "Beans"
    Item 3: "Oil"
    Item 4: "Salt"
    

Diagram 4 — A Function

    A FUNCTION IS LIKE A RECIPE
    ===========================

    FUNCTION greet(name)
      print "Hello, " + name
    END FUNCTION

    greet("Amina")   -> "Hello, Amina"
    greet("Chidi")   -> "Hello, Chidi"
    

Diagram 5 — Input and Output

    INPUT AND OUTPUT
    ================

    [ Input ] --> [ Program ] --> [ Output ]

    Example:
    [ 2 + 3 ] --> [ Calculator ] --> [ 5 ]
    

Diagram 6 — Putting It All Together

    PUTTING IT ALL TOGETHER
    =======================

    [ Variables ]  ->  [ Data Types ]  ->  [ Lists ]
          |                 |                  |
          V                 V                  V
    [ Functions ]  ->  [ Input/Output ]  ->  [ Complete Program! ]
    

Summary of Illustrations

These diagrams help you see how programs store and use information. Draw them yourself to remember them better.

19. Comparison Tables

Table 1 — The Three Data Types

Table 2 — Variable vs List

Table 3 — Input vs Output

Summary of Comparison Tables

Comparing ideas side by side helps you remember the differences clearly.

20. Summary After Every Lesson (Consolidated)

21. End-of-Module Summary

Congratulations! You have completed Module 3. Let us review what you have learned.

You began by learning that a variable is a named box that stores information. You learned how to give variables good names.

You discovered data types — the kind of information a variable holds. You learned about numbers, text, and true/false.

You explored lists — ways to store many items in one variable. You learned how to add, remove, read, and loop through items.

You learned about functions — reusable blocks of steps. Functions save time and keep programs organised.

You discovered input and output — how programs receive and send information.

Finally, you learned how to put it all together and how to become a programmer.

    MODULE 3 SUMMARY MAP
    ====================

    [ Variables ] --> [ Data Types ] --> [ Lists ]
          |
          V
    [ Functions ] --> [ Input/Output ] --> [ Complete Program! ]
          |
          V
    [ You can now store and use information! ]
    

Well done! You have completed the entire Programming Logic for Web Developers course. You now have the logical foundation to learn any programming language.

22. Frequently Asked Questions (10 Questions)

Question 1: What is a variable in the simplest words?

A variable is a named box that stores information in a program.

Question 2: Why do variable names matter?

Clear names make programs easy to read and understand. Bad names cause confusion.

Question 3: What is a data type?

A data type tells the program what kind of information is stored — a number, text, or true/false.

Question 4: What are the three main data types?

Numbers, text (strings), and true/false.

Question 5: What is a list?

A list stores many items in one variable. Each item can be used separately.

Question 6: What is a function?

A function is a reusable block of steps. You write it once and call it whenever needed.

Question 7: What is input?

Input is information going into a program, like typing your name.

Question 8: What is output?

Output is information coming out of a program, like showing your greeting on the screen.

Question 9: Can I use variables, lists, and functions in real life?

Yes! You already use them for shopping lists, recipes, and routines.

Question 10: What should I learn next?

After this course, you can learn HTML, CSS, and JavaScript for web development.

23. Matching Exercises

Exercise 1 — Match the Word to the Meaning

Answers: 1-B, 2-E, 3-D, 4-A, 5-C

Exercise 2 — Match the Example to Its Type

Answers: 1-C, 2-A, 3-B, 4-D

Summary of Matching Exercises

Matching helps you connect words to meanings quickly.

24. Scenario-based Exercises

Scenario 1 — The Lost Score

A game developer forgets to store the score in a variable. Every time the game restarts, the score is lost.

Questions:

1. What is missing?
2. What should the developer do?
3. Write pseudocode for storing the score.

Scenario 2 — The Confused Shopping Cart

An online shop stores each item in a separate variable. After 50 items, the developer gets confused.

Questions:

1. What is the problem?
2. What should the developer use instead?
3. How would a list help?

Scenario 3 — The Repeated Code

A developer writes the same 10 lines of code 20 times in a program. The program is very long and hard to fix.

Questions:

1. What should the developer use?
2. How does this help?
3. What is the name of this feature?

Summary of Scenario-based Exercises

These scenarios help you apply what you have learned to real situations.

25. Group Activity

Activity: Plan a Simple Shopping Program

Group size: 3–5 students

Time: 40 minutes

Materials: Paper, pencil, ruler

Instructions:

1. Imagine a small shop that sells 5 items.
2. Create variables for the shop name and total sales.
3. Create a list of items and their prices.
4. Write a function to calculate the total price of an order.
5. Write a loop that shows all items.
6. Present your program to the class.

Goal: To practise using variables, lists, and functions together.

26. Individual Activity

Activity: My Personal Variables

Time: 20 minutes

Materials: Notebook, pencil

Instructions:

1. Write 5 variables that describe you (e.g., myName, myAge).
2. Write what data type each variable is.
3. Write one list of your favourite foods.
4. Write one function that takes your name and prints a greeting.
5. Write the input and output of your function.

Goal: To connect variables, lists, and functions to your own life.

27. Mini Project

Project: Design a Simple Grade Calculator on Paper

Time: 1–2 hours

Materials: Paper, pencil, ruler

Instructions:

1. Create a list of 5 subjects.
2. Create a variable for each score.
3. Write a function to calculate the average score.
4. Use an if/else to decide the grade (A, B, C, D, F).
5. Print the results as output.
6. Draw a flowchart of your program.
7. Present it to the class.

Goal: To combine variables, lists, functions, decisions, and loops.

28. Practical Assignment

Assignment: Observe Information Storage in Daily Life

Time: 1 week

Materials: Notebook, pencil

Instructions:

1. For one week, look for examples of variables, lists, and functions in daily life.
2. Write down at least 5 examples of each.
3. For one example, write pseudocode using variables and a list.
4. For one example, write pseudocode for a function.
5. Write a short report on what you learned.

Goal: To see how programs store and use information, just like real life.

29. Key Takeaways

1. A variable is a named box that stores information.
2. Good variable names are clear and short.
3. A data type tells what kind of information is stored.
4. The three main data types are numbers, text, and true/false.
5. A list stores many items in one variable.
6. Using a list means adding, removing, reading, and looping.
7. A function is a reusable block of steps.
8. Input is information going into a program.
9. Output is information coming out of a program.
10. Real programs use all these parts together.

30. Classroom Discussion Questions

1. Why do programs need variables?
2. Can you give an example of a variable from your daily life?
3. Why do you think data types matter?
4. What is the difference between a variable and a list?
5. Can you think of a list from your daily life?
6. Why do you think functions are useful?
7. What is the difference between input and output?
8. Can you give an example of input and output from a bank app?
9. Why do you think programs need both input and output?
10. What did you enjoy most in this module?

31. Course Completion & Next Steps

You have completed the entire Programming Logic for Web Developers course. Well done! Here is what to do next.

1. Review all modules. Go back through Module 1, 2, and 3. Make sure you can explain every key idea in your own words.
2. Finish your final project. Complete the design you started in this module.
3. Start learning HTML. Free resources like W3Schools can help you begin.
4. Practice logic daily. Write pseudocode for simple tasks.
5. Learn a real language. JavaScript is a great next step for web development.
6. Build small projects. A to-do list, a simple calculator, or a quiz.
7. Keep learning. Programming is a journey. Enjoy it.

    YOUR COURSE JOURNEY
    ===================

    [ Module 1: Thinking in Steps ]
              |
              V
    [ Module 2: Making Decisions and Repeating Tasks ]
              |
              V
    [ Module 3: Storing and Using Information ]
              |
              V
    [ You can now think like a programmer! ] 🎉

    Next step: Learn HTML, CSS, and JavaScript.
    

Congratulations on completing the course. Keep thinking, keep practising, and one day you will build something amazing.