Четверг Computational Thinking, Algorithmic Problem Design, and Boolean Logic

Problem Design, Scoping, and Fundamentals of Computation

• Problem Definition and Objectives:

  • Problem-solving begins with identifying an underlying concern and translating it into a clearly defined problem and objective.
  • Exemplar scenario: Alleviating the operational concern of arriving late to class.
  • Defined system objective: Reduce the average order-to-collection time (the duration elapsed between placing an order and receiving the food/item).
  • Process focus: The specific operational stage under evaluation is strictly from order placement to final collection.

• Constraints and Quantification:

  • System constraints: Existing personnel, staff, and physical equipment within the facility are fixed assets that cannot be altered or replaced.
  • Need for quantitative measurement: System evaluations require concrete numeric quantities. Vague instructions (e.g., instructing someone to take "a few steps" without specifying the exact step count or a stopping condition) lead to unbounded execution where the action continues indefinitely until an external halt command is issued.
  • Metric of performance: Minutes elapsed between payment confirmation and order collection.
  • Operational scope: Restricted to weekday lunch service. Setting an operational scope or problem definition too wide prevents measurable progress and feasible implementation.

• Modularity and Computational Thinking:

  • Sub-objectives: Complex programs, tools, modules, and user interfaces are partitioned into smaller, discrete objectives. Each component or application icon is engineered to fulfill an exact sub-goal that directs the user to their target outcome.
  • Frequent measurement: Frequent tracking against established metrics is necessary to observe and verify system improvement over time.
  • Definition of computation: The systematic application of defined operations to structured information.
  • Departure time computation model:
  • Required arrival time: $9:00\text{ AM}$.
  • Estimated transit duration: $45\,\text{minutes}$.
  • Computational operation: Subtracting $45\,\text{minutes}$ from the arrival deadline of $9:00\text{ AM}$.
  • Resulting computed departure time: $8:15\text{ AM}$.

Algorithms, Programs, and Execution Assumptions

• Distinction Between Procedures and Programs:

  • Procedure (Algorithm): A structured sequence of precise instructions executed to complete a specific task.
  • Door-opening algorithmic sequence: Stand up, take $2$ steps forward, turn left, and walk $10$ paces toward the departure point.
  • Program: A concrete tool or interface bridging the algorithm and the end user, wherein instructions are formally encoded in an executable programming language.
  • Language independence: While programs may be written in various programming languages, they execute the identical underlying algorithmic logic.

• The Role of Context and Implicit Assumptions:

  • Human communication relies heavily on shared context and unstated assumptions (e.g., knowing the contextual definition of "coffee" and the implied expectations of the person requesting it).
  • Dangers in algorithmic execution: Ambiguous instructions (such as "add coffee") introduce unverified assumptions regarding whether the ingredient should be instant coffee or ground coffee.
  • Excessive assumptions undermine algorithmic precision, causing systemic failures and hallucinations.

• Observables and Termination States:

  • Completion observables: Systems require explicit indicators to signify task completion.
  • Automated appliance: Emits an auditory signal (a beep) upon cycle completion.
  • Traditional method (e.g., a traditional pot for brewing Turkish coffee): Requires specific observable visual benchmarks to confirm readiness and terminate the process.

• Cafe Operational Procedure:

  • Step 1: Record the specific item requested by the customer.
  • Step 2: Confirm and validate payment processing.
  • Step 3: Prepare the ordered items according to specification.
  • Step 4: Match the prepared items against the original customer order.
  • Step 5: Notify the customer that the order is ready for collection.

• Core Evaluation Criteria for Computational Solutions:

  • Problem decomposition: Computational thinking resolves broader concerns by decomposing them into tangible questions and modular tasks, each directed toward an explicit objective.
  • Correctness: The foundational prerequisite; without verified correctness, subsequent development cannot proceed.
  • Resource efficiency: Deployed programs running on remote servers or cloud computing environments consume physical infrastructure resources (computational energy, processor cycles, and network bandwidth). Inefficient code increases consumption, incurring higher financial costs for cloud resources.

Program Specification, Termination, and Tracing

• Instruction Delivery and Error Propagation:

  • Transferring workflows: Delivering a personal procedure to colleagues without precise documentation often leads to execution failure, as different individuals apply disparate cognitive models.
  • Absence of explicit instruction forces agents to introduce personal assumptions, directly causing procedural errors.
  • Mitigation: Procedures must be defined with total precision to eliminate ambiguity.

• Boundary Conditions and Termination:

  • Program termination criteria: Programs must explicitly define end conditions, instructing execution to halt either upon finding a matching result or upon reaching the end of a dataset.
  • Search mechanism analogy: Text search functionality within spreadsheet software (such as Ctrl + F or Cmd + F) relies on rigidly demarcated boundaries to determine where the search begins, where it queries, and where it terminates.

• Debugging and Tracing:

  • Debugging methodology: Involves retracing all executed operational steps in sequence to isolate and diagnose the origin of an anomaly or failure.
  • Multi-item state tracking example: Initializing a procedure configured to process an initial trigger state consisting of $3$ mugs/cups of coffee alongside breakfast cookies.

Questions & Discussion

• Student Inquiry Regarding Submission Attempts:
  • Student: Stated that they attempted the submission $3$ times.
  • Instructor Response: Confirmed that the student's name will be recorded on the system roster and verified directly without concern.

Boolean Logic, Relational Operators, and Compound Conditions

• Logical Expressions and Assertions:

  • Interrogative questions versus assertions: The question "Is the coffee open?" resolves to an explicit truth value ($\text{True}$ or $\text{False}$ / $\text{Yes}$ or $\text{No}$).
  • Subjective assertions: A statement such as "The coffee is nice" cannot serve as an algorithmic condition without quantifiable operational metrics (e.g., an average customer review score threshold of $4$ or $5$).

• Relational Comparison Operators:

  • Comparison expressions evaluate whether an operational condition holds $\text{True}$ or $\text{False}$.
  • Numerical comparison evaluation:
  • Given the current variable state: $\text{hours} = 3$.
  • Evaluated conditional test: $\text{hours} < 3$.
  • Evaluation result: The relational expression evaluates to $\text{False}$, as $3$ is not strictly less than $3$.

• Logical Operators (AND vs. OR):

  • Conjunction (AND): Connects multiple conditions, evaluating to $\text{True}$ if and only if all conjoined conditions are satisfied simultaneously (represented by the overlapping intersection in Venn diagrams).
  • Disjunction (OR): Evaluates to $\text{True}$ if at least one constituent condition is satisfied, or if all are satisfied simultaneously (represented by the union across sets in Venn diagrams).
  • Discount eligibility scenario:
  • Condition 1: Individual is a verified student.
  • Condition 2: Individual is under $18\,\text{years of age}$.
  • Under an AND operator: A discount is applied exclusively if an individual is concurrently a student and strictly under $18\,\text{years of age}$.
  • Under an OR operator: A discount is applied if the patron is a student, if the patron is under $18\,\text{years of age}$, or if the patron satisfies both criteria simultaneously.

Complex Compound Expressions and Branching Control Structures

• Logical Negation (NOT):

  • The NOT operator inverts the truth value of a given proposition.
  • Account suspension state:
  • Condition $s$ represents an account that is suspended.
  • Condition $\text{not } s$ represents an account that is not suspended.
  • If an entry rule mandates $\text{not } s$, an account with an active suspension ($s = \text{True}$) fails the requirement.

• Analysis of Compound Logical Expressions:

  • Target Boolean formula: $A \land (B \lor G) \land \neg S$

• Term $A$: Valid entry point.

• Term $B$: Confirmed booking.

• Term $G$: Alternate permitted parameter (e.g., guest pass).

• Term $\neg S$: Account is not suspended ($\text{not } S$).

• Case evaluation: If $A = \text{True}$ and $B = \text{False}$, the overall compound expression cannot pass via $B$; access will strictly evaluate to $\text{False}$ unless alternate disjunctive term $G$ is $\text{True}$ while $\neg S$ remains $\text{True}$.

• Control Flow, Decision Trees, and Conditional Branching:

  • Decision tree structures model complex conditional evaluations.
  • Umbrella decision tree:
  • Primary condition: Check whether rain is expected.
  • If rain is expected ($\text{True}$): Evaluate downstream condition: "Is the activity taking place outside today?"
  • If rain is not expected ($\text{False}$): No subsequent tests are required; an umbrella is not needed.
  • Chained conditionals (else if / elif): Used to sequence multiple sequential tests.
  • Hierarchical ordering principle: Conditional branches must be ordered from the narrowest, most restrictive condition to the broadest condition to prevent premature, incorrect branch execution.
  • Multi-tiered parking fee schedule:
  • Threshold benchmarks: Half-hour ($0.5\,\text{hour}$), $5\,\text{hours}$, and $8\,\text{hours}$.
  • Specific rate rule: A parking duration of half an hour ($0.5\,\text{hour}$) should cost exactly $0\,\text{Turkish lira}$.
  • Verification: Requires comparing actual operational outputs produced by the procedure against the expected result of $0\,\text{Turkish lira}$.