Posts

Categories

All posts

  1. A small Markdown showcasePinned
  2. Borrowing notes

    Borrowing is easiest to understand as a statement about relationships rather than punctuation. A reference says that some value remains owned elsewhere and that the current code may use it under a particular set of rules.

  3. Error messages are part of the interface

    An error variant may be designed for a program, but its final message is read by a person who needs to decide what to do next. That makes wording and context part of the interface rather than decoration added at the end.

  4. Types and text

    Text is rarely “just a string.” The moment a program needs to compare, display, slice, normalize, or persist it, an implicit model of text becomes part of the design.

  5. What a type name promises

    A type name is a small promise about the values a program may contain. When the name and the representation disagree, every caller must quietly repair that promise in its own head.

  6. Defaults are part of the interface

    A default is a decision made on behalf of every person who does not stop to configure the software. That makes it more important than most advanced options, even when it occupies only one line of code.

  7. Reading old code slowly

    Old code is easiest to misunderstand when approached as a cleanup exercise. Before changing it, I try to learn which constraints shaped it and which of those constraints still exist.

  8. A small essay worth keepingRepost

    This fictional repost demonstrates how Inkcairn credits an original author and points readers back to the source without hiding the local copy.

  9. Tools that disappear

    The small tools I trust most become almost invisible during use. They preserve the shape of the task, respond quickly, and leave behind results that do not depend on the tool remaining installed forever.

  10. Software that keeps working

    Longevity rarely comes from predicting every future requirement. It comes from choosing inputs and outputs that remain understandable when the implementation between them has to change.