Project:M36 — Relational Algebra DBMS

Project:M36 is a relational-algebra-based database management system implemented in Haskell. It adheres strictly to the mathematics of the relational algebra — no NULL, no SQL compromises. Key differentiators:

• •Transaction Graph: Git-like branching/merging for database transactions (not a linear log)
• •Pure Relational Algebra: Type-safe, composable operators with algebraic optimization
• •Native Haskell Integration: Any Atomable type can be a database value; Haskell functions run inside the DB
• •TutorialD: Chris Date's teaching language as the primary interactive interface

When to use this skill

Invoke this skill when the user asks about:

• •Project:M36 architecture, setup, or usage
• •Relational algebra concepts (in the context of Project:M36)
• •TutorialD syntax or operations
• •Haskell ↔ Project:M36 integration (Tupleable, AtomFunctions, custom types)
• •Transaction graph operations (branching, merging, time-travel)
• •SQLegacy (SQL compatibility layer)

Additional Resources

Getting Started

• •Introduction to Project:M36 — Overview, installation (Docker/source), and feature summary
• •Introduction to the Relational Algebra — Mathematical foundations underpinning the system
• •15-Minute Tutorial — Quick hands-on walkthrough
• •TutorialD Tutorial — Comprehensive TutorialD language guide
• •TutorialD Cheatsheet — Quick reference for TutorialD syntax
• •Developer Setup — Building from source and development environment

Architecture & Theory

• •ACID Assessment — How Project:M36 satisfies ACID properties
• •Data Independence — Towards an architecture for data independence
• •On NULL — Why Project:M36 rejects NULL and what replaces it
• •Reaching Out of the Tarpit — Philosophical design rationale (cf. "Out of the Tar Pit")
• •Commits in O(1) — Constant-time transactional commits
• •Merkle Transaction Graph — Merkle hashing for transaction integrity
• •Filesystem Persistence — Persistence layer design proposal

Transaction Graph

• •Transaction Graph Operators — Branching, jumping, and graph navigation
• •Merge Transactions — Merging divergent branches
• •Merge Notes — Automatic merge conflict resolution details
• •Trans-Graph Relational Expressions — Querying across transaction graph nodes

Client Libraries & Access

• •Haskell Client Library — Native ProjectM36.Client API
• •Simple Client API — Simplified client interface
• •JavaScript Driver — JS/Node.js driver
• •WebSocket Server — WebSocket-based access layer
• •Server Mode — Running as a network server

Haskell Integration

• •Tupleable — Marshaling Haskell data types to/from database tuples
• •Atom Functions — Extendable functions operating on atomic values
• •Database Context Functions — Functions that modify database context
• •Creating New Data Types — Defining custom algebraic data types in the DB
• •Haskell Integration Guide — End-to-end Haskell application integration

Schema & DDL

• •Isomorphic Schemas — Schema transformations preserving information content
• •Handling DDL Changes — Managing data definition language changes

Features

• •DataFrames — DataFrame-style ordered/limited result sets
• •CSV Import/Export — Importing and exporting relations as CSV
• •Notifications — Event-driven notification system
• •Replication — Multi-node replication architecture
• •Jupyter Kernel — TutorialD kernel for Jupyter notebooks

SQL Compatibility

• •SQLegacy — SQL frontend on the relational algebra engine
• •Why SQLegacy? — Rationale for providing SQL compatibility

Assets

• •basic_benchmarks.html — Criterion benchmark report
• •committed_database_state.dot / initial_database_state.dot — Graphviz diagrams of database state
• •sample_session.asciinema.json — Terminal session recording