Archives

An introduction to property-based testing in Python using the hypothesis library, with practical examples.

Deploying a PostgreSQL-backed application with one-click deploys to AWS and Heroku.

Applying Haskell's 'lifting into structure' concept to compose individual shell commands cleanly within Docker.

An exploration of using PostgreSQL directly as an application backend, covering architecture and motivation.

The specific AWS and cloud services that justify the cost and complexity of moving infrastructure to the cloud.

What makes cloud infrastructure uniquely valuable: the optionality it provides to scale, swap, and adapt.

Using the ice rink as an analogy for DevOps: high learning curve, but infrastructure becomes natural with practice.

Using Docker as a drop-in replacement for Vagrant to create reproducible, isolated development environments.

How people with a process-oriented mindset can lead effectively in ambiguous, exploratory environments.

A Python developer's honest review of Haskell: the type system, tooling, learning curve, and practical tradeoffs.

Why Disqus is worth removing from your blog and what lightweight alternatives exist.

What the durability and interface design of Bose QC25 headphones can teach us about building long-lasting software.

Design principles for writing software meant to survive decades of changing requirements and technology.

A practical, approachable introduction to monads in Python — no category theory required.

How changelogs evolve as a product matures, and what they reveal about team culture and process.

Key takeaways from the Python concurrency series and guidance on choosing the right concurrency model.

Designing data-intensive Python systems using concurrency patterns suited for high-throughput workloads.

Leveraging CPU and hardware-level parallelism in Python for compute-bound workloads.

Communicating Sequential Processes and Python coroutines as a structured approach to concurrency.

The actor model as a higher-level abstraction for concurrency in Python.

Separating identity from mutable state to make concurrent Python programs easier to reason about, drawing from Clojure.

Why isolating development environments matters, and practical tools for doing it in Python.

Applying functional programming principles to simplify concurrent code in Python.

A mental model for thinking about product dimensions when scoping features and making tradeoffs.

A quick look at character encodings in Python 3 and common mistakes to avoid.

Using threads and locks as low-level concurrency primitives in Python, and the pitfalls to watch for.

An introduction to concurrency in Python: what it is, why it matters, and when to reach for it.

A quick snippet for generating randomized spatial test data in PostGIS.

Applying gestalt principles — proximity, similarity, and closure — to software design for more cohesive system architecture.

How the pytest-based ETL test harness evolved to manage fungible infrastructure and capture stateful resource dependencies.

How chained operations in an ETL pipeline drove a breaking schema update to the pytest-based data-driven test harness.

How data-driven testing with pytest evolved to handle data engineering challenges in an ETL tool built on odo.

Exploring requirements for building a data-driven testing framework with pytest.

Debugging Julian/Gregorian calendar mismatches encountered in PySpark date handling.

Hello World!