Recreational Programming

You guys are getting paid?

Show of hands:

How many of you learned programming because it was fun?

Part 1

What is Recreational Programming?

Definition

Programming for the joy of programming itself - not for work, not for money, not for external requirements.

What it looks like:

  • Building things because you're curious how they work
  • Exploring new languages just to see what they feel like
  • Solving problems that only exist in your head
  • Creating tools for problems you don't actually have
  • Writing code that makes you smile

What it's NOT:

  • Side hustles or potential startups
  • Skill building for career advancement
  • Following tutorials step-by-step
  • Grinding through coding challenges for interviews
  • Building what others expect you to build
The key distinction: Internal motivation vs. external pressure

Why it matters:

  • Prevents burnout by reconnecting with intrinsic motivation
  • Develops intuition through low-stakes exploration
  • Maintains long-term passion for the craft
  • Often leads to unexpected breakthroughs and learning

Part 2

The Recreational Programming Spectrum

Style 1: The Live Explorer

  • Builds in public through streams or blogs
  • Shows the messy process: dead ends, bugs, restarts
  • Community becomes accountability and energy source
  • Projects range from practical tools to pure experiments

Style 2: The Deep Diver

  • Obsesses over understanding how things really work
  • Builds toy versions of complex systems
  • Values learning over shipping
  • Often has multiple "educational" implementations

Style 3: The Creative Technologist

  • Uses code as artistic medium
  • Generative art, music synthesis, interactive installations
  • Technology serves creative vision
  • Often blends programming with other disciplines

Style 4: The Problem Solver

  • Scratches personal itches with code
  • Tools that solve tiny annoying problems
  • "Good enough" solutions that work for them
  • Often accidentally builds useful things

Style 5: The Language Explorer

  • Constantly trying new languages and paradigms
  • Implements same concepts across different languages
  • Drawn to unusual or experimental languages
  • Code as intellectual curiosity

Part 3

Common Patterns Across All Styles

Permission to Build "Useless" Things

  • No business case required
  • Curiosity is sufficient justification
  • Failed experiments still teach valuable lessons
Key insight: ROI doesn't apply to recreational programming

Follow Energy, Not Plans

  • Switch projects when excitement fades
  • Multiple abandoned repos are exploration, not failure
  • Boredom is data about what interests you
Key insight: Boredom is data, not defeat

Document the Journey

  • Share process, not just results
  • Teaching forces deeper understanding
  • Creates connection with others on similar paths
Key insight: Narrate your decisions

Embrace the Learning Process

  • Beginner's mind in new domains
  • Comfortable with not knowing
  • Process over product
Key insight: Progress over perfection

Part 4

Your Personal Programming Playground

The Environment

  • Dedicated "experiments" folder/repo
  • No production concerns: minimal setup, no CI/CD pressure
  • Quick project initialization scripts
  • Version control optional

Approaches You Can Try

  • Weekly Experiments (2-4 hours exploring one new thing)
  • Scratch-Built Challenges (Build toy versions of tools you use)
  • Itch-Scratching Projects (Solve your own annoying problems)
  • Teaching Projects (Build something while explaining it)
  • Cross-Language Challenges (Same problem, different languages)

The Mindset Shifts

  • "What if..." instead of "I should..."
  • Progress over perfection
  • Learning over shipping
  • Curiosity over productivity

Part 5

Real Examples in the Wild

Zikani Nyirenda - The Practical Experimenter

  • Creates random but useful tools: browser automation, file organizers, Git utilities
  • Experiments across Go, Rust, Python, Vue, and React
  • "What small problem can I solve today?" approach to coding
  • Perfect example of scratching personal itches through code

github.com/zikani03

Jeremiah Chienda - The Full-Stack Experimenter

  • Explores different architectural patterns and frameworks
  • Builds tools that solve real problems while learning new technologies
  • Shows how recreational programming can span the entire tech stack

github.com/liwoo

Tsoding Daily - The Live Explorer

  • Streams 4+ hours daily building random projects from scratch
  • Built his own text editors, programming languages, ray tracers
  • Shows complete process including failures and debugging
  • "Let's see what happens if..." approach to everything

ThePrimeagen - The High-Energy Problem Solver

  • Creates CLI tools and Neovim plugins for personal workflow optimization
  • Infectious enthusiasm for dev tools and performance
  • Reacts to and critiques other developers' code/approaches
  • Makes optimization and tooling feel like extreme sports

Casey Muratori - The Systems Deep Diver

  • Handmade Hero: Building a complete game from scratch on stream
  • Explains every single line of code and system design decision
  • No libraries, understanding everything from first principles
  • Demonstrates that you can build modern software without frameworks

Ben Eater - The Educational Builder

  • Builds computers on breadboards, explains every component
  • Creates video series on how CPUs, memory, and networks actually work
  • Takes months to build what you could buy for $5
  • Makes hardware fundamentals accessible and fascinating

Dan Luu - The Deep Technical Investigator

  • Writes detailed blog posts investigating performance mysteries
  • Benchmarks everything: keyboards, terminals, programming languages
  • Turns curiosity about "why is X slow?" into multi-thousand word research
  • Demonstrates how recreational investigation can uncover industry-wide issues

Each represents a different path back to programming joy

Closing Challenge

Pick one experiment:

  1. Build the worst possible version of a tool you use daily
  2. Spend 2 hours with a language you've been curious about
  3. Document yourself solving a small problem
  4. Fork an interesting project and mess with it
  5. Try live coding or streaming your process
The only rule: Stop if it stops being fun.

Final Thought

"The goal isn't to become any of these programmers. It's to remember why you started coding and keep that curiosity alive alongside your career."