9.3 Programming Logic, Control Flow & Data Structures

Programming Logic, Control Flow & Data Structures

Core Foundation: Computer software achieves meaningful work by directing how instructions execute over time. By default, computer programs execute sequentially from top to bottom, one statement after another. To solve complex problems, developers introduce control flow structures: branching logic to make decisions, loops to repeat operations, data structures to organize related information, and subroutines to structure code modularly.

---

Organizational Techniques: Algorithms, Pseudocode & Flowcharts

Before writing code in a formal programming language, software engineers organize their logic using standardized design abstractions that are independent of any specific language syntax.

1. Algorithms

An algorithm is a finite, unambiguous, step-by-step sequence of instructions designed to solve a specific problem, perform a computational calculation, or process data.

• Properties of a Valid Algorithm:
  • Finiteness: The algorithm must terminate after a countable, finite number of steps; it cannot loop indefinitely.
  • Definiteness: Every individual instruction must be clear, precise, and completely unambiguous.
  • Input & Output: Accepts zero or more clearly defined inputs and produces one or more verified outputs.
  • Effectiveness: Every operation must be feasible and computationally possible on standard hardware.

2. Pseudocode

Pseudocode is a high-level, human-readable representation of program logic that combines structured programming constructs with plain English natural language. It allows developers to design algorithms without worrying about strict language syntax, semicolons, or memory declarations.

ALGORITHM CalculateInvoiceTotal
  INPUT: subtotal, customerState
  OUTPUT: finalTotal

  SET taxRate = 0.0
  IF customerState == "CA" THEN
    SET taxRate = 0.0725
  ELSE IF customerState == "NY" THEN
    SET taxRate = 0.08875
  ELSE
    SET taxRate = 0.05
  END IF

  SET calculatedTax = subtotal * taxRate
  SET finalTotal = subtotal + calculatedTax
  RETURN finalTotal
END ALGORITHM

3. Flowcharts

A flowchart is a standardized diagrammatic representation that visualizes the sequential steps, decisions, and data movements of a program algorithm. Standardized by the American National Standards Institute (ANSI) and the International Organization for Standardization (ISO), flowcharts use specific geometric shapes to represent different operational tasks:

• Oval / Rounded Rectangle (Terminator): Signifies the entry (Start) or exit (End / Stop) point of an entire program or a discrete subroutine.
• Rectangle (Process): Represents an internal computational action, data transformation, or variable assignment (e.g., SET total = count * price).
• Diamond (Decision): Represents a conditional evaluation or branching question that tests a logical predicate. It has one incoming flowline and two or more outgoing flowlines labeled with outcomes (typically True/False or Yes/No).
• Parallelogram (Input / Output): Represents an operation that receives external input into the system (e.g., reading keyboard entry, capturing a barcode scan) or sends output to an external destination (e.g., displaying text on a monitor, sending a page to a printer).
• Directed Arrows (Flowlines): Connect symbols to indicate the precise chronological sequence of execution.

---

Comments, Documentation & Sequence

Comments explain intent for human readers and are normally ignored by the compiler or interpreter. Good comments record why a non-obvious choice exists; they should not merely repeat a clear statement, and they must be updated when code changes. Broader documentation may describe inputs, outputs, dependencies, error conditions, algorithms, and setup procedures so another developer can safely maintain the program.

Sequence is the default logic pattern: statements execute in their written order unless a branch, loop, function call, exception, or other control transfer changes the path. In a flowchart, ordinary process boxes connected top-to-bottom demonstrate sequence; a decision diamond introduces branching.

Boolean Logic, Relational Operators & Truth Tables

Computer decision-making relies on Boolean logic, evaluating expressions that resolve strictly to either true or false.

1. Relational (Comparison) Operators

Relational operators compare two values or expressions and return a boolean truth state:

• == (Equal To): Returns true if operands have identical values (5 == 5 is true).
• != (Not Equal To): Returns true if operands have different values (5 != 3 is true).
• < (Less Than) and > (Greater Than): Tests relative numeric magnitude.
• <= (Less Than or Equal To) and >= (Greater Than or Equal To): Inclusive boundary tests.

2. Logical Operators

Logical operators combine multiple relational comparisons into compound logical expressions:

• Logical AND (&& or AND): Evaluates to true only if BOTH operands are true. If either operand is false, the entire expression evaluates to false.
• Logical OR (|| or OR): Evaluates to true if AT LEAST ONE operand is true. It evaluates to false only if both operands are false.
• Logical NOT (! or NOT): A unary operator that inverts the logical truth state. If an expression is true, NOT makes it false; if false, NOT makes it true.

Standard Boolean Truth Table

• Compound Expression Walkthrough: Consider the security rule: (userAge >= 18 && hasPhotoID == true) || hasAdminOverride == true.
  • If userAge is 16 and hasPhotoID is true, the left sub-expression (16 >= 18 && true) evaluates to (false && true) = false.
  • However, if hasAdminOverride is true, the overarching expression evaluates to false || true, resolving successfully to true.
• Short-Circuit Evaluation: Modern programming runtimes optimize boolean evaluation through short-circuiting. In an AND expression, if the first operand evaluates to false, the system skips evaluating subsequent operands because the expression can never be true. In an OR expression, if the first operand is true, subsequent evaluations are bypassed immediately.

---

Control Flow: Branching & Conditional Logic

Branching structures allow a computer to choose different execution paths depending on the evaluation of boolean conditions.

1. if and if-else Branching

• Single-Path if Statement: Tests a condition; if true, it executes an inner block of code. If false, the block is bypassed entirely.
• Two-Path if-else Statement: Provides a fork in execution. If the condition is true, the if block executes; if the condition is false, the alternative else block executes.
• Cascading if-else if-else Ladder: Evaluates a series of mutually exclusive conditions sequentially until one evaluates to true. If none evaluate to true, the final fallback else block executes.

2. switch / case Statements

When a program must evaluate a single discrete variable against dozens of possible constant values, cascading if-else ladders become unreadable and inefficient. A switch statement evaluates an expression once and branches directly to the matching case block.

• The break Statement: At the end of each case block, a break keyword transfers control immediately outside the switch structure. Omitting a break statement causes fall-through, where execution cascades into the next case's instructions regardless of whether that case matches.
• The default Block: Functions like the final fallback else clause, executing only when none of the explicit case values match the evaluated variable.

SWITCH (userRole)
  CASE "Admin":
    GRANT fullSystemAccess()
    BREAK
  CASE "Manager":
    GRANT reportingAccess()
    BREAK
  CASE "Guest":
    GRANT readOnlyAccess()
    BREAK
  DEFAULT:
    DENY allAccess()
    LOG securityAlert("Unrecognized role")
END SWITCH

---

Iterative Structures: Loops & Hazards

Iterative structures (loops) automate repetitive computational tasks by executing a block of code multiple times until a terminating condition is met.

1. Count-Controlled Loops: The for Loop

A for loop is a count-controlled loop used when the program knows in advance how many times an operation must execute (such as iterating through every element in an array of 50 items).

• Three Control Expressions:
  1. Initialization: Initializes a loop counter variable (e.g., let i = 0).
  2. Condition: Evaluated before every iteration; the loop continues as long as this evaluates to true (e.g., i < 10).
  3. Step / Increment: Modifies the counter at the end of every iteration (e.g., i = i + 1 or i++).

2. Condition-Controlled Loops: while vs. do-while

Condition-controlled loops repeat based strictly on a boolean condition, rather than a fixed counter.

• The while Loop (Pre-Test Loop):

  • Evaluates its terminating condition BEFORE executing the loop body.
  • If the condition is false on the very first check, the loop body executes zero times.
  • Use Case: Reading data from a network stream where the stream may already be empty upon arrival.

• The do-while Loop (Post-Test Loop):

  • Executes the loop body first, and evaluates the terminating condition AFTER the loop body finishes.
  • Because the check occurs at the end, the loop body is guaranteed to execute AT LEAST ONCE, regardless of whether the condition is true or false initially.
  • Use Case: Prompting a user to enter their password or PIN on an ATM screen. The keypad and prompt must display at least once before testing whether the entered PIN matches.

3. Loop Control Statements

• break: Terminates the entire loop immediately, transferring execution to the first statement following the loop.
• continue: Immediately halts the remainder of the current iteration, jumping directly to the condition test and increment step for the next iteration.

4. The Infinite Loop Hazard

An infinite loop occurs when a loop's terminating condition never evaluates to false. This typically happens when the developer forgets to increment the counter variable, writes a faulty comparison, or hardcodes a static while (true) loop without an internal break exit.

• Consequences: The loop locks an entire CPU core thread at 100% utilization, starves other processes of processor cycles, causes the application to freeze, and can lead to out-of-memory crashes.

---

Core Data Structures: Organizing Information in Memory

Data structures define how related data values are organized, linked, and accessed within computer memory.

1. Arrays

An array is a fixed-size, sequential collection of elements of the same data type stored in contiguous (adjacent) physical memory locations.

• Zero-Indexed Access: Arrays are indexed starting at zero (0). For an array of size $N$, the first element is located at index [0], the second element at index [1], and the final element at index [N - 1].
• Instant Random Access ($O(1)$ Time): Because elements are stored in contiguous memory and have identical bit sizes, the processor can calculate the exact physical memory address of any element instantly using the formula: $\text{Memory Address} = \text{Base Address} + (\text{Index} \times \text{Element Size})$
• Limitation: In static languages, an array's size is fixed at allocation. An array created with 10 elements cannot expand to hold an 11th element.

2. Lists and Vectors (Dynamic Arrays)

A list (or vector / dynamic array) is a linear collection of elements that can dynamically grow and shrink in size during program execution.

• When elements are appended to a list that has reached its internal memory threshold, the runtime engine automatically allocates a larger contiguous memory buffer, copies existing elements over, and frees the old buffer.
• Example: Python list, Java ArrayList, or C++ std::vector.

3. Key-Value Pairs / Dictionaries / Hash Maps

A dictionary (also known as a hash map, associative array, or key-value store) organizes data into pairs of unique keys mapped to specific values.

• Unlike arrays (which access data using sequential numeric integers 0, 1, 2), dictionaries access data using unique descriptive keys (typically strings).
• Example: userProfile = { "username": "alex99", "email": "alex@corp.com", "role": "Auditor" }. Accessing userProfile["role"] returns "Auditor" instantly.

---

Modular Programming: Subroutines, Scope & Object-Oriented Concepts

To build maintainable software, engineers break monolithic programs into smaller, reusable building blocks.

1. Subroutines: Functions and Methods

A function (or procedure / subroutine) is a named, self-contained block of reusable code that performs a specific operational task.

• Parameters vs. Arguments:
  • Parameters: The formal variable names declared in the function's definition signature (e.g., function calculateTax(price, rate)).
  • Arguments: The actual, concrete values passed into the function when it is invoked (e.g., calculateTax(100.0, 0.08)).
• Return Values: When a function completes its execution, it sends a value back to the calling statement via a return keyword.

2. Variable Scope: Local vs. Global

Scope defines the visibility and operational lifetime of a variable within a program's codebase:

• Local Scope: Variables declared inside a function or block. They are created on the thread's call stack when the function begins and destroyed when the function exits. They cannot be accessed or altered by code outside that function.
• Global Scope: Variables declared outside all functions at the root program level. They remain in memory throughout the entire execution lifetime of the application and are accessible from any subroutine.
• Engineering Best Practice: Overusing global variables is a major technical antipattern. Global variables create tight coupling, unpredictable side effects, and race conditions in multithreaded applications. Developers should prioritize local scoping.

3. Object-Oriented Programming (OOP) Concepts

Object-Oriented Programming (OOP) is an industry-standard programming paradigm that organizes software design around data entities—called objects—rather than procedural functions and standalone logic.

• Class (The Blueprint): A class is an abstract template, definition, or prototype that specifies what data an entity will contain and what actions it can perform. A class does not occupy active object memory; it is merely the structural blueprint.
• Object (The Instance): An object is a concrete, individual entity instantiated in active memory from a class blueprint. Creating an object is termed instantiation (e.g., let account1 = new BankAccount();).
• Attributes / Fields (State Data): Variables defined within a class that store the internal state or characteristics of an object (e.g., accountNumber, accountBalance, ownerName).
• Methods (Behaviors): Functions defined within a class that define the actions or behaviors an object can execute, often manipulating its internal attributes (e.g., deposit(amount), withdraw(amount)).

+-------------------------------------------------------------------------+
|                         CLASS: BankAccount                              |
|                                                                         |
|   ATTRIBUTES (State / Fields):                                          |
|     - accountNumber: String                                             |
|     - balance: Float                                                    |
|                                                                         |
|   METHODS (Behavior / Functions):                                       |
|     + deposit(amount)                                                   |
|     + withdraw(amount)                                                  |
+-------------------------------------------------------------------------+
                                     │
                       Instantiates (Creates in RAM)
                                     ▼
+-------------------------------------------------------------------------+
|                        OBJECT: account1 (Instance)                      |
|   accountNumber = "ACT-8841"                                            |
|   balance = $1,450.00                                                   |
+-------------------------------------------------------------------------+

---

Practical Diagnostic Scenarios & Exam Pitfalls

• Trap 1: The Off-by-One Array Index Error. In zero-indexed languages, the last element of an array with 10 elements is at index [9], not [10]. Attempting to access array[10] results in an IndexOutOfBoundsException or memory violation crash.
• Trap 2: Confusing while with do-while Execution Counts. Remember that a pre-test while loop can execute 0 times if the condition evaluates to false immediately. A post-test do-while loop is guaranteed to execute at least 1 time because the condition is evaluated at the end.
• Trap 3: Omitting break in a switch Statement. Forgetting a break keyword at the end of a case block causes accidental "fall-through," executing subsequent cases until a break is encountered.
• Trap 4: Confusing a Class with an Object. A class is the non-physical architectural blueprint (like the schematic drawing of a building); an object is the tangible, memory-consuming entity instantiated from that blueprint (like the physical skyscraper itself).