Writing.

A look back at Riot's OCaml actor runtime, the scheduler and I/O challenges it faced, and what comes next.

A comparison of exceptions and results in OCaml, from signaling failures to handling and reporting errors ergonomically.

Parsing WebSocket frames in OCaml with bitstring pattern matching, inspired by Erlang, Elixir, and Gleam.

A socket-pool bug reveals the low-level pitfalls of OCaml's Unix module and makes the case for safer networking APIs.

Use type-state in OCaml to make invalid state-machine transitions impossible while keeping the API approachable.

An OCaml validation example shows when GADTs help, when they add complexity, and why simpler types often suffice.

Model a web router with OCaml types to explore a domain, challenge assumptions, and refine the design quickly.

Make Rust HashSet literals easier to write with array conversions and a small set! macro.

A reflection on the tension between building tools for your own problems and solving problems that matter to other people.

Lessons from a large ReScript codebase on standard libraries, bindings, package interfaces, and maintainable project structure.

Build on ReScript's type-checking rules to understand how the compiler types functions and compound expressions.

A practical introduction to how ReScript infers types for variables and uses the environment to check code.

An account of starting Warp while managing ADHD, constant distractions, and the rhythms of digital nomad life.

Build a concurrent queue in TypeScript and ReScript to compare correctness, developer experience, and interoperability.

Bind Deno's Flags module from ReScript to parse command-line arguments with stronger types and a cleaner API.

Explore using Deno to build and distribute standalone ReScript programs without relying on Node.js tooling.

Why semantic data tools still make domain modeling, schema evolution, and code generation harder than they should be.

An OCaml command-line library shows how powerful abstractions can become difficult to use without approachable APIs and documentation.

A comparison of organically grown systems and planned architectures, and the tradeoffs between immediate value and long-term design.

A short story about a programmer who learns to carry a critical, constructive compiler into every code review.

Code that is easy to write can burden future readers unless its hidden context and assumptions are made explicit.

Fast prototypes can still be maintainable when their domain concepts are explicit and implementation details stay behind clear boundaries.

An attempt to type Erlang exposes the challenges of unions, records, receive expressions, and dynamic dispatch on the BEAM.

A hands-on journey from Markdown to a live-updating website argues for understanding and managing complexity rather than hiding it.

Extend a Dota 2 ontology so different kinds of ability affinity can describe how one effect changes another.

Model Dota 2 ability affinities as relationships and explore how an ontology can represent synergy between spells.

Describe Dota 2 heroes and abilities in an ontology to reason about why particular spells work well together.

Start a Dota 2 ontology in Protégé with the goal of reasoning about interactions between heroes and abilities.

The hardest part of ontology work is acquiring and questioning domain knowledge, not learning formal logic or tooling.

Generate application code from ontology data to make semantic models more practical for everyday engineering.

Global, durable identifiers can help knowledge systems keep their data meaningful as software and ownership change.

Every data language makes tradeoffs about validation, domain fit, and how much information a program can express.

Revisit older computing ideas to rethink web applications around failure isolation, asynchronous work, and parallel execution.

Compare JavaScript symbols with atoms in other languages and show how Symbol.for creates stable, reusable names.

A pragmatic look at running long-lived services in Docker and deciding when each process deserves its own container.

A woodworking detour and a family illness prompt a reflection on time, craft, and choosing what deserves attention.

Public GitHub activity tells only part of the story when much of a developer's work happens in private repositories.

Practical fixes for building a PhoneGap app with Ember App Kit, from assets and bootstrapping to REST adapters.

Leaving home for Denmark becomes a reflection on change, resilience, and learning to trust your own direction.

A proposal for a lightweight development process that connects code changes, deployment, planning, and team communication.

Testing can sting because it exposes mistakes, but that discomfort is what helps us write better software.

How TucJS helped a local JavaScript community in Tucumán grow into new meetups and lasting connections.