Is the Unix philosophy really outdated? - Nice Micro Monday #8

Summary

The video argues that Unix philosophy is still relevant in the Linux/free software ecosystem, despite criticism that modern Linux favors monolithic or multifunction software suites.

Core concept: Unix philosophy

• Assumption: each program should do one specific thing.
• It should do that thing well and predictably.
• Criticism mentioned:
  • Some projects (e.g., systemd) are said to not align with this principle.
  • Even the Linux kernel is argued by some to not “fit” the philosophy.

Why the philosophy is defended

In free software, the key advantage is user freedom:

• You can modify programs, fork, and repurpose them.

Unix-style small, composable tools are claimed to increase practical freedom:

• Outputs from one program can be used as inputs to another.
• This enables building workflows by “linking” programs together instead of relying on one giant application.
• Claimed benefit: more flexibility, including combinations creators may not have originally anticipated.

Example: custom bash backup script

The speaker describes a personal backup script written in bash that:

• checks file update times/dates,
• uses rsync for copying/syncing,
• combines multiple small utilities to create a flexible backup process.

Contrast:

• Instead of a single-purpose tool like TimeShift, the script can be modified to match specific needs.

The speaker claims:

• While shell scripting can seem “scary,” it offers greater achievable flexibility than changing and recompiling a large monolithic program (e.g., modifying C source).

Future-proofing and maintainability

The video suggests Unix philosophy can improve sustainability of free software:

• Smaller components are separately maintainable.
• Easier for others to reuse parts of a project without understanding/removing everything.
• Easier for community-driven development (often hobbyist or partially funded contributors) to keep components usable over time.

Counterexample discussed: Audacity

Audacity is presented as an example of problematic software evolution:

• Described as old with a complex codebase.
• In proprietary contexts, maintainers might monetize to retain developers.
• In free software contexts, maintainability and forkability are emphasized, but the speaker notes that complex/entangled code makes reuse harder.

The speaker imagines how a Unix-philosophy approach could help:

• For instance, separate binaries/components for specific functions (like an audio compressor) that could be embedded into other applications.
• Without this, developers may have to surgically remove code or rewrite basic operations from scratch.

Conclusion

Although Unix philosophy can seem outdated at the user experience level (big “do everything” applications), the speaker argues it remains valuable for:

• free software freedom (reuse, modification, forkability),
• sustainable development,
• and building future projects from smaller reusable parts.

Main speakers / sources

• Main speaker: Not explicitly identified in the subtitles (speaker is the video creator/host).
• Projects/tools mentioned as sources/examples:
  • systemd
  • Linux kernel
  • bash
  • rsync
  • TimeShift
  • Audacity
  • Mastodon (for channel presence)