Funk2: Causal Reflective Programming Funk2: kausale Reflexive Programmierung |
|
| Funk2: reflective programming language Funk2: reflektierende Programmiersprache
Overview Überblick
Supported systems Unterstützte Systeme
| Funk2 currently compiles on 32-bit and 64-bit Linux operating systems. Funk2 erstellt derzeit auf 32-Bit-und 64-Bit-Linux-Betriebssystemen. 64-bit pointers are recommended because of the amount of memory needed for the reflective capabilities; a 32-bit machine is currently only able to index a few gigabytes of memory. 64-Bit-Zeiger werden empfohlen, wegen der Größe des Speichers, die für die reflektierende Fähigkeiten, ein 32-Bit-Maschine ist derzeit nur in der Lage, Inhalt von einigen Gigabyte Speicher. |
The goal Das Ziel
| The goal of the programming language Funk2 is to enable reflective algorithmic tracing for large heterogenous control systems. Das Ziel der Programmiersprache Funk2 ist es, reflektierende algorithmischen Rückverfolgung zu großen heterogenen Steuerungssystemen. A few point emphasized in the Funk2 programming language are: Ein paar Punkt betonte in der Funk2 Programmiersprache sind: | o o | Layered Critical Causal Reflection Layered kritische Reflexion kausale | | o o | Efficient and Robust Control Effiziente und robuste Kontrolle | | o o | Learning by Credit Assignment Learning by Credit Zuteilung | | o o | Divergent Solution Paths Abweichende Lösung Pfade | | o o | Intricate Thread Control Intricate Thread Control | | o o | Goal-oriented Learning Zielorientiert lernen |
|
How does it work? Wie funktioniert es? | Examples of the most basic computational features include: (1) memory creation , (2) memory read , and (3) memory write . Beispiele für die elementarsten Computational Features zählen: (1) Speicher-Erstellung, (2) Speicher gelesen, und (3) Speicher schreiben. Tracing all causal relationships between these basic features allows tracing the context of all other programmer-defined semantic abstractions . Tracing alle kausalen Beziehungen zwischen diesen grundlegenden Funktionen ermöglicht Rückverfolgung Zusammenhang mit allen anderen Programmierer definierten semantischen Abstraktionen. All of these computational features create an intricate trace network of dependencies, automatically traceable and shared by many parallel threads of execution. Alle diese Funktionen Computational schaffen ein kompliziertes Netz von Trace-Abhängigkeiten automatisch nachvollziehbar und von vielen parallelen Threads der Ausführung. Funk2 allows causal tracing to occur modularly to dynamically chosen parts of large commonsense-scale artificial intelligence projects. Funk2 ermöglicht kausale Rückverfolgung auftreten modular zu dynamisch gewählt Teile von großen allgemein-Skala künstliche Intelligenz Projekte. The resulting causal dependency trace networks can be processed by critical causal reflection threads. Die sich daraus ergebenden kausalen Abhängigkeit Trace-Netze bearbeitet werden kann, durch kritische Reflexion kausalen Threads. |
Examples of causal reflective programming Beispiele für kausale Reflexive Programmierung
|
Here is how to retrieve the creation Cause for any piece of memory ( [] , the value of the symbol nil , is the only thing that does not reference a piece of memory): Hier ist, wie um die Schaffung Ursache für jegliche Art von Speicher ([], wird der Wert des Symbols Null, ist das Einzige, was das bezieht sich nicht auf ein Stück Erinnerung): Note that in the Cause object there are multiple named slots holding information in the frame of the cause. Beachten Sie, dass die Ursache im Objekt gibt es mehrere benannte Slots Betrieb Informationen im Rahmen der Ursache. The frames of a Cause are thread , env , name , and args . Die Rahmen einer Sache sind Fäden, env, den Namen und args. By default only 7 levels of recursion are printed to the screen. Standardmäßig nur 7 Ebenen der Rekursion sind gedruckt auf dem Bildschirm. The symbol used for ending a recursion is the astrisk, * .In order to access the slots of an object, you can use funktions that are named to access and mutate objects. Das Symbol für die Beendigung eines Rekursion ist das Sternchen, *. Um den Zugriff auf die Slots eines Objekts, können Sie mit Funktionen, die den Namen für den Zugriff auf und mutieren Objekte. For example, the following example shows how to retrieve only the name and args slots of a cause object. Zum Beispiel ist das folgende Beispiel zeigt, wie zum Abrufen nur den Namen und die args Slots eines Objekts verursachen.
| in--> [let [[cause [cause-of 12]]] [cons [cause-name cause] [cause-args cause]]] --> [let [[Ursache [Ursache-von 12]]] [cons [Ursache-name Ursache] [Ursache-args Ursache]]] read> [ let [ [ cause [ cause-of 12 ] ] ] [ cons [ cause-name cause ] [ cause-args cause ] ] ] lesen> [let [[Ursache [Ursache-von 12]]] [cons [Ursache-name Ursache] [Ursache-args Ursache]]] out-> [ primfunk:read #xb7f03420 ] Out-> [primfunk: # xb7f03420 lesen]
|
Here is an example of how to remember the state of an object at specific historical points in time: Hier ist ein Beispiel dafür, wie zu erinnern, den Zustand eines Objekts in spezifischen historischen Punkten in der Zeit:
| in--> [globalize a [array-new 10]] --> [globalisieren [Array-new 10]] read> [ globalize a [ array-new 10 ] ] lesen> [globalisieren [Array-new 10]] out-> [] Out-> []
in--> a in der -> ein read> a lesen> a out-> ( [] [] [] [] [] [] [] [] [] [] ) Out-> ([] [] [] [] [] [] [] [] [] [])
in--> [tracing_on-set at] --> [tracing_on-set at] read> [ tracing_on-set a t ] lesen> [tracing_on-set a t] out-> [] Out-> []
in--> [system_date] --> [system_date] read> [ system_date ] lesen> [system_date] out-> ( date 1970 0 13983 6 29 7 526235 ) Out-> (es gilt das Datum 1970 0 13983 6 29 7 526235)
in--> [dotimes [i 5] [array-elt-set ai [+ i 10]]] --> [DOTIMES [i 5] [Array-ELT-set ai [i + 10]]] read> [ dotimes [ i 5 ] [ array-elt-set a i [ + i 10 ] ] ] lesen> [DOTIMES [i 5] [Array-ELT-set a i [i + 10]]] out-> [] Out-> []
in--> a in der -> ein read> a lesen> a out-> ( 10 11 12 13 14 [] [] [] [] [] ) Out-> (10 11 12 13 14 [] [] [] [] [])
in--> [remember a (date 1970 0 13983 6 28 44 908595)] --> [erinnern ein (es gilt das Datum 1970 0 13983 6 28 44 908595)] read> [ remember a ( date 1970 0 13983 6 28 44 908595 ) ] lesen> [erinnern ein (es gilt das Datum 1970 0 13983 6 28 44 908595)] out-> ( [] [] [] [] [] [] [] [] [] [] ) Out-> ([] [] [] [] [] [] [] [] [] [])
in--> a --> a read> a lesen> a out-> ( 10 11 12 13 14 [] [] [] [] [] ) Out-> (10 11 12 13 14 [] [] [] [] [])
|
Here is another example of how to remember the state of an object at specific historical points in time: Hier ist ein weiteres Beispiel dafür, wie man daran erinnern, den Zustand eines Objekts in spezifischen historischen Punkten in der Zeit:
| in--> [globalize a [array-new 10]] --> [globalisieren [Array-new 10]] read> [ globalize a [ array-new 10 ] ] lesen> [globalisieren [Array-new 10]] out-> [] Out-> []
in--> [tracing_on-set at] --> [tracing_on-set at] read> [ tracing_on-set a t ] lesen> [tracing_on-set a t] out-> [] Out-> []
in--> [globalize dates [array-new 10]] --> [globalisieren Termine [Array-neu-10]] read> [ globalize dates [ array-new 10 ] ] lesen> [globalisieren Termine [Array-neu-10]] out-> [] Out-> []
in--> [dotimes [i 10] [array-elt-set dates i [system_date]] [array-elt-set aii]] --> [DOTIMES [i 10] [Array-ELT-festen Terminen i [system_date]] [Array-ELT-Set AII]] read> [ dotimes [ i 10 ] [ array-elt-set dates i [ system_date ] ] [ array-elt-set a i i ] ] lesen> [DOTIMES [i 10] [Array-ELT-festen Terminen i [system_date]] [Array-ELT-set a i i]] out-> [] Out-> []
in--> a --> a read> a lesen> a out-> ( 0 1 2 3 4 5 6 7 8 9 ) Out-> (0 1 2 3 4 5 6 7 8 9)
in--> dates --> Termine read> dates lesen> Termine out-> ( ( date 1970 0 13983 6 12 19 283811 ) Out-> ((es gilt das Datum 1970 0 13983 6 12 19 283811) ( date 1970 0 13983 6 12 19 561113 ) (Es gilt das Datum 1970 0 13983 6 12 19 561113) ( date 1970 0 13983 6 12 19 828195 ) (Es gilt das Datum 1970 0 13983 6 12 19 828195) ( date 1970 0 13983 6 12 20 94674 ) (Es gilt das Datum 1970 0 13983 6 12 20 94674) ( date 1970 0 13983 6 12 20 361727 ) (Es gilt das Datum 1970 0 13983 6 12 20 361727) ( date 1970 0 13983 6 12 20 629388 ) (Es gilt das Datum 1970 0 13983 6 12 20 629388) ( date 1970 0 13983 6 12 20 896560 ) (Es gilt das Datum 1970 0 13983 6 12 20 896560) ( date 1970 0 13983 6 12 21 163860 ) (Es gilt das Datum 1970 0 13983 6 12 21 163860) ( date 1970 0 13983 6 12 21 431032 ) (Es gilt das Datum 1970 0 13983 6 12 21 431032) ( date 1970 0 13983 6 12 21 699425 ) ) (Es gilt das Datum 1970 0 13983 6 12 21 699425))
in--> [let [[history nil]] [dotimes [i 10] [set history [cons [remember a [array-elt dates i]] history]]] history] --> [let [[Geschichte nil]] [DOTIMES [i 10] [set Geschichte [cons [merken [Array-Daten ELT i]] Geschichte]]] Geschichte] read> [ let [ [ history [] ] ] [ dotimes [ i 10 ] [ set history [ cons [ remember a [ array-elt dates i ] ] history ] ] ] history ] lesen> [let [[Geschichte []]] [DOTIMES [i 10] [set Geschichte [cons [merken [Array-Daten ELT i]] Geschichte]]] Geschichte] out-> [ ( 0 1 2 3 4 5 6 7 8 [] ) Out-> [(0 1 2 3 4 5 6 7 8 []) ( 0 1 2 3 4 5 6 7 [] [] ) (0 1 2 3 4 5 6 7 [] []) ( 0 1 2 3 4 5 6 [] [] [] ) (0 1 2 3 4 5 6 [] [] []) ( 0 1 2 3 4 5 [] [] [] [] ) (0 1 2 3 4 5 [] [] [] []) ( 0 1 2 3 4 [] [] [] [] [] ) (0 1 2 3 4 [] [] [] [] []) ( 0 1 2 3 [] [] [] [] [] [] ) (0 1 2 3 [] [] [] [] [] []) ( 0 1 2 [] [] [] [] [] [] [] ) (0 1 2 [] [] [] [] [] [] []) ( 0 1 [] [] [] [] [] [] [] [] ) (0 1 [] [] [] [] [] [] [] []) ( 0 [] [] [] [] [] [] [] [] [] ) (0 [] [] [] [] [] [] [] [] []) ( [] [] [] [] [] [] [] [] [] [] ) ] ([] [] [] [] [] [] [] [] [] [])]
|
|
Basic Programming Examples Basic-Programmierung Beispiele
|
Here is one straightforward way to write a "Hello world!" Hier ist eine einfache Art und Weise zu schreiben, ein "hallo welt!" program in the Funk2 language: Programm in der Funk2 Sprache:
| in--> [print 'Hello world!'] --> [print 'hallo welt! "] read> [ print 'Hello world!' ] lesen> [print 'hallo welt! "] 'Hello world!' 'Hallo welt! " out-> 'Hello world!' Out-> 'hallo welt! "
|
Here is another more advanced way to holla your planet: Hier ist ein weiteres weiter fortgeschritten Weg zu Ihrem Planeten holla:
| in--> [let [[planet 'Earth']] [format stdout 'Hello ' planet '!']] --> [let [[Planet "Erde"]] [-Format stdout 'hallo' Planeten'!']] read> [ let [ [ planet 'Earth' ] ] [ format stdout 'Hello ' planet '!' ] ] Hello Earth! lesen> [let [[Planet "Erde"]] [-Format stdout 'hallo' Planet '! "]] hallo Erde! out-> [] Out-> []
|
Here is how to define and subsequently call a funktion: Gehen Sie dabei wie folgt zu definieren und anschließend rufen Sie eine Funktion:
| in--> [defunk say-hi [x] [format stdout 'Why, hello there ' x '. --> [defunk sagen-hi [x] [-Format stdout 'Warum gibt hallo' x '. It is really great to see you.']] Es ist wirklich toll, man sieht sich. "]] read> [ defunk say-hi [ x ] [ format stdout 'Why, hello there ' x '. It is really great to see you.' ] ] lesen> [defunk sagen-hi [x] [-Format stdout 'Warum gibt hallo' x '. Es ist wirklich toll, man sieht sich. "]] defunk say-hi [ x ] defunk sagen-hi [x] out-> [] Out-> []
| | in--> [say-hi 'Marvin'] --> [sagen-hi "Marvin"] read> [ say-hi 'Marvin' ] lesen> [sagen-hi "Marvin"] Why, hello there Marvin. Warum, hallo es Marvin. It is really great to see you. Es ist wirklich toll, man sieht sich. out-> [] Out-> []
|
Here is how to loop over a list of values: Hier ist, wie man Schleife über eine Liste von Werten:
| in--> [mapc [funk [x] [print x]] [list 1 2 3 #xFF 'dog' `[2 3]]] --> [mapc [funk [x] [print x]] [Liste 1 2 3 # xff 'Hund' "[2 3]]] read> [ mapc [ funk [ x ] [ print x ] ] [ list 1 2 3 #xff 'dog' ` [ 2 3 ] ] ] lesen> [mapc [funk [x] [print x]] [Liste 1 2 3 # xff 'Hund' "[2 3]]] 1 1 2 2 3 3 #xff # xff 'dog' "Hund" [ 2 3 ] [2 3] out-> [] Out-> []
|
Here is how to call our funktion above in a parallel thread: Hier ist zu nennen, wie unsere Funktion oben in einem parallelen Thread:
| in--> [prog [thread &say-hi [list 'Gerry']] nil] --> [prog [thread & sagen-hi [Liste 'Gerry']] nil] read> [ prog [ thread &say &say-hi [ list 'Gerry' ] ] [] ] lesen> [prog [thread & & sagen sagen-hi [Liste 'Gerry']] []] Why, hello there Warum gibt hallo out-> Gerry. Out-> Gerry. It is really great to see you. [] Es ist wirklich toll, man sieht sich. []
|
Here is how to serially filter every element in a list: Hier ist, wie man Filter seriell jedes Element in einer Liste:
| in--> [mapcar [funk [x] [+ x 10]] [list 1 2 3 4 5]] --> [mapcar [funk [x] [10 + x]] [Liste 1 2 3 4 5]] read> [ mapcar [ funk [ x ] [ + x 10 ] ] [ list 1 2 3 4 5 ] ] lesen> [mapcar [funk [x] [10 + x]] [Liste 1 2 3 4 5]] out-> [ 11 12 13 14 15 ] Out-> [11 12 13 14 15]
|
Here is how to concurrently filter every element in a list: Hier ist, wie man gleichzeitig Filter jedes Element in einer Liste:
| in--> [parcar [funk [x] [+ x 10]] [list 1 2 3 4 5]] --> [parcar [funk [x] [10 + x]] [Liste 1 2 3 4 5]] read> [ parcar [ funk [ x ] [ + x 10 ] ] [ list 1 2 3 4 5 ] ] lesen> [parcar [funk [x] [10 + x]] [Liste 1 2 3 4 5]] out-> [ 11 12 13 14 15 ] Out-> [11 12 13 14 15]
|
The scheduler:global_scheduler variable in the global environment can be used as a reference to the global funk2 scheduler for the local machine. Der Scheduler: global_scheduler Variable im globalen Umfeld kann als Referenz auf das globale funk2 Scheduler für die lokale Maschine. Processor information available from "/dev/proc" during funk2 initial bootstrap compile is available for all machines currently logged into the grid. Prozessor zur Verfügung stehenden Informationen von "/ dev / proc" funk2 während der ersten Bootstrap kompilieren ist für alle aktuell angemeldeten Maschinen in das Netz eingespeist. Grid support is in development, this only shows this information for the local machine. Grid-Unterstützung ist in der Entwicklung, dies zeigt nur, diese Informationen für die lokale Maschine. Once support for multiple machines is available, this variable will change into a funktion that takes a machine-id as an argument and returns that machine's scheduler object. Sobald Unterstützung für mehrere Maschinen verfügbar ist, wird diese Variable ändern, in eine Funktion, die ein Rechner-ID als Argument und liefert das Gerät's Scheduler-Objekt.
| in--> scheduler:global_scheduler --> Scheduler: global_scheduler read> scheduler:global_scheduler lesen> Scheduler: global_scheduler out-> [ scheduler Out-> [Scheduler :processors ( [ processor : Prozessoren ([Prozessor :mutation_mutex [ mutex] : mutation_mutex [Mutex] :scheduler [ scheduler :processors * ] : Scheduler [Scheduler: Prozessoren *] :pthread #x40a00960 : # pthread x40a00960 :threads [ [ thread : Threads [[Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : ENV * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : * args :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : ENV * :args * : * args :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * :parent_thread * : parent_thread * :parent_env * : parent_env * :execute_mutex * : execute_mutex * :last_executed_time * ] : last_executed_time *] [ thread [Diskussionsfaden :program_counter * : program_counter * :stack * : Stack * :iter * : ITER * :env * : env * :args * : args * :return * : return * :value * : Wert * :trace * : trace * :critics * : Kritiker * :cause_reg * : cause_reg * :keep_undead * : keep_undead * |
|
|
|
|