2017-02-18

future.md

• Blockchain of blockchains with RSA public keys for resource registry (domain + intents/messages accepted)
• Go down from HTTP/WS to have a simpler/more essential protocol for communication. Protocol not based on simple human analogies (verb, noun)
• Protocol is (hopefully) implementation of Real OOP.
• External resources in the language are represented with URLs
• Discovery/caching decisions (URL resolution) is delegated to the runtime
• Runtime should eventually be a hypervisor that only manages resource allocation. Or dedicated hardware, programs for FPGA. High level functional language for FPGA programming.
• Language is expressed in an AST. AST can be formatted in different transport encodings (JSON for example).
• Language is just representation of category theory operations between the resources, assuming they fulfillthe expected types.
• Language is lazy and asynchonous by default. Tagline: "sync is just async that works very fast"
• Under the hood, operations are Real OOP (messages)
• Even if everything is actually local, the language and module system are modelled to be "internet native". The language is a "systems language", much like Erlang/Rust, but where the "system" is the internet. Purely functional, strongly typed systems programming language.

using types as data:

Note: Mistakes made here: the types are not necessary as argument if lifting is not being done.

[
  {
    id: 1,
    nodeType: 'Link',
    url: 'http://dormammu.com/Monoid'
  },
  {
    id: 2,
    nodeType: 'Link',
    url: 'http://dormammu.com/NaturalTransformation'
  },
  {
    id: 3,
    nodeType: 'ValueReference',
    type: 1
  },
  {
    id: 4,
    nodeType: 'ValueReference',
    type: 1
  },
  {
    id: 5,
    nodeType: 'ValueReference',
    type: 2
  },
  {
    id: 4,
    nodeType: 'ValueReference',
    type: 3
  },
  {
    id: 5,
    nodeType: 'ValueReference',
    type: 3
  },
  {
    id: 6,
    nodeType: 'ValueReference',
    type: 4
  },
  {
    id: 7,
    nodeType: 'Operation/Concatenation',
    arguments: [4, 5]
  },
  {
    id: 8,
    nodeType: 'Operation/NaturalTransformation',
    arguments: [5, 7]
  },
  {
    id: 9,
    nodeType: 'Operation/Concatenation',
    arguments: [8, 6]
  },
  {
    id: 10,
    nodeType: 'ReturnValue',
    reference: 9
  }
]

equivalent to:

import {Add, Multiply} from 'fantasy-monoids'

const fromAddToMultiply = x => Multiply(x.fold())

abstractChainedConcat = a => b => c => x => y => z => 

http://dormammu.com/Monoid : Monoid
http://dormammu.com/Data : Data

-> Monoid : a
-> Monoid : b
-> Data : c
-> c : y
-> c : z

> a (-> c x)) : aX
> a y : aY

+ aX aY : aXY

> b (< aXY) : bXY

<- (+ bXY (> b c))

same program

> a (-> c x)) : aX

-> http://dormammu.com/Monoid : a
http://dormammu.com/Data : Data

-> Monoid : b

> a y : aY

-> c : y

-> Data : c

<- (+ bXY (> b -> z))

+ aX aY : aXY

> b (< aXY) : bXY

> a (-> c x)) : aX

-> http://dormammu.com/Monoid : a
-> http://dormammu.com/Monoid : b
http://dormammu.com/Data : Data

> a y : aY

-> c : y

-> Data : c

<- (+ bXY (> b -> z))

+ aX aY : aXY

> b (< aXY) : bXY