This detailed curriculum reconstructs the original seven-day masterclass and is now surfaced as an academy offering.

Detailed Curriculum (Original Programme Reconstruction)

---

Programme Overview

This masterclass introduces students to practical software engineering through a single evolving project.

The programme focuses on:

• Software engineering workflows
• Version control
• Testing
• Problem solving
• Functional programming concepts
• Client-server architecture
• Distributed systems fundamentals
• Persistence
• Reliability engineering

Participants progressively evolve an Expense Tracker application from a simple in-memory program into a distributed, fault-tolerant system.

The objective is not merely to learn programming syntax, but to understand how software systems are designed, tested, deployed and maintained.

---

Day 1

Development Environment and Engineering Workflow

Topics

Development Workflow

• Review of the programme plan
• Understanding the engineering workflow
• Introduction to version control

---

GitLab Setup

Create a GitLab account.

Tasks:

• Create GitLab account
• Connect GitLab account to VSCode
• Clone repository
• Push changes
• Pull changes
• Commit changes
• Create branches
• Merge branches

---

Development Environment

Create a development container.

Create:

.devcontainer.json

Example:

{
    "name": "dev",
    "image": "node"
}

Supported images:

docker pull node
docker pull rust
docker pull python
docker pull gcc
docker pull eclipse-temurin:21-jdk

Tasks:

• Create dev container configuration
• Reopen project inside container
• Verify development environment

---

Hello World

Create a simple application.

Objectives:

• Verify development environment
• Verify Git workflow
• Verify commit and push process

---

Programming Exercises

Implement:

• Fibonacci
• Palindrome
• Prime Number
• Odd / Even

---

Testing

Write test cases for all exercises.

Requirements:

• No third-party libraries
• Focus on correctness
• Validate expected behaviour

---

Deliverable

• Working repository
• Development container
• Programming exercises
• Unit tests
• Feedback document

---

Day 2

Testing and Software Design

Problem Solving

Continue solving algorithmic problems.

Additional exercises from LeetCode.

Objectives:

• Improve problem solving
• Improve coding discipline
• Improve testing discipline

---

Longevity Testing

Introduction to:

• Longevity Testing
• Randomized Testing

Topics:

• Why deterministic tests are insufficient
• Discovering hidden edge cases
• Repeated execution
• Confidence building through randomized input

---

Test Design

Students are required to manage:

Positive Scenarios

Valid input.

Negative Scenarios

Invalid input.

Edge Cases

Boundary conditions.

Error Scenarios

Unexpected conditions.

Test suites must cover:

• Success cases
• Failure cases
• Invalid inputs
• Edge cases
• Error handling

---

Functional Programming

Introduction to:

• Functional Programming
• Functions as building blocks
• Separation of logic
• Simpler program design

---

Expense Tracker Project

Design and implement an Expense Tracker.

Requirements:

At least two users.

Track:

Money Received

• Date received
• Amount received

Money Spent

• Date spent
• Amount spent
• Purpose of spending

---

Menu Requirements

Menu must support:

List Transactions

Display all transactions.

Current Balance

Display current balance.

Money Received

Display income.

Money Spent

Display expenses.

---

Testing Requirements

Test cases required for all functions.

Coverage must include:

• Edge cases
• Empty wallet
• Negative balance
• Invalid inputs
• User switching
• Data isolation between users

---

Deliverable

Multi-user Expense Tracker with test coverage.

---

Day 3

Distributed Systems Fundamentals

Code Review

Review Expense Tracker implementations.

Topics:

• Design
• Structure
• Testing
• Maintainability

---

Introduction to Distributed Systems

Topics:

• Client
• Server
• Communication
• State management

---

WebSocket Programming

Implement a simple server-client program.

Requirements:

• Use WebSocket
• No third-party frameworks
• Understand connection establishment
• Understand communication flow

---

Protocol Design

Design a protocol for the Expense Tracker.

Operations:

ADD_TR

ADD_TR(userName, Amount)

Behaviour:

if user found
    add amount
    return success

else
    return failure

---

SPEND_TR

SPEND_TR(userName, Amount, Purpose)

Behaviour:

if user found
    add spending transaction

else
    return failure

---

VIEW_TR

VIEW_TR(userName)

Behaviour:

if user found
    return user object

else
    return failure

---

CURRENT_BAL

CURRENT_BAL(userName)

Behaviour:

if user found
    calculate balance

else
    return failure

---

Expense Tracker Integration

Replace direct menu interaction with:

Client
    ↓
Protocol
    ↓
Server

---

Deliverable

Network-enabled Expense Tracker.

---

Day 4

Integration and Delivery

Code Review

Review previous implementations.

---

Echo Server

Complete:

• Echo Server
• Uppercase Server
• Lowercase Server

Using:

• Client
• Server
• WebSocket

---

Testing

Write test cases for:

• Echo functionality
• Uppercase conversion
• Lowercase conversion

---

Expense Tracker Integration

Implement:

Menu
    ↓
Client
    ↓
Server
    ↓
Business Logic

The menu becomes the client.

The business logic becomes the server.

---

Testing

Write tests for:

• Menu operations
• Client communication
• Server operations
• Error conditions

---

Deliverable

Fully integrated client-server Expense Tracker.

---

Day 5

Persistence and Architecture

Database Concepts

Introduction to:

• Data persistence
• Data storage
• Long-term data management

Topics:

• Memory vs storage
• Data durability
• Data retrieval

---

Architectural Separation

Split:

Business Logic

from

Database

Objectives:

• Separation of concerns
• Maintainability
• Testability

---

Refactoring

Existing implementation:

Client
    ↓
Business Logic + Data

Refactor to:

Client
    ↓
Business Logic
    ↓
Persistence

---

Deliverable

Expense Tracker with separated persistence layer.

---

Day 6

Reliability and Distributed Systems

Multiple Databases

Create:

• Multiple database instances
• Independent storage nodes

---

Multiple Servers

Create:

• Multiple servers
• Independent database connections

Architecture:

Client
    ↓
Server A
    ↓
Database A

Client
    ↓
Server B
    ↓
Database B

---

Server-to-Server Communication

Requirements:

• Servers communicate directly
• Synchronize information
• Exchange updates

---

Database Synchronization

Scenario:

Compare databases.

If one database has fewer files or records:

• Detect missing data
• Synchronize data
• Restore consistency

---

Active-Passive Clustering

Topics:

• Primary server
• Secondary server
• Synchronization
• Failover
• Recovery

---

Failure Scenario

Primary server fails.

Requirements:

• Secondary server continues operation
• Client reconnects
• Data remains available

---

Recovery Scenario

Primary server returns.

Requirements:

• Synchronize missing data
• Restore consistency
• Resume normal operation

---

Deliverable

Replicated Expense Tracker system with Active-Passive architecture.

---

Day 7

Revision and Systems Thinking

Programme Review

Review all concepts covered.

Topics:

• Version control
• Testing
• Functional programming
• Expense Tracker
• Client-server architecture
• Protocols
• Persistence
• Distributed systems
• Synchronization
• Active-Passive clustering

---

System Walkthrough

Trace complete transaction flow:

User
    ↓
Client
    ↓
Protocol
    ↓
Server
    ↓
Business Logic
    ↓
Persistence
    ↓
Synchronization

---

Discussion Topics

• Reliability
• Maintainability
• Scalability
• Software architecture
• Failure handling

---

Final Review

Review implementation decisions.

Discuss:

• What worked
• What failed
• Lessons learned
• Future improvements

---

Final Outcome

Participants complete an Expense Tracker that evolves through the following stages:

Stage 1:

CLI Application

Stage 2:

Tested Application

Stage 3:

Client-Server Application

Stage 4:

Persistent Application

Stage 5:

Replicated Distributed Application

Throughout the programme students are expected to:

• Use GitLab
• Commit regularly
• Write tests
• Handle failure scenarios
• Think about architecture
• Understand system evolution
• Build software incrementally
• Review and improve existing code