OGP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# State Machine and Object Graph Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "shared project with Valeri Rakitine on the [eco-programming course](http://www.evaclick.ca/courses/course_01_eco-programming/)\n",
    "* (c) Valeri Rakitine https://www.linkedin.com/in/valrakitine/\n",
    "* (c) Dmitry Ponyatov <<dponyatov@gmail.com>>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Install (Linux)\n",
    "\n",
    "```\n",
    "~$ git clone -o gh https://github.com/ponyatov/OGP.git\n",
    "~$ cd OGP\n",
    "~/OGP$ make install\n",
    "```\n",
    "#### Run\n",
    "```\n",
    "~/OGP$ make jupyter\n",
    "```\n",
    "or use Binder interactive session: https://mybinder.org/v2/gh/ponyatov/OGP/master?filepath=OGP.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concept Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CP here is a programming model described in the works of Enn Heraldovich Tyugu about model-based software development. It is not mean [the term by Alexsandr Stepanov](https://en.wikipedia.org/wiki/Concept_(generic_programming) ) here. The common idea is about making domain models describe the problem in a wide in the form of relation networks, and automatic program (code) synthesis from specifications to solve concrete tasks. This synthesis works over these networks using them as generic knowledge representation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://www.cs.ioc.ee/~tyugu/\n",
    "* [Концептуальное программирование](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%86%D0%B5%D0%BF%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)\n",
    "* Э.Х.Тыугу **Концептуальное программирование** [tyugu]\n",
    "* J. Symbolic Computation (1988) 5, 359-375\\ **The Programming System PRIZ** [sym88]\n",
    "* М.И.Кахро, А.П.Калья, Э.Х.Тыугу **Инструментальная система программирования ПРИЗ** [priz]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "from graphviz import Digraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Base Node Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The core of the graph interpreter system is a homoiconic model uses a directed graph of objects as both program and data representation. The idea was taken from [1] and extended with the ability to store not only slots (attributes) but also hold any frames in an ordered container.\n",
    "* https://www.youtube.com/watch?v=nXJ_2uGWM-M\n",
    "\n",
    "Frames originated as a technology used for knowledge representation in artificial intelligence. They are very close to objects and class hierarchies in object-oriented languages although their fundamental design goals are different. Frames are focused on the explicit and intuitive representation of knowledge whereas objects focus on encapsulation and binding data with processing procedures. Original Marvin Minsky's concept *lacks some principal features for software design*, so it must be extended with the ability to *store sequential collections*.\n",
    "\n",
    "In practice, the techniques and capabilities of the frame model and object-oriented languages overlap significantly so much as we can treat frames not only a native superset of OOP but they drastically extend object design concepts wider: we can represent any knowledge in frames, and use any programming paradigms as we desire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Frame:\n",
    "    def __init__(self, V):\n",
    "        # scalar data value\n",
    "        # mostly names the frame, but also can store things like numbers and strings\n",
    "        self.val = V\n",
    "        # named slots = attributes = string-keyed associative array\n",
    "        self.slot = {}\n",
    "        # ordered storage = program AST nested elemens = vector = stack\n",
    "        self.nest = []\n",
    "        # unique storage id (Redis,RDBMS,..)\n",
    "        self.sid = '@%x' % id(self)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This data node structure which combines named slots with the ordered collection is definitively required for representing any program source code, as this is very close to classical AST and attribute grammar but uses graph in place of the attributed tree. The object graph (frame) representation of a program as a primary form is effective and *native for any work involved with source code transformations*: synthesis, modifications, analysis, cross-language translation, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Factically, **we don't require any text programming language at all**, as this *Executable Data Structure* can\n",
    "* hold any program statically (as storage),\n",
    "* be executed by the EDS-interpreter, so it is *active data*\n",
    "* translated into any mainstream language or\n",
    "* [cross-]compiled into machine code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Homoiconic programming model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Homoiconicity** is a property of a programming language in which any program is simultaneously\n",
    "* an easy to modify *data structure*, and\n",
    "* an *executable program representation* (program source code).\n",
    "\n",
    "In a homoiconic language, a programmer does not just have access to the source code, but the language itself specifically provides tools and easy to use methods for convenient work with parts of programs (represented as generic data) in runtime.\n",
    "* Say, if you include source code of your program in C++ into the distribution package, you can work with the program code as data, but only at the level of text files, or using third-party analysis libraries. In the C++ language itself, there are no dedicated tools for reading, modifying, or generating source code.\n",
    "* Conversely, in the Lisp language, all programs are represented in the form of executable lists -- these lists are simultaneously a program and the usual universal data structure for working with which the language was specially created."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EDS Interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to use the advantages of homoiconicity in your programs written in any conventional languages (C++, Java,..), you need to integrate an EDS-interpreter into your programs that will\n",
    "* *execute some data structure as a program*, and additionally\n",
    "* provides high-level *tools for modifying it* in runtime.\n",
    "\n",
    "It is not necessary that this interpreter should include a parser of some scripting language, as graph structure can be generated by code in the *implementation* language, and structure self-transformation. To create a program in such a system, you only need to have any way to create an executable data structure in memory: it can be GUI-based drawing, text format parser, external graph database, or some C++ code that forces the compiler to include such a structure in the executable file statically."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metaprogramming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metaprogramming -- when one program modifies (generates) another program, including itself.\n",
    "\n",
    "Metaprogramming is a method of boosting your efficiency as a programmer by expanding the language you use. If you write very similar code every day, in languages ​​that can do meta (Lisp, Nim), you can write small macro programs that will run during the compilation stage, and generate new code by a template, or modify an existing code the way as you need it. Factically, you can add to the language those features that are needed for a narrow set of your specific tasks.\n",
    "\n",
    "In order to be able to use metaprogramming in a full scale, the language or programming system you are using must be homoiconic. If you want to use this method with industrial programming languages, the use of an EDS interpreter will allow you to quickly and conveniently solve your problems, paying for it with some losses in the speed of programs and memory usage (see a comparison of interpreters vs the compilers into machine code)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dump and plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To display an object graph in a human-readable form, we need a way to print in a text form and show it in a graphical plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text tree dump"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Frame(Frame):\n",
    "\n",
    "    # callback for print\n",
    "    def __repr__(self): return self.dump(test=True)\n",
    "\n",
    "    # full tree dump\n",
    "    def dump(self, done=None, depth=0, prefix='', test=False):\n",
    "        # subtree header\n",
    "        tree = self.pad(depth) + self.head(prefix, test)\n",
    "        # block infinitive recursion on graph cycles\n",
    "        if not done:\n",
    "            done = set()  # initialize in the recursion root\n",
    "        if self in done:\n",
    "            return tree + ' _/'\n",
    "        else:\n",
    "            done.add(self)\n",
    "        # slot{}s\n",
    "        for i in self.slot:\n",
    "            tree += self.slot[i].dump(done, depth+1, '%s = ' % i, test)\n",
    "        # nest[]ed\n",
    "        idx = 0\n",
    "        for j in self.nest:\n",
    "            tree += j.dump(done, depth+1, '%s = ' % idx, test)\n",
    "            idx += 1\n",
    "        # resulting subtree\n",
    "        return tree\n",
    "\n",
    "    # short-form dump: <T:V> header only\n",
    "    def head(self, prefix='', test=False):\n",
    "        header = '%s<%s:%s>' % (prefix, self._type(), self._val())\n",
    "        if not test:\n",
    "            header += ' %s' % self.sid\n",
    "        return header\n",
    "\n",
    "    # tree padding\n",
    "    def pad(self, depth): return '\\n' + '\\t' * depth\n",
    "\n",
    "    # type/class tag\n",
    "    def _type(self): return self.__class__.__name__.lower()\n",
    "\n",
    "    # .val dump must be tunable for strings, numbers,..\n",
    "    def _val(self): return '%s' % self.val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "<frame:Hello>\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "hello = Frame('Hello')\n",
    "print(hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot /graphviz/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Frame(Frame):\n",
    "    # recursive traversal with graphviz calls\n",
    "    def plot(self, done=None, dot=None, depth=0, parent=None, link='', color='black', file=None):\n",
    "        def n(frame): return '\\\"%s\\\"' % frame.sid\n",
    "        # block cycles\n",
    "        if not done:\n",
    "            done = set()  # initialize in the recursion root\n",
    "        if self in done:\n",
    "            return dot\n",
    "        else:\n",
    "            done.add(self)\n",
    "        # init plot\n",
    "        if not dot:\n",
    "            dot = Digraph(format='dot', graph_attr={'rankdir': 'LR'})\n",
    "        # node\n",
    "        dot.node(n(self), label=self.head(test=True))\n",
    "        # parent edge\n",
    "        if parent:\n",
    "            dot.edge(n(parent), n(self), label=link, color=color)\n",
    "        # slot{}s\n",
    "        for i in self.slot:\n",
    "            self.slot[i].plot(done, dot, depth+1, self,\n",
    "                              link=i, color='blue')\n",
    "        # nest[]ed\n",
    "        idx = 0\n",
    "        for j in self.nest:\n",
    "            j.plot(done, dot, depth+1, self,\n",
    "                   link='/%s' % idx, color='red')\n",
    "            idx += 1\n",
    "        # subgraph\n",
    "        if depth:\n",
    "            return dot\n",
    "        else: # in recursion root\n",
    "            if not file:\n",
    "                return dot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For ease of graph construction, we need to define a set of operators for frames to use in a Python code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Frame(Frame):\n",
    "\n",
    "    # A[key]\n",
    "    def __getitem__(self, key): return self.slot[key]\n",
    "\n",
    "    # A[key] = B\n",
    "    def __setitem__(self, key, that):\n",
    "        self.slot[key] = that\n",
    "        return self\n",
    "\n",
    "    # A << B --> A[B.type] = B\n",
    "    def __lshift__(self, that):\n",
    "        return self.__setitem__(that._type(), that)\n",
    "\n",
    "    # A >> B --> A[B.val] = B\n",
    "    def __rshift__(self, that):\n",
    "        return self.__setitem__(that.val, that)\n",
    "\n",
    "    # A // B\n",
    "    def __floordiv__(self, that):\n",
    "        self.nest.append(that)\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "<frame:Hello>\n",
      "\tframe = <frame:left>\n",
      "\tright = <frame:right>\n",
      "\t0 = <frame:World>\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"299pt\" height=\"152pt\"\n",
       " viewBox=\"0.00 0.00 299.28 152.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 148)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-148 295.2803,-148 295.2803,4 -4,4\"/>\n",
       "<!-- &quot;@7f5c18080a90&quot; -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>&quot;@7f5c18080a90&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"53.9452\" cy=\"-72\" rx=\"53.8905\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"20.4452\" y=\"-68.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">frame:Hello</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18080eb8&quot; -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>&quot;@7f5c18080eb8&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"234.0854\" cy=\"-126\" rx=\"46.2923\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"206.5854\" y=\"-122.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">frame:left</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18080a90&quot;&#45;&gt;&quot;@7f5c18080eb8&quot; -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>&quot;@7f5c18080a90&quot;&#45;&gt;&quot;@7f5c18080eb8&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#0000ff\" d=\"M94.3722,-84.1187C122.0243,-92.4078 158.7548,-103.4184 187.6147,-112.0697\"/>\n",
       "<polygon fill=\"#0000ff\" stroke=\"#0000ff\" points=\"186.8829,-115.5041 197.4668,-115.023 188.8929,-108.7989 186.8829,-115.5041\"/>\n",
       "<text text-anchor=\"middle\" x=\"142.3904\" y=\"-105.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">frame</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18080e80&quot; -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>&quot;@7f5c18080e80&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"234.0854\" cy=\"-72\" rx=\"50.8918\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"203.0854\" y=\"-68.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">frame:right</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18080a90&quot;&#45;&gt;&quot;@7f5c18080e80&quot; -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>&quot;@7f5c18080a90&quot;&#45;&gt;&quot;@7f5c18080e80&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#0000ff\" d=\"M107.9932,-72C128.4774,-72 151.9377,-72 173.0235,-72\"/>\n",
       "<polygon fill=\"#0000ff\" stroke=\"#0000ff\" points=\"173.1605,-75.5001 183.1604,-72 173.1604,-68.5001 173.1605,-75.5001\"/>\n",
       "<text text-anchor=\"middle\" x=\"142.3904\" y=\"-75.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">right</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18069160&quot; -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>&quot;@7f5c18069160&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"234.0854\" cy=\"-18\" rx=\"57.3905\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"198.0854\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">frame:World</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18080a90&quot;&#45;&gt;&quot;@7f5c18069160&quot; -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>&quot;@7f5c18080a90&quot;&#45;&gt;&quot;@7f5c18069160&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M94.3722,-59.8813C120.5396,-52.0372 154.8368,-41.7561 182.9007,-33.3435\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"183.9699,-36.6769 192.5438,-30.4528 181.9599,-29.9717 183.9699,-36.6769\"/>\n",
       "<text text-anchor=\"middle\" x=\"142.3904\" y=\"-52.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/0</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f5c180b8588>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello = Frame('Hello')\n",
    "world = hello // Frame('World') << Frame('left') >> Frame('right')\n",
    "print(world)\n",
    "world.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stack operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`nest[]` part of the `Frame` object can work both as vector and stack, so to manipulate with this stack we need to define a set of methods, will be used later in the FORTH-like language demo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stack effect if comments were taken from FORTH: `( before -- after )`\n",
    "* stack state is written in `( parens )`\n",
    "* `before` is a top of stack state, the rightmost element is the top element on the stack\n",
    "* `after` part shows stack state after some function/word execution\n",
    "* the optional element after `->` shows return value from the Python method\n",
    "  * if there is no `->` method returns the object itself which contains a modified stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Frame(Frame):\n",
    "\n",
    "    # ( 1 2 3 -- 1 2 3 ) -> 3\n",
    "    def top(self): return self.nest[-1]\n",
    "    # ( 1 2 3 -- 1 2 3 ) -> 2\n",
    "    def tip(self): return self.nest[-2]\n",
    "    # ( 1 2 3 -- 1 2 ) -> 3\n",
    "    def pop(self): return self.nest.pop(-1)\n",
    "    # ( 1 2 3 -- 1 3 ) -> 2\n",
    "    def pip(self): return self.nest.pop(-2)\n",
    "\n",
    "    # ( 1 2 3 -- 1 2 3 3 )\n",
    "    def dup(self): return self // self.top()\n",
    "    # ( 1 2 3 -- 1 2 )\n",
    "    def drop(self): self.pop(); return self\n",
    "    # ( 1 2 3 -- 1 3 2 )\n",
    "    def swap(self): return self // self.pip()\n",
    "    # ( 1 2 3 -- 1 2 3 2 )\n",
    "    def over(self): return self // self.tip()\n",
    "    # ( 1 2 3 -- 1 3 )\n",
    "    def press(self): self.pip(); return self\n",
    "    # ( 1 2 3 -- )\n",
    "    def dot(self): self.nest = []; return self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Meta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Meta(Frame): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"115pt\" height=\"44pt\"\n",
       " viewBox=\"0.00 0.00 114.59 44.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 40)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-40 110.5905,-40 110.5905,4 -4,4\"/>\n",
       "<!-- &quot;@7f5c18075be0&quot; -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>&quot;@7f5c18075be0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"53.2953\" cy=\"-18\" rx=\"53.0913\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"20.2953\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Frame</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f5c18075ac8>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Class(Meta):\n",
    "    # initialize Class objects from Python classes\n",
    "    def __init__(self, C):\n",
    "        Meta.__init__(self, C.__name__)\n",
    "\n",
    "frame = Class(Frame)\n",
    "frame.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Primitive types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primitive types can be implemented at a low level close to machine hardware, or language primitives, runtime, and core library from the viewpoint of the implementation (target) language in code synthesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Primitive(Frame): pass\n",
    "class Symbol(Primitive): pass\n",
    "class String(Primitive): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "<number:12.34>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Number(Primitive):\n",
    "    def __init__(self, V): Primitive.__init__(self, float(V))\n",
    "\n",
    "Number('+012.340')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "<integer:1234>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Integer(Number):\n",
    "    def __init__(self, V): Primitive.__init__(self, int(V))\n",
    "\n",
    "Integer('+01234')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "<hex:0xdeadbeef>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Hex(Integer):\n",
    "    def __init__(self, V): Primitive.__init__(self, int(V[2:], 0x10))\n",
    "    def _val(self): return hex(self.val)\n",
    "\n",
    "Hex('0xDeadBeef')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "<bin:0b1101>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Bin(Integer):\n",
    "    def __init__(self, V): Primitive.__init__(self, int(V[2:], 0x02))\n",
    "    def _val(self): return bin(self.val)\n",
    "\n",
    "Bin('0b1101')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"615pt\" height=\"233pt\"\n",
       " viewBox=\"0.00 0.00 615.16 233.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 229)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-229 611.1603,-229 611.1603,4 -4,4\"/>\n",
       "<!-- &quot;@7f5c03fdc208&quot; -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>&quot;@7f5c03fdc208&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"63.6943\" cy=\"-126\" rx=\"63.8893\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"22.6943\" y=\"-122.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Primitive</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075be0&quot; -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>&quot;@7f5c18075be0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"253.1834\" cy=\"-207\" rx=\"53.0913\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"220.1834\" y=\"-203.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Frame</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c18075be0&quot; -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c18075be0&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#0000ff\" d=\"M98.8917,-141.0456C130.4535,-154.5372 176.8416,-174.3665 210.5074,-188.7575\"/>\n",
       "<polygon fill=\"#0000ff\" stroke=\"#0000ff\" points=\"209.5079,-192.1365 220.0787,-192.8489 212.2593,-185.6999 209.5079,-192.1365\"/>\n",
       "<text text-anchor=\"middle\" x=\"160.3887\" y=\"-174.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">super</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180754e0&quot; -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>&quot;@7f5c180754e0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"253.1834\" cy=\"-153\" rx=\"57.6901\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"216.6834\" y=\"-149.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Symbol</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c180754e0&quot; -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c180754e0&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M120.8043,-134.1375C142.7281,-137.2614 167.8623,-140.8427 190.2986,-144.0396\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"190.0024,-147.5327 200.3962,-145.4784 190.9899,-140.6027 190.0024,-147.5327\"/>\n",
       "<text text-anchor=\"middle\" x=\"160.3887\" y=\"-144.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/0</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075518&quot; -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>&quot;@7f5c18075518&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"253.1834\" cy=\"-99\" rx=\"51.9908\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"221.1834\" y=\"-95.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:String</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c18075518&quot; -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c18075518&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M120.8043,-117.8625C144.1558,-114.5352 171.1494,-110.6889 194.6459,-107.3409\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"195.418,-110.7663 204.8243,-105.8906 194.4305,-103.8363 195.418,-110.7663\"/>\n",
       "<text text-anchor=\"middle\" x=\"160.3887\" y=\"-117.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/1</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075550&quot; -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>&quot;@7f5c18075550&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"253.1834\" cy=\"-45\" rx=\"59.5901\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"215.1834\" y=\"-41.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Number</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c18075550&quot; -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdc208&quot;&#45;&gt;&quot;@7f5c18075550&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M99.0759,-110.8286C113.4458,-104.6702 130.2082,-97.4909 145.3887,-91 166.2898,-82.0631 189.4774,-72.1658 208.9754,-63.8484\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"210.3995,-67.0461 218.2245,-59.9033 207.6531,-60.6073 210.3995,-67.0461\"/>\n",
       "<text text-anchor=\"middle\" x=\"160.3887\" y=\"-94.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/2</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075588&quot; -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>&quot;@7f5c18075588&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"415.2232\" cy=\"-45\" rx=\"55.4913\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"380.7232\" y=\"-41.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Integer</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075550&quot;&#45;&gt;&quot;@7f5c18075588&quot; -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>&quot;@7f5c18075550&quot;&#45;&gt;&quot;@7f5c18075588&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M313.0606,-45C325.0343,-45 337.6703,-45 349.8195,-45\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"349.885,-48.5001 359.885,-45 349.8849,-41.5001 349.885,-48.5001\"/>\n",
       "<text text-anchor=\"middle\" x=\"336.4781\" y=\"-48.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/0</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180755c0&quot; -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>&quot;@7f5c180755c0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"562.3143\" cy=\"-72\" rx=\"44.6926\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"535.8143\" y=\"-68.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Hex</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075588&quot;&#45;&gt;&quot;@7f5c180755c0&quot; -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>&quot;@7f5c18075588&quot;&#45;&gt;&quot;@7f5c180755c0&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M463.3863,-53.8408C478.7818,-56.6668 495.8687,-59.8033 511.4501,-62.6634\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"510.9713,-66.1339 521.4389,-64.4969 512.2352,-59.2489 510.9713,-66.1339\"/>\n",
       "<text text-anchor=\"middle\" x=\"493.9683\" y=\"-63.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/0</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180755f8&quot; -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>&quot;@7f5c180755f8&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"562.3143\" cy=\"-18\" rx=\"42.7926\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"537.3143\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Bin</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075588&quot;&#45;&gt;&quot;@7f5c180755f8&quot; -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>&quot;@7f5c18075588&quot;&#45;&gt;&quot;@7f5c180755f8&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M463.3863,-36.1592C479.1942,-33.2575 496.7853,-30.0285 512.6989,-27.1074\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"513.6747,-30.4868 522.8785,-25.2388 512.4109,-23.6019 513.6747,-30.4868\"/>\n",
       "<text text-anchor=\"middle\" x=\"493.9683\" y=\"-34.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/1</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f5c180b7b70>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prim = Class(Primitive) ; prim['super'] = frame\n",
    "symbol = Class(Symbol) ; prim // symbol\n",
    "string = Class(String) ; prim // string\n",
    "number = Class(Number) ; prim // number\n",
    "number // ( Class(Integer) // Class(Hex) // Class(Bin) )\n",
    "prim.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Container(Frame): pass\n",
    "class Vector(Container): pass\n",
    "class Stack(Container): pass\n",
    "class Dict(Container): pass\n",
    "class Set(Container): pass\n",
    "class Queue(Container): pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Frame` is a universal container type, but for most programming tasks we need to specify some container types which have some *special behavior*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"293pt\" height=\"260pt\"\n",
       " viewBox=\"0.00 0.00 292.88 260.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 256)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-256 288.8789,-256 288.8789,4 -4,4\"/>\n",
       "<!-- &quot;@7f5c180b7198&quot; -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>&quot;@7f5c180b7198&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"64.9942\" cy=\"-126\" rx=\"64.9885\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"22.9942\" y=\"-122.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Container</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18075630&quot; -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>&quot;@7f5c18075630&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"230.9337\" cy=\"-234\" rx=\"53.8905\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"197.4337\" y=\"-230.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Vector</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c18075630&quot; -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>&quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c18075630&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M86.5801,-143.2305C108.6189,-160.4289 144.1594,-187.0926 176.9885,-207 181.189,-209.5472 185.6613,-212.0674 190.1648,-214.485\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"188.889,-217.7667 199.3754,-219.2791 192.121,-211.5574 188.889,-217.7667\"/>\n",
       "<text text-anchor=\"middle\" x=\"153.4885\" y=\"-197.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/0</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b79b0&quot; -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>&quot;@7f5c180b79b0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"230.9337\" cy=\"-180\" rx=\"50.0912\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"200.4337\" y=\"-176.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Stack</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180b79b0&quot; -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>&quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180b79b0&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M107.2971,-139.7662C130.759,-147.4012 159.9846,-156.9118 184.1298,-164.7691\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"183.1998,-168.1471 193.7921,-167.9134 185.366,-161.4906 183.1998,-168.1471\"/>\n",
       "<text text-anchor=\"middle\" x=\"153.4885\" y=\"-159.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/1</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b7748&quot; -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>&quot;@7f5c180b7748&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"230.9337\" cy=\"-126\" rx=\"45.4919\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"203.9337\" y=\"-122.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Dict</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180b7748&quot; -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>&quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180b7748&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M130.1016,-126C144.9337,-126 160.5653,-126 174.9765,-126\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"175.2255,-129.5001 185.2255,-126 175.2254,-122.5001 175.2255,-129.5001\"/>\n",
       "<text text-anchor=\"middle\" x=\"153.4885\" y=\"-129.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/2</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180a6ac8&quot; -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>&quot;@7f5c180a6ac8&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"230.9337\" cy=\"-72\" rx=\"41.6928\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"206.9337\" y=\"-68.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Set</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180a6ac8&quot; -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>&quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180a6ac8&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M107.2971,-112.2338C132.05,-104.1787 163.2186,-94.0359 188.0678,-85.9494\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"189.1736,-89.2703 197.5997,-82.8475 187.0074,-82.6139 189.1736,-89.2703\"/>\n",
       "<text text-anchor=\"middle\" x=\"153.4885\" y=\"-100.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/3</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b7320&quot; -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>&quot;@7f5c180b7320&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"230.9337\" cy=\"-18\" rx=\"53.0913\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"197.9337\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:Queue</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180b7320&quot; -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>&quot;@7f5c180b7198&quot;&#45;&gt;&quot;@7f5c180b7320&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M86.5801,-108.7695C108.6189,-91.5711 144.1594,-64.9074 176.9885,-45 181.3541,-42.3527 186.0133,-39.7345 190.696,-37.2304\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"192.3959,-40.2915 199.6587,-32.5777 189.1708,-34.0787 192.3959,-40.2915\"/>\n",
       "<text text-anchor=\"middle\" x=\"153.4885\" y=\"-66.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/4</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f5c180b7c50>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cont = Class(Container)\n",
    "cont // Class(Vector) // Class(Stack) // Class(Dict)\n",
    "cont // Class(Set) // Class(Queue)\n",
    "cont.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stack Machine Interpreter (FORTH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [starting] https://www.forth.com/starting-forth/\n",
    "\n",
    "The Forth programming language is well known as the simplest programming language that can ever be from the viewpoint of the implementation (not programming in it). While you are reading some manual on it such as [starting] or [kelly] you have a feel of understanding how it works inside in case you already have any experience in programming.\n",
    "\n",
    "Forth is not intended to be used as a general-purpose language, it is ugly in this role (see disadvantages later). But, due to its internal simplicity, it stays unbeatable as a command interpreter (CLI shell) and config file parser/interpreter. One of the best usages is using FORTH as a command interface on microcontroller-based devices works over the UART serial port. The language was first designed as a macro system for direct low-level programming of radiotelescope hardware in place of assembler. Its design was great at that moment, having few kilobytes of RAM in a system, provides interactive and programmable command shell. And it still stays good for this narrow use case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What makes Forth unusable, and should be avoided if possible in our sample demo:\n",
    "* **direct byte-level memory addressing**<br>most implementations use a single writable memory area which contains both machine/threaded code and data; any error in a program can write random executable code which guarantees system fault (in the best case) and unpredictable data corrupt<br>this biggest problem can be fixed by using symbolic `.slot{}` names in place of random integer addresses\n",
    "* **lack of any data types**<br>besides integers, bytes, and byte-counted strings, there are no floating-point numbers (optional!), and any other data structures must be programmed at a machine level<br>using `Frame`-based objects will save us from this hell\n",
    "* **Forth is no-syntax language**<br>any group of non-space characters is a legal Forth command (word) name or integer number; interpreter parses these groups one by one and executes it in place every time it sees next word name<br>factically, *it is not a problem but the most advantage of Forth*: parser is extra simple and need only dozen machine commands to work\n",
    "* **postfix notation**<br>it's a primary huge problem which makes source code unreadable; while Forth executes commands (words) one by one, there is no way to code things like math statements in a readable form, all code is full of stack fluffing and memory byte banging\n",
    "* **lack of libraries and compatibility between different systems**<br>It's a tradition that every Forth programmer writes his own Forth system incompatible with every other. So, not a surprise that incompatibility makes writing libraries a questionable thing. Most popular systems with big communities have a chance to have common libraries, but it's level so low that most times it is better to write your own yet another Forth in C then using assembly and direct .dll calls. Here we have Python with batteries included."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll not avoid postfix no-syntax and stack manipulations: our goal here to show how you can brew your own programming language in a few hours (maybe in assembly). To do it the system must be cutted down to the most simple shape:\n",
    "* extra simple parser (lexer only), \n",
    "* **stack** for data in `.nest[]`, and \n",
    "* global single **vocabulary** in `.slot{}` for variables and command definitions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Easy to guess and fun to mess that any Frame-inherited object can act as a Forth Virtual Machine (FVM): any object graph element has its own stack and vocabulary hardcoded into the base node class. Moreover, computations on a stack when you push data, run operations on top elements, and pop results are so fundamental in compiler/interpreter programming and computer language design, as all mainstream languages such as Java, C#, and Python uses this stack architecture almost in every VM internals."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Active (Executable) Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll introduce the special subset of data types which has an ability to be executed. **Execution** is the fundamental entity described by lambda calculus, which is also unsplittable from the next concept -- **execution context** `ctx` which holds the state between every elementary computation step. Not a surprise that context must include as a minimum both **environment** (vocabulary) and **stack**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# executable data\n",
    "class Active(Frame): pass\n",
    "# [FORTH] Virtual Machine\n",
    "class VM(Active): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "<vm:FORTH>\n",
       "\tvm = <vm:FORTH> _/"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vm = VM('FORTH') ; vm << vm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "<vm:FORTH>\n",
       "\tvm = <vm:FORTH> _/\n",
       "\tBYE = <command:BYE>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# wrapper class for Python functions\n",
    "class Command(Active):\n",
    "    def __init__(self,F):\n",
    "        Active.__init__(self,F.__name__)\n",
    "        self.fn = F # wrap\n",
    "    def eval(self,ctx):\n",
    "        return self.fn(ctx) # run wrapped\n",
    "\n",
    "def BYE(ctx): sys.exit(0)\n",
    "vm >> Command(BYE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## metaL: [meta]programming [L]anguage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `metaL` is not about the syntax of programs written in plain text files such as used by most traditional programming languages. In a reverse, It is an experimental concept of a programming language without language syntax, files, and parsing. The idea was:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Is it possible and a handful to implement a programming system that directly uses some data structure in memory as a program specification, without any source code in plain text files?\n",
    "* What effects and impact on programming habits will be in case of programs able to be modified in runtime by itself and maybe by a user? Will the real metaprogramming be a powerful magic weapon able to beat C++ and Java in their fatherlands, or it will introduce a lot of errors and problems?\n",
    "* Can the parsing stage which presents practically in any programming language compiler/interpreter be totally avoided? This can be done by using your host language (Python, Java,..) to create a program graph in memory in runtime, or at a compile stage. But how painless will be the use of language was not especially targetted on graph construction and manipulations?\n",
    "* Is concept programming idea alive? What are changes if we mix the system's code, specification, and documentation in a single active knowledge graph, and use the knowledge but not source code for software design?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "metaL not a language with its own syntax, but a set of principles for homoiconic and symbolic programming system design. It is provided as a tutorial with step by step understanding and implementation of universal runtime, which contains elements of procedural, functional, logic, message passing, data flow, and any other programming. If you want some feature, you should be able to add it itself, or with a help of the open community."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax-based data input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* What will happens if we allow the user to specify his own arbitrary programming language syntax he wants to use?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Program specification in plain text source code still here dozens of years, as it showed itself as a good enough practice. Even if we move to alternative programming, storing data in human-readable ASCII files is known as the best approach for cross-system exchange. If we want to have the ability to use any syntax for programming or data input, we should find a powerful method to do it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can found this manual too highly biased to interpreters and compilers programming. It is not only because of pitching the [secret weapon](http://www.paulgraham.com/avg.html) but compiler programming is widely known as a complex enough area that uses multiple state machine types and graph-like data structures as its main methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* typical compiler scheme\n",
    "\n",
    "![](img/compiler.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hierarchical State Machines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [Бесконечные возможности конечных автоматов | Введение в \"eco-programming\"](https://www.youtube.com/watch?v=6xzn78onzQk) /video/\n",
    "* [psicc2] Book on using HSM approach for embedded reactive software development by Miro Samek"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph Matching and Transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some ideas about the power of pattern matching and declarative programming via graph transformations:\n",
    "* Professor Richard J. Gaylord's<br>**Wolfram Language Fundamentals** \n",
    "  * [Part One](https://www.youtube.com/watch?v=H-rnezxOCA8) /video/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distributed Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* parallelization\n",
    "* distribution\n",
    "* computation balancing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFlow programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Marvin Humphrey **Dataflow Programming** /[video](https://www.youtube.com/watch?v=aPh4Z3SioB8)/\n",
    "  * Wesley M. Johnston, J.R. Paul Hanna, Richard J. Millar<br>**Advances in Dataflow Programming Languages** [pdf](http://www.cs.ucf.edu/~dcm/Teaching/COT4810-Spring2011/Literature/DataFlowProgrammingLanguages.pdf)\n",
    "* [lucid] William W. Wadge **Lucid, the dataflow programming language**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Async Messaging: Actor model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Hewitt, Meijer and Szyperski: **The Actor Model (everything you wanted to know...)** /[video](https://www.youtube.com/watch?v=7erJ1DV_Tlo)/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type Systems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In programming languages, a **type system** is a *logical system* built upon a set of rules that assigns a property called a type (class) to the various constructs of a computer program or parts of an object graph in our case. The use of this type system formalism enforces the correct application of categories the programmer uses for building algebraic data types, data structures, and other components assembled from elements available in a system (for example it forces the correct combinations of such elements as String, Vector of Numbers, Function returns Bool, etc). The *main purpose of a type system* is to **reduce bugs** in a computer system specification by defining interfaces and relations between different parts of a system, and then checking that all these parts were connected in a consistent way. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The importance of type checker (can be included as an optional part or external tool) in a software development system is preventing a lot of errors in executable specifications and data combining before these executable data will be run. For a generic application programming methods of type control can be very useful for such tasks as a business process description, and arbitrary data transformations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* https://en.wikipedia.org/wiki/Type_system\n",
    "* https://www.youtube.com/watch?v=gTrU_BxWH7c\n",
    "* https://www.youtube.com/watch?v=hy1wjkcIBCU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automated Code Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compiling application graph models into static code for embedded systems.\n",
    "\n",
    "* https://wiki.c2.com/?AutomatedCodeGeneration\n",
    "\n",
    "Target systems:\n",
    "* **ARM Cortex-M** (most wide and used microcontrollers family)\n",
    "* embedded **Linux** (mostly Web hosting variant + home routers)\n",
    "* **HTML/JS stack** for running application in a client-side Web browser\n",
    "\n",
    "Target language candidates:\n",
    "* **ANSI C/C++** (embedded dialects)<br>it is required to be compatible with your development teammates\n",
    "* **Rust**<br>perspective language with rigid type system good for error checking\n",
    "* **LLVM** IR (most low-level)<br>can be good for narrow tasks like parsers and tiny computation blocks\n",
    "* **Python**<br>metacircular graph engine (re)implementation\n",
    "* **JavaScript** / [WebAssembly](https://webassembly.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ANSI C is the most common denominator between low-level assembly and high-level code In complex languages, and the most universal form for any platform available -- C compiler available almost everywhere including Android NDK, Emscripten$\\rightarrow$JS/WASM, tiny system were built with microcontrollers, etc. Here we'll use C as a target language for illustration purposes, but you can adapt the same principle for something like Java/Android, or anything else."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The idea of object graph compiling to mainstream language focuses on \n",
    "* making a special subset of compilable node types and \n",
    "* transforming other graph nodes to this limited typeset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"414pt\" height=\"179pt\"\n",
       " viewBox=\"0.00 0.00 413.97 179.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 175)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-175 409.9723,-175 409.9723,4 -4,4\"/>\n",
       "<!-- &quot;@7f5c03fea048&quot; -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>&quot;@7f5c03fea048&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"42.2463\" cy=\"-99\" rx=\"42.4939\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"17.7463\" y=\"-95.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:CC</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fea080&quot; -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>&quot;@7f5c03fea080&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"193.237\" cy=\"-153\" rx=\"61.99\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"153.737\" y=\"-149.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:cModule</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fea048&quot;&#45;&gt;&quot;@7f5c03fea080&quot; -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fea048&quot;&#45;&gt;&quot;@7f5c03fea080&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M74.6376,-110.5844C95.0334,-117.8787 121.7414,-127.4305 144.6474,-135.6225\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"143.6075,-138.9676 154.2021,-139.0396 145.9648,-132.3765 143.6075,-138.9676\"/>\n",
       "<text text-anchor=\"middle\" x=\"107.9925\" y=\"-127.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/0</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fea0f0&quot; -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>&quot;@7f5c03fea0f0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"193.237\" cy=\"-99\" rx=\"43.5923\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"167.737\" y=\"-95.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:cFn</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fea048&quot;&#45;&gt;&quot;@7f5c03fea0f0&quot; -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fea048&quot;&#45;&gt;&quot;@7f5c03fea0f0&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M84.7074,-99C101.7027,-99 121.4802,-99 139.461,-99\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"139.5199,-102.5001 149.5199,-99 139.5199,-95.5001 139.5199,-102.5001\"/>\n",
       "<text text-anchor=\"middle\" x=\"107.9925\" y=\"-102.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/1</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdcfd0&quot; -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>&quot;@7f5c03fdcfd0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"193.237\" cy=\"-45\" rx=\"51.9908\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"161.237\" y=\"-41.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:cType</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fea048&quot;&#45;&gt;&quot;@7f5c03fdcfd0&quot; -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fea048&quot;&#45;&gt;&quot;@7f5c03fdcfd0&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M74.6376,-87.4156C95.886,-79.8164 123.9854,-69.767 147.4995,-61.3575\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"148.6903,-64.6487 156.9276,-57.9856 146.333,-58.0576 148.6903,-64.6487\"/>\n",
       "<text text-anchor=\"middle\" x=\"107.9925\" y=\"-79.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/2</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18079d68&quot; -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>&quot;@7f5c18079d68&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"353.9769\" cy=\"-72\" rx=\"51.9908\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"321.9769\" y=\"-68.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:cVoid</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdcfd0&quot;&#45;&gt;&quot;@7f5c18079d68&quot; -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdcfd0&quot;&#45;&gt;&quot;@7f5c18079d68&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M240.1618,-52.8821C257.91,-55.8633 278.3068,-59.2894 296.8869,-62.4104\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"296.5522,-65.9031 306.9939,-64.1081 297.7118,-58.9999 296.5522,-65.9031\"/>\n",
       "<text text-anchor=\"middle\" x=\"278.4815\" y=\"-63.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/0</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c18079dd8&quot; -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>&quot;@7f5c18079dd8&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"353.9769\" cy=\"-18\" rx=\"51.9908\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"321.9769\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">class:cType</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdcfd0&quot;&#45;&gt;&quot;@7f5c18079dd8&quot; -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdcfd0&quot;&#45;&gt;&quot;@7f5c18079dd8&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#ff0000\" d=\"M240.1618,-37.1179C257.91,-34.1367 278.3068,-30.7106 296.8869,-27.5896\"/>\n",
       "<polygon fill=\"#ff0000\" stroke=\"#ff0000\" points=\"297.7118,-31.0001 306.9939,-25.8919 296.5522,-24.0969 297.7118,-31.0001\"/>\n",
       "<text text-anchor=\"middle\" x=\"278.4815\" y=\"-34.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">/1</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f5c18079d30>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# embedded C/C++ compilable type set\n",
    "class CC(Frame): pass\n",
    "# single compilable module (object file)\n",
    "class cModule(CC): pass\n",
    "# C function\n",
    "class cFn(CC): pass\n",
    "# C types\n",
    "class cType(CC): pass\n",
    "class cVoid(cType): pass\n",
    "class cInt(cType): pass\n",
    "\n",
    "cc = Class(CC) // Class(cModule) // Class(cFn)\n",
    "cc // ( Class(cType) // Class(cVoid) // Class(cType) )\n",
    "cc.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these node types, we can manually build a tiny C program using Python as a tooling language: we don't need to write parsers to write a compiler or translator, Python can be used as a metaprogramming and software specification language (or any other which you like to use such as Java, Haskell, whatever)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"239pt\" height=\"98pt\"\n",
       " viewBox=\"0.00 0.00 238.78 98.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 94)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-94 234.7843,-94 234.7843,4 -4,4\"/>\n",
       "<!-- &quot;@7f5c03fdc908&quot; -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>&quot;@7f5c03fdc908&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"42.2463\" cy=\"-45\" rx=\"42.4939\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"17.7463\" y=\"-41.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">cfn:main</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdca58&quot; -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>&quot;@7f5c03fdca58&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"184.6384\" cy=\"-72\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"172.1384\" y=\"-68.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">cint:</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdc908&quot;&#45;&gt;&quot;@7f5c03fdca58&quot; -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdc908&quot;&#45;&gt;&quot;@7f5c03fdca58&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#0000ff\" d=\"M81.1555,-52.3779C102.1472,-56.3583 127.8899,-61.2395 148.4482,-65.1377\"/>\n",
       "<polygon fill=\"#0000ff\" stroke=\"#0000ff\" points=\"147.8993,-68.5959 158.3763,-67.0203 149.2034,-61.7185 147.8993,-68.5959\"/>\n",
       "<text text-anchor=\"middle\" x=\"111.4925\" y=\"-62.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">ret</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c180801d0&quot; -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>&quot;@7f5c180801d0&quot;</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"184.6384\" cy=\"-18\" rx=\"46.2923\" ry=\"18\"/>\n",
       "<text text-anchor=\"start\" x=\"157.1384\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">vector:arg</text>\n",
       "</g>\n",
       "<!-- &quot;@7f5c03fdc908&quot;&#45;&gt;&quot;@7f5c180801d0&quot; -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>&quot;@7f5c03fdc908&quot;&#45;&gt;&quot;@7f5c180801d0&quot;</title>\n",
       "<path fill=\"none\" stroke=\"#0000ff\" d=\"M81.1555,-37.6221C97.1938,-34.581 116.0053,-31.014 133.1591,-27.7614\"/>\n",
       "<polygon fill=\"#0000ff\" stroke=\"#0000ff\" points=\"133.8611,-31.1907 143.034,-25.8889 132.557,-24.3132 133.8611,-31.1907\"/>\n",
       "<text text-anchor=\"middle\" x=\"111.4925\" y=\"-36.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">arg</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f5c03fdc9e8>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_void = cVoid('')\n",
    "_int = cInt('')\n",
    "_main = cFn('main') ; _main['ret'] = _int\n",
    "_main >> Vector('arg')\n",
    "_main.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Android"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most widely used mobile platform is Android:\n",
    "* low-price devices\n",
    "* no-cost development tools and deployment\n",
    "\n",
    "Disadvantages:\n",
    "- requires native Java & NDK development, or\n",
    "- requires special tools and methods to port from Python/Web to mobile Web app able to run in offline\n",
    "\n",
    "- **Native Java & NDK**: full control of the device, any service available without any problems.\n",
    "- *PhoneGap*s build a bridge between Web and mobile platform using mobile browser or WebView OS component and a lot of intermediate library layers: slow, memory/RAM hungry, especially slow start, a lot of dependences\n",
    "  - Cordova\n",
    "  - PWA: Progressive Web App\n",
    "  - React Native"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPS: Personal Planning System"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object graph is good for modeling information with a weak structure, which has no rigid data scheme. As a sample, it can be used for task management, business and personal organizing and planning software (PIM systems). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PPS(Frame): pass\n",
    "class Task(PPS): pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Translation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/ModelTrans.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* https://en.wikipedia.org/wiki/Model-driven_engineering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model-driven development (MDD) is a software development methodology that focuses on using concept models that are specific to the domain of a set of problems. This method targets on abstract representations of the knowledge and activities that form a particular application domain, in place of algorithmic computing. The goal of this approach is to raise the level of programmer's thinking above the programming tools and languages are used for implementation, and make the development as much as possible closer to system specification, and level of diagrams mostly used when humans speak about the system architecture and algorithms.\n",
    "\n",
    "For the goals of legacy software raking (refurbishing) this approach can be used as an intermediate representation between old project and target model for modern software stack. As a variant, this can be circular targeting on transforming source model in tiny steps not breaking its working state.\n",
    "\n",
    "The input arc can be done by manually building a knowledge graph, or some tools can be used such as source code parsers closer to some sort of compiler frontend by design. Intermediate transformations should be performed at a level of a knowledge graph using pattern matching, analysis, optimization algorithms, etc. Finally, the parts of the target system can be generated automatically into the form of source code, build scripts, data, and generated documentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metacircular Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Metacircular implementation* of a programming language means that it is *implemented in itself*. In the case of the interpreter, it also can mean that the **guest language** works *using the runtime* of a **host language**, and it is easier to write a whole system.\n",
    "\n",
    "In books for many programming languages with names like \"The Language and its implementation\", it is a common case to describe semantics or even tiny implementation of a described language. This like section presents in a manual combines many goals:\n",
    "* shows a real usage of a language used for relatively complex task such as interpreter/compiler coding\n",
    "* describes many details of internal mechanics and the language semantics\n",
    "* test interpreter/compiler over a set of complex source code of itself\n",
    "* demonstrates the advantages and misses of the language such as syntax readability, expressiveness, flexibility, use of core libraries, etc.\n",
    "\n",
    "Since we describe the system which targets on replacement of general-purpose languages, it is a good practice to include a special section with the metacircular implementation of the system to show its advantages over classical ways of software development.\n",
    "\n",
    "Providing ready to use metasystem in a bundle with this manual can also be a workaround about copyright laws and license limitations, as you can use it to brew your own derived system not covered by restrictions. Thus this work goes under OpenSource license to protect described technology from the [Smalltalk price-induced death](http://wiki.c2.com/?WhyIsSmalltalkDead) and commercial capture, but you can reimplement it for your own needs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interactive Web Platform demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This manual is a part of distribution available at https://github.com/ponyatov/OGP/<br>\n",
    "If you look into a list of files there, you'll find two files:\n",
    "* `OGP.ipynb` is this Jupyter notebook, it was first selected for writing the tutorial, but its linear structure is not a handful for the writing of a more or less big manual\n",
    "* `metaL.py` consist of the more full and fun version of the interactive system [available online](https://kbase.pythonanywhere.com/)\n",
    "\n",
    "This `metaL` subpackage is a special implementation of the object graph engine specially tuned for Web applications interactive development. It uses the Flask framework, some set of extra libraries, and graph knowledge database which loads initial configuration from the `metaL.ini` file. This graph database holds most data for the demo site, and also includes a lot of active elements that make the system alive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Web application was selected as a demo because it has the most potential for practical use of some experimental technology (including commercial use). Web development is widely known as one of a complex area of programming, as its methods and tools develops very quickly, and sometimes goes into production in early stages. While you are making your project, you got a few updates of the framework and libraries you use. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second reason is **I hate software tools for writing which forces me to organize text and illustrations in a linear manner** as it must be done in books. Tutorial and reference texts like any other knowledge are not linear in its roots. While I'm writing a large manual such as this one, I want to collect information in short parts of a text, images, source code snippets, references to books and external sites, etc. Then, I want to be able to build a few variants of output documents, such as a large book, a set of short papers for printing or online publications, separate term definitions index, table of contents, etc. While I'm working on a manual section, I want to have it alone in a separate preview window without other parts of the book. And all of these printable views must be automatically updated every time I individually change some elements in a knowledge database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The system must provide me a way to construct multiple variants of a manual, at least lets me write every paragraph in two languages for translation of local and international versions. Some manual can contain only observation of the theme and newbies intro tutorial, but it must be synchronous with the second manual which describes the topic in details, and maybe also coexist with special additions for some narrow details in separate documents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of cause, the system should not be so dumb as Facebook posts editor, it must have power comparable with the LaTeX, and I must be able to write my own extensions for text analysis and render some special formats specific fo my themes or even for the single work. So, I can't find anything even close to these wishes. It is not bad, as I think that writing such a system myself as a Web engine can also give me a product for making knowledge-oriented sites."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Speaking about other experimental and esoteric programming languages, I see a problem: it exists in a single implementation, which mostly not portable. The one or only a few authors can't spend most of their free time with testing and porting of some interpreter for 3+ platforms in place of the system core development. Most authors don't have enough skills to use build tools that provide multiplatform source-based distribution. As a result, we can see a system that can be run only in one OS, and frequently only on author's computer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second, the biggest problem is the lack of good newbie tutorials and frequently there is not even any documentation. The author is proud of his ideas, he thinks every time how and what can he do for the next feature adding or fixing bugs, but the writing of a gently step by step tutorial for the new user never in the first place."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Providing an online version of such a system as a free online service on a cloud, cheap VDS, or on a free application hosting can be a solution which able to decrease these problems. Any interested geek can connect from the any device and try to use the thing online. If engine provides documenting abilities that were described above, the author will be stimulated to write some docs in the form of short notes in parallel with development. It is not so hard as a writing of a large manual or tutorial when you need to find time to do it, update it every time you change something, arrange information in proper order, write text understandable not only by you. *Writing user manuals should be light as a butter(bread) fly, and not makes your brains boil*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graph Recursive HTML Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Object: # ex. Frame\n",
    "    ########################################## represent in html form\n",
    "    def html(self):\n",
    "        return '<pre>\\n%s</pre>\\n' % self.dump()\n",
    "\n",
    "class Primitive(Object):\n",
    "    def eval(self, ctx): return self\n",
    "\n",
    "class String(Primitive):\n",
    "    def html(self): return markdown(self.val, extensions=['extra'])\n",
    "    \n",
    "class Container(Object):\n",
    "    def eval(self, ctx): return self\n",
    "\n",
    "class Vector(Container):\n",
    "    def html(self):\n",
    "        ht = ''\n",
    "        for j in self.nest:\n",
    "            ht += j.html()\n",
    "        return ht"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus any object and subgraph can be evaluated (executed), the same way any object can be represented in the HTML form. In the simplest case, the `Object.html()` method will provide the dump as a web representation. For documentation elements grouping we'll use `Vector`s which can be nested, so it is required to use recursion to call `.html()` of every item stored in some hierarchical document subgraph. And finally, for `String`s as a most primitive documentation form, it will be handful to use Markdown syntax and call Python library to render it into a printable form."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Markdown render to HTML\n",
    "* https://coderbook.com/@marcus/how-to-render-markdown-syntax-as-html-using-python/\n",
    "* https://github.com/Python-Markdown/markdown/wiki/Third-Party-Extensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[minsky] Marvin Minsky **Frames for data representation** [html](https://web.media.mit.edu/~minsky/papers/Frames/frames.html)\n",
    "\n",
    "[tyugu] Э.Х.Тыугу **Концептуальное программирование**. М.: Наука, 1984. 255 с [djvu](https://github.com/ponyatov/OGP/releases/download/260420-5d5e/ConceptProg.ru.djvu)\n",
    "\n",
    "[sym88] J. Symbolic Computation (1988) 5, 359-375\\ **The Programming System PRIZ**<br>\\ G.Mints, E.Tyugu, Institute of Cybernetics, Estonian Academy of Sciences,Tallinn 200108, USSR \\ [pdf](https://www.academia.edu/18315153/The_programming_system_PRIZ?auto=download)\n",
    "\n",
    "[priz] **Инструментальная система программирования ЕС ЭВМ (ПРИЗ)** / М.И. Кахро, А.П. Калья, Энн Харальдович Тыугу . – Изд. 2-е – Москва : Финансы и статистика, 1988 . – 181 с ISBN 5-279-00111-2 [pdf](https://github.com/ponyatov/OGP/releases/download/260420-5d5e/PRIZ.ru.pdf)\n",
    "\n",
    "[starting] Leo Brodie **Starting FORTH** [html](https://www.forth.com/starting-forth/)\n",
    "\n",
    "[kelly] M.G.Kelly, N.Spies **Forth - A Text and Reference** [amazon](https://www.amazon.com/Forth-Text-Reference-Prentice-Hall-Software/dp/0133263312) | [ru.djvu](https://github.com/ponyatov/OGP/releases/download/260420-5d5e/KellySpies.ru.djvu)\n",
    "\n",
    "[cactus] http://www.forth.org.ru/~cactus/library.htm (ru)\n",
    "\n",
    "[psicc2] Miro Samek **Practical UML Statecharts in C/C++**, 2nd Edition:\n",
    "Event-Driven Programming for Embedded Systems [html](https://www.state-machine.com/psicc2/) | [pdf](https://sourceforge.net/projects/qpc/files/doc/PSiCC2.pdf)\n",
    "\n",
    "[lucid] William W. Wadge **Lucid, the dataflow programming language**\n",
    "\n",
    "[pierce] Benjamin C. Pierce **Types and Programming Languages**\n",
    "\n",
    "[pierceru] Пирс Бенджамин **Типы в языках программирования** /[ozon](https://www.ozon.ru/context/detail/id/7410082/)/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}