Pseudocode: Planning and Communication in Software Development

Pseudocode is writing down the logic and steps of your code in plain English before you write the actual code in a programming language.
It helps you brainstorm, plan, and communicate the approach clearly without worrying about syntax.
The goal is to understand the problem’s logic first to avoid errors later.

Easy to write and quick to draft, helping you figure out the logic of a problem.
Facilitates communication of your approach to others who may not know programming syntax, such as nontechnical team members.
Saves time during the ideation phase of creating a program; you can talk through solutions on a whiteboard.
Useful in software engineering jobs at any level, including senior roles.
Recruiters sometimes view rushing into code without a plan (pseudocode) as a red flag during interviews.

Write each step of your code in plain English from top to bottom.
Use keywords to describe the control structures that would appear in Python (or another language).
For programs with output, describe the action with keywords like print or display rather than the actual Python function.
For programs with input, use keywords like read or get and describe how you'll prompt the user for input.
Describe calculations with everyday math terms (e.g., divide, multiply, add, subtract).
Describe variable assignment with terms like save, set, or store.
For conditional logic, use similar words to Python syntax, since Python is close to plain English for these statements.

Output: Python uses print(...); in pseudocode, describe as display or print when appropriate.
Input: Python uses input(...); in pseudocode, describe as read or get and indicate the prompt to the user.
Assignment: Python uses x = ...; in pseudocode, describe as save x, set x, or store x.
Calculations: Use natural language terms like add, subtract, multiply, divide.
Conditional logic: Use if, else, and an ending marker like end if (or equivalent) to describe blocks.
These keywords are designed to be intuitive and understandable by both technical and nontechnical stakeholders.

The talk mentions a Python attendance-tracker program.
To describe its conditional logic in pseudocode, you would outline the same logic in plain English with the same control structure keywords, without writing Python syntax.
The focus is on communicating the flow of decisions (e.g., when a student is present, increment attendance; otherwise handle a different case) rather than the exact Python code.

Project manager asks how we should implement a message to tell restaurant owners that they just got a new rating.
The mental model is to translate user input (the rating) into a notification to the restaurant owner based on the rating value.
This demonstrates how pseudocode helps teams discuss and plan solutions before committing to code.

On a whiteboard, a builder might use simple keywords and plain English to describe the entire logic from start to end.
The transcript notes that such a depiction can be hard for attendees to understand if the logic is not expressed in a clear, shared vocabulary.
Pseudocode serves as a bridge: easy for diverse audiences to understand while still guiding actual implementation.

The whiteboard sketch for a rating-based message is:
- prompt for rating
- Get the rating and make it a number
- If rating is greater than or equal to seven, display hooray
- Else, display Oh, no
- End if
This example uses plain English keywords to convey the flow of logic and decision points without Python syntax.

Threshold used in the example: $7$
Core condition expressed in math notation: $ext{rating} \ge 7$
Logical continuation: If $ext{rating} \ge 7$ then display "hooray"; else display "Oh, no". In LaTeX form, this can be written as:
$(\text{rating} \ge 7) \Rightarrow \text{display } \text{"hooray"}$
(\text{rating} < 7) \Rightarrow \text{display } \text{"Oh, no"}

Pseudocode is a foundational skill for effective communication in software development.
It helps bridge gaps between technical and nontechnical stakeholders, enabling collaborative problem solving.
Using pseudocode can streamline the design phase, reduce errors, and make interviews more informative (demonstrating planning ability).
The approach emphasizes thinking through the problem before worrying about syntax, which is especially valuable when collaborating across teams or explaining architecture decisions.

Aligns with foundational software engineering practices:
- Abstract planning before implementation
- Clear communication and documentation
- Iterative refinement of logic during design discussions
Supports ethical and practical considerations by making reasoning auditable and shareable among diverse team members.

Input: read / get
Output: display / print
Assignment: save / set / store
Calculations: use terms like add, subtract, multiply, divide
Conditionals: if, else, end if
Encourages planning and communication over jumping straight into language-specific syntax