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.