The laboratory

Model the decimal place-value system with a Japanese soroban abacus: one heaven bead worth 5, four earth beads worth 1, and a bar that separates counted beads from free beads.

Inspect the three-dimensional anatomy of a bipolar junction transistor, then drive it as a switch through cut-off, active and saturation by sweeping the base supply voltage and reading the base and collector currents.

Open a dual in-line package (DIP) and trace the signal path from the pins, through the lead frame and bond wires, to the silicon die where millions of transistors form a complete circuit.

Inspect the anatomy of a triode vacuum tube - filament, cathode, grid and anode - and see how thermionic emission and the control grid let one tube amplify a signal.

Explore every major component of a working desktop computer - CPU, RAM, GPU, motherboard, PSU, storage and cooling - and understand the role each one plays in the fetch-decode-execute cycle.

Compile and run your first C program, and understand the journey from source code to terminal output.

Read input, perform arithmetic with variables, and produce formatted output in C.

Use if-else branching and arithmetic operators in C to classify an integer as positive, negative or zero, and to test divisibility.

Generate and print a multiplication table using a for loop, and understand loop control variables.

Print a right-angled triangle of numbers using nested for loops, and reason about inner vs outer loop counts.

Store a list of numbers in a one-dimensional array and find the largest value by traversing it.

Compute the factorial of a number with a recursive function and trace how the calls unwind.

Swap two variables through a function using pointers, and understand why call by value alone cannot do it.

Model a student as a struct, store several records in an array of structures, and search through them.

Open a source file, copy its contents character by character to a destination file, and verify the result.

Read a string, traverse it with strlen, and count how many characters are vowels (a, e, i, o, u).

Construct a half adder from logic gates and confirm that it correctly adds two binary digits, producing a sum and a carry.

Build each essential logic gate one at a time and confirm its output matches its truth table exactly.

Extend the half adder into a full adder that adds two bits together with a carry-in, producing a two-bit result.

Build SR, D, JK and T flip-flops from logic gates on a blank canvas and verify their characteristic behaviour: set, reset, hold and toggle.

Build a 4-to-1 multiplexer from gates and verify that the select lines route the chosen data input to the output.

Build a 2-to-4 decoder from gates and verify that exactly one output activates for each input combination.

Simplify a 4-variable Boolean function with a Karnaugh map, then implement and verify the minimized circuit.

Build a clocked D flip-flop and verify that it captures the D input exactly at the clock edge and holds it between edges.

Build a 3-bit synchronous binary counter from T flip-flops and verify that it counts 0 to 7 in binary and wraps around.

Master the factor-and-cancel technique for 0/0 limits and the standard limit sin(x)/x → 1, by evaluating limits numerically and exactly.

Fluently apply the power rule, sum rule and chain rule to polynomials and exponentials, evaluating derivatives at a point.

Evaluate definite integrals with the Fundamental Theorem of Calculus, using antiderivatives of polynomials and trigonometric functions.

Sum infinite geometric series when they converge and approximate functions with Taylor polynomials.

Fire a projectile under adjustable speed, angle and gravity, and connect the shape of its trajectory to range, maximum height and time of flight.

Watch a mass on a spring oscillate and connect its frequency, period, amplitude, phase and energy to the parameters you control.

Place positive and negative charges and watch their electric fields and potentials take shape across the canvas.

Heat a blackbody and watch its emission spectrum shift from infrared to visible, mapping the peak wavelength to its temperature.

Excite the electron in a hydrogen atom and observe the exact spectral lines it emits as it cascades down the energy levels.

Explore quantized energy states of a particle confined in a box and see how the wave functions and their probabilities depend on the quantum number n.

See how overlapping atomic levels spread into energy bands and why the gap between bands decides whether a material is a conductor, insulator or semiconductor.

Apply bias to a p-n junction and watch the depletion region shrink or grow while the current-voltage characteristic traces out a diode curve.

Build any logic function using only NAND (or only NOR) gates, and prove that these two gates are universal.

Overload arithmetic operators for a Complex class and verify results against hand computation.

Build a class hierarchy, inherit members and constructors across levels, and verify construction order.

Demonstrate runtime polymorphism with virtual functions and an abstract base class.

Write generic functions and a class template that work with int, double and string types.

Protect unsafe operations with try, throw and catch, and route errors through the standard exception hierarchy.

Write, read and search records in a file, combining text files, binary files and random access.

Write and step through 8085 programs that perform addition, subtraction, AND, OR and XOR, and read the resulting flag states.

Use a counted loop to copy a block of data from one memory region to another and verify the result byte by byte.

Write an 8085 program that scans a block of memory and finds the largest value, then verify it on multiple test data sets.

Write 8085 programs that convert between BCD, hexadecimal and ASCII representations and check the results by hand and by simulation.

Build a delay subroutine, call it from a main program, and use a look-up table to convert a digit into its seven-segment pattern.

Program a simulated 8255 in mode 0, configure port directions with a control word, and move data through ports A and B.

Study a fully-labelled internal architecture diagram and a 40-pin DIP pin diagram of the 8085, and map every block and every pin group to its function.

Solve 2×2 systems of linear equations with the elimination and determinant methods, and recognise when a system has a unique solution.

Compute determinants and inverse matrices for 2×2 matrices, using the adjugate formula A⁻¹ = (1/det)[[d, −b], [−c, a]].

Find eigenvalues from the characteristic equation det(A − λI) = 0, and connect them to the behaviour of the matrix.

Apply rotation matrices to points in the plane, the same operation graphics engines use to spin sprites and 3D objects on screen.

Manipulate a dataset and watch mean, median, mode, range and standard deviation update in real time.

Group raw data into class intervals and watch the histogram, frequency polygon and ogive update as class width changes.

Compare range, variance, standard deviation and IQR across two datasets and see how outliers and sample size affect each measure.

Drag points on a scatter plot and watch Pearson's r and Spearman's rho respond, exploring outliers, curvature and strength.

Fit a least-squares line to a scatter plot, inspect residuals, and practice prediction within and beyond the data range.

Compare binomial, Poisson and normal distributions by adjusting their parameters and reading probabilities, means and variances live.

Learn how an array behaves as an Abstract Data Type by performing insert, delete, search and traversal operations at chosen positions.

Understand the LIFO discipline of a stack by performing push, pop and peek, and watching the top pointer move.

Convert an infix expression into postfix notation using the shunting-yard algorithm, with the operator stack and output visibly traced.

Evaluate a postfix expression with a value stack, applying each operator to the two most recent operands.

See how a circular queue reuses array slots by wrapping the front and rear pointers, avoiding the waste of a linear queue.

Observe a priority queue where the highest-priority element is always served first, regardless of arrival order.

Watch recursive calls unfold as a call tree, and relate the base case, recursive case and the return-value unwind.

Solve the Tower of Hanoi puzzle recursively and observe the exponential 2ⁿ−1 move count and the recursive structure of each move.

Build and manipulate a singly linked list, observing how each node stores a value and a single pointer to the next node.

Manipulate a doubly linked list and use the backward (prev) pointers to traverse in both directions.

Watch sorting algorithms execute step by step, and compare their behaviour on the same dataset.

Compare linear search over any list with binary search over a sorted list, counting the comparisons each strategy makes.

Map keys to slots with a hash function, resolve collisions by linear probing, and see why average search stays near O(1).

Build a binary search tree by inserting values and compare inorder, preorder and postorder traversal orders.

Study height-balanced trees, observe the balance factor of every node, and see how rotations restore balance after insertions.

Build a max-heap and observe the complete-tree layout and heap-order invariant that powers priority queues.

Traverse a graph with breadth-first search (queue) and depth-first search (stack/recursion), comparing the visitation order and use of each data structure.

Compute single-source shortest paths on a weighted graph and watch tentative distances settle in order of increasing weight.

Find the minimum spanning tree of a weighted graph with Kruskal's algorithm, adding edges in order of weight while avoiding cycles.

Insert and remove from both ends of a double-ended queue and observe how the front and rear pointers move in both directions.

Watch quick sort partition around a pivot and recursively sort each side, tracking pivot choices, comparisons and swaps.

Map keys to slots with a hash function and resolve collisions by storing colliding keys in per-slot linked chains.

Place N queens on an N×N board using backtracking, watching the search place queens row by row and retreat from dead ends.

Implement the bisection method in C and use it to find a root of a nonlinear equation within a given tolerance.

Implement Newton-Raphson iteration in C and observe its quadratic convergence on a smooth equation.

Implement Gaussian elimination with back substitution in C and solve a small system of linear equations.

Implement the composite trapezoidal and Simpson's 1/3 rules in C and compare their accuracy on the same integral.

Implement Lagrange interpolation in C and use it to estimate function values between given data points.

Implement the classical fourth-order Runge-Kutta method in C and solve an initial value problem with high accuracy.

Convert values between binary, octal, decimal and hexadecimal and verify the result with step-by-step arithmetic.

Add and subtract signed 8-bit numbers in two's complement, watching the bit patterns, carry and overflow flags update live.

Drive a 4-bit arithmetic, logic and shift unit with select bits and a carry-in, and verify every operation against its truth table.

Trace a sequence of memory addresses through direct, fully associative and set-associative caches and count the hits and misses.

Draw the timing diagram of a 4-stage instruction pipeline, then introduce a data hazard and watch bubbles appear and disappear.

Explore the speed, size and cost trade-offs of each memory level and compute the average access time for a chosen hit rate.

Plot a line between two endpoints with the DDA algorithm and observe how rounding maps continuous coordinates to pixels.

Plot a line using only integer arithmetic and track the decision parameter that chooses each pixel.

Generate a circle with the midpoint algorithm and watch 8-way symmetry fill all eight octants from one eighth of the arc.

Apply translation, rotation, scaling and composite transformations to a 2D shape and see the matrices act on every vertex.

Fill a polygon using the scan-line algorithm and a seed-fill algorithm, and compare their behaviour.

Project a 3D wireframe object onto a 2D view plane with parallel and perspective projections and compare the results.

Build confidence intervals for a mean and a proportion from live data and see how the interval width responds to sample size and confidence level.

Run a one-sample test for a mean against a claimed value, switching between the z and t procedures, and read the test statistic and p-value live.

Test whether observed category counts match a proposed model by computing the chi-square statistic and comparing it with the critical value.

Compare several group means with one-way ANOVA, reading the sums of squares, F statistic and p-value from a live ANOVA table.

Compare the variances of two independent samples with the F-test and use the ratio to judge whether equal-variance assumptions (like the pooled t-test) are safe.

Create a working LAN, configure the devices, and verify that data actually travels from one end to the other.

Divide an address block into subnets, compute network and broadcast addresses, and validate your answers instantly.

Watch how an application's data is wrapped (encapsulated) into segments, packets and frames on the way out, then unwrapped layer by layer on arrival.

Given any IPv4 address and prefix length, compute the network, broadcast, first and last usable host addresses, and explain the subnet mask.

Simulate the TCP three-way handshake and connection teardown, and explain the meaning of SYN, ACK and FIN flags and sequence numbers.

Construct raw HTTP requests, send them over a TCP connection, and parse the status line, headers and body of the response.

Trace a host name from the root of the DNS hierarchy to its authoritative answer and interpret the returned resource records.

Compute the CRC of a message with a given generator polynomial, append it to form a valid codeword, and verify that bit errors are detected.

Simulate CPU scheduling algorithms on the same set of processes and compare average waiting and turnaround times.

Simulate FIFO, LRU and Optimal page replacement on the same reference string and compare their page-fault behaviour.

Synchronize a producer and a consumer sharing a bounded buffer using semaphores, and observe the race condition when synchronization is removed.

Compute Need, run the safety algorithm, and decide whether resource requests can be granted without risking deadlock.

Apply first-fit, best-fit and worst-fit contiguous allocation to a set of holes and requests, and measure fragmentation.

Simulate contiguous, linked and indexed file allocation on a block device and compare their space use and access behaviour.

Create multiple threads, observe interleaved execution, and see why shared data needs synchronization.

Navigate the Linux file system, manage files and permissions, and inspect processes using core shell commands.

Create a database table with the right types and constraints, insert records, and answer questions with SELECT queries.

Take a denormalized relation, identify its functional dependencies, and redesign it into 1NF, 2NF and 3NF using the SQL console.

Build a schema with DDL and maintain data with DML while watching the database enforce constraints on every operation.

Write INNER, LEFT and self joins plus subqueries to answer multi-table questions, and verify equivalent queries return the same answer.

Create views to simplify access and indexes to accelerate queries, then use EXPLAIN to observe how the DBMS changes its execution plan.

Manage BEGIN, COMMIT and ROLLBACK to control transaction boundaries and observe atomicity and isolation with concurrent sessions.

Convert a written scenario into an ER diagram with entities, relationships, cardinality and participation constraints, then translate it to relational tables.

Use COUNT, SUM, AVG, MIN and MAX with GROUP BY and HAVING to summarize data, and explain how WHERE differs from HAVING.

Simulate breadth-first and depth-first search on the same graph and compare expansion order, memory use and the paths each one finds.

Simulate A* search on a weighted graph, watch f = g + h decide the expansion order, and verify the returned path is optimal.

Simulate greedy hill climbing on a value landscape and observe how local maxima, plateaus and random restarts affect the best solution found.

Simulate minimax with alpha-beta pruning on a game tree and verify the optimal move and the value guarantee for MAX.

Design a small rule-based knowledge base for a diagnostic expert system and test it against a set of patient cases.

Simulate forward and backward chaining on a small rule base and compare how each strategy reaches a goal.

Watch merge sort split an array in half, sort each half recursively, and merge the sorted halves back together.

Compare quicksort's in-place partitioning with mergesort's divide-and-conquer merging on identical inputs.

Explore the fractional knapsack problem and verify that the value-per-weight greedy choice is optimal.

Build the DP table for the longest common subsequence of two strings and trace the optimal solution back.

Run Dijkstra's algorithm on a weighted graph and observe how the frontier of settled vertices grows.

Watch backtracking place N queens on an N x N board, retreating whenever a placement conflicts with earlier queens.

Model the boundary of a system with a context diagram that shows the single process, its external entities and the data flows between them.

Decompose the context diagram into its main processes, data stores and internal data flows.

Capture functional requirements as use cases, actors and relationships in a use case diagram.

Design an entity-relationship diagram for a library covering entities, attributes, keys and relationships.

Document the data flows and stores of a system with a data dictionary of names, types, meanings and constraints.

Implement and test the Caesar cipher, the classic monoalphabetic shift cipher, in C.

Inspect a working Enigma rotor machine - keyboard, plugboard, rotor stack, reflector and lampboard - and see how rotating substitution wheels encipher each letter.

Inspect the Bombe - nine stepping drums in three bays, the commutator menu panels and the test register - and see how it tested Enigma rotor settings at machine speed.

Implement the Vigenere cipher, a polyalphabetic cipher that uses a keyword to vary the shift for each letter.

Build a simple hash function and a CRC-style checksum and test how they detect changes to input data.

Implement the key generation, encryption and decryption steps of RSA with small numbers.

Simulate the Diffie-Hellman key exchange and verify that two parties arrive at the same shared secret.

Sign a message with the private key and verify it with the public key using modular exponentiation.

Implement a linear congruential generator and test the quality of the produced pseudo-random sequence.

Generate samples from an exponential distribution using the inverse transform method on uniform random numbers.

Estimate the value of a definite integral by averaging random samples inside and outside the function.

Simulate an M/M/1 queue with a discrete-event clock and measure utilization, queue length and waiting time.

Simulate an inventory system with random demand and periodic review, and compare reorder policies by total cost.

Apply verification and validation techniques to a simulation model and report its accuracy against known results.

Structure a page with semantic HTML and lay it out with CSS using the box model, Flexbox and Grid.

Select and modify DOM elements from JavaScript and respond to user events with event listeners.

Process HTML form data in PHP with GET and POST, and persist state across requests using sessions.

Connect PHP to a MySQL database, run SQL queries with prepared statements, and display the results.

Fetch data from a server asynchronously with XMLHttpRequest and update the page without a full reload.

Make a layout adapt to any screen size using fluid units, flexible grids and CSS media queries.

Improve a low-contrast image with point operations: adjust brightness and contrast, then apply histogram equalization and watch the intensity histogram flatten.

Convolve the source image with 3x3 smoothing and sharpening kernels and compare how each kernel changes edges, noise and texture.

Transform the image into the frequency domain with the 2D FFT, inspect the magnitude spectrum, and filter the image with circular lowpass and highpass masks.

Compute gradient magnitude with Sobel, Prewitt and Roberts operators, threshold it, and relate the threshold to the number and thickness of detected edges.

Binarize the image with manual or Otsu thresholding, then apply dilation, erosion, opening and closing with a structuring element and observe the geometric changes.

Separate foreground from background by global thresholding: choose the threshold manually or let Otsu's method find the value that maximizes between-class variance.

Build a tokenizer that reads source text and classifies each lexeme as identifier, keyword, number, operator or symbol.

Build a symbol table that stores identifier attributes such as name, type and scope, with insert and lookup operations.

Write a recursive descent parser for arithmetic expressions and verify it follows a context-free grammar.

Use an operator precedence table to parse expressions, giving each operator its binding power.

Convert a nondeterministic finite automaton to an equivalent deterministic one using the subset construction.

Translate expressions into three-address intermediate code using temporary variables.

Write, compile and run your first C# program in the .NET environment and get comfortable with Console I/O.

Model a bank account as a class with private fields, public properties, constructors and methods.

Query in-memory collections with LINQ using filtering, projection, ordering and aggregation.

Build a Windows Forms interface with controls, layouts and event handlers that react to user actions.

Connect to a database with ADO.NET, run a parameterized query and read the results into a collection.

Build an ASP.NET MVC controller, understand routing, and return views and JSON from action methods.