Comprehensive Study Notes on Computational Thinking, Algorithms, and Python Programming

Computational Thinking Principles and Methods

• Computational thinking is an established problem-solving framework that utilizes a combination of logic and mathematics to solve complex problems.

• The three core methods of computational thinking are:

  • Abstraction

  • Decomposition

  • Algorithmic thinking

• Abstraction:

  • Verbatim definition: Focusing on the main parts of a problem and removing unnecessary detail.

  • Application: Requires identifying what information is relevant to solving a specific problem and filtering out whatever is not relevant, allowing sole concentration on the core objective.

  • Programming relevance: Prevents wasting time developing ideas or writing code that does not directly contribute to solving the original problem.

  • Scenario analysis: When analyzing a problem scenario, extract strictly the criteria specified for the solution and discard auxiliary metadata.

• Decomposition:

  • Verbatim definition: Breaking down a large, complex problem into smaller, manageable sub-problems that are easier to understand, solve, and deal with.

  • Primary benefits:

  • Smaller problems can be solved faster individually.

  • Sub-problems can be distributed among team members to accelerate overall development.

  • Solutions to smaller sub-problems feed back together to resolve the overarching primary problem.

  • Combined workflow: Abstraction is first applied to isolate relevant details; decomposition then divides the essential tasks across a team.

• Algorithmic Thinking:

  • Verbatim definition: Formulating an algorithm, which is a set of step-by-step instructions that can be followed to solve a problem.

  • Analogy: Comparable to following sequential instructions to brew a cup of tea, where actions must execute in the correct logical order.

  • Representations of algorithmic thinking include flowcharts, pseudocode, high-level programming languages, and exam reference language.

Practice Examination: Computational Thinking and Abstraction

• Problem Scenario:

  • A library uses a computer system to record book details: author, edition, book title, year published, and the number of times it has been borrowed.

  • The system computes a book rating based exclusively on the author and the number of times borrowed.

• Question 1: Define the term abstraction.

  • Solution: Focusing on the main parts of the problem and removing unnecessary detail.

• Question 2: Give one example of how abstraction is being used in the design of the rating system.

  • Solution: The design focuses solely on the author and the number of times borrowed, ignoring the edition and year published.

Algorithm Representation: Flowcharts and Pseudocode

• Fundamental Components of Algorithms:

  • Input: Data received from the user (prompted integers, strings, etc.) and assigned to variables.

  • Process: Operations, calculations, or instructions performed on data (e.g., mathematical arithmetic, variable assignments).

  • Output: Displaying processed information or messages back to the user to confirm outcomes.

• Standard Flowchart Symbols:

  • Oval / Terminator: Marks the absolute start or end of an algorithm.

  • Flow Arrows: Connect symbols and dictate the directional flow of control.

  • Parallelogram: Represents both input and output operations (e.g., input username, output welcome).

  • Diamond / Decision: Represents conditional branching; poses a comparison question leading to distinct paths (typically labeled Yes and No). Relational equality uses double equals ($==$).

  • Rectangle / Process: Represents operational instructions, data processing, variable assignments (e.g., $\text{num1} = 5$, $\text{num2} = 10$), and arithmetic calculations (e.g., $\text{total} = \text{num1} + \text{num2}$).

  • Subprogram Rectangle (rectangle with double vertical borders): Calls an external subroutine or parallel flowchart by its designated identifier.

• Flowchart Case Study: Login Verification System:

  • Process starts with an oval containing start.

  • Parallelogram inputs username into the variable username.

  • Parallelogram inputs password into the variable password.

  • Diamond evaluates condition: is username == "mister Moore CS".

  • If No: Outputs try again (parallelogram) and loops flow back to re-enter username.

  • If Yes: Moves to next decision diamond.

  • Diamond evaluates condition: is password == "Cool Beans".

  • If No: Outputs try again (parallelogram) and loops flow back to start.

  • If Yes: Outputs welcome (parallelogram).

  • Flow terminates at an oval containing end.

• Pseudocode Characteristics and Conventions:

  • Human-readable, structured language closely aligned with high-level languages like Python, serving as a universal design notation.

  • String concatenation merges text sequences together using the plus operator ($+$).

  • Practical Example 1:

  • Assign string "hello" to variable word1.

  • Assign string "everyone" to variable word2.

  • Concatenate into variable message: message = word1 + word2.

  • Practical Example 2:

  • word1 = "good"

  • word2 = "morning"

  • greeting = word1 + word2

  • repeats = 3

  • final_message = greeting * repeats

  • Flowchart representation consists entirely of sequential process rectangles terminated by an end oval.

Trace Tables and Loop Analysis

• Trace Table Purpose:

  • A systematic diagnostic grid designed to track changes in variable values and monitor outputs line-by-line during program execution.

  • Used primarily to trace execution steps, verify logic, and pinpoint exact points of runtime failure.

• Trace Walkthrough 1: Accumulator While Loop:

  • Pseudocode logic:

  • Initialize $\text{counter} = 1$, $\text{total} = 0$.

  • Loop condition: $\text{while } \text{counter} \le 5$.

  • Processing: $\text{total} = \text{total} + \text{counter}$; display $\text{total}$; increment $\text{counter} = \text{counter} + 1$.

  • Trace Execution Grid:

  • Iteration $1$: $\text{counter} = 1$, $\text{total} = 1$, $\text{output} = 1$.

  • Iteration $2$: $\text{counter} = 2$, $\text{total} = 3$, $\text{output} = 3$.

  • Iteration $3$: $\text{counter} = 3$, $\text{total} = 6$, $\text{output} = 6$.

  • Iteration $4$: $\text{counter} = 4$, $\text{total} = 10$, $\text{output} = 10$.

  • Iteration $5$: $\text{counter} = 5$, $\text{total} = 15$, $\text{output} = 15$.

  • Loop terminates because incrementing $\text{counter}$ to $6$ violates condition $\text{counter} \le 5$.

• Trace Walkthrough 2: Decrementing While Loop:

  • Pseudocode logic:

  • Initialize $\text{number} = 10$.

  • Loop condition: $\text{while } \text{number} > 0$.

  • Processing: display $\text{number}$; decrement $\text{number} = \text{number} - 3$.

  • Trace Execution Sequence:

  • Step $1$: $\text{number} = 10$, $\text{output} = 10$.

  • Step $2$: $\text{number} = 7$, $\text{output} = 7$.

  • Step $3$: $\text{number} = 4$, $\text{output} = 4$.

  • Step $4$: $\text{number} = 1$, $\text{output} = 1$.

  • Loop terminates after $\text{number}$ decrements to $-2$, making condition $\text{number} > 0$ false.

Sorting Algorithms

• Bubble Sort:

  • Mechanism: Traverses an unsorted list sequentially, comparing adjacent elements. If the element on the left is greater than the element on the right, they swap positions. Continues through the list until the end of the pass. Multiple passes execute until a full pass completes without any swaps.

  • Trace Example with dataset [2, 4, 1, 5, 3]:

  • Pass 1:

    • Compare $2$ and $4$: no swap ($2 < 4$).

    • Compare $4$ and $1$: swap ($4 > 1$) $\rightarrow [2, 1, 4, 5, 3]$.

    • Compare $4$ and $5$: no swap ($4 < 5$).

    • Compare $5$ and $3$: swap ($5 > 3$) $\rightarrow [2, 1, 4, 3, 5]$.

  • Pass 2:

    • Compare $2$ and $1$: swap ($2 > 1$) $\rightarrow [1, 2, 4, 3, 5]$.

    • Compare $2$ and $4$: no swap ($2 < 4$).

    • Compare $4$ and $3$: swap ($4 > 3$) $\rightarrow [1, 2, 3, 4, 5]$.

    • Compare $4$ and $5$: no swap ($4 < 5$).

  • Advantages: Simple to understand and implement; highly efficient on small or nearly sorted datasets.

  • Disadvantages: Inefficient and slow on large lists compared to merge sort.

• Merge Sort:

  • Mechanism: Applies a divide-and-conquer strategy. Successively divides an unsorted list into halves until each sub-list contains exactly one individual element. Pairs and merges adjacent elements in sorted order, repeating until all sub-lists are recombined into a single sorted list.

  • Trace Example with dataset [2, 8, 1, 4, 5, 3, 7, 6]:

  • Split 1: [2, 8, 1, 4] and [5, 3, 7, 6].

  • Split 2: [2, 8], [1, 4], [5, 3], and [7, 6].

  • Split 3 (individual elements): [2], [8], [1], [4], [5], [3], [7], [6].

  • Merge Level 1: [2, 8], [1, 4], [3, 5], and [6, 7].

  • Merge Level 2: [1, 2, 4, 8] and [3, 5, 6, 7].

  • Merge Level 3: [1, 2, 3, 4, 5, 6, 7, 8].

  • Advantages: Highly efficient for large datasets; consistent execution speed taking the same number of steps regardless of initial order.

  • Disadvantages: Requires additional working memory space; more complex to program.

• Insertion Sort:

  • Mechanism: Iterates through the list, taking one element at a time and comparing it backward against sorted items to its left until reaching a smaller value, inserting it into its correct position.

  • Trace Example with dataset [4, 6, 5, 3, 8, 2]:

  • Check $4$: first element; remains in place.

  • Check $6$: $6 > 4$; remains in place $\rightarrow [4, 6, 5, 3, 8, 2]$.

  • Check $5$: $5 < 6$; swaps left; $5 > 4$; stops $\rightarrow [4, 5, 6, 3, 8, 2]$.

  • Check $3$: $3 < 6$, $3 < 5$, $3 < 4$; swaps left to index $0$ $\rightarrow [3, 4, 5, 6, 8, 2]$.

  • Check $8$: $8 > 6$; remains in place $\rightarrow [3, 4, 5, 6, 8, 2]$.

  • Check $2$: $2 < 8$, $2 < 6$, $2 < 5$, $2 < 4$, $2 < 3$; swaps left to index $0$ $\rightarrow [2, 3, 4, 5, 6, 8]$.

  • Advantages: Exceptional performance when data is already nearly sorted; easy for beginners to understand and code.

  • Disadvantages: Becomes inefficient and degrades significantly in speed with large datasets.

• Comparative Practice:

  • Executing bubble sort on [3, 4, 1, 2, 5]:

  • Pass 1: Compare $3, 4$ (no swap); Compare $4, 1$ (swap $\rightarrow [3, 1, 4, 2, 5]$); Compare $4, 2$ (swap $\rightarrow [3, 1, 2, 4, 5]$); Compare $4, 5$ (no swap).

  • Pass 2: Compare $3, 1$ (swap $\rightarrow [1, 3, 2, 4, 5]$); Compare $3, 2$ (swap $\rightarrow [1, 2, 3, 4, 5]$); remaining elements sorted.

  • Evaluation: Merge sort is superior to bubble sort because it scales efficiently on large amounts of data, whereas bubble sort takes significantly more time.

Searching Algorithms

• Binary Search:

  • Absolute Prerequisite: The dataset must be sorted prior to execution.

  • Mechanism: Compares target value with the list midpoint. Halves the remaining search range on each step by discarding the irrelevant portion.

  • Midpoint Mathematical Calculation (zero-based index system):

  • Formula: $\text{midpoint} = (\text{left index} + \text{right index}) \text{ div } 2$.

  • The integer division operation (div) returns solely the whole number quotient, discarding decimal remainders.

  • Walkthrough 1 (Target: $18$ in an array with indices $0$ to $7$):

  • Left = $0$, Right = $7$.

  • Midpoint calculation: $(0 + 7) \text{ div } 2 = 3$.

  • Check index $3$: contains value $12$.

  • Since $18 > 12$, discard entire left side including index $3$ (indices $0, 1, 2, 3$).

  • New bounds: Left = $4$, Right = $7$.

  • Midpoint calculation: $(4 + 7) \text{ div } 2 = 5$.

  • Check index $5$: contains value $21$.

  • Since $18 < 21$, discard entire right side including index $5$ (indices $5, 6, 7$).

  • New bounds: Left = $4$, Right = $4$.

  • Midpoint calculation: $(4 + 4) \text{ div } 2 = 4$.

  • Check index $4$: contains value $18$. Target found.

  • Walkthrough 2 (Target: $7$ in an array with indices $0$ to $8$):

  • Left = $0$, Right = $8$.

  • Midpoint: $(0 + 8) \text{ div } 2 = 4$.

  • Value at index $4$ is greater than $7$. Discard right side including index $4$.

  • New bounds: Left = $0$, Right = $3$.

  • Midpoint: $(0 + 3) \text{ div } 2 = 1$.

  • Target $7$ identified at index $1$.

  • Advantages: Exceptionally fast for large datasets due to halving search space per step.

  • Disadvantages: Cannot execute on unsorted data; more complex to program.

• Linear Search:

  • Mechanism: Inspects elements sequentially starting at index $0$, checking one item at a time until the target is found or the end of the list is reached.

  • Advantages: Does not require data to be sorted; straightforward to program.

  • Disadvantages: Inefficient on large datasets (must check every element in worst-case scenario).

  • Selection Rationale: A linear search is more suitable than a binary search when handling an unsorted list because binary search cannot function without pre-sorting.

Python Language Fundamentals and Environment Setup

• Language Classification:

  • High-level programming language featuring syntax closely aligned with English vocabulary and grammar.

  • Significantly easier to read, write, and maintain compared to low-level languages.

  • Real-world applications: Application development, web platforms, artificial intelligence (AI), and automation.

• Integrated Development Environment (IDE):

  • A dedicated software suite providing development tools such as editors and debuggers.

  • Python 3.13 standard installation includes IDLE.

  • Operating Modes in IDLE:

  • Interactive Shell Mode: Executes single commands immediately upon pressing Enter (e.g., entering 2 + 10 instantly evaluates and displays 12).

  • Script Mode: Accessed via File -> New File. Provides a multiline code editor. Files must be saved before execution (triggered via Run -> Run Module or shortcut key F5).

• Output Statements and Syntax Rules:

  • Function: print() displays messages or results on screen.

  • Strings must be wrapped in quotation marks (which render green in IDLE).

  • Case Sensitivity: Python keywords must match exact casing. Entering Print() causes a syntax error (NameError: name 'print' is not defined), as Python syntax mandates all-lowercase print().

  • Execution Sequence: Statements execute top to bottom, line-by-line, unless redirected by control structures.

Variables, Data Types, and Maintainability

• Variables:

  • A reserved location in computer memory designated to hold data values that can be updated and retrieved during execution.

• Data Types:

  • String (str): Alphanumeric text sequences enclosed in quotation marks (e.g., "mister Moore").

  • Integer (int): Whole numbers without decimal components (e.g., 54).

  • Float / Real (float): Numbers containing fractional, decimal components (e.g., 8.5).

  • Boolean (bool): Binary logic values, strictly represented with capitalized first letters: True or False.

• Software Maintainability Principles:

  • White Space: Intentional blank lines between logical sections to increase code legibility.

  • Comments: Prefaced by a hash symbol (#). Comments are ignored by the Python interpreter and serve to explain code logic, variable purposes, or flag development areas.

  • Meaningful Identifiers: Assigning self-explanatory names matching stored data (e.g., hoursWorked = 8.5 rather than ambiguous letters like x = 8.5).

  • Camel Case Convention: Concatenating multi-word identifiers by capitalizing each word after the first (e.g., houseNumber).

• Output Combining:

  • Comma separation: print("nice to meet you,", surname) inserts an automatic space between arguments.

String Manipulation Techniques

• Operations Overview:

  • Length (len()): Evaluates total character count within a string, counting all spaces and symbols.

  • Example: For name = "Alice", len(name) outputs 5. For "Alice ", it outputs 6.

  • Case Modification:

  • .upper(): Converts entire string to uppercase (e.g., name.upper()). Requires empty parentheses.

  • .lower(): Converts entire string to lowercase (e.g., name.lower()).

  • String Slicing:

  • Uses square brackets [start:stop] based on zero-indexed character positions, extracting up to but not including the stop index.

  • Positive Slicing: name[0:3] on "Alice" returns the first three characters ("Ali").

  • Negative Slicing: Counts from the right end of the string. name[-3:] extracts the last three characters ("ice"). name[-3:-1] extracts "ic".

  • String Concatenation:

  • Combines strings using the plus operator (+).

  • Unlike comma-separated print statements, "Alice" + "Moore" yields "AliceMoore" without automatic whitespace.

Program Errors and Debugging Methodologies

• Error Classifications:

  • Syntax Error:

  • Definition: Occurs when code violates the structural, grammatical rules of the programming language.

  • Examples: Missing closing parentheses print("hello world", misspelling keywords, or capitalizing identifiers like Print().

  • Outcome: Prevents execution or crashes instantly on parsing.

  • Runtime Error:

  • Definition: Occurs while the program is actively executing, causing it to crash unexpectedly.

  • Common Cause: Incompatible user input violating type expectations. For example, applying integer casting int(input()) when a user inputs textual strings like "twenty" triggers: ValueError: invalid literal for int() with base 10: 'twenty'.

  • Logic Error:

  • Definition: Code executes without syntax errors and without crashing, but generates incorrect or unintended output.

  • Example: Inverting comparison operators in conditional checks, such as checking if an adult age is age <= 18 instead of age >= 18, misclassifying a $20$-year-old as a child.

• Debugging Techniques:

  • Definition: The iterative process of locating, diagnosing, and fixing errors within code.

  • Practices include:

  • Running code incrementally and frequently during development.

  • Interpreting error diagnostics, traceback messages, and highlighted line indicators.

  • Test execution with boundary, normal, and invalid test inputs.

  • Inserting diagnostic print() statements throughout code blocks to inspect variable states during execution.

Selection Constructs and Conditional Logic

• Selection Definition:

  • A fundamental programming construct that tests Boolean conditions to branch program execution down alternative pathways.

  • Executed using if, elif (else if), and else statements.

• Indentation and Syntax Rules:

  • Conditions terminate with a colon (:).

  • Indentation (uniform whitespace gap on subsequent lines) is mandatory in Python syntax to delineate blocks of code belonging to a branch.

• Relational and Logical Operators:

  • Relational: Equality ($==$), inequality ($!=$), greater than ($>$), less than ($<$), greater than or equal to ($\ge$), less than or equal to ($\le$).

  • Logical Operators: and (all conditions must evaluate true), or (at least one condition must evaluate true), not (inverts the Boolean result).

  • Critical Syntax Requirement: Compound conditions must re-state the variable explicitly:

  • Correct: if age >= 13 and age <= 18:

  • Incorrect: if age >= 13 and <= 18:

• Selection Case Studies:

  • Age Group Branching:

  • if age >= 13 and age <= 18: branches to teenager.

  • elif age > 18: branches to adult.

  • else: branches to child.

  • Input Validation Checks:

  • Checking empty input: if name == "": print("You didn't type anything").

  • Minimum length check: elif len(name) < 2: print("enter at least two characters").

Data Structures: Lists and Two-Dimensional (2D) Arrays

• Lists vs. Arrays:

  • Arrays: Require all stored elements to be of a single, identical data type.

  • Lists: Dynamic, mutable data structures capable of holding multiple elements of varying data types simultaneously.

• List Operations in Python:

  • Indexing: Elements are zero-indexed (list[0] references the first element).

  • Adding Elements: .append(value) inserts the value at the end of the list.

  • Removing Elements: .pop(index) removes the specific element located at the designated index.

• Two-Dimensional (2D) Arrays:

  • Formed by nesting lists within lists, conceptually mapping to a grid of rows and columns.

  • Syntax format: grid = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].

  • Accessing elements: grid[row_index][column_index].

  • Example: grid[0][2] references row $0$, column index $2$, accessing the integer $3$.

Iteration: Count-Controlled and Condition-Controlled Loops

• Iteration Concept:

  • A programming construct used to execute a block of code repeatedly.

• Count-Controlled Iteration (for loops):

  • Executes a predetermined number of iterations.

  • range(start, stop) function: Starts at start and terminates immediately before reaching stop.

  • Example: for x in range(1, 11): executes with $x$ taking values $1$ through $10$.

  • Automatically increments the tracking variable after each iteration.

  • Iterating through Data Collections:

  • Traversing lists: for fruit in fruits: sequentially processes each element.

  • Traversing strings: for letter in name: processes each individual character and whitespace in sequence.

• Condition-Controlled Iteration (while loops):

  • Verbatim definition: Repeatedly executes a block of code while a specified condition remains True; execution terminates once the condition evaluates to False.

  • Infinite Loops: Caused when code within the loop fails to modify the variable controlling the condition, leaving the condition indefinitely True.

  • Loop Control Patterns:

  • Counter-limited attempts: Combining input retry checks with an attempt counter ($\text{counter} < 3$).

  • Boolean flags: Looping over a state variable (e.g., while running:), setting running = False to terminate on a specific user response.

  • Break statements: Executing break to immediately exit the active loop structure upon satisfying an authentication condition.

Arithmetic Operators: Floor Division (Div) and Modulo (Mod)

• Definitions and Operations:

  • div (Integer Floor Division):

  • Calculates division and returns exclusively the integer quotient, completely discarding remainders.

  • Python Operator: Double forward slash (//).

  • Example: 10 // 3 evaluates to $3$.

  • mod (Modulo):

  • Calculates division and returns exclusively the remainder.

  • Python Operator: Percentage symbol (%).

  • Example: 10 % 3 evaluates to remainder $1$.

• Practical Applications:

  • Splitting time: // isolates whole hours, while % isolates leftover seconds.

  • Odd/Even Number Detection: Evaluating num % 2 == 0 confirms an even number (no remainder); a remainder of $1$ confirms an odd number.

Persistent File Handling in Python

• Purpose of File Handling:

  • Enables permanent data storage in secondary storage. Volatile variables stored in RAM disappear once program execution halts.

  • Used to preserve high scores, configuration settings, and user logs between sessions.

• File Access Modes:

  • Write Mode ("w"):

  • Creates the specified file if it does not exist.

  • Overwrites and destroys all existing content within the file if it already exists.

  • Append Mode ("a"):

  • Appends new records directly to the end of the existing file without overwriting earlier content.

  • Read Mode ("r"):

  • Opens an existing file strictly to extract and process data.

• Operations and Methods:

  • Open: file = open("filename.txt", "mode").

  • Write: file.write("string ") (the escape character inserts a newline to prevent concatenation of adjacent lines).

• Read single lines: file.readline() reads one line at a time sequentially.

• Read all lines: file.readlines() reads all file content into a list of strings.

• Close: file.close() releases system locks and finalizes file writes.

Modular Programming: Subroutines (Procedures and Functions)

• Subroutine Overview:

  • Self-contained blocks of code designed to perform specific tasks, enabling modular code reuse and organization.

  • Declared using the def keyword followed by the subroutine name, parameter brackets, and a colon.

• Procedures vs. Functions:

  • Procedure: A subroutine that performs an operational task but does not return any value back to the calling code.

  • Function: A subroutine that performs processing and explicitly returns a value back to the calling code using the return keyword.

• Scope Definitions:

  • Local Scope: Variables instantiated inside a subroutine. They exist only while that subroutine executes and cannot be accessed externally.

  • Global Scope: Variables instantiated within the main program body, accessible anywhere across the entire script.

• Parameters and Arguments:

  • Parameters: Placeholder identifiers declared in the subroutine definition brackets (e.g., def get_area(width, height):).

  • Arguments: Concrete data values passed into the subroutine parameters when called (e.g., get_area(5, 10)).

Defensive Design, Misuse Prevention, and Validation

• Defensive Design Principles:

  • Proactive design practices to ensure a system functions reliably, preventing crashes caused by accidental user error or malicious tampering.

• Anticipating Misuse:

  • Blank input handling: Checking for empty strings (if input == "":).

  • Input range restriction: Rejecting inputs outside allowable options (e.g., forcing menu selections between $1$ and $3$).

• Authentication Systems:

  • Verifying user identity before granting access (e.g., username and password checks).

  • Brute Force Prevention: Limiting consecutive failed attempts using an attempt counter to lock out unauthorized users.

• Data Validation Techniques:

  • Range Check: Verifies numerical data falls within defined lower and upper bounds (e.g., ensuring entered age satisfies $0 \le \text{age} \le 120$).

  • Length Check: Verifies data matches exact length constraints (e.g., requiring bank PIN to equal four digits: len(pin) == 4).

  • Type Check: Confirms entered data matches the expected data type (e.g., utilizing .isdigit() to confirm an input contains purely numeric characters prior to casting to integer).

  • Format Check: Verifies that data complies with a predetermined structural format.

Software Testing Methodologies and Test Data

• Testing Categories:

  • Iterative Testing: Continuous testing conducted dynamically throughout the development lifecycle as individual modules are coded, catching bugs early.

  • Terminal / Final Testing: Comprehensive testing conducted at the conclusion of development to verify that the complete program fulfills original requirements.

• Test Data Classifications:

  • Normal Test Data: Sensible, typical data within the allowed range expected by the program (e.g., entering $45$ for a test score valid from $0$ to $100$).

  • Boundary Test Data: Values positioned at the absolute extreme edges of acceptable parameters (e.g., exactly $0$ and $100$ for a $0$-$100$ scale).

  • Invalid Test Data: Out-of-bounds data of the correct data type that violates logic criteria and must be rejected (e.g., entering $-10$ or $121$).

  • Erroneous Test Data: Data of the incorrect data type that violates data constraints (e.g., entering the string "one hundred" instead of an integer).

Boolean Logic, Logic Gates, and Truth Tables

• Core Definition:

  • Boolean logic operates on binary values: True ($1$) and False ($0$), governing hardware decisions and logic circuits.

• Primary Logic Gates:

  • NOT Gate:

  • Inverts a single input to its opposite state.

  • Circuit Symbol: Triangle with an inversion circle on the right output tip.

  • Boolean Notation: $P = \text{not } A$ or $P = \neg A$.

  • Truth Table: Input $A = 1 \rightarrow P = 0$; Input $A = 0 \rightarrow P = 1$.

  • AND Gate:

  • Output is $1$ if and only if all inputs are $1$.

  • Circuit Symbol: Straight back with a curved, D-shaped front.

  • Boolean Notation: $P = A \text{ and } B$ or $P = A \wedge B$.

  • Truth Table: Output is $0$ for $(0,0)$, $(0,1)$, $(1,0)$; Output is $1$ exclusively for $(1,1)$.

  • OR Gate:

  • Output is $1$ if at least one input is $1$.

  • Circuit Symbol: Curved back with a pointed shield front.

  • Boolean Notation: $P = A \text{ or } B$ or $P = A \vee B$.

  • Truth Table: Output is $0$ exclusively for $(0,0)$; Output is $1$ for $(0,1)$, $(1,0)$, $(1,1)$.

• Logic Circuit Practice Combinations:

  • Circuit 1 ($P = (\text{not } A) \text{ and } B$):

  • Input $A$ feeds through a NOT gate, producing $\text{not } A$.

  • Output $\text{not } A$ and Input $B$ feed into an AND gate.

  • Output $P = 1$ exclusively when $A = 0$ and $B = 1$.

  • Circuit 2 ($\text{not } A \text{ or } B$):

  • Input $A$ feeds into a NOT gate; the inverted output and Input $B$ feed into an OR gate.

  • Circuit 3 ($\text{not } B \text{ and } A$):

  • Input $B$ feeds into a NOT gate; the inverted output and Input $A$ feed into an AND gate.

Programming Languages: High-Level vs. Low-Level

• High-Level Languages:

  • Characteristics: Resemble human languages, portable across different computer hardware systems, and easier to debug and maintain.

  • Examples: Python, Java, C#, Visual Basic (VB).

  • Execution Constraint: Cannot execute directly on computer hardware; must undergo translation into binary machine code.

• Low-Level Languages:

  • Machine Code: Pure binary ($0$s and $1$s); executes directly by the CPU at maximum speed; processor-specific and difficult for humans to read or write.

  • Assembly Language:

  • Sits just above machine code; uses mnemonics (short text commands like MOV to transfer data to registers, or ADD to execute addition).

  • Requires an Assembler to translate mnemonics into executable machine code.

  • Applications: Embedded systems, operating system development, hardware device drivers, and direct CPU hardware control.

Program Translators: Compilers vs. Interpreters

• Role of Translators:

  • Software converting high-level source code into binary machine code for CPU execution.

• Compilers:

  • Mechanism: Translates the complete source program in a single batch operation prior to execution.

  • Output: Produces a standalone, machine-executable file.

  • Advantages:

  • Fast execution speed once compiled, requiring no re-translation.

  • Protects intellectual property, as the original source code does not need to be distributed.

  • Disadvantages:

  • Initial compilation of large programs is time-consuming.

  • Compiles all errors into a list only after attempting to translate the entire program.

• Interpreters:

  • Mechanism: Analyzes, translates, and executes source code line-by-line sequentially.

  • Output: Does not produce an independent executable file; source code must be present.

  • Advantages:

  • Superior debugging environment; execution halts immediately upon encountering an error, isolating the fault location.

  • Disadvantages:

  • Slower execution speed because translation occurs concurrently on every run.

  • Source code must be distributed to end users.

Tools of an Integrated Development Environment (IDE)

• Core Definition:

  • A comprehensive software suite that supplies developers with tools to write, test, and debug code.

• Fundamental IDE Tools:

  • Source Code Editor:

  • Syntax Highlighting: Automatically colors keywords, strings, variables, and operators to verify correct spelling and structure.

  • Auto-Indentation: Indents code automatically following colons, preventing syntax errors.

  • Code Auto-Complete: Suggests matching functions and keywords as characters are typed.

  • Line Numbering: Numbers code lines to help locate flagged syntax and logic errors.

  • Error Diagnostics:

  • Identifies syntax errors, highlights points of failure, and prints error diagnostic strings with suspected line numbers.

  • Runtime Environment:

  • Provides an integrated console or shell (e.g., IDLE Shell) to run, test, and view output immediately within the environment.

  • Built-in Translators:

  • Integrated compilers and interpreters enabling immediate code translation and execution.