Mastodon logo Join the Digital Sovereignty Movement on Mastodon!

Intro

6 min read
1185 words

Philosophical Explorations

Welcome to my philosophical explorations, where absurdism meets algorithms and humanity grapples with the machines we've built.

Philosophical Musings on Modern Absurdism

Exploring Humanist Absurdism, Techno-Absurdism, and Neo-Absurdism through the lens of "The Labyrinth of Sisyphus" and real-world implementation in code, community, and commerce.

The Three Extensions of Absurdism

Humanist Absurdism

The radical act of choosing compassion in systems designed for cruelty

The philosophy of embedding kindness within inhuman systems. When we cannot escape the labyrinth, we can at least ensure it contains windows, gardens, and secret doors. Every line of code is a moral choice.

Living This Philosophy:

  • Code as Care: Every error message, every comment, every interface choice affects real humans. Django Spellbook includes educational content in documentation. Storm Checker explains type errors instead of just flagging them. AI2U keeps data local-first by default.
  • Business as Compassion: Storm Development doesn't just build websites - we enable digital transformation for small businesses who can't afford Silicon Valley agencies. We teach while we build, ensuring clients understand their own systems.
  • Teaching as Resistance: Creating educational content that preserves human understanding in an age of AI automation. The 80-20 philosophy keeps humans in the loop, not because it's efficient, but because human judgment matters.
  • Community as Garden: Building spaces where people grow together. The Django community, the Mastodon migration, the 80-20 movement - these aren't just networks but gardens we tend together.

Practical Actions You Can Take:

  • Write documentation that teaches, not just describes
  • Choose open source over proprietary when possible
  • Share knowledge freely despite capitalism's demand for scarcity
  • Build accessibility into everything from the start
  • Refuse to implement dark patterns, even under pressure

→ Explore Humanist Absurdism in depth

Techno-Absurdism

We build prisons of logic that learn to perfect themselves

The recognition that we've created systems that operate beyond human comprehension while still serving human-defined goals. We are architects of our own incomprehension, debugging processes that debug themselves.

How This Manifests:

  • The Toolchain Paradox: Django Spellbook generates views from markdown which gets parsed to HTML which gets served by Django which renders templates. Each layer of abstraction makes development "easier" while making the system more opaque.
  • The Framework Recursion: We build frameworks (Spellbook) on frameworks (Django) on frameworks (Python) to manage complexity we created by building frameworks.
  • The Testing Loop: Storm Checker checks types that TypeScript infers from JavaScript that runs on engines written in C++ that compile to assembly. We test our tests with tests.
  • The AI Education Trap: We teach AI to help us code, which generates code we don't understand, which we need AI to explain, creating a dependency loop that strengthens with each iteration.

Breaking Through:

  • Build tools that reveal their own workings (Django Mercury's educational mode)
  • Choose transparency over black boxes (open source everything)
  • Document not just what but why (philosophical code comments)
  • Preserve human understanding alongside automation

→ Explore Techno-Absurdism in depth

Neo-Absurdism

The boulder was training for building better boulders

The philosophy that our punishments evolve to match our capacity to endure them. We don't just push boulders—we optimize boulder-pushing, gamify it, monetize it, and teach others to do the same. We become complicit in perfecting our own containment.

The Cycles We Build:

  • The Agency Trap: Storm Development helps businesses go digital, knowing they'll become dependent on the very platforms we're helping them escape. But we teach them enough to maintain agency within dependency.
  • The Content Loop: Creating educational content about escaping content creation. Writing about not writing. Teaching productivity to procrastinate productively.
  • The Open Source Paradox: Contributing free labor to projects that corporations monetize. But we do it anyway because the alternative - closed source - is worse.
  • The Optimization Obsession: Every tool promises to save time that we spend learning new tools. Django Spellbook saves boilerplate writing time that we spend writing SpellBlocks.

Conscious Participation:

  • Acknowledge the absurdity without surrendering to cynicism
  • Choose which systems to participate in thoughtfully
  • Build exit ramps into everything you create
  • Celebrate small rebellions within larger compliance

→ Explore Humanist Absurdism in depth

Core Practices for Living These Philosophies

In Code

# Humanist: Every error message is a teaching opportunity
raise ValueError("Expected a string, got {type(value).__name__}. "
                "Strings in Python are text surrounded by quotes: 'like this'")

# Techno: Acknowledge the absurdity of our abstractions
# This function calls a function that returns a function 
# that generates functions. I'm sorry.

# Neo: Build the tools of our own liberation/containment
class SpellBlock:
   """Makes Django development magical, or at least less painful.
   Yes, we're adding complexity to reduce complexity. 
   Welcome to software engineering."""

In Business

  • Pricing Transparency: Show clients exactly what they're paying for
  • Knowledge Transfer: Every project includes teaching the client
  • Open Source First: Default to sharing unless there's a reason not to
  • Exit Strategy: Help clients become independent, not dependent

In Community

  • Teach While You Learn: Document your journey for others
  • Lift While You Climb: Bring others up with you
  • Question While You Build: Ask why, not just how
  • Share While You Compete: Cooperation over competition

The Daily Practice

Morning Questions:

  • What small act of kindness can I embed in today's work?
  • Which system am I perpetuating, and how can I humanize it?
  • What knowledge can I share freely today?

Evening Reflection:

  • Did I make technology more human or humans more technological?
  • What did I build that constrains, and what did I build that liberates?
  • Where did I choose compassion when efficiency would have been easier?

Projects as Philosophy

Each project embodies these principles:

  • Django Spellbook: Making Django development magical through simplicity, not complexity
  • Storm Checker: Type checking that makes you better, not dependent
  • AI2U: Local-first data because privacy is a form of compassion
  • Storm Development: Enabling small businesses because David needs tools against Goliath
  • Educational Content: Teaching because knowledge wants to be free
  • 80-20 Movement: Keeping humans in the loop because wisdom matters

Join the Exploration

This isn't academic philosophy - it's lived practice. Every commit is a choice. Every client interaction is an opportunity. Every line of documentation is an act of rebellion against opacity.

Get Involved:

Read More:

  • "The Labyrinth of Sisyphus" - Fiction exploring these themes
  • Code comments in my repos - Philosophy in practice
  • Blog posts on tech ethics - Thoughts in progress

"We build the labyrinth that contains us. The question isn't whether to build - we must. The question is whether we build with windows, gardens, and secret doors for others to find. Every project is a choice: prison or playground, maze or garden, constraint or liberation. Choose wisely, build kindly, document thoroughly."