01 Programming Foundations and Problem Solving

Programming as Problem Solving

Programming is the process of describing a solution precisely enough for a computer to execute. A program accepts inputs, performs operations according to an algorithm, and produces outputs.

Most programming languages provide related building blocks:

• Variables and data types represent information.

• Expressions combine values and produce results.

• Conditionals select among alternatives.

• Loops repeat operations.

• Functions and methods package reusable behavior.

• Collections organize groups of values.

• Classes and objects combine data with behavior.

The same underlying solution can be implemented in different programming languages because the algorithm is separate from the particular syntax used to express it.

Takeaway: Programming connects precise problem descriptions, executable instructions, and observable results.

Computational Thinking

Computational thinking provides a disciplined way to move from a vague problem to a workable solution. Start by breaking the problem into smaller tasks through Decomposition. Look for similarities with problems that have already been solved, then use Abstraction to keep important details while hiding irrelevant complexity.

A practical sequence is:

1. Identify the required output.

2. Define the inputs and constraints.

3. Separate the work into smaller tasks.

4. Recognize useful patterns.

5. Design an algorithm.

6. Test the result and improve it.

For example, to calculate an average, read the numbers, add them, count them, divide the total by the count, and display the result. Each step is simple, ordered, and precise enough to implement.

Takeaway: Good solutions begin with problem structure rather than programming-language syntax.

From Source Code to Execution

Source code is human-readable text containing declarations, expressions, statements, functions, classes, and comments. Before a computer can execute it, a language implementation must transform or process it.

A compiler commonly translates source code into machine code or intermediate code, often before execution. An interpreter executes source code or an intermediate representation during execution. Modern systems can combine these approaches by translating code into bytecode, running it on a virtual machine, or compiling frequently used portions during execution.

Errors can appear at different stages:

• A syntax error breaks the grammar of the language.

• A type or semantic error uses a construct in an invalid or unintended way.

• A runtime error occurs while the program is running.

• A logic error produces an incorrect result even though the program runs.

Distinguishing these categories helps you choose an appropriate response: correct the form of the code, correct its use of values, handle the failing execution case, or revise the underlying reasoning.

Takeaway: Execution depends on language processing, and error categories indicate where to begin diagnosis.

Values, Variables, and Types

A variable is a named reference to a value, while a data type describes the kind of value and the operations valid for it. Common types include integers, floating-point numbers, Booleans, strings, collections, and objects.

Languages differ in when they check types. Statically typed languages usually declare or check types before execution; dynamically typed languages generally perform type checking during execution. Some languages require explicit conversion, while others allow implicit conversion in particular expressions.

An expression produces a value. For example, a program can multiply a price by a quantity, compare a quantity with a limit, or join text with a converted number. Meaningful variable names, focused responsibilities, and appropriate types make those expressions easier to understand.

When choosing a representation, ask what the value means, which operations it needs, and whether it should be changed. A collection is useful for related values, while an object is useful when data and the operations that use it belong together.

Takeaway: Clear representations make later conditions, loops, and algorithms easier to write correctly.

Decisions and Boolean Logic

A conditional selects statements according to a Boolean expression. Conditions are tested in order: the first true branch executes, and later branches are skipped. Boolean operators combine conditions:

• and is true only when both conditions are true.

• or is true when at least one condition is true.

• not reverses a Boolean value.

Before writing a conditional, list the possible cases. Include boundary cases such as zero, an empty collection, a minimum value, and a maximum value. This prevents assumptions about ordinary inputs from hiding missing branches.

A conditional is easier to verify when each branch has a clear purpose and the conditions do not overlap unexpectedly. For example, a temperature classification can test the hottest range first, then a milder range, and use a final branch for the remaining case.

Takeaway: Enumerating cases before coding helps ensure that every relevant input receives an intentional result.

Repetition and Loop Control

A loop repeats a block of statements. Use a for loop when processing each item in a collection or a known sequence. Use a while loop when repetition should continue until a condition changes.

A reliable loop follows this pattern:

1. Initialize the state.

2. Test the termination condition.

3. Perform the repeated work.

4. Update the state.

5. Return to the condition.

Every loop must make progress toward termination. An infinite loop occurs when the termination condition never becomes false. break can stop a loop and continue can skip to its next iteration, but a clear condition and update are usually easier to understand.

When reviewing a loop, check its initial state, the values processed, the update step, and what happens when the collection is empty or the condition is already false.

Takeaway: A loop is correct only when its repeated work and its path to termination are both clear.

Reusable Behavior

A function is a named, reusable operation. Parameters are the names in a function definition; arguments are the values supplied when calling it. A function can return a result and should usually have one clear purpose.

Functions reduce duplication, separate responsibilities, and make code easier to test. A method is a function associated with an object or class and often operates on that object's data. A function's scope determines where its variables can be accessed, so local variables should generally remain local unless shared state is intentional.

For example, a clamping function can compare a value with a lower and upper bound, return the lower bound when the value is too small, return the upper bound when it is too large, and otherwise return the original value. This packages a repeated rule behind a simple interface.

Takeaway: Well-designed functions hide implementation details while exposing a focused operation that can be reused and tested.

Collections and Safe Traversal

An array stores multiple values in an ordered structure, usually accessed by a numeric index. Indexing often begins at zero, so the first element is at index 0. Collection operations include accessing, updating, adding, removing, searching, traversing, and determining length.

Before using an index, verify that it is within the valid range. Empty collections need special handling because they have no first element. A common traversal pattern initializes a result from a valid element and then compares each remaining element with it. That pattern must account for the possibility that the collection is empty.

Collections support common algorithms such as summing values, counting values that satisfy a condition, finding a maximum, and transforming each element. Choosing the collection structure should depend on the required access and update operations.

Takeaway: Index boundaries and empty inputs are essential cases whenever an algorithm works with collections.

Objects, Classes, and Invariants

An object combines state and behavior. State is represented by attributes or properties, while behavior is represented by methods. A class is a blueprint used to create object instances.

A constructor initializes a new instance. For example, a counter object can store a starting value, provide an increment method, and provide another method that reports its current value. Keeping related operations with the data they use can make a program easier to understand.

Classes should protect important invariants: conditions that should remain true throughout the object's lifetime. If a bank balance must not become negative when overdrafts are forbidden, the class's operations should enforce that rule rather than relying on every caller to remember it.

Takeaway: Objects are most useful when they keep related data, operations, and validity rules together.

Relationships Between Objects

Inheritance allows a subclass to reuse or specialize a superclass. A subclass may override a method, allowing different object types to respond differently to the same operation. This supports polymorphism, in which code uses a common interface while each type supplies its own implementation.

Inheritance is appropriate when the subclass truly represents a specialized form of the base class. Composition is an alternative in which one object contains or uses another object. Composition often fits a “has a” relationship, such as a car having an engine, whereas inheritance fits an “is a” relationship.

Inheritance hierarchies should remain understandable. Excessive inheritance can create tight dependencies and make behavior difficult to trace. Prefer the relationship that most clearly expresses the domain and keeps responsibilities manageable.

Takeaway: Use inheritance for genuine specialization and composition for assembled behavior or contained parts.

Algorithm Design and Efficiency

An algorithm should be correct, finite, unambiguous, effective, and efficient enough for its intended use. A practical design process is:

1. Restate the problem and identify the exact required output.

2. Define inputs, constraints, and special cases.

3. Work through ordinary, boundary, and invalid examples by hand.

4. Choose a suitable representation.

5. Write pseudocode before focusing on language syntax.

6. Implement incrementally.

7. Compare actual results with expected results.

8. Debug and refine the cause of any failure.

9. Consider how time and memory use grow as the input grows.

For example, to count values greater than a threshold, initialize a count, inspect each value once, increment the count when the condition is true, and return the count. If there are $n$ input values, the running time grows linearly and is commonly described as $O(n)$ time.

Takeaway: A deliberate algorithm-design process reduces errors before implementation and provides a basis for evaluating performance.

Testing and Debugging

Debugging is the process of locating and correcting the cause of a program's incorrect behavior. Start by reading the complete error message and identifying the relevant line, but do not assume that the reported line is the entire cause.

Useful strategies include:

• Reproduce the problem with the smallest useful input.

• Inspect intermediate values.

• Check assumptions about types, indexes, and loop conditions.

• Compare behavior with a hand-worked example.

• Test boundary cases and invalid cases.

• Change one thing at a time and retest.

Testing should compare actual results with expected results. Incremental implementation makes it easier to identify which change introduced a failure. A program that runs is not necessarily correct; tests must also verify its logic and handling of special cases.

Takeaway: Effective debugging uses evidence, controlled changes, and explicit expected behavior rather than guesses.