Programming Concepts Through Pseudocode: Variables, Loops, Functions, and Logic

Pseudocode lets you work through a program’s logic before dealing with a language’s exact keywords, punctuation, and rules. Resolving unclear steps early can prevent mistakes before syntax errors even enter the picture.

Start With a Plain-Language Problem Before Writing Pseudocode

Pseudocode is a readable description of an algorithm: a sequence of instructions for solving a problem. It resembles code, but it is not intended to run on a computer as written. Its job is to make the plan understandable.

Consider a simple study-goal tracker. A learner records the points earned during each study session. The tracker adds those points, counts the sessions, and checks whether the learner has reached a goal.

Before writing pseudocode, describe the task in ordinary language:

• Start with zero points and no recorded sessions.
• Examine each study-session score.
• Add the score to the total.
• Increase the session count.
• Check whether the learner has enough points and sessions.
• Show the result.

That outline already gives the program its basic shape. It includes information to track, repeated work, a decision, and an outcome.

Here is a first pseudocode plan. In this plan, STUDY_SCORES, TARGET_SCORE, and REQUIRED_SESSIONS are provided inputs:

SET TOTAL_SCORE TO 0
SET SESSION_COUNT TO 0

FOR EACH SESSION_SCORE IN STUDY_SCORES
    ADD SESSION_SCORE TO TOTAL_SCORE
    ADD 1 TO SESSION_COUNT
END FOR

IF TOTAL_SCORE IS AT LEAST TARGET_SCORE
   AND SESSION_COUNT IS AT LEAST REQUIRED_SESSIONS
    DISPLAY "Study goal met"
ELSE
    DISPLAY "More points or sessions are needed"
END IF

Clear names and consistent verbs make the plan easier to follow. ADD SESSION_SCORE TO TOTAL_SCORE describes a specific action. An instruction such as PROCESS THE DATA does not. “Process” leaves too much unspecified.

Indentation matters as well. The indented instructions belong to the loop or condition above them. Pseudocode has no single official format, but a consistent layout makes it easier to see which steps belong together.

Real story

I once wrote pseudocode for a simple counter and felt very smug until I noticed I had never actually told it to start at zero. I opened my notebook, stared at the blank first line, and realized my “algorithm” was basically a vibe with indentation. The funniest part was that I’d spent ten minutes debating whether the loop should be a while or a for, when the real issue was that nothing had a first step.

Have a story of your own? Share it in the comments below.

Represent Information With Variables and Basic Values

A variable is a named place for information that a program can use or change while it runs. In the study tracker, both the total score and the session count change as each new score is processed.

A useful variable name tells you what its value represents:

• TOTAL_SCORE stores the accumulated study points.
• SESSION_COUNT stores the number of recorded sessions.
• TARGET_SCORE stores the goal to reach.
• REQUIRED_SESSIONS stores the minimum number of required sessions.
• GOAL_MET stores a true-or-false result.
• STUDY_SCORES stores a collection of individual scores.

Programs commonly work with several broad types of values:

• Numbers, such as 25, 3, or 100
• Text, such as "Goal met"
• True-or-false values, such as TRUE and FALSE
• Collections, such as a list of session scores

The following pseudocode initializes the tracker and updates it for one session:

SET TOTAL_SCORE TO 0
SET SESSION_COUNT TO 0

SET SESSION_SCORE TO 25

ADD SESSION_SCORE TO TOTAL_SCORE
ADD 1 TO SESSION_COUNT

After these instructions run, TOTAL_SCORE is 25 and SESSION_COUNT is 1.

Initialization gives each variable a sensible starting value. A total normally begins at zero, as does a session count. If a variable starts with an unknown value, later calculations may not be reliable.

Saving a value and displaying it are separate operations:

SET STATUS_MESSAGE TO "You have completed 3 sessions"
DISPLAY STATUS_MESSAGE

The first instruction stores text in a variable. The second makes that text visible to a person.

Similarly, the number 3 is not the same as the text "three sessions". A program can add 1 to the number 3 or compare it with another number. Text works well in messages, but it cannot automatically be used for calculations.

Make Programs Choose With Conditions and Logical Operators

Conditions allow a program to follow different paths depending on the information available. In pseudocode, this is commonly expressed with IF, ELSE IF, and ELSE.

For the study tracker, the first question is whether the total score has reached the target:

IF TOTAL_SCORE IS AT LEAST TARGET_SCORE
    DISPLAY "Point goal met"
ELSE
    SET POINTS_REMAINING TO TARGET_SCORE MINUS TOTAL_SCORE
    DISPLAY POINTS_REMAINING
    DISPLAY "more points are needed"
END IF

A condition asks a question whose answer is true or false. Common comparisons include:

• Is one value equal to another?
• Is a score greater than a target?
• Is a count less than a required number?
• Is a value at least or at most a limit?

Conditions can also be combined. Suppose a learner earns a completion badge only after reaching 100 points and attending at least three sessions:

IF TOTAL_SCORE IS AT LEAST 100
   AND SESSION_COUNT IS AT LEAST 3
    SET GOAL_MET TO TRUE
    DISPLAY "Completion badge earned"
ELSE
    SET GOAL_MET TO FALSE
    DISPLAY "Keep studying"
END IF

AND requires every listed condition to be true. Reaching 100 points in a single session would not earn the badge when three sessions are required.

OR requires at least one condition to be true. For example, a reminder might appear when a learner is low on points or has completed too few sessions:

IF TOTAL_SCORE IS LESS THAN 100
   OR SESSION_COUNT IS LESS THAN 3
    DISPLAY "There is still progress to make"
END IF

NOT reverses a true-or-false value. If GOAL_MET is false, then NOT GOAL_MET is true:

IF NOT GOAL_MET
    DISPLAY "Review the next study session"
END IF

Keep combined rules readable. If a condition is difficult to explain in one sentence, calculate part of it separately and give that result a clear name.

Repeat Work With Loops Without Losing Track of State

Loops handle tasks that must be performed more than once. Rather than writing the same instructions for every study session, a loop applies them to each score.

A FOR EACH pattern is useful when the values already exist in a collection:

SET TOTAL_SCORE TO 0
SET SESSION_COUNT TO 0

FOR EACH SESSION_SCORE IN STUDY_SCORES
    ADD SESSION_SCORE TO TOTAL_SCORE
    ADD 1 TO SESSION_COUNT
END FOR

To understand what the loop is doing, follow its main parts:

1. Start with a known state. Here, both the total and the session count begin at zero.
2. Repeat the same actions. For each score, add it to the total and increase the count by one.
3. Reach a stopping point. The loop ends after every item in STUDY_SCORES has been handled.

The variables that change during a loop are sometimes called the program’s state. In this example, TOTAL_SCORE and SESSION_COUNT change on every pass.

A different pattern is useful when the number of entries is unknown. A WHILE loop continues as long as its condition remains true:

SET RECORDING_SESSIONS TO TRUE

WHILE RECORDING_SESSIONS IS TRUE
    ASK FOR A SESSION SCORE OR A STOP SIGNAL

    IF THE USER ENTERED A STOP SIGNAL
        SET RECORDING_SESSIONS TO FALSE
    ELSE
        RECORD THE SESSION SCORE
    END IF
END WHILE

Every WHILE loop needs a dependable path toward stopping. If RECORDING_SESSIONS never changes to FALSE, the loop runs forever. Computers are remarkably patient about that, which is not always useful.

Package Reusable Logic Into Functions With Inputs and Results

A function is a named group of instructions for one focused task. Functions make longer algorithms easier to read: they let you describe what should happen without repeating every implementation detail.

For example, a function can calculate the total of a collection of scores:

FUNCTION CALCULATE_TOTAL(SCORES)
    SET TOTAL TO 0

    FOR EACH SCORE IN SCORES
        ADD SCORE TO TOTAL
    END FOR

    RETURN TOTAL
END FUNCTION

SCORES is a parameter, or a value the function receives when it is called. TOTAL is a local working value used inside the function. RETURN TOTAL sends the completed result back to the part of the program that called the function.

A second function can determine whether a learner meets both requirements:

FUNCTION CHECK_GOAL(TOTAL_SCORE, SESSION_COUNT, TARGET_SCORE, REQUIRED_SESSIONS)
    IF TOTAL_SCORE IS AT LEAST TARGET_SCORE
       AND SESSION_COUNT IS AT LEAST REQUIRED_SESSIONS
        RETURN TRUE
    ELSE
        RETURN FALSE
    END IF
END FUNCTION

The main program can use the returned result like this:

SET GOAL_MET TO CHECK_GOAL(
    TOTAL_SCORE,
    SESSION_COUNT,
    TARGET_SCORE,
    REQUIRED_SESSIONS
)

A good function has a specific responsibility. CALCULATE_TOTAL calculates a total, while CHECK_GOAL checks a goal. A name such as DO_STUDY_THINGS gives future readers almost no useful information, including the person who wrote it last week.

Functions also make inputs and outputs easier to check independently. If the score total is wrong, inspect CALCULATE_TOTAL. If the badge appears at the wrong time, inspect CHECK_GOAL. Dividing the work into smaller pieces makes the reasoning easier to follow.

Assemble the Concepts Into One Complete Pseudocode Solution

The complete study-goal tracker brings together the basic programming concepts of variables, a loop, a function, and conditional logic. Before writing it, identify what the program needs:

• A collection of study-session scores
• A target number of points
• A required number of sessions
• A final status message

Build the Solution Step by Step

1. Set the starting values. The target and required session count are known goals. The total and count begin at zero.
2. Process each recorded score. The loop adds every score and counts the sessions it handles.
3. Use a function to decide whether the goal was met. The function receives the calculated values and returns either TRUE or FALSE.
4. Choose the final message. A condition uses the returned result to display feedback.
5. Trace the result with sample data. Following the values by hand confirms that the algorithm matches the plain-language rules.

FUNCTION CHECK_GOAL(TOTAL_SCORE, SESSION_COUNT, TARGET_SCORE, REQUIRED_SESSIONS)
    IF TOTAL_SCORE IS AT LEAST TARGET_SCORE
       AND SESSION_COUNT IS AT LEAST REQUIRED_SESSIONS
        RETURN TRUE
    ELSE
        RETURN FALSE
    END IF
END FUNCTION

SET STUDY_SCORES TO [30, 35, 40]
SET TARGET_SCORE TO 100
SET REQUIRED_SESSIONS TO 3

SET TOTAL_SCORE TO 0
SET SESSION_COUNT TO 0

FOR EACH SESSION_SCORE IN STUDY_SCORES
    ADD SESSION_SCORE TO TOTAL_SCORE
    ADD 1 TO SESSION_COUNT
END FOR

SET GOAL_MET TO CHECK_GOAL(
    TOTAL_SCORE,
    SESSION_COUNT,
    TARGET_SCORE,
    REQUIRED_SESSIONS
)

IF GOAL_MET IS TRUE
    DISPLAY "Goal met. Completion badge earned."
ELSE
    SET POINTS_REMAINING TO TARGET_SCORE MINUS TOTAL_SCORE
    DISPLAY "Goal not met yet."
    DISPLAY POINTS_REMAINING
    DISPLAY "more points are needed."
END IF

Trace the Loop Manually

With sample scores of 30, 35, and 40, the values change as follows:

At the end, the total is 105 and the session count is 3. Both conditions in CHECK_GOAL are true, so GOAL_MET becomes TRUE.

When you later select a programming language, its syntax and types may differ. It may use different punctuation, rules for setting up variables, or a different way to display text. The underlying plan remains the same: programs solve problems by storing values, repeating work, making decisions, and grouping reusable instructions into functions.

A useful next exercise is to change one rule at a time. Try rejecting scores below zero, calculating an average score, raising the target, or displaying a different message when the learner has enough points but too few sessions. Each variation reinforces the same core programming habits.