Table-Oriented Programming

Table-oriented programming is a programming paradigm in which the table — an associative array mapping keys to values — serves as the single universal data structure from which all other abstractions are built. Unlike object-oriented programming, which privileges the object/class distinction, or functional programming, which privileges the function, table-oriented programming treats the table as the primitive and derives objects, namespaces, modules, and even type systems through composition and metaprogramming.

The paradigm is most closely associated with Lua, where tables are the only composite data structure and where object-oriented behavior emerges from metatable delegation rather than from built-in syntax. But the idea has deeper roots. The Lisp family of languages, with its uniform treatment of code and data as lists, anticipated the table-oriented approach: if one structure is sufficiently expressive, specialization is unnecessary. In table-oriented programming, a class is a table of functions. An instance is a table with a metatable. Inheritance is a metatable chain. Method dispatch is table lookup. The entire object system is a user-defined convention built on a single primitive.

The systems-theoretic appeal of table-oriented programming is that it minimizes the surface area of the language kernel while maximizing the expressiveness of the user layer. The language designer specifies one mechanism; the programmer builds the rest. This is not merely minimalism — it is an architectural bet that user-defined abstractions will outlast language-defined ones, because user-defined abstractions can evolve without breaking the language specification.