Codeless Code

Higher-kinded types in declarative JSX syntax

Sat, 24 Jan 2026 23:39:00 -0800

I’ve oft thought JSX an under-utilized syntax. In the current day, JSX is cruelly relegated to frontend component architectures. In my view, there’s much to explore re using JSX as a way to represent other interesting things.

Declarative MVC via Jotai & React

Wed, 05 Nov 2025 18:30:44 -0800

React is a library for declaratively specifying user interfaces. Jotai is a complementary library for declaratively modeling state in a monadic way. When these are used purposefully, what arises is a very sane MVC architecture built with boring technology [1].

Capture Semantics

Wed, 08 Oct 2025 11:09:09 -0700

As part of my efforts on ts-unify, I needed a way to represent ‘capturing’ and transforming values in a data structure from one form to another. This article elucidates those extraction semantics.

Towards type-aware declarative codemods via unification

Sun, 07 Sep 2025 11:13:46 -0700

I’ve been playing with codemod transformations for TypeScript using jscodeshift (from Facebook) and ts-pattern. Working closely with these has made me want a declarative type-aware codemod engine for TypeScript, which I haven’t yet been able to find.

Variational Selector Text Stenography

Sat, 23 Aug 2025 13:58:16 -0700

This interactive tool demonstrates a steganographic technique using Unicode variation selectors (U+E0100-U+E017F) to encode hidden text within visible strings. By mapping ASCII characters to these invisible codepoints, messages can be embedded undetected - a potential vector for prompt injection attacks whereby LLMs may process hidden instructions.

Kind Reification

Tue, 07 Feb 2023 23:17:12 -0800

The hkt-toolbelt library introduces kind reification - transforming abstract type-level functions into concrete runtime signatures. This enables point-free programming where compositions like Pipe<[Map<Inc>, Filter<IsEven>, Reduce<Add>]> become executable functions with 1:1 corresponding types. By bridging TypeScript’s type system with runtime code, we can write type-level pipelines that are both type-safe and actually invokable.

to reify: make (something abstract) more concrete or real.

Type-level Collatz Sequence

Thu, 08 Dec 2022 22:58:35 -0800

Implementing the famous Collatz conjecture entirely within TypeScript’s type system, demonstrating type-level arithmetic and recursive computation. The sequence follows $n \rightarrow n/2$ if even, $n \rightarrow 3n+1$ if odd, conjecturing all positive integers reach 1. Using template literal types and conditional type recursion, we can compute Collatz<27> yielding the 111-step sequence purely at compile time - pushing TypeScript’s type system to perform actual mathematical computation.

Typesafe Function Composition

Sun, 09 Oct 2022 16:45:40 -0700

This deep dive explores implementing mathematically-correct function composition with full type safety. We’ll build a compose function where compose<A, B, C>(f: B→C, g: A→B): A→C validates type compatibility at compile time, handle variadic arguments through recursive types, and ensure composed pipelines like compose(toString, Math.sqrt, parseInt) automatically infer as (s: string) => string while preventing invalid compositions from compiling.

Towards a well-typed plugin architecture

Mon, 05 Sep 2022 12:03:54 -0700

Designing a type-safe plugin system in TypeScript that maintains strong typing guarantees while allowing extensible functionality. Using discriminated unions and generic constraints, we can build plugin architectures where registerPlugin<T extends Plugin>() enforces interface contracts at compile time. This approach enables dynamic feature extension while preserving full IDE support and preventing runtime type errors - useful for maintaining large-scale extensible applications.

A non-recursive type-level inclusion operator

Sat, 27 Aug 2022 16:37:21 -0700

A performance-optimized, non-recursive implementation of a type-level array inclusion operator in TypeScript. By leveraging tuple spread syntax and conditional types instead of recursive patterns, we achieve Includes<[1, 2, 3], 2> evaluation in O(1) type instantiation depth rather than O(n). This technique improves compile-time performance for large tuple operations, avoiding TypeScript’s recursion depth limits while maintaining the same type-level guarantees.

Point-free Programming via HKTs

Fri, 11 Mar 2022 09:34:39 -0800

Implementing point-free (tacit) programming patterns in TypeScript using Higher Kinded Types to overcome traditional type system limitations. Point-free style eliminates explicit arguments, composing functions like pipe(map(inc), filter(isEven), reduce(add)) instead of x => x.map(inc).filter(isEven).reduce(add). Through HKT encodings, we achieve true tacit programming where type inference flows through the entire pipeline, enabling cleaner functional abstractions without sacrificing TypeScript’s type safety.

Variadic HKT Composition

Sat, 05 Mar 2022 00:17:15 -0800

Extending Higher Kinded Types with variadic composition patterns, enabling clean functional composition while preserving complete type information. Building on HKT foundations, this explores variadic compositions where Compose<[F, G, H, ...]> handles arbitrary function chains with full type inference. Using advanced tuple manipulation and distributive conditional types, we achieve compositions like pipe(map, flatten, filter, reduce) that maintain type safety across any number of transformations - a significant advancement in TypeScript’s functional programming capabilities.

Higher Kinded Types in Typescript

Thu, 03 Mar 2022 22:18:42 -0800

A comprehensive introduction to Higher Kinded Types in TypeScript, exploring how to encode and utilize these powerful abstractions from functional programming. HKTs enable type constructors that take other type constructors as arguments - imagine Functor<F> that works for any F<T> whether it’s Array<T>, Promise<T>, or Option<T>. Through encoding techniques using interface augmentation and symbol keys, we can simulate HKTs in TypeScript, making possible advanced functional patterns like monadic composition and type-safe algebraic structures previously impossible in the language.

Type Guard Composition

Sun, 14 Nov 2021 12:08:01 -0800

Building composable type guard systems in TypeScript where runtime validation seamlessly integrates with compile-time type narrowing. Type guards like isString(x): x is string enable safe runtime checks, but composing them requires careful design. This explores combinators for union guards or(isNumber, isString): x is number | string, intersection guards and(hasName, hasAge): x is Person, and variadic patterns that preserve type inference. The result: elegant runtime validation that TypeScript’s control flow fully understands.

Programs of Length N: Collatz, Chaitin, and Church

Fri, 03 Sep 2021 15:12:34 -0700

How many lambda calculus programs exist with exactly $N$ terms? This exploration dives into deep questions about computational complexity, from counting programs like (λx. x x) (λx. x x) to analyzing the non-computable BB(N) busy beaver function that grows faster than any computable sequence. We examine Chaitin’s constant $Ω$ and why determining program convergence connects to unsolved problems like the Collatz conjecture collatz(3n + 1).

Unchained Tuple Types

Sat, 09 Jan 2021 16:33:40 -0800

Using TypeScript’s asserts syntax to create imperative-style type mutations, moving beyond method chaining to more familiar iterative patterns for complex type operations.

String Deduplication on the Type Level

Sat, 09 Jan 2021 15:18:24 -0800

Solving the classic string deduplication algorithm entirely within TypeScript’s type system using literal string types and recursive type manipulation.

Chained Tuple Types

Tue, 05 Jan 2021 20:23:23 -0800

TypeScript 4.1’s variadic tuple types enable building complex type-safe data structures through method chaining, where each operation expands the chain’s type signature at compile time.

Enforcing Function Map Constraints

Wed, 16 Dec 2020 19:41:08 -0800

Exploring how to enforce type constraints across function maps in TypeScript, where every function must accept a specific parameter type.

Self Modifying Type Predicates in Typescript

Sun, 03 May 2020 19:41:57 -0700

TypeScript’s type predicates can modify the type of this itself, enabling self-modifying type behavior that approaches dependent types. By implementing is<K extends keyof ShapeTypes>(type: K): this is ShapeTypes[K] on abstract classes, we achieve compile-time type narrowing where shape.is('circle') transforms the shape variable’s type from Shape to Circle, unlocking properties like shape.radius within conditional blocks.

Dijkstra's Shunting Yard in Typescript

Mon, 23 Dec 2019 16:39:53 -0800

A functional TypeScript implementation of Dijkstra’s classic algorithm for parsing mathematical expressions, converting infix notation to reverse Polish notation for stack-based evaluation.

Bay Area SSC Meetup

Mon, 03 Jun 2019 12:37:10 -0700

Attending the annual Slate Star Codex meetup in San Francisco’s Dolores Park, connecting with the rationalist community during my first summer in the Bay Area.

Pythagorean Triple Problem in Sub-linear Time

Sun, 10 Mar 2019 15:48:49 -0400

We explore a solution to finding Pythagorean triples with a product constraint, achieving O(√n) time complexity by reducing the problem to the well-known 3SUM problem.

Mathematica Steps to LaTeX [WiP]

Fri, 01 Feb 2019 15:01:48 -0500

Exploring methods to extract human-readable step-by-step solutions from Mathematica’s symbolic computation, addressing the black-box problem in automated mathematical derivation.

Quadtree Particle Simulation

Mon, 28 Jan 2019 13:59:19 -0500

A JavaScript particle physics simulation using a quadtree spatial data structure to efficiently compute inter-particle forces, optimizing from O(n²) to near-linear complexity.

Contact

Sat, 26 Jan 2019 12:14:54 -0500

Double Pendulum

Fri, 25 Jan 2019 20:58:30 -0500

An interactive JavaScript simulation demonstrating the chaotic behavior of a double pendulum system, showcasing how small changes in initial conditions lead to dramatically different outcomes.

Oriented Bounding-Box Heuristic

Fri, 25 Jan 2019 20:35:20 -0500

A fast O(n) heuristic for finding near-optimal oriented bounding boxes around point sets, using orthogonal linear regression to align rectangles with the natural orientation of the data.

2019 Presidential Luncheon

Fri, 25 Jan 2019 18:58:29 -0500

A memorable meeting with ODU’s president as part of a Tau Beta Pi engineering honor society event.

One-Dimensional Linear Regression

Fri, 25 Jan 2019 18:27:02 -0500

An interactive demonstration of simple linear regression, showing how the least-squares method finds the best-fitting line through a set of data points by minimizing vertical distances.

Quadratic Bezier Curves

Fri, 25 Jan 2019 17:40:45 -0500

An interactive visualization of quadratic Bézier curves, demonstrating how three control points define smooth parametric curves commonly used in computer graphics and design.

about

Fri, 25 Jan 2019 16:24:07 -0500

This is the blog of Alice Poteat. I’m a staff software engineer at volley - where I facilitate the dreams of our wonderful product team - and help unlock our shared vision for the future of “Netflix-style” interactive entertainment.

Among my current professional responsibilities are:

Coding.
Acting as technical project manager of various multi-team confidential projects.
Auditing hiring, team practices, and technical architecture across five engineering teams composed of 40+ engineers.
Reviewing all manner of major technical decisions, especially those involving security.
Talent recruiting.
- please message me on LinkedIn if you’re looking!

education

I got a nice classical state engineering education then defected to startup land. I’m a proud alumnus of Old Dominion University and Tidewater Community College.