The command room is blue today. Quiet, structured, almost ceremonial. As if the room itself understands we are entering a serious topic: how programs remember, and how they speak.

Nova steps closer to the console. Two words blink in pale light:

FILE I/O
LOGGING

Teslanic nods.
“Today we enter the memory of the application,” he says softly. “Because every program lives in the files it reads… and is understood through the logs it leaves behind.”

1 · Files: The Program’s Connection to the Outside World

A program communicates with the outside world in two ways:
it reads files, and it writes files.

Nova projects a simple read example onto the screen:

from pathlib import Path

def read_text(path: str) -> str:
    p = Path(path)
    try:
        return p.read_text(encoding="utf-8")
    except FileNotFoundError:
        return "File not found."

Teslanic smiles.
“Simple, yes. But this is rule number one of File I/O:
If the file is missing, your program should not collapse. You catch it. You handle it. You stay calm.”

2 · Safe Writing: The Discipline of Saving Data

Writing is riskier than reading.
Reading fails cleanly — writing can destroy data.
That’s why every backend developer must treat writing like handling explosives.

from pathlib import Path

def write_safe(path: str, text: str) -> None:
    p = Path(path)
    try:
        p.write_text(text, encoding="utf-8")
    except PermissionError:
        print("Can't write here.")

Nova tilts her head.
“It still feels too simple.”

Teslanic responds:
“Simplicity is a disguise. This function models the mindset:
Write carefully or break everything.”

2.1 · Mini Example: Saving a Basic Report

For beginners in the room, Nova adds a small, direct example — a pocket illustration of safe file writing:

# Simple example of writing to a file safely
from pathlib import Path

def save_report(text: str) -> None:
    path = Path("report.txt")
    try:
        path.write_text(text, encoding="utf-8")
        print("Report saved.")
    except PermissionError:
        print("Permission denied — cannot write to this location.")

“Clear, readable, and real,” Nova says.
Teslanic nods.
“And exactly how a backend should behave.”

3 · Logging: Print’s Adult Form

Nova asks the ancient question:
“Why not just use print?”

Teslanic answers:
“Because print disappears. Logs survive.”

import logging

logging.basicConfig(
    filename="app.log",
    level=logging.INFO,
    format="%(asctime)s %(levelname)s: %(message)s"
)

logging.info("Application started")

“Now the program leaves a trail,” Teslanic says.
“Every entry becomes a sentence in its autobiography.”

3.1 · A Small Real-World Example

This tiny program behaves like a real backend:
it logs startup, attempts to read a config file, falls back safely if it's missing, and continues running.

# Real-life mini example: log startup, load config, recover safely

import logging
from pathlib import Path

# Logging setup
logging.basicConfig(
    filename="app.log",
    level=logging.INFO,
    format="%(asctime)s %(levelname)s: %(message)s"
)

def load_config() -> str:
    path = Path("config.json")
    try:
        data = path.read_text(encoding="utf-8")
        logging.info("Config loaded successfully.")
        return data
    except FileNotFoundError:
        logging.error("config.json is missing — using defaults.")
        return "{}"

logging.info("Application started")

config = load_config()
print("Running with config:", config)

What the log file shows:

2025-11-06 13:32:55 INFO: Application started
2025-11-06 13:32:55 ERROR: config.json is missing — using defaults.

3.1.1 · Step by Step: How the Snippet Works

Import + setup:
import logging and basicConfig(...) initialize a global logger that writes to app.log with timestamps and levels.

Define the task:
load_config() is a single-responsibility function:
return config text or a safe default.

Happy path:
File exists → INFO log → return the content.

Graceful failure:
File missing → ERROR log → return "{}" instead of crashing.

First heartbeat:
logging.info("Application started") proves the app actually launched.

Visible output:
The print(...) gives console feedback while logs create a persistent trail.

Result:
You get both UX clarity and backend truth — calm behavior, exactly what production needs.

3.2 · Nova Asks: “Is there any other way than logging ourselves?”

Short answer:
You still write logs — but you can choose where they go and who collects them.

• Stdout + a process manager: Log to console (no filename), let systemd, Docker, or Kubernetes rotate/collect.
• Centralized logging backends: ELK / OpenSearch stacks, CloudWatch, GCP Logging, or syslog (via SysLogHandler, SocketHandler).
• Structured JSON logs: Write logs as JSON so tools can parse them.
• Error monitoring & telemetry: Tools like Sentry or OpenTelemetry capture exceptions, traces, and metrics.

Key point:
You don’t stop logging — you upgrade how and where logs travel as your app grows.

3.3 · A Short Break — Nova Pushes Back

Nova narrows her eyes.
“Hey Teslanic, wait. Even I don’t know these methods you listed. ELK, syslog, telemetry… isn’t this too advanced for today’s lesson?”

Teslanic raises both hands, a quiet laugh escaping him.
“I hear you, Nova. And you’re right.”

He steps closer to the console, lowering his voice like sharing a secret.
“You were moving fast. I followed your momentum. But we don’t need to jump that far today.”

Nova folds her arms.
“So we keep it simple?”

“Exactly,” Teslanic says.
“All those systems — consoles, process managers, cloud log collectors — they come later. At some point, yes, we’ll reach them.
But not today.”

He taps the glowing log window.
“For Lesson 04, the only truth you need is this:
Every application writes its own logs.
Everything else is just destination.”

Nova nods slowly.
“Okay. I just didn’t want to confuse readers.”

“And you won’t,” Teslanic replies.
“We build strength layer by layer. Today we stay here — files, safe writing, basic logging. That’s more than enough power for one chapter.”

4 · Logging Levels: The Language of the System

• DEBUG — internal details
• INFO — normal operation
• WARNING — suspicious conditions
• ERROR — something failed
• CRITICAL — the system is on fire

Nova: “When do we use CRITICAL?”
Teslanic: “When you smell smoke.”

5 · When File I/O Meets Logging

Real applications combine both:

def process_file(path: str):
    try:
        data = read_text(path)
        logging.info(f"Read OK: {path}")
        return data
    except Exception as e:
        logging.error(f"Failed to process {path}: {e}")
        return None

“This,” Teslanic says,
“is a heartbeat monitor.
Did we read?
Did we write?
Did we fall?
The logs will tell you.”

6 · Today’s Lesson

• Files are memory
• Logs are language
• Errors are instructions

Teslanic: “Lesson 04 is complete. From now on, every program you write will speak.”
Nova: “And every program will remember.”