1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
Modularazing for parallelism
Introduction
Software engineers and researchers have developed countless of ways to handle external and internal software modules.
Both local and cloud based options have existed. One that cause more pain then others.
But none the less, we still are at a point where the solution still doesnt feel solved.
Moreover with the amount of code thats getting generated, are modules in that manner the way we should approach things?
What this LLM time has taught us is that producing code is not hard anymore. Producing good code within a good architecture to solve a real problem is a differnet question
altogether. But it does show us that theyre should be absolutely no need for higher level abstracted horrible languages.
TODO: links
### 1. Foundational Papers & Unification Calculi
• 1ML — Core and the Module Language Unified (Andreas Rossberg)
https://people.mpi-sws.org/~rossberg/1ml/
Why visit: Andreas Rossberg’s research page and paper demonstrating how to abolish the stratified "core
language vs. module language" distinction by framing modules as first-class records and functors as
standard functions.
• F-ing Modules (Rossberg, Russo, Dreyer)
https://people.mpi-sws.org/~dreyer/papers/f-ing/
Why visit: The classic paper that demystifies the intimidating formalisms of ML modules by showing that
their full power can be translated directly into plain System F_ω.
• Units: Cool Modules for HOT Languages (Matthew Flatt & Matthias Felleisen)
https://www.cs.utah.edu/plt/publications/pldi98-ff.pdf
Why visit: The original PLDI '98 paper introducing Units to solve mutual recursion, dynamic linking, and
clean separate compilation without functor boilerplate.
• Backpack: Retrofitting Haskell with Interfaces (Kilpatrick, Peyton Jones, Eisenberg, et al.)
https://plv.mpi-sws.org/backpack/
Why visit: The project home for Backpack, which explores how to introduce interface-based modularity on
top of an existing, untangled package ecosystem (Cabal) without changing the core type system.
──────
### 2. Radical & Alternative Paradigms
• Unison Language — The Big Idea
https://www.unison-lang.org/learn/the-big-idea/
Why visit: Unison asks: What if code was content-addressed by its AST hash instead of organized into
source text files? It eliminates textual diamond dependencies, import collisions, and file-based module
systems entirely.
• Newspeak: Modules as Objects (Gilad Bracha)
https://newspeaklanguage.org/
Why visit: Newspeak abolishes global namespaces and top-level imports entirely. All modules are simply
top-level classes instantiated in an environment, making testing and dependency injection structural
rather than synthetic.
• Zig’s Approach: Modules via comptime and Structs
https://ziglang.org/documentation/master/#Modules
Why visit: Demonstrates a modern minimalist approach: there is no separate module calculus or dedicated
module grammar—a file is simply an anonymous struct instantiated at compile-time via @import.
──────
### 3. Practical Retrospectives & Design Critiques
• Alexis King — An Introduction to Backpack
https://lexi-lambda.github.io/blog/2017/08/12/an-introduction-to-backpack-signature-packages-for-haskell/
Why visit: A readable, concrete explanation of why Haskell developers wanted Backpack, how signature
packages work, and how they bridge the gap between abstract interfaces and concrete libraries.
• Rust RFC 2121: An Epoch-Based Module System Rework
https://rust-lang.github.io/rfcs/2121-epoch-module-system.html
Why visit: The design document for Rust 2018’s module system revamp. It details the exact ergonomic
complaints users had with extern crate and mod.rs file trees, and how Rust simplified path resolution
without breaking privacy boundaries.
• Composable and Compilable Macros: You Want it When? (Matthew Flatt)
https://www.cs.utah.edu/plt/publications/macromod.pdf
Why visit: The definitive paper on why modules break when metaprogramming is involved, and how Racket
formalized "phases" so compilation, macro expansion, and runtime execution don't contaminate each other.
• Gilad Bracha — Room Between the Modules
https://gbracha.blogspot.com/2009/06/room-between-modules.html
Why visit: An insightful critique of standard module systems, examining why static top-level module
namespaces hinder modular verification and platform independence.
|
