The Rust community turned .clone() into a moral failing. That dogma is as dangerous as the Jedi Council’s inability to adapt. We put the guilt under a microscope: the real performance numbers, the clippy lint that reinforces it, and the type theory that explains why Rust makes duplication visible in the first place.
Move, borrow, clone, Rc, Arc, Cow. Rust gives you six lightsaber forms for ownership. Each one counters a specific threat. Using the wrong form against the wrong opponent is not just inelegant, it is fatal. We map each strategy to the situations where it excels and where it fails catastrophically.
The Rust community treats .clone() like a code smell. Sometimes it is. But most of the time, the instinct to avoid it costs more in complexity than the clone costs in nanoseconds. We dissect what clone actually does for every common type, the real cost spectrum across six orders of magnitude, and why Clone and Copy are not the same conversation.
We start a new series by migrating the CLI adapter to a ratatui TUI. We set up the new dependencies, design the module structure under adapters/tui/, model the interaction modes as an enum to make invalid states unrepresentable, and solve the ownership puzzle of cloning a repository in a persistent session.
We close the series by exploring what it means to migrate from CLI to TUI with ratatui: how the interaction model changes, what frictions Rust introduces with ownership and &mut in a persistent event loop, and why hexagonal architecture absorbs the change without surgery.
My first impressions of Rust from a functional programming background (Scala and Haskell). A mix of excitement, frustration, and a paradigm shift in thinking.