Hypotheses 1

A weirded man on programming the world

/me taps on the mic & loudly speaks: “PREPARE YOUR MIND(S) AS A COLLECTIVE OF INDIVIDUALS!”
/me continues in a lighter manner…

Hypotheses:

Transpilers can automatically compile source code from one programming language to another as long as the compiler is “fully abstract.”

Fully abstract compilation requires source/target languages to meet certain criteria that can be met by any physical context.

Every physical context can be paired with a language context to form a programming language.

Source codes are a type of thing (re)defining, containing & returning infinitely-subtyped, contextually-embeddable types of things.

We can create programming languages to pair with physical contexts that meet full abstraction requirements.

Now, say we know of two source codes that return the same type of thing when executed in the same context.

In other words, the source codes are type & context equivalent.

Fully abstract compilation can be used to go from one context set of sets of type-equivalent sources codes paired with their return types to any physical context we choose.

What this means is we can directly map the reasons common type-equivalent abstract data types in programs are equivalent directly to some type-equivalent abstract data types in the language of whatever…how about the language of gardening? Or theorem-building? Or design?

If you want to get a physical intuition for what monads, functors, functions, etc. look like in the real world, fully abstract compilation lets us identify them.

We can automate the generation of type-equivalent sources in suitably-typed languages for any chosen contexts.

Certain kinds of computer programs occur in nature in ways we’re not noticing.

To start finding them, we need to figure out a way to craft the context’s type system.

That could be bootstrapped by identifying the semantics & syntax of however we communicate in a context.

If we want to write a program for gardening, we can start by using machine learning to build the initial semantics/syntax of gardening.

Then we can manually tweak it til it’s sufficiently typed & accurate.

After that, we can take verbs & the most abstract types from the semantics/syntax of gardening, pair them all up, and see which make sense.

The ones that make sense are types of programs of gardening.

They can be strung together to write new programs.

We can write programs in the real world we’ve never encountered in the real world.

This is how we turn software-centric design into human-centric design into creature-centric design into organic-centric design into life-centric design.

Therefore, we can write human-executed programs operating on types of things related to mindfulness, human connection, attention, addiction, and emotion.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.