Theories & Hypotheses

These are the current theories and hypotheses (in a slightly more scientific meaning of the words) influencing the design and implementation of the 3L Project's development. They are just theories and hypotheses and are not set in stone. Most will probably change and be adjusted to match newly gained knowledge, viewpoints, and understandings. Note that many of these hypotheses are built on top of the core system and do not have to be followed or used. The system allows developing completely different systems based on completely different ideas. Hypotheses are generally not proven. Theories have been proven but solutions will likely change. There is no particular ordering to the listings.

For questions, suggestions, and feedback send an email to the 3L Project hackers list.


Theory: people ultimately write code, not computers.

Small Core

Hypothesis: The core system, the part that must be compiled or implemented in hardware, benefits from being small.

Language Mixing

Hypothesis: Different languages can be mixed together without FFIs.

Mixed together in this case means, for example, a function from one language can invoke a function from another language or reference a variable from another language, seamlessly. Given some care in design of the lowest level all languages can be compiled down to the same base language which allows for seamless integration. This is made significantly easier because of Small Core.

This can be further enabled by providing an environment of readers to each reader and a separate eval and/or compilation step for each language.

(scheme (+ 1 ((lambda (proc) (proc 2))
  (javascript function(n) { return scheme((+ n 1)); }))))

; returns 4

In the example '(scheme ...)', 'scheme(...)', and '(javascript ...)' denote the reader to be used. Readers are lexically scoped to a 'reader' environment. A reader can, of course, also include a compilation/translation step before returning the underlying lisp code.

In the example, a possible compilation of the Javascript portion could be:

(lambda (n) (+ n 1))

It would also be possible for readers to extend other readers to process "intermediate" forms.


Hypothesis: domain specific languages lead to better systems than layers of libraries and frameworks.

Descriptors Instead of Data Structures and Algorithms

Hypothesis: data structures and algorithms are irrelevant details when describing solutions to problems.


Hypothesis: performance is an implementation detail and should not influence system design.

Dropping System Support for Strings, Arrays, other Structures

Hypothesis: strings, arrays, booleans, and other common programming language data structures and types are unnecessary in the core system and lead to code bloat which conflicts with "Small Core".


Hypothesis: Lisp is the optimal language for the core system. As we know it today it is probably not the end game but the best we have now. More research and experimentation is highly welcome and encouraged.


Theory: hardware architecture can be massively improved.