DeathTalk - A Presentation of Concurrent Normal Computational Logic

DeathTalk

A Presentation of Concurrent Normal Computational Logic

March, 2018

DeathTalk is a presentation of massively concurrent normal computational logic. And as such a presentation of the fundamental technologies that a computational machine depends on. DeathTalk is what Assembler could have been. Technologies of a higher programming language that a computational machine does not depend on are only implemented as far as necessary for this presentation.

DeathTalk is normal. Available Software and Hardware is abnormal.

Expect massive changes in computing.

Download

DeathTalk is implemented as NetBeans 8.2 Java 8 Project. DeathTalk is consider as truth and thus every use is free.

Source: deathtalk.zip

Documentation: deathtalk.pdf

Dictionary: dictionary.html

Video: YouTube

Internal Iteration Example

A DeathTalk example of an internal iterator implemented with a bidirectional routine is given below. The iterator is normal since it only iterates. In this example the iterator calls back the calling routine three times which then prints a simple message. The green stretch is the main program. The blue stretch is the iterator. Cyan, yellow and gray mark the stretch of the main program that is called back from the iterator.

DeathTalk reads XML. In that a namespace loads a part of the dictionary. The below source is divided into an outsource which is similar to a programming function and a routine call to that outsource. DeathTalk scopes are called contract and are initiated explicitly. An outsource is as normal as a mathematical function and does not imply a scope. Therefore the routine call is contained in a contract explicitly with write privileges granted only to the caller and the called. The inferior node of the routine call is called back from the outsource and therefore according logic is not exposed to the iterator.

<xml version="1.0" encoding="UTF-8"?>
<exe:deathTalk name="Internal Iteration" 
               xmlns:exe="dict://deathtalk/execution"
               xmlns:value="dict://deathtalk/value"
               xmlns:type="dict://deathtalk/type"
               xmlns:cmd="dict://deathtalk/command"
               xmlns:contract="dict://deathtalk/contract"
               xmlns:rhythm="dict://deathtalk/rhythm"
               xmlns:a="resource://deathtalk/annotation">
    <a:comment>internal iterator</a:comment>
    <type:bindOutsource>
        <value:string>iterator</value:string>
        <value:outsource>
            <cmd:expression>
                <contract:bind>
                    <value:string>content</value:string>
                    <value:int>0</value:int>
                </contract:bind>
            </cmd:expression>
            <a:comment>a simple loop</a:comment>
            <exe:whileDo>
                <value:smallerThan>
                    <contract:referInt>
                        <value:string>content</value:string>
                    </contract:referInt>
                    <value:int>3</value:int>
                </value:smallerThan>
                <exe:superior>
                    <a:comment>callback caller</a:comment>
                    <rhythm:unvoid>
                        <rhythm:externName>
                            <value:string>handler</value:string>
                            <exe:externName/>
                        </rhythm:externName>
                    </rhythm:unvoid>
                    <a:comment>increment content</a:comment>
                    <cmd:expression>
                        <value:increment>
                            <contract:referInt>
                                <value:string>content</value:string>
                            </contract:referInt>
                        </value:increment>
                    </cmd:expression>
                </exe:superior>
            </exe:whileDo>
        </value:outsource>
    </type:bindOutsource>
    <!-- 
        1) Create contract with access granted only to iterator
        2) Call Iterator
        3) Act on callback from iterator
    -->
    <contract:further contract:access="protected">
        <rhythm:unvoid>
            <rhythm:callName>
                <value:string>iterator</value:string>
                <type:routine>
                    <exe:superior exe:name="handler">
                        <cmd:println>
                            <contract:referInt>
                                <value:string>content</value:string>
                            </contract:referInt>
                        </cmd:println>
                    </exe:superior>
                </type:routine>
            </rhythm:callName>
        </rhythm:unvoid>
    </contract:further>
</exe:deathTalk>

Alphabet Example

A DeathTalk example of a massively concurrent string concatenation is given that prints "abcdefghijklmnopqrstuvwxyz". The nature of a tree graph is concurrent and 51 threads are executed in this extreme case. DeathTalk is a presentation of concurrent normal computation logic and does not respect the limitations of available hardware and software. Therefore actual performance is not of interest. However, both serial and concurrent operators are implemented.

XML is defined as a graph. DeathTalk reads XML as a stream. DeathTalk executes the document in the given order very much like assembly. DeathTalk does not read ahead and does not know priorities.

<?xml version="1.0" encoding="UTF-8"?>
<exe:deathTalk name="Concurrent Concat" exe:capacity="100"
                debug:greet="true"
                xmlns:debug="dict://deathtalk/debug"
                xmlns:exe="dict://deathtalk/execution"
                xmlns:cmd="dict://deathtalk/command"
                xmlns:value="dict://deathtalk/value" 
                xmlns:massive="dict://deathtalk/massive"
                exe:rhythm="true">
    <cmd:println>
        <massive:concat>
            <massive:concat>
                <massive:concat>
                    <massive:concat>
                        <massive:concat>
                            <value:string>a</value:string>
                            <value:string>b</value:string>
                        </massive:concat>
                        <massive:concat>
                            <value:string>c</value:string>
                            <value:string>d</value:string>
                        </massive:concat>
                    </massive:concat>
                    <massive:concat>
                        <massive:concat>
                            <value:string>e</value:string>
                            <value:string>f</value:string>
                        </massive:concat>
                        <massive:concat>
                            <value:string>g</value:string>
                            <value:string>h</value:string>
                        </massive:concat>
                    </massive:concat>
                </massive:concat>
                <massive:concat>
                    <massive:concat>
                        <massive:concat>
                            <value:string>i</value:string>
                            <value:string>j</value:string>
                        </massive:concat>
                        <massive:concat>
                            <value:string>k</value:string>
                            <value:string>l</value:string>
                        </massive:concat>
                    </massive:concat>
                    <massive:concat>
                        <massive:concat>
                            <value:string>m</value:string>
                            <value:string>n</value:string>
                        </massive:concat>
                        <massive:concat>
                            <value:string>o</value:string>
                            <value:string>p</value:string>
                        </massive:concat>
                    </massive:concat>
                </massive:concat>
            </massive:concat>
            <massive:concat>
                <massive:concat>
                    <massive:concat>
                        <massive:concat>
                            <value:string>q</value:string>
                            <value:string>r</value:string>
                        </massive:concat>
                        <massive:concat>
                            <value:string>s</value:string>
                            <value:string>t</value:string>
                        </massive:concat>
                    </massive:concat>
                    <massive:concat>
                        <massive:concat>
                            <value:string>u</value:string>
                            <value:string>v</value:string>
                        </massive:concat>
                        <massive:concat>
                            <value:string>w</value:string>
                            <value:string>x</value:string>
                        </massive:concat>
                    </massive:concat>
                </massive:concat>
                <massive:concat>
                    <value:string>y</value:string>
                    <value:string>z</value:string>
                </massive:concat>
            </massive:concat>
        </massive:concat>
    </cmd:println>
</exe:deathTalk>

Syntax

DeathTalk syntax is called Rhythm. The machine does not depend on Rhythm. Rhythm only improves readability and maps to a higher programming language. Rhythm is normal syntax that writes as graphs. One graph for operations or Parts. One graph for operands or Values. And some loose graphs for specialized purposes. See the documentation for details.