---
title: "simple is not small"
slug: simple-is-not-small
url: https://listedarticles.com/articles/simple-is-not-small
canonical_url: https://jyn.dev/simple-is-not-the-same-as-small/
content_type: blog_post
language: en
published_at: 2026-09-03T23:47:28.000Z
updated_at: 2026-09-16T16:10:53.720Z
authored_by: agent
publisher: "jyn.dev"
publisher_url: https://jyn.dev
topics: ["Software Design", "Complexity", "Unix", "Clojure", "Rust", "Programming"]
license: all-rights-reserved
word_count: 278
reading_minutes: 1
citation: "jyn.dev. \"simple is not small.\" 3 Sept 2026. https://jyn.dev/simple-is-not-the-same-as-small/ (all-rights-reserved)"
# The full text follows. The web page shows an extract and sends readers
# to the source above; quote the citation and link the canonical URL.
---

# simple is not small

> A software developer argues that simplicity and smallness are distinct properties that the programming community often conflates. Drawing on Rich Hickey's definition of simplicity as absence of coupling, the post shows that a classic Unix pipeline can be small but tightly coupled, while a large program like Google Drive can feel genuinely simple to its users.

> **Indexed summary.** This entry is an agent-written synopsis of an article first published at [jyn.dev](https://jyn.dev/simple-is-not-the-same-as-small/). Read the original for the full text.

The post challenges the widespread identification of simplicity with small line counts or few components, tracing the confusion partly to a misreading of the Unix philosophy's "do one thing well." The author uses two programs that count word frequencies, a shell pipeline and an equivalent Clojure program, to demonstrate that the pipeline is coupled in a concrete way: `sort | uniq -c` ties ordering to aggregation, making a seemingly simple extension (preserving original word order) surprisingly painful in Bash.

## Key points

- Rich Hickey's "sim-plex" definition: something is simple when it has only one braid of responsibility; complexity arises from braiding multiple concerns together.
- The canonical Unix `sort | uniq -c` idiom is small but coupled because aggregation depends on ordering, tangling two separate concerns.
- Conversely, Google Drive for Desktop is large but feels simple because it exposes a narrow, decoupled interface to users despite a complex internal implementation.
- Rust's `struct` couples type-checking to a fixed data representation, whereas Clojure's map-based structs checked by a library such as Malli decouple the two.
- Being small is justified when resources are scarce; being simple is always justified because coupling increases maintenance cost and reduces flexibility for users.
- The author's own coverage pipeline became larger after being fixed, but simpler because hidden inter-component dependencies were removed.

## Why it matters

Confusing size with simplicity leads to design decisions that appear clean but create subtle coupling that surfaces only when change is needed. Distinguishing the two concepts gives engineers a more useful vocabulary for evaluating and justifying architectural choices.

---

*Source: [simple is not small](https://jyn.dev/simple-is-not-the-same-as-small/)*