Programming Logic on Software Engineering Learning Paths

Variables, Data Types, and Memory

Mon, 01 Jan 0001 00:00:00 +0000

What is a Variable?#

A variable is a named reference to a location in memory where a value is stored. The name is for humans; the computer only cares about the memory address.

Declaration: int age = 25;

What happens:
1. Compiler allocates 4 bytes (for int) at address 0x7FFF001A
2. Stores the value 25 in those bytes
3. Associates the name "age" with address 0x7FFF001A

Variable Lifecycle#

flowchart LR
 D["Declaration<br/>(allocate space)"] --> I["Initialization<br/>(assign first value)"]
 I --> U["Usage<br/>(read/write)"]
 U --> F["Destruction<br/>(free memory)"]

In most languages, destruction is automatic — either when the variable goes out of scope (stack) or when the garbage collector reclaims it (heap).

Control Flow

Mon, 01 Jan 0001 00:00:00 +0000

Control flow determines the execution order of statements. Without it, programs would be strictly sequential — no decisions, no repetition, no branching.

The Three Fundamental Structures#

Every algorithm can be expressed using only three structures (Böhm-Jacopini theorem):

flowchart LR
 subgraph Sequence
 A1["Statement A"] --> B1["Statement B"] --> C1["Statement C"]
 end
 
 subgraph Selection
 D1{"Condition?"} -->|True| E1["Path A"]
 D1 -->|False| F1["Path B"]
 end
 
 subgraph Iteration
 G1{"Condition?"} -->|True| H1["Body"]
 H1 --> G1
 G1 -->|False| I1["Exit"]
 end

Conditionals (Selection)#

If/Else#

The most basic decision structure:

Functions, Scope, and Recursion

Mon, 01 Jan 0001 00:00:00 +0000

Functions#

A function encapsulates a unit of work — it takes inputs, performs computation, and produces output. Functions are the primary tool for managing complexity in software.

Anatomy of a Function#

def calculate_shipping(weight_kg: float, distance_km: float, express: bool = False) -> float:
 """
 Calculate shipping cost based on weight, distance, and speed.
 
 Args:
 weight_kg: Package weight in kilograms
 distance_km: Shipping distance in kilometers
 express: Whether to use express delivery
 
 Returns:
 Shipping cost in euros
 """
 base_rate = 2.50
 weight_rate = 0.75 * weight_kg
 distance_rate = 0.01 * distance_km
 
 cost = base_rate + weight_rate + distance_rate
 
 if express:
 cost *= 1.5
 
 return round(cost, 2)

Components:

Data Structures

Mon, 01 Jan 0001 00:00:00 +0000

Data structures organize data for efficient access and modification. The right structure can make the difference between an algorithm that runs in milliseconds and one that takes hours.

Choosing a Data Structure#

flowchart TD
 A["What operations do you need?"] --> B{"Ordered access?"}
 B -->|"By index"| C["Array / ArrayList"]
 B -->|"By key"| D["Hash Map"]
 B -->|"Sorted order"| E["Tree / Sorted Set"]
 B -->|"No"| F{"Access pattern?"}
 F -->|"FIFO"| G["Queue"]
 F -->|"LIFO"| H["Stack"]
 F -->|"Priority"| I["Heap / Priority Queue"]
 F -->|"Unique elements"| J["Set"]
 F -->|"Relationships"| K["Graph"]

Arrays and Dynamic Arrays#

Static Arrays#

Fixed-size, contiguous memory block. The most fundamental data structure.

Algorithms

Mon, 01 Jan 0001 00:00:00 +0000

An algorithm is a finite, well-defined sequence of steps that solves a problem. This section covers the essential algorithms every programmer should know — sorting, searching, and graph traversal — with implementations and analysis.

Sorting Algorithms#

Why Sorting Matters#

Sorting is a prerequisite for many other algorithms (binary search, merge operations, duplicate detection). Understanding sorting algorithms teaches fundamental algorithmic techniques: divide-and-conquer, incremental construction, and heap properties.

Bubble Sort — The Teaching Algorithm#

Repeatedly swap adjacent elements if they’re in the wrong order:

Big-O Notation and Complexity Analysis

Mon, 01 Jan 0001 00:00:00 +0000

What Big-O Measures#

Big-O notation describes how an algorithm’s resource usage (time or space) scales as input size grows. It captures the upper bound of growth rate, ignoring constants and lower-order terms.

O(n) means: "grows linearly with input size"
O(n²) means: "grows quadratically with input size"
O(1) means: "constant — doesn't grow with input size"

Why Constants Don’t Matter#

# Both are O(n) — the constant factor (3 vs 1) is irrelevant at scale
def triple_loop(arr): # 3n operations
 for x in arr: pass
 for x in arr: pass
 for x in arr: pass

def single_loop(arr): # n operations
 for x in arr: pass

At n = 1,000,000: 3n = 3,000,000 vs n = 1,000,000. Both are “millions.” But O(n) vs O(n²): n = 1,000,000 vs n² = 1,000,000,000,000. That’s the difference that matters.

Computational Thinking and Problem Decomposition

Mon, 01 Jan 0001 00:00:00 +0000

Computational thinking is the process of formulating problems so they can be solved systematically. It’s not about computers — it’s about structured problem-solving that happens to be executable by machines.

The Four Pillars#

flowchart TD
 CT["Computational Thinking"] --> D["Decomposition"]
 CT --> PR["Pattern Recognition"]
 CT --> AB["Abstraction"]
 CT --> AL["Algorithm Design"]
 
 D --> D1["Break into manageable sub-problems"]
 PR --> PR1["Find similarities across problems"]
 AB --> AB1["Remove irrelevant detail"]
 AL --> AL1["Define step-by-step solutions"]

Decomposition#

Breaking Problems Down#

Every complex system is made of simpler parts. Decomposition is identifying those parts and their relationships.

Recursion Deep Dive

Mon, 01 Jan 0001 00:00:00 +0000

Recursion is a strategy where a function solves a problem by reducing it to smaller instances of the same problem. Section 03 introduced the concept — this section explores recursive thinking in depth, visualises the call stack, and tackles classic recursive problems.

Recursive Thinking#

Every recursive solution requires two components:

Component	Purpose	Example (factorial)
Base case	Stops recursion, returns a known value	`factorial(0) = 1`
Recursive case	Reduces the problem toward the base case	`factorial(n) = n × factorial(n-1)`

The Reduction Pattern#

Recursive thinking means asking: “If I already had the answer for a smaller input, how would I build the answer for the current input?”

Graph Algorithms

Mon, 01 Jan 0001 00:00:00 +0000

Graphs model relationships between entities — social networks, road maps, dependency chains, web links. This section covers graph representations, traversal algorithms, shortest paths, and topological ordering.

Graph Fundamentals#

A graph G = (V, E) consists of vertices (nodes) and edges (connections between nodes).

Property	Directed	Undirected
Edge meaning	A → B (one-way)	A — B (both ways)
Example	Web links, task dependencies	Friendships, roads
Edge count (complete)	V × (V-1)	V × (V-1) / 2

Term	Definition
Degree	Number of edges connected to a vertex
Path	Sequence of vertices connected by edges
Cycle	Path that starts and ends at the same vertex
Connected	Path exists between every pair of vertices
Weighted	Edges carry a numeric cost/distance
DAG	Directed Acyclic Graph — directed, no cycles

Graph Representations#

Adjacency Matrix#

A 2D array where matrix[i][j] = 1 (or the weight) if an edge exists from vertex i to vertex j.

Dynamic Programming

Mon, 01 Jan 0001 00:00:00 +0000

Dynamic programming (DP) is an optimisation technique that solves complex problems by breaking them into overlapping subproblems, solving each subproblem once, and storing the result. It transforms exponential brute-force solutions into polynomial ones.

When Does DP Apply?#

A problem is suitable for dynamic programming when it exhibits both properties:

Property	Definition	Test
Overlapping subproblems	The same smaller problems are solved repeatedly	Draw the recursion tree — do you see repeated nodes?
Optimal substructure	The optimal solution contains optimal solutions to subproblems	Can you express the answer in terms of answers to smaller inputs?

flowchart TD
 A["Problem has optimal substructure?"] -->|No| B["DP won't help"]
 A -->|Yes| C["Subproblems overlap?"]
 C -->|No| D["Use Divide & Conquer (no caching needed)"]
 C -->|Yes| E["Use Dynamic Programming"]
 E --> F["Top-down (memoisation)"]
 E --> G["Bottom-up (tabulation)"]

Memoisation vs Tabulation#

Top-Down (Memoisation)#

Write the natural recursive solution, then cache results to avoid recomputation.

Complexity Analysis In Depth

Mon, 01 Jan 0001 00:00:00 +0000

Section 06 introduced Big-O notation and common complexity classes. This section goes deeper — covering formal analysis techniques, space complexity, amortised analysis, and practical measurement. The goal is to move from “memorising complexities” to “deriving them yourself.”

Big-O: The Formal Definition#

O(f(n)) describes an upper bound on growth rate:

T(n) is O(f(n)) if there exist constants c > 0 and n₀ ≥ 0 such that T(n) ≤ c·f(n) for all n ≥ n₀.