Unit 7 The Power of Pseudocode and Flowcharts

Instructions

In this lesson, you'll learn about two essential tools that programmers use to plan their work before writing any actual code: pseudocode and flowcharts. As you read, pay attention to what these tools are, why they're important, and how they help programmers create better software. After each section, take a moment to reflect on the key concepts and think about how you might use these planning tools in your own programming projects.

Why Planning Matters in Programming

Imagine you’re about to build a complex LEGOⓇ model. Would you immediately start connecting pieces, or would you first look at the instructions? Most of us would choose to follow the instructions because planning ahead makes the building process smoother and helps avoid mistakes.

Programming works the same way. When programmers begin a new project, they don’t immediately start writing code. Instead, they take time to design their program first. This planning phase is crucial for creating successful software, and it’s a practice followed by all professional programmers.

The Program Development Cycle

Creating a program involves several steps, which together form what we call the program development cycle:

Design the program: Plan what the program will do and how it will work
Write the code: Translate the design into a programming language
Correct syntax errors: Fix any mistakes in the code’s grammar or structure
Test the program: Run the program to see if it works as expected
Debug: Find and fix any logical errors
Final program: The completed, working software

The first step—designing the program—is the foundation of the entire process. Just as a house built on a weak foundation will eventually develop problems, a program created without proper design will likely require extensive rework later.

Understanding the Task

Before you can design a program, you need to understand exactly what the program is supposed to do. Professional programmers typically work with a customer: the person, group, or organization that needs the program. The programmer interviews the customer to gather information about what the program should accomplish.

After gathering this information, the programmer creates a list of software requirements: specific functions the program must perform to satisfy the customer. Once the customer agrees that the requirements are complete, the programmer can move to the next phase: determining the steps needed to perform the task.

Breaking Down the Task

With a clear understanding of what the program needs to do, the programmer breaks down the task into a series of logical steps. This is similar to writing instructions for someone to follow.

For example, if you were explaining how to boil water, you might break it down like this:

Pour the desired amount of water into a pot
Put the pot on a stove burner
Turn the burner to high
Watch the water until it bubbles continually

This step-by-step breakdown is an example of an algorithm: a series of logical steps for completing a task or solving a problem. In programming, algorithms are the foundation of every program.

Let’s look at a simple programming example. If you were creating a program to calculate an employee’s gross pay (what they earn before any taxes or other money is withheld), your algorithm might look like this:

Get the number of hours worked
Get the hourly pay rate
Multiply the number of hours worked by the hourly pay rate
Display the result of the calculation

Breaking down tasks into clear, logical steps helps programmers understand exactly what their code needs to do. But how do programmers document these steps? That’s where pseudocode and flowcharts come in.

Pseudocode: Writing Code in Plain Language

When programmers design a program, they need a way to plan the code without worrying about strict syntax rules. This is where pseudocode comes in. The word “pseudo” means fake, so pseudocode is essentially “fake code;" it looks similar to real programming code, but is written in a more flexible, human-readable format.

What Is Pseudocode?

How to solve problems pseudocode heuristic — stockphotofan1 / Shutterstock

Pseudocode is an informal language that has no syntax rules and is not meant to be compiled or executed by a computer. Instead, it serves as a planning tool that helps programmers create models or “mock-ups” of their programs before writing actual code.

Think of pseudocode as a bridge between human language and programming language. It allows programmers to focus on the logic and structure of their program without getting bogged down in syntax details like semicolons, brackets, or indentation rules.

Benefits of Using Pseudocode

Using pseudocode offers several important advantages:

Focus on logic: Programmers can concentrate on solving the problem without worrying about syntax errors.
Language independence: Pseudocode isn’t tied to any specific programming language, so the same pseudocode can be translated into Java, Python, C++, or any other language.
Easier collaboration: Team members can understand and contribute to the program design even if they’re not familiar with the specific programming language that will be used.
Clearer thinking: Writing pseudocode forces programmers to think through the logic of their solution step by step.

How to Write Pseudocode

There are no strict rules for writing pseudocode, but it typically includes common programming operations written in a simplified way. Here’s an example of pseudocode for our pay calculation program:

Display "Enter the number of hours the employee worked."
Input hours

Display "Enter the employee's hourly pay rate."
Input payRate

Set grossPay = hours * payRate

Display "The employee's gross pay is $", grossPay

Notice how this pseudocode is easy to read and understand, even if you’re not a programmer. Each line represents an operation that can be performed in any high-level language:

“Display” statements show messages on the screen
“Input” statements read data from the keyboard
“Set” statements assign values to variables
Mathematical operations like multiplication (*) work as expected

While pseudocode doesn’t have strict syntax rules, it’s important to be consistent in your style. This makes it easier to translate the pseudocode into actual programming code later.

Flowcharts: Visualizing Program Logic

While pseudocode is an excellent text-based tool for program design, sometimes a visual representation can make the program’s logic even clearer. This is where flowcharts come in.

A flowchart is a diagram that graphically shows the steps that take place in a program, using different shapes connected by arrows to represent the flow of execution.

What Is a Flowchart?

A flowchart is a type of diagram that uses different shapes, connected by arrows, to show the sequence of steps in a process or program. In programming, flowcharts provide a visual map of how a program will execute, making it easier to understand the program’s logic at a glance.

Flowcharts use standardized symbols to represent different types of operations:

Ovals (terminal symbols): mark the beginning and end of the program
Parallelograms: represent input and output operations
Rectangles: represent processing steps (like calculations or variable assignments)
Diamonds: represent decision points where the program can take different paths

These symbols are connected by arrows that show the flow of execution from one step to the next.

Benefits of Using Flowcharts

Flowcharts offer several advantages in program design:

Visual clarity: The graphical nature of flowcharts makes program logic easier to understand, especially for visual learners.
Easy to follow: The arrows clearly show the path of execution, making it easy to trace through the program’s flow.
Identifying decision points: Flowcharts clearly show where the program makes decisions and the different paths that can result.

Communication tool: Flowcharts can be understood by non-programmers, making them useful for discussing program design with customers or team members from different backgrounds.

Creating a Simple Step-by-Step Process

Let’s create a step-by-step process for our pay calculation program. The program needs to:

Get the number of hours worked
Get the hourly pay rate
Calculate the gross pay
Display the result

In a simple step-by-step process, this would look like:

Start
The program begins.
Input: Get hours worked
Prompt the user to enter the number of hours worked.
Input: Get hourly pay rate
Prompt the user to enter their hourly wage.
Process: Calculate gross pay
Multiply the number of hours worked by the hourly pay rate to get the gross pay.
gross_pay = hours_worked * hourly_rate
Output: Display gross pay
Show the calculated gross pay to the user.
End
The program finishes.

Flowchart Connector Symbols

Sometimes a flowchart is too large to fit on a single page or in one column. In these cases, programmers use connector symbols to link different parts of the flowchart.

A connector symbol is a small circle with a letter or number inside it. It indicates that the flowchart continues at another location where the same connector symbol appears.

For larger flowcharts that span multiple pages, programmers use off-page connector symbols, which look like home plates in baseball. These symbols include page numbers to help readers follow the flowchart across different pages.

Putting It All Together

Now that we’ve explored pseudocode and flowcharts, let’s discuss how these tools fit into the broader context of program development and why planning is so crucial for successful programming.

Why Planning Before Coding Is Essential

Professional programmers invest time in planning for several important reasons:

Saves time overall: While planning takes time upfront, it saves much more time during coding and debugging. A well-designed program is easier to write and has fewer errors.
Reduces errors: By thinking through the logic before writing code, programmers can identify and fix potential problems early, when they’re easier to solve.
Improves program quality: Planned programs tend to be more efficient, reliable, and maintainable than those created without proper design.

Facilitates teamwork: When multiple programmers work on the same project, clear designs ensure everyone understands how the different parts of the program should work together.

Using Pseudocode and Flowcharts Together

Pseudocode and flowcharts complement each other, and many programmers use both tools when designing programs:

Pseudocode excels at detailing specific operations and calculations, making it useful for describing complex algorithms or mathematical operations.
Flowcharts are better at showing the overall structure and flow of a program, particularly when there are multiple decision points or branching paths.

By using both tools, programmers can create comprehensive designs that address both the detailed operations and the overall structure of their programs.

Select Next to Continue