Research

JAPL is a typed actor language designed from first principles. These papers document the rationale behind each core decision — from typed processes and supervision to LLM effects and distribution.

Design Papers

Seven papers covering JAPL's type system, ownership model, concurrency, error handling, distribution, composition, and runtime.

I

Values Are Primary

Immutable data, algebraic types, and pattern matching.

View PDF → II

Mutation Is Local and Explicit

Linear types, ownership, confined mutability.

View PDF → III

Process-Based Concurrency

Lightweight processes, typed messages, supervision.

View PDF → IV

Typed Failures

Error values, result types, recovery strategies.

View PDF → V

Native Distribution

Location-transparent processes, typed protocols.

View PDF → VI

Function Composition

Pipelines, higher-order functions, algebraic effects.

View PDF → VII

Runtime Simplicity

Minimal runtime, compile-time reasoning.

View PDF →

Foundations

JAPL's design is informed by category theory and a biological analogy for type classification.

Category Theory & the Yoneda Lemma

JAPL's type system is grounded in the insight from the Yoneda lemma: an object is fully characterized by its relationships to all other objects. In practice, this means a type in JAPL is defined by how it can be constructed, destructured, and transformed -- not by an internal representation. This principle drives the design of algebraic data types, pattern matching, and trait-based polymorphism throughout the language.

DNA-Inspired Type Classification

JAPL maps biological DNA classifications to programming language constructs, revealing structural parallels between genetic systems and type systems.

DNA Class Language Construct Role
ProteinCode Functions Executable code -- the fundamental units of computation.
Regulator Effects Control flow and scheduling -- determines when and how code executes.
RNAControl Signals Interrupts and modifiers -- runtime events that alter execution paths.
Structure Types Memory layout and architecture -- the shape of data at rest.
Repeat Macros Self-modifying and dynamic -- code that generates other code.
Epigenetic State Runtime state and permissions -- mutable context governed by the type system.
Developmental Programs High-level orchestrators -- compositions that emerge from simpler parts.