2.1.2 Computational Solution Design

Introduction

During computational thinking, developers use certain tools to design the solution before writing any code. These tools are called computational artifacts for solution design. The three most commonly used artifacts are algorithms, flowcharts, and pseudocode. Together, they serve as a structured and systematic representation of a computational process.

Definition

Computational solution design refers to the process of planning and representing a computational solution using standard artifacts such as algorithms, flowcharts, and pseudocode.

In simple words, it is the stage where we decide how we will solve the problem and represent that solution in a form that can later be converted into actual code.

Main Idea

Algorithms, pseudocodes, and flowcharts serve as a structured and systematic representation of a computational process. They help the developer move from the problem statement to a clear, logical solution without worrying about the syntax of any specific programming language.

Core Concept

The three computational artifacts used during solution design are:

• Algorithms — step-by-step instructions written in natural language
• Flowcharts — visual representation of flow and logic using defined symbols
• Pseudocode — semi-formal, structured representation between algorithm and actual code

These artifacts are used in a sequence, though the sequence can vary depending on the complexity of the problem and the developer's personal preference.

Detailed Explanation

Algorithms

While solving a problem using a computer, the first step is to think about the algorithm. An algorithm is a step-by-step set of instructions that defines how a specific problem should be solved. It is a high-level description of the solution without worrying about the implementation details such as specific programming language. Algorithms are normally written in natural language.

Example — Algorithm: Add Two Numbers

• Input two numbers, let's call them num1 and num2.
• Add num1 and num2 together.
• Store the result in a variable, let's call it sum.
• Output the value of sum.

Flowcharts

A flowchart is another tool used in the process of algorithm design. It provides a visual representation of flow and logic using defined symbols. Flowcharts are mostly helpful in explaining complex loops and decision-making processes.

Example — Flowchart: Add Two Numbers

• Start (Oval)
• Input num1 (Parallelogram)
• Input num2 (Parallelogram)
• sum = num1 + num2 (Rectangle)
• Output sum (Parallelogram)
• End (Oval)

Pseudocode

Once you have devised an algorithm, the next step is to create pseudocode. Pseudocode is an intermediate step between the algorithm and actual programming code. It is a more structured and semi-formal way of representing the algorithm using a combination of natural language and simplified programming constructs. Pseudocode helps in explaining the logic and structure of the algorithm before starting programming. It can be thought of as a detailed plan of how the algorithm should be implemented.

Example — Pseudocode: Add Two Numbers

``` //Step 1: Input two numbers Input "Enter the first number:" into num1 Input "Enter the second number:" into num2

//Step 2: Add the two numbers and store result in sum sum <- num1 + num2

//Step 3: Output the result Output "The sum of two numbers is:" sum ```

Sequence of Artifacts

The typical sequence is:

Algorithm → Flowchart → Pseudocode → Code

However, it is important to note that the above sequence can vary depending on the complexity of the problem and your personal preference. Some programmers may skip flowcharts and go directly from algorithms to pseudocode or even from algorithms to writing code, especially for simpler tasks.

Intermediate Level

Why Use These Artifacts?

Each artifact serves a specific purpose in the design process:

How Algorithms Differ from Pseudocode

• Algorithm is written in pure natural language — anyone can read it.
• Pseudocode uses some programming-like constructs (like `if`, `else`, `for`, `while`) but is still not tied to any specific language.
• Pseudocode is more structured and closer to actual code than an algorithm.

How Flowcharts Help

Flowcharts are especially useful when:

• The logic involves many decisions (if-else chains)
• There are loops that repeat certain steps
• The flow of control is not straightforward
• You need to explain the solution to someone visually

Common Flowchart Symbols

Formula / Mathematical Form

Not applicable for this topic.

Solved Example

Not applicable for this topic.

Important Points

• - Algorithms, pseudocodes, and flowcharts serve as a structured and systematic representation of a computational process.
• - An algorithm is a step-by-step set of instructions written in natural language.
• - A flowchart provides a visual representation of flow and logic using defined symbols.
• - Pseudocode is an intermediate step between the algorithm and actual programming code.
• - Pseudocode is a combination of natural language and simplified programming constructs.
• - The typical sequence is: Algorithm → Flowchart → Pseudocode → Code.
• - The sequence can vary depending on the complexity of the problem and personal preference.
• - Flowcharts are mostly helpful in explaining complex loops and decision-making processes.

Remember

• - Algorithm = Natural language, step-by-step.
• - Flowchart = Visual, uses standard symbols.
• - Pseudocode = Semi-formal, structured, closer to code.
• - Sequence can vary — not all artifacts are always required.
• - Flowchart symbols: Oval (Start/End), Parallelogram (Input/Output), Diamond (Decision), Rectangle (Process), Arrows (Flow), Circle (Connector).
• - Pseudocode is not standardized — no universal rules for formatting.

Common Mistakes

• - Confusing algorithm with pseudocode: An algorithm is pure natural language; pseudocode uses programming-like constructs.
• - Thinking flowcharts are always required: Some programmers skip flowcharts for simpler tasks.
• - Using the wrong flowchart symbols: Each symbol has a specific meaning — Oval for start/end, Diamond for decisions, etc.
• - Not following consistent indentation in pseudocode: While pseudocode is not standardized, consistent indentation improves readability.
• - Assuming one fixed sequence: The sequence of algorithm → flowchart → pseudocode can vary based on complexity and preference.
• - Writing pseudocode in a specific programming language: Pseudocode should be language-independent.

Quick Revision

Computational solution design uses three main artifacts:

• Algorithms — step-by-step instructions written in natural language
• Flowcharts — visual representation of flow and logic using defined symbols
• Pseudocode — intermediate step between algorithm and actual programming code

Algorithms, pseudocodes, and flowcharts serve as a structured and systematic representation of a computational process. The typical sequence is Algorithm → Flowchart → Pseudocode → Code, but this can vary depending on the complexity of the problem and personal preference.

Flowcharts are mostly helpful in explaining complex loops and decision-making processes. Pseudocode is a combination of natural language and simplified programming constructs.

60-Second Revision

• Computational Solution Design = Planning using algorithms, flowcharts, pseudocode.
• Algorithm = Natural language, step-by-step.
• Flowchart = Visual, uses symbols (Oval, Parallelogram, Diamond, Rectangle, Arrows, Circle).
• Pseudocode = Semi-formal, structured, between algorithm and code.
• Typical sequence: Algorithm → Flowchart → Pseudocode → Code.
• Sequence can vary — not all artifacts are always required.
• Warning: Do not confuse algorithm with pseudocode — algorithm is pure natural language.