Computing · JC 2 · Advanced Programming Paradigms · Semester 1

File I/O and Data Persistence

Students will learn to read from and write to files, enabling data persistence in their applications.

About This Topic

File I/O and Data Persistence teaches students to read from and write to files, ensuring data survives program termination. In JC 2 Computing under MOE's Advanced Programming Paradigms unit, students design programs that process CSV files, assess security risks of plain text storage, and compare text files, which store readable characters, with binary files that hold compact, machine-readable data. These concepts prepare students for real applications like data logging or configuration saving.

This topic builds on prior programming skills, integrating file handling with loops, conditionals, and exception management. Students tackle key questions by coding CSV parsers that compute statistics or simulate secure writes, aligning with standards for robust, secure code. It emphasizes error handling for issues like file not found or permission denied, vital for production-ready programs.

Active learning excels with this topic since students code, run, and inspect files instantly. Pair debugging sessions or group file-processing challenges expose errors in real time, making abstract persistence concrete and reinforcing secure practices through immediate feedback and peer collaboration.

Key Questions

1. Design a program that reads data from a CSV file and processes it.
2. Evaluate the security implications of storing sensitive data in plain text files.
3. Explain the difference between text files and binary files for data storage.

Learning Objectives

• Design a program that reads data from a CSV file and calculates summary statistics.
• Evaluate the security risks associated with storing sensitive user credentials in plain text files.
• Compare and contrast the use cases for text files versus binary files in application development.
• Create Python code to write structured data to a file and subsequently read it back.
• Implement exception handling for common file I/O errors such as 'FileNotFoundError' and 'PermissionError'.

Before You Start

Basic Programming Constructs (Variables, Data Types, Control Flow)

Why: Students need a solid understanding of variables, data types (like strings and numbers), and control flow (loops, conditionals) to manipulate data read from files.

Introduction to Data Structures (Lists, Dictionaries)

Why: File I/O often involves reading data into lists or dictionaries for easier processing and organization.

Key Vocabulary

File Handle	An object that represents an open file, allowing a program to interact with it for reading or writing.
CSV (Comma Separated Values)	A common file format for storing tabular data, where values in each row are separated by commas.
Text File	A file that stores data as a sequence of characters, human-readable and typically encoded using ASCII or UTF-8.
Binary File	A file that stores data in its native binary format, not directly human-readable and often more compact or efficient for specific data types.
Data Persistence	The ability of data to survive the termination of the program that created it, typically achieved by storing it in files or databases.

Watch Out for These Misconceptions

Common Misconception

All files open correctly in any editor or mode.

What to Teach Instead

Binary files use non-printable bytes, appearing garbled in text editors, while text files use encoded characters. Small group experiments with cross-opening files reveal this instantly, prompting correct mode usage through trial and observation.

Common Misconception

File writes always succeed without checks.

What to Teach Instead

Operations fail from full disks or locks; unchecked code crashes silently. Pair debugging challenges simulate failures, teaching exception handling as students trace and fix errors collaboratively.

Common Misconception

Plain text files securely store sensitive data.

What to Teach Instead

Anyone with access reads them directly, risking breaches. Whole-class breach simulations show exposures, leading to encryption explorations via hands-on coding and group risk assessments.

Active Learning Ideas

Pair Programming: CSV Score Analyzer

Pairs receive a CSV file with mock exam data. They code a reader to calculate class averages, handle missing entries with defaults, and write summaries to a new file. Pairs exchange files for cross-testing and discuss discrepancies.

35 min·Pairs

Small Groups: Text vs Binary File Challenge

Groups create identical data in text and binary formats using appropriate modes. They attempt cross-reading and note failures, then refactor code for correct parsing. Groups demo one success and one common pitfall to the class.

40 min·Small Groups

Whole Class: Secure Write Simulation

Display a plain text file with sensitive data. Class codes a simple encryption wrapper before writing, tests breaches by swapping files, and debates best practices. Compile class code into a shared secure writer template.

45 min·Whole Class

Individual: Error Handling Hunt

Students get buggy file I/O code with deliberate faults like no exception checks. They run it, identify crashes from simulated errors, and add try-except blocks. Submit fixed versions with log reports.

25 min·Individual

Real-World Connections

• Software engineers at financial institutions use file I/O to read transaction logs from CSV files, process them to generate reports, and store sensitive customer data securely, not in plain text.
• Game developers utilize file persistence to save player progress, settings, and inventory. This data is often stored in binary formats for efficiency, ensuring game states are maintained between play sessions.
• Web application developers read configuration settings from files to customize application behavior. For example, a web server might read a list of allowed IP addresses from a text file to control access.

Assessment Ideas

Quick Check

Present students with a short Python code snippet that attempts to read from a non-existent file. Ask them to identify the specific exception that will be raised and write the correct 'try-except' block to handle it gracefully.

Discussion Prompt

Pose the question: 'Imagine you are developing an application to store user passwords. Discuss the pros and cons of storing these passwords in a plain text file versus a binary file, considering both security and efficiency.' Facilitate a class discussion comparing their arguments.

Exit Ticket

Provide students with a small CSV file containing sample student scores. Ask them to write down the Python code required to open the file, read the scores, and calculate the average score. They should also write one sentence explaining why this data needs to be persistent.

Frequently Asked Questions

What are the main differences between text and binary files in JC2 Computing?

Text files store human-readable characters using encodings like UTF-8, ideal for logs or CSVs but larger. Binary files pack data efficiently in bytes, suiting images or executables, but require specific readers. Students learn modes like 'rb' for binary to avoid corruption, practicing with paired coding tasks to compare sizes and outputs directly.

How do you teach security implications of plain text file storage?

Highlight risks like unauthorized access by demoing readable sensitive data. Students code encrypted alternatives using simple ciphers, test vulnerabilities in groups, and evaluate trade-offs. This builds awareness of hashing or encryption libraries, aligning with MOE standards for secure programming practices.

What skills do students gain from File I/O in Advanced Programming Paradigms?

Students master reading/writing CSVs, error handling with try-except, and mode selection for text/binary. They design processors for real data like scores, fostering persistence in apps. Activities emphasize secure practices, preparing for projects with lasting data needs.

How does active learning help with File I/O and data persistence?

Active approaches like pair coding CSV readers or group binary experiments let students create, break, and fix files immediately, demystifying persistence. Whole-class debates on security reinforce concepts through real breaches. This hands-on cycle boosts retention over lectures, as peers spot errors faster and connect theory to debugged successes, matching JC2's problem-solving focus.