File I/O

Introduction

File I/O (short for File Input/Output) refers to the process of reading data from and writing data to files using software. In computing, File I/O operations are essential for persistent data storage, allowing programs to retain information across sessions—whether it’s configuration files, logs, databases, or user-generated content.

From simple text files to complex binary formats, File I/O forms the backbone of data persistence, data exchange, and system logging. It is supported in virtually every programming language and operating system.

“File I/O is how software remembers. Without it, all data would be gone the moment a program ends.”

What Is File I/O?

File I/O is the process by which a program:

• Reads data from files (input)
• Writes data to files (output)

Files can be:

• Text files: human-readable (e.g., .txt, .csv)
• Binary files: structured but not directly human-readable (e.g., .exe, .jpg, .dat)

File I/O can be sequential (read/write in order) or random access (seek to a position in the file).

File I/O Lifecycle

1. Open a file
   Choose mode: read (r), write (w), append (a), etc.
2. Perform operations
   Read from or write to the file
3. Close the file
   Release resources and flush buffers

File I/O Modes (Common Across Languages)

File I/O in Different Programming Languages

Python

# Writing to a file
with open('data.txt', 'w') as f:
    f.write('Hello, world!')

# Reading from a file
with open('data.txt', 'r') as f:
    content = f.read()

C

FILE *fp = fopen("data.txt", "w");
fprintf(fp, "Hello, world!\n");
fclose(fp);

Java

BufferedWriter writer = new BufferedWriter(new FileWriter("data.txt"));
writer.write("Hello, world!");
writer.close();

BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
String line = reader.readLine();
reader.close();

JavaScript (Node.js)

const fs = require('fs');
fs.writeFileSync('data.txt', 'Hello, world!');
let data = fs.readFileSync('data.txt', 'utf-8');

Buffering in File I/O

When data is read or written, it is often first stored in a buffer to optimize performance.

• Buffered I/O: High performance, data is batched
• Unbuffered I/O: Direct read/write, less efficient
• Flushing: Forces buffered data to be written to disk

In many languages, file closing implicitly flushes the buffer.

Text vs Binary Files

Reading a binary file as text may result in decoding errors or corrupt data.

Common File I/O Errors

Best practice: always use try-catch or exception handling to handle I/O operations gracefully.

File Metadata and Attributes

Many systems support retrieving metadata like:

• Size
• Creation/modification time
• File permissions
• File type (regular, directory, symlink)

Python Example:

import os
info = os.stat("data.txt")
print(info.st_size)  # size in bytes

Random Access with Seek

For large files, it’s inefficient to read from the beginning each time. Use seek() to move the file pointer.

Python

with open('data.txt', 'rb') as f:
    f.seek(10)         # Move 10 bytes from beginning
    chunk = f.read(4)  # Read 4 bytes

C

fseek(fp, 10, SEEK_SET);
fread(buffer, sizeof(char), 4, fp);

This is useful for:

• Updating specific bytes
• Implementing custom data structures (e.g., B-trees)
• Handling large binary logs

File Locking and Concurrency

When multiple processes or threads access the same file, race conditions and data corruption can occur.

• File locks prevent concurrent write/read clashes
• Most OSs support:
  • Advisory locks (cooperative)
  • Mandatory locks (enforced by OS)
• Cross-platform locking is tricky—platform APIs differ

Best Practices for File I/O

✅ Use with or context managers to auto-close files
✅ Handle exceptions explicitly
✅ Prefer buffered I/O for performance
✅ Avoid hardcoding paths; use environment configs
✅ Use binary mode for non-text data
✅ Validate and sanitize user input file paths (security!)

File I/O Performance Considerations

• Batching writes is faster than multiple small writes
• Buffered I/O is faster than unbuffered
• Disk I/O is slower than memory or cache—minimize disk hits
• Use memory-mapped files for high-speed access to large data
  • e.g., mmap module in Python, mmap() syscall in C

Use Cases of File I/O

Real-World Analogy

Imagine a filing cabinet. You:

• Open a drawer (open a file)
• Find the right folder (seek position)
• Read or insert documents (read/write)
• Close the drawer when done (close file)

File I/O is how software interacts with the digital equivalent of that cabinet.

Summary Table

Related Keywords

Append Mode
Binary File
Buffered I/O
Character Encoding
EOF (End of File)
File Descriptor
File Handle
File Lock
File Mode
Filesystem
Memory-Mapped File
Path Resolution
Read Operation
Random Access File
Seek Pointer
Stream
Text File
Unbuffered I/O
Write Operation
Working Directory