Architecture of Complexity

There are recurring emergent “patterns” in the architecture of complexity.

First of all, the seminal paper https://www2.econ.iastate.edu/tesfatsi/ArchitectureOfComplexity.HSimon1962.pdf

It demonstrates an emergent hierarchical layered structure of stable complex systems.

This is, of course, only the beginning. Notice that a properly abstracted out algebra captures actual universal patterns (like a Monod).

Notice also that all the properly captured “universal patterns” can be found in what constitutes a proper functional language Haskell (and the best parts of Ocaml), which is (an implementation of) just extended with syntactic sugar, types and literals pure Lambda Calculus.

Notice that lots of patterns are artificial or just socially constructed (Monad, Category, etc).

emergent patterns are:

just 3 terms of the Lambda Calculus enough to compute everything.
just 3 flow-chart patterns to express any sequential algorithm.
just 3 algebraic types are enough to define everything.

The , | -> is worth of a “sacred symbol”.

The abstraction principle of the mind of an observer

the “natural” capturing and formation of generalized concepts
a “word” as an association and a reference to a concept

the meta-patterns

an indirection (an association, binding or a reference)
a procedural (the lambda) abstraction (by parameterization)
algebraic closures (the result of an operation is in the same set)
lexical closures (capturing of “free variables”)
function composition defined as nesting
an ordered sequence (and its traversal)
environments and extending “frames” (sequences of “bindings”)
generalized recursion and mathematical induction
branching on a condition (if)

emergent

All you need is lambda
currying and partial application
general recursion (a spiral) as the way of looping (cycling)
while (loop) as a generalization of if (condition)

captured and generalized

AND ALSO (in the same locality)
OR ELSE (otherwise)
AND THEN (connected arrows)

Abstracted structural patterns

arrows between dots
sequences as connected arrows
tree-like structures (as having more than one “tail”)

Data patterns

offsets as addresses

Behavioral patterns

a systematic search (breadth-first)
backtracking and restarts (Prolog)

Communication patterns

restarts (on expected failures)
restarts on an offset (from the last “good” state)
streams of individual packets
re-transmission of individual packets
arbitrary order of arrival of packets.
arbitrary routes
asynchronity (decoupling)
timeouts (only to avoid “getting stuck”)