Class Report: Systems Development (Year 3) – Week 51~ Final Project Implementation Begins: Turning Design into a Working System ~

greeden

3 hours ago

Class Report: Systems Development (Year 3) – Week 51

~ Final Project Implementation Begins: Turning Design into a Working System ~

In Week 51, based on the final project designs decided previously,
the implementation phase officially began.

From this point forward, students started transforming the design documents into actual code, including:

API integration
Generative AI functionality
Error handling
Logging design

■ Teacher’s Introduction: “Trust the Design During Implementation”

Mr. Tanaka:
“When implementation begins, you may feel tempted to ignore the design and just write code.

But whenever you get lost, always return to the design.
The design is the map of development.”

He pointed out common issues that occur during implementation:

Writing code that deviates from the design
Gradual collapse of the system structure
UI layers starting to call APIs directly

He emphasized the importance of maintaining separation of responsibilities.

■ Goals for Today

Create the project’s basic structure in code
Implement the framework for an API client
Prepare the AI client invocation layer
Set up the foundation for logging and exception handling

■ Exercise 1: Creating the Project Structure

Each team began by building the folder structure for their project.

Example:

project/
 ├─ app/
 │   ├─ ui/
 │   ├─ service/
 │   ├─ api_clients/
 │   ├─ ai_clients/
 │   └─ models/
 ├─ logs/
 ├─ tests/
 └─ README.md

Key points:

Separate UI / Service / API layers
Group AI functionality into a dedicated client
Prepare a logging directory from the beginning

Student A:
“Just creating the structure already makes it feel like a real project!”

■ Exercise 2: Implementing the API Client

Next, students created a class for calling external APIs.

Learning Example

class WeatherApiClient:

    def fetch(self, city):
        response = requests.get(
            "https://api.example.com/weather",
            params={"city": city},
            timeout=5
        )
        response.raise_for_status()
        return response.json()

Important points:

Set a timeout
Handle HTTP errors
Convert responses to JSON

The teacher reminded the class:

“Always write API code assuming it will fail.”

■ Exercise 3: Building the AI Client Skeleton

The generative AI integration was structured similarly.

Service
 ↓
AiClient
 ↓
AI API

Conceptual example:

class AiClient:

    def generate(self, prompt):
        response = ai_api_call(prompt)
        return response

At this stage:

Prompt generation
Output validation

were designed to remain in the Service layer.

Student B:
“Treating AI as just another external service makes the structure easier to manage.”

■ Exercise 4: Setting Up Logging and Error Handling

Students added a shared logging configuration across the project.

Example:

import logging

logging.basicConfig(
    filename="logs/app.log",
    level=logging.INFO
)

Logs will record:

API calls
AI outputs
Errors
Fallback execution

Student C:
“Having logs makes implementation feel much safer.”

■ Exercise 5: First Execution Test

Finally, the teams tested:

API calls
AI calls (using a dummy implementation)

Although the features are not yet complete,
the foundation of a working system has now been established.

■ Key Insights from the Class

Following the design reduces confusion
Separating API clients from Services is important
Logging should be implemented early
AI functionality can be treated like any other API service

■ Teacher’s Closing Comment

“Today’s work is like laying the foundation of a building.

If the foundation is weak,
any additional features added later will cause the structure to collapse.

But if the structure is solid,
you can add as many features as you want.”

■ Homework (Before Next Week)

Complete the basic API integration functionality
Add AI prompt generation logic in the Service layer
Implement fallback handling for error scenarios

■ Preview of Next Week: Feature Implementation Phase

Next week, students will work on:

Implementing AI functionality
Processing API data
Displaying results in the UI

This will move the project into the stage where
the system’s main features begin to take shape.

Week 51 marked the moment when
the final project truly started coming to life.

By transforming their designs into working code,
students are beginning to turn three years of learning into a real system.