# Lucid Glitch

> A confluence of code, chronicles, and my thoughts. Explore functional programming in Java, Clojure, and F#. Delve into the history and uncover the stories that shape our craft. Here, every glitch reveals a deeper understanding. — I’m Stefan von Stein.

Markdown pages preserve the original text and code examples. Relative links in each page resolve against its Source URL.

## Full content

- [All published content](https://lucidglitch.com/llms-full.txt): Complete text of the pages listed below, including source code.

## Posts

- [Classes are Cheap. Object Orientation is Expensive](https://lucidglitch.com/posts/ooisexpensive/index.md): Private fields do not guarantee ownership. This article explores why objects become costly to reason about, how immutable values help, and what happens when AI accelerates the code.
- [When AI Writes the Code, Who Preserves the Meaning?](https://lucidglitch.com/posts/when-ai-writes-the-code/index.md): As AI writes more of the implementation, the human task becomes preserving the meaning, structure and evolution of the system.
- [Own the Model of Reality](https://lucidglitch.com/posts/own-the-model-of-reality/index.md): Data ownership is really about owning how reality is explained over time.
- [Institutionalized Complexity as Organizational Debt](https://lucidglitch.com/posts/institutionalizedcomplexity/index.md): Noise is rarely a sign of quality. Simple systems need to move only when the domain changes.
- [Software that grows with business](https://lucidglitch.com/posts/software-that-grows/index.md): We are entering a time where software grows alongside the business. In that development we will need more programmers, not fewer.
- [Clojure with M-expressions](https://lucidglitch.com/posts/clojure-with-m/index.md): Would M-expressions make Clojure more popular?
- [Building Strange Loops with GPT](https://lucidglitch.com/posts/strangeloopswithgpt/index.md): From Assistant to Collaborator: The GPT experience gets better when it works with you
- [Java’s Daemon Threads and Their Roots in Ancient Greece](https://lucidglitch.com/posts/daemon-threads/index.md): From Sokrates’ whispering spirit to a Victorian physics prank and into your Java code. Daemon threads have been working quietly in the background for over two millennia.
- [Computational Expressions in Java](https://lucidglitch.com/posts/computational-expressions-in-java/index.md): Simplify error handling further with computational expressions, in Java
- [Early functional Fortran](https://lucidglitch.com/posts/functional-fortran/index.md): Was early fortran a functional assembly language
- [Why Relational Databases Are Absurd](https://lucidglitch.com/posts/relational-databases-absurd/index.md): A rant about how SQL databases forget the past and how immutable, append-only models like Datomic offer a better approach.
- [Backronym Programming Language Poetry](https://lucidglitch.com/posts/backronym-language-poetry/index.md): A whimsical walk through programming languages as acronym spells and poetic code-rants. Nerdy wordplay and irreverent insights.
- [Java without exceptions](https://lucidglitch.com/posts/java-without-exceptions/index.md): Java without exceptions. Using Result in Java
- [Twos complement](https://lucidglitch.com/posts/twos-complement/index.md): How I built a tiny computer
- [Turn your comments into test](https://lucidglitch.com/posts/testify/index.md): Automate your Rich-comments and turn them into e.g. testcases
- [The 14-Year-Old Who Gave Lisp a Home](https://lucidglitch.com/posts/lisp-peter-deutsch-pdp/index.md): From building Lisp on the PDP-1 at age 14 to shaping the future of programming
- [Worry About Data Structures](https://lucidglitch.com/posts/worry-about-datastructures/index.md): Why thinking about data, not syntax, might be the best thing you've done for your code all year.
- [The Tip-Ex key](https://lucidglitch.com/posts/delete-key-history/index.md): A brief and geeky history of the Delete key, ASCII 127, and how mistakes used to be punched into paper.
- [The Teletype Model 33 – And the Curse of line breaks](https://lucidglitch.com/posts/teletype-thirty-three/index.md): The Teletype Model 33 is often blamed for why Windows and Linux have never quite agreed on how to break a line of text
- [Emacs, Java, and the Finger-Twisting History Between Them](https://lucidglitch.com/posts/emacs-and-java/index.md): The unexpected historical overlap between Emacs, Java, and the people who shaped both.
- [Pioneering Women in Programming](https://lucidglitch.com/posts/pioneering-women/index.md): From Ada Lovelace to Fran Allen — a tribute to the women who quietly (and not-so-quietly) built the foundation of modern computing.
- [Lock-free Atoms in F# and Java](https://lucidglitch.com/posts/fsharp-atom/index.md): Lock-free update of state in Java and F# using the the atom model
- [Iterables for functional transformation](https://lucidglitch.com/posts/java-iterable-functional-transformation/index.md): Use recursion with a trampoline to implement functional transformations in Java
- [Map, Filter, Fold with optimized recursion](https://lucidglitch.com/posts/java-map-filter-trampoline/index.md): Use recursion with a trampoline to implement lazy versions of map, filter and fold
- [Immutable Beans in Java](https://lucidglitch.com/posts/immutable-beans/index.md): Using AtomicReference to maintain immutable data with transactional updates in Java
- [Isolation Levels and Write Skew](https://lucidglitch.com/posts/isolation-and-skew/index.md): A few notes on isolation levels in relational databases
- [Functional Composition and Threading Calls in Java](https://lucidglitch.com/posts/java-thread-functions/index.md): Compose to get some flow in Java
- [Expressive Conditionals in Java - Reclaiming the 'if' expression](https://lucidglitch.com/posts/java-cond-expression/index.md):  Replace noisy if statements in Java with expressive, composable alternatives. An implementation of the cond expression for java, similar to the ones in Lisps, using lambda expressions.
- [Random Functional Values](https://lucidglitch.com/posts/random-functional-values/index.md): Reapeatable randomness
- [Tail Call Recursion in Java](https://lucidglitch.com/posts/java-tail-calls-trampoline/index.md): Tail calls in java using a trampoline
- [Reducers & Leibniz](https://lucidglitch.com/posts/reducers-and-leibniz/index.md): Trying out reducers while searching for 𝜋
- [Read Eval Print Loop like Art](https://lucidglitch.com/posts/tiny-clojure-repl/index.md): The source code of REPL is literally (-> (read) (eval) (print) (Loop))
- [Hello World Polyglot in Brainf*ck and Whitespace](https://lucidglitch.com/posts/polyglot-bf-ws/index.md): Esoteric fun with mixing Brainf*ck and Whitespace in the same file
- [Fibo](https://lucidglitch.com/posts/fibo-in-languages/index.md): An interesting walk in lazy calculation of fibo numbers lazilly
- [Strings: Thread Safe at Last](https://lucidglitch.com/posts/java-strings-threadsafe/index.md): Java String is finally thread safe

## Code

- [Result.java](https://lucidglitch.com/code/javawithoutexceptionsresult.java/index.md)
- [Result.java](https://lucidglitch.com/code/computationalexpressioninjavaresultexpression.java/index.md)
- [OptionalExpression.java](https://lucidglitch.com/code/computationalexpressioninjavaoptionalexpression.java/index.md)
- [Iterables.java](https://lucidglitch.com/code/javaiterablefunctionaltransformation.java/index.md)
- [Iterables.java](https://lucidglitch.com/code/iterablesfiltermapfold.java/index.md)
- [Atom.fs](https://lucidglitch.com/code/atom.fs/index.md)

## About and policies

- [Privacy Policy](https://lucidglitch.com/privacypolicy/index.md)
- [License](https://lucidglitch.com/license/index.md)
- [Contact](https://lucidglitch.com/contact/index.md): Reach out or start a discussion
- [About](https://lucidglitch.com/about/index.md)