How my approach to stories evolved toward delivering value in every commit
Ideas for optimizing web apps for users with slow internet connections
How Clojure's thread operators improve code readability
A high-level look at how atoms manage state in Clojure
A quick overview of Java interop in Clojure
A tour of Clojure's function composers like comp, partial, and juxt
Why developers should test their own apps the way a tester would
Fixing Reagent components that weren't re-rendering on data changes
Applying the Liskov Substitution Principle to unify similar entity interfaces
Sorting collections in reverse while keeping Clojure's laziness intact
Recommending coding koans as a first step for new programmers
Programmatically capitalizing the first letter of textarea input
Hiding known bugs behind feature flags until they can be properly fixed
Using multimethods to simplify dispatch for drag and drop handlers
Using stubs to develop and test features that need authentication
Implementing ordered one-to-many associations in Datomic
That relieving moment when you finally squash an elusive environment bug
Auto-resizing textareas to fit their content
Implementing scroll-on-click behavior in ClojureScript
Thinking about what code actually deserves tests on a fundamental level
The complexity of managing state across drag, hover, and drop events
Figuring out what is and isn't worth testing in ClojureScript view code
Applying Occam's Razor to favor simpler solutions in code
Keeping lower-level functions simple and predictable for their callers
Why users notice how an app looks and feels before anything else
Choosing component names that reveal the page structure at a glance
How reading test specs can answer questions faster than reading source code
Running into a new limit of Clojure's lazy evaluation
Finding simpler solutions by stepping back from the current implementation
What it really takes to become a programmer: desire and willingness to learn
Strategies for keeping entity data tidy during active development
How I overcame the fear of leaving a stable job for an apprenticeship
The bugs and headaches that come with linked list data structures
Trying to get Semantic UI working in a ClojureScript Hiccup project
Implementing XOR logic from basic gates in Clojure
Different ways to create anonymous functions in Clojure with partial
When to extract markup code into components and when to leave it inline
Using truth tables from discrete math to simplify boolean logic in code
Simplifying math expressions step by step, in code and on paper
What if Quil drawing commands used Hiccup syntax instead
Identifying and removing unused code to keep the codebase clean
Why delivering less but complete beats delivering more but broken
Resisting the urge to skip tests for tricky ClojureScript interop code
Using CSS variables to implement light and dark mode toggling
Debugging a Reagent Form 2 component that wasn't picking up new props
Why experimentation is essential to making discoveries in code
The value of working through problems together with other developers
How frequent merges prevent painful conflicts on team projects
Why I stopped optimizing code before it actually needed it
Why learning should come from genuine curiosity, not just career pressure
Refactoring a sprawling file into small, focused namespaces
Why enthusiasm, pride, and purpose keep developers loving their work
Adding focus and blur event listeners to Reagent components
Comparing Form 2 atoms vs namespace-level state management in ClojureScript
Testing core logic without coupling tests to the HTTP rendering layer
Getting more comfortable with git branches and merges on a team project
Sometimes it's faster to build on the whole design than decompose first
Working with pre-built HTML/CSS designs and adding functionality on top
A debugging rabbit hole caused by mixing up Reagent form types
Testing ClojureScript component behavior with c3kit spec-helper
Building my first ClojureScript project with Reagent for Tic Tac Toe
Using clojure.tools.namespace to track file and dependency changes
The different ways to pass functions as arguments in Ruby
Using a compiled Clojure JAR from Ruby code
A closer look at how compiled Clojure functions appear in Java
Why Ruby feels surprisingly functional coming from Clojure
Compiling Clojure into a JAR file for the first time
How Clojure maps pass seamlessly into Java code without type casting
Making Clojure functions conform to Java's Function interface
How easy it is to pull external Java JARs into a Clojure project
Applying Occam's Razor to keep software configurations simple
A simpler approach to serving different file types over Java sockets
Handling multiple POST actions on a single web page
Using anonymous classes to unit test Java functions with complex dependencies
My first impressions of Hiccup and building a web page with it
Figuring out state management for a Quil-based Tic Tac Toe GUI
Writing test descriptions that read well in console output, not just the file
Defining the rules for how fish choose their next move in Wa-Tor
How hash maps work under the hood in Clojure
Breaking down the Wa-Tor simulation into kata-sized pieces
Struggling through Quil setup and the classpath issues that came with it
My first year participating in Advent of Code
Finding mathematical shortcuts for Project Euler grid path problems
Finally getting Datomic set up locally after hours of troubleshooting
Using Clojure's and/or operators for more than just boolean logic
Choosing the right AI difficulty for different Tic Tac Toe board sizes
Mapping out every winning path for a 3D Tic Tac Toe game
Following up on destructuring with how it works for Clojure maps
Finally making sense of collection destructuring in Clojure
The subtle but important difference: Clojure macros aren't values
Trying to add sorting methods directly onto generic List types in Java
Keeping multiple views in sync without coupling them together
Passing comparison functions as parameters for generic sorting in Java
How the Abstract Factory pattern connects to the Liskov Substitution Principle
Notes on Bubble Sort, Merge Sort, and Quick Sort from a great documentary
Finding Clojure's reduce-kv for cleaner key-value reductions
Fixing my minimax algorithm to handle tie scenarios correctly
Reflecting on missed sprint goals and how to estimate better
Using Clojure protocols to dispatch behavior for different player types
Discovering reduced, repeatedly, and get-in while building Tic Tac Toe
Understanding Java iterators while implementing the List interface
Refactoring a recursive combinations algorithm into something cleaner
Walking through my thought process on the Coin Changer Kata
Eliminating code duplication while implementing Java's List interface
Using Clojure's try-catch to clean up messy input validation
Finding out Clojure had integer division all along
Rethinking how to count factors efficiently for a Project Euler problem
Why software developers should embrace creativity in their code
How gensym helps generate unique symbols for Clojure macros
My first real experience writing Java from scratch
Learning Clojure's different quoting syntax for macros
Why overdoing SOLID principles can make code worse, not better
Tracing the origins of the Single Responsibility Principle
Wrapping my head around Clojure's code-is-data philosophy
How Clojure multimethods compare to interfaces in typed languages
Experimenting with different ways to write the same function in Clojure
Breaking down the Decorator Pattern and its key components
Getting my head around Clojure's thread-first and thread-last macros
How I solved Euler Problem 3 by rethinking prime factorization