French Français German Allemand Greek Grec Hindi Hindi Italian Italien Japanese Japonais Korean Coréen Portuguese Portugais Russian Russe Spanish Espagnol

Funk2: Causal Reflective Programming Funk2: programmation de causalité réflexion

Funk2: reflective programming language Funk2: langage de programmation de réflexion



Overview Présentation


o o Supported systems Systèmes supportés
o o The goal L'objectif
o o How does it work? Comment ça marche?
o o Examples of causal reflective programming Exemples de programmation de causalité réflexion
o o Basic programming examples Exemples de programmation de base
o o Programming with primfunk funktions Programmation avec primfunk funktions
o o Programming with ptype objects Programmation avec ptype objets
o o Programming with primobject objects Programmation avec primobject objets
o o Current plan Plan actuel
o o Society of Mind final project ideas Société de l'esprit des idées de projet final
o o Downloads Téléchargements
o o Publications Publications
o o Media presentations Media
o o Developers Développeurs


Supported systems Systèmes supportés


Funk2 currently compiles on 32-bit and 64-bit Linux operating systems. Funk2 compile actuellement sur 32 bits et 64 bits systèmes d'exploitation Linux. 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 pointeurs sont recommandés à cause de la quantité de mémoire nécessaire pour les capacités de réflexion, un 32-bit machine n'est actuellement capable d'indexer quelques giga-octets de mémoire.



The goal L'objectif


The goal of the programming language Funk2 is to enable reflective algorithmic tracing for large heterogenous control systems. L'objectif du langage de programmation Funk2 est de permettre le traçage de réflexion algorithmique hétérogène pour les grands systèmes de contrôle. A few point emphasized in the Funk2 programming language are: Quelques point souligné dans le Funk2 langage de programmation sont:

o o Layered Critical Causal Reflection Layered réflexion critique de causalité
o o Efficient and Robust Control Efficace et robuste
o o Learning by Credit Assignment L'apprentissage par la cession de crédit
o o Divergent Solution Paths Les divergences de pistes de solutions
o o Intricate Thread Control Trajectoires thread de contrôle
o o Goal-oriented Learning Axé sur des objectifs d'apprentissage


How does it work? Comment ça marche?

Examples of the most basic computational features include: (1) memory creation , (2) memory read , and (3) memory write . Parmi les plus élémentaires de calcul présente les caractéristiques suivantes: (1) création de mémoire, (2) lire la mémoire, et (3) la mémoire à écrire. Tracing all causal relationships between these basic features allows tracing the context of all other programmer-defined semantic abstractions . Tracing toutes les relations de causalité entre ces caractéristiques de base permet de retrouver le contexte de tous les autres programmeur-sémantique des abstractions définies. All of these computational features create an intricate trace network of dependencies, automatically traceable and shared by many parallel threads of execution. Tous ces éléments de calcul de créer un réseau complexe de traces de dépendances, la traçabilité et automatiquement partagé par de nombreux parallèles fils d'exécution. Funk2 allows causal tracing to occur modularly to dynamically chosen parts of large commonsense-scale artificial intelligence projects. Funk2 traçage de causalité permet de se produire de façon dynamique modulaire choisi parties de commonsense grande échelle l'intelligence artificielle. The resulting causal dependency trace networks can be processed by critical causal reflection threads. La dépendance de causalité oligo-réseaux peuvent être traitées par la réflexion critique de causalité fils.



Examples of causal reflective programming Exemples de programmation de causalité réflexion



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): Voici comment récupérer la création Cause pour toute pièce de mémoire ([], la valeur du symbole zéro, est la seule chose qui ne référence pas un morceau de mémoire):

Note that in the Cause object there are multiple named slots holding information in the frame of the cause. Notez que dans la Cause objet de multiples nom de créneaux d'information tenue dans le cadre de la cause. The frames of a Cause are thread , env , name , and args . Les cadres d'une cause sont thread, env, le nom et args. By default only 7 levels of recursion are printed to the screen. Par défaut, seulement 7 niveaux de récursivité sont imprimées à l'écran. 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. Le symbole utilisé pour mettre fin à une récursion est l'astérisque *,. Afin d'accéder aux créneaux horaires d'un objet, vous pouvez utiliser funktions qui sont nommés d'accès et de muter les objets. For example, the following example shows how to retrieve only the name and args slots of a cause object. Par exemple, l'exemple suivant montre comment récupérer uniquement le nom et args créneaux d'une cause objet.


in--> [let [[cause [cause-of 12]]] [cons [cause-name cause] [cause-args cause]]] --> [let [[cause [de cause à 12]]] [les inconvénients [nom de cause à cause] [args de cause à cause]]]
read> [ let [ [ cause [ cause-of 12 ] ] ] [ cons [ cause-name cause ] [ cause-args cause ] ] ] lire> [let [[cause [de cause à 12]]] [les inconvénients [nom de cause à cause] [args de cause à cause]]]
out-> [ primfunk:read #xb7f03420 ] à-> [primfunk: # xb7f03420 lire]


Here is an example of how to remember the state of an object at specific historical points in time: Voici un exemple de la manière de se rappeler l'état d'un objet historique à des points dans le temps:


in--> [globalize a [array-new 10]] --> [mondialiser une [nouvelle gamme 10]]
read> [ globalize a [ array-new 10 ] ] lire> [mondialiser une [nouvelle gamme 10]]
out-> [] à-> []

in--> a --> un
read> a lire> un
out-> ( [] [] [] [] [] [] [] [] [] [] ) sur-> ([] [] [] [] [] [] [] [] [] [])

in--> [tracing_on-set at] --> [tracing_on-fixé à]
read> [ tracing_on-set a t ] lire> [tracing_on un ensemble de t]
out-> [] à-> []

in--> [system_date] --> [system_date]
read> [ system_date ] lire> [system_date]
out-> ( date 1970 0 13983 6 29 7 526235 ) sur-> (date 1970 0 13983 6 29 7 526235)

in--> [dotimes [i 5] [array-elt-set ai [+ i 10]]] --> [dotimes [i 5] [tab-elt-set par intérim [i + 10]]]
read> [ dotimes [ i 5 ] [ array-elt-set a i [ + i 10 ] ] ] lire> [dotimes [i 5] [tab-elt-set a i [i + 10]]]
out-> [] à-> []

in--> a --> un
read> a lire> un
out-> ( 10 11 12 13 14 [] [] [] [] [] ) sur-> (10 11 12 13 14 [] [] [] [] [])

in--> [remember a (date 1970 0 13983 6 28 44 908595)] --> [rappelez-vous un (Date 1970 0 13983 6 28 44 908595)]
read> [ remember a ( date 1970 0 13983 6 28 44 908595 ) ] lire> [rappelez-vous un (Date 1970 0 13983 6 28 44 908595)]
out-> ( [] [] [] [] [] [] [] [] [] [] ) sur-> ([] [] [] [] [] [] [] [] [] [])

in--> a --> un
read> a lire> un
out-> ( 10 11 12 13 14 [] [] [] [] [] ) sur-> (10 11 12 13 14 [] [] [] [] [])


Here is another example of how to remember the state of an object at specific historical points in time: Voici un autre exemple de la manière de se rappeler l'état d'un objet historique à des points dans le temps:


in--> [globalize a [array-new 10]] --> [mondialiser une [nouvelle gamme 10]]
read> [ globalize a [ array-new 10 ] ] lire> [mondialiser une [nouvelle gamme 10]]
out-> [] à-> []

in--> [tracing_on-set at] --> [tracing_on-fixé à]
read> [ tracing_on-set a t ] lire> [tracing_on un ensemble de t]
out-> [] à-> []

in--> [globalize dates [array-new 10]] --> [mondialiser dates [nouveau tableau 10]]
read> [ globalize dates [ array-new 10 ] ] lire> [mondialiser dates [nouveau tableau 10]]
out-> [] à-> []

in--> [dotimes [i 10] [array-elt-set dates i [system_date]] [array-elt-set aii]] --> [dotimes [10 i] [tab-elt fixer des dates-i [system_date]] [tab-elt-set aii]]
read> [ dotimes [ i 10 ] [ array-elt-set dates i [ system_date ] ] [ array-elt-set a i i ] ] lire> [dotimes [10 i] [tab-elt fixer des dates-i [system_date]] [tab-elt-set a i i]]
out-> [] à-> []

in--> a --> un
read> a lire> un
out-> ( 0 1 2 3 4 5 6 7 8 9 ) sur-> (0 1 2 3 4 5 6 7 8 9)

in--> dates --> dates
read> dates lire> dates
out-> ( ( date 1970 0 13983 6 12 19 283811 ) sur-> ((date 1970 0 13983 6 12 19 283811)
( date 1970 0 13983 6 12 19 561113 ) (Date 1970 0 13983 6 12 19 561113)
( date 1970 0 13983 6 12 19 828195 ) (Date 1970 0 13983 6 12 19 828195)
( date 1970 0 13983 6 12 20 94674 ) (Date 1970 0 13983 6 12 20 94674)
( date 1970 0 13983 6 12 20 361727 ) (Date 1970 0 13983 6 12 20 361727)
( date 1970 0 13983 6 12 20 629388 ) (Date 1970 0 13983 6 12 20 629388)
( date 1970 0 13983 6 12 20 896560 ) (Date 1970 0 13983 6 12 20 896560)
( date 1970 0 13983 6 12 21 163860 ) (Date 1970 0 13983 6 12 21 163860)
( date 1970 0 13983 6 12 21 431032 ) (Date 1970 0 13983 6 12 21 431032)
( date 1970 0 13983 6 12 21 699425 ) ) (Date 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 [[histoire néant]] [dotimes [10 i] [set histoire [les inconvénients [rappelez-vous un [tab-elt dates]] histoire]]] histoire]
read> [ let [ [ history [] ] ] [ dotimes [ i 10 ] [ set history [ cons [ remember a [ array-elt dates i ] ] history ] ] ] history ] lire> [let [[histoire []]] [dotimes [10 i] [set histoire [les inconvénients [rappelez-vous un [tab-elt dates]] histoire]]] histoire]
out-> [ ( 0 1 2 3 4 5 6 7 8 [] ) à-> [(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 Exemples de programmation de base




Here is one straightforward way to write a "Hello world!" Voici une façon simple d'écrire un "Bonjour monde!" program in the Funk2 language: programme dans la langue Funk2:


in--> [print 'Hello world!'] --> [print 'Bonjour monde! "]
read> [ print 'Hello world!' ] lire> [print 'Bonjour monde! "]
'Hello world!' "Bonjour monde!"
out-> 'Hello world!' sur-> "Bonjour monde!"


Here is another more advanced way to holla your planet: Voici une autre méthode avancée de votre planète holla:


in--> [let [[planet 'Earth']] [format stdout 'Hello ' planet '!']] --> [let [[planète "Terre"]] [format stdout 'Bonjour' planète'!']]
read> [ let [ [ planet 'Earth' ] ] [ format stdout 'Hello ' planet '!' ] ] Hello Earth! lire> [let [[planète "Terre"]] [format stdout 'Bonjour' planète '! "]] Bonjour la terre!
out-> [] à-> []


Here is how to define and subsequently call a funktion: Voici comment définir et, par la suite un appel Funktion:


in--> [defunk say-hi [x] [format stdout 'Why, hello there ' x '. --> [defunk-dire salut [x] [format stdout "Pourquoi, il bonjour 'x'. It is really great to see you.']] Il est vraiment grand de vous voir ".]]
read> [ defunk say-hi [ x ] [ format stdout 'Why, hello there ' x '.  It is really great to see you.' ] ] lire> [defunk-dire salut [x] [format stdout "Pourquoi, il bonjour 'x'. Il est vraiment grand de vous voir".]]
defunk say-hi [ x ] defunk-dire salut [x]
out-> [] à-> []
in--> [say-hi 'Marvin'] --> [-dire salut 'Marvin']
read> [ say-hi 'Marvin' ] lire> [-dire salut 'Marvin']
Why, hello there Marvin. Pourquoi, il Marvin bonjour. It is really great to see you. Il est vraiment grand de vous voir.
out-> [] à-> []


Here is how to loop over a list of values: Voici comment une boucle sur une liste de valeurs:


in--> [mapc [funk [x] [print x]] [list 1 2 3 #xFF 'dog' `[2 3]]] --> [mapc [funk [x] [print x]] [liste 1 2 3 # xff "chien" »[2 3]]]
read> [ mapc [ funk [ x ] [ print x ] ] [ list 1 2 3 #xff 'dog' ` [ 2 3 ] ] ] lire> [mapc [funk [x] [print x]] [liste 1 2 3 # xff "chien" »[2 3]]]
1 1
2 2
3 3
#xff # xff
'dog' "chien"
[ 2 3 ] [2 3]
out-> [] à-> []


Here is how to call our funktion above in a parallel thread: Voici comment appeler notre funktion ci-dessus en parallèle un thread:


in--> [prog [thread &say-hi [list 'Gerry']] nil] --> [prog [thread &-dire salut [liste 'Gerry']] néant]
read> [ prog [ thread &say &say-hi [ list 'Gerry' ] ] [] ] lire> [prog [thread & & dire-dire salut [liste 'Gerry']] []]
Why, hello there Pourquoi, il bonjour
out-> Gerry. sur-> Gerry. It is really great to see you. [] Il est vraiment grand de vous voir. []


Here is how to serially filter every element in a list: Voici comment en série du filtre à chaque élément dans une liste:


in--> [mapcar [funk [x] [+ x 10]] [list 1 2 3 4 5]] --> [mapcar [funk [x] [x + 10]] [list 1 2 3 4 5]]
read> [ mapcar [ funk [ x ] [ + x 10 ] ] [ list 1 2 3 4 5 ] ] lire> [mapcar [funk [x] [x + 10]] [liste 1 2 3 4 5]]
out-> [ 11 12 13 14 15 ] à-> [11 12 13 14 15]


Here is how to concurrently filter every element in a list: Voici comment en même filtre chaque élément dans une liste:


in--> [parcar [funk [x] [+ x 10]] [list 1 2 3 4 5]] --> [parcar [funk [x] [x + 10]] [liste 1 2 3 4 5]]
read> [ parcar [ funk [ x ] [ + x 10 ] ] [ list 1 2 3 4 5 ] ] lire> [parcar [funk [x] [x + 10]] [liste 1 2 3 4 5]]
out-> [ 11 12 13 14 15 ] à-> [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. L'ordonnanceur: global_scheduler variable dans l'environnement mondial peut être utilisé comme une référence au niveau mondial funk2 programmateur pour la machine locale. Processor information available from "/dev/proc" during funk2 initial bootstrap compile is available for all machines currently logged into the grid. Fabrication de l'information disponible "/ dev / proc" au cours de funk2 initiale de démarrage compilation est disponible pour toutes les machines actuellement connecté au réseau. Grid support is in development, this only shows this information for the local machine. Grille de soutien est en cours de développement, ce que montre cette information pour la machine locale. 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. Une fois prise en charge de plusieurs machines est disponible, cette variable va changer en un funktion que prend une machine-id comme un argument et retourne la machine objet de l'ordonnanceur.


in--> scheduler:global_scheduler --> programmateur: global_scheduler
read> scheduler:global_scheduler lire> programmateur: global_scheduler
out-> [ scheduler à-> [Scheduler
:processors ( [ processor : processeurs ([processeur
:mutation_mutex [ mutex] : mutation_mutex [mutex]
:scheduler [ scheduler :processors * ] : scheduler [programmateur: processeurs *]
:pthread #x40a00960 : pthread # x40a00960
:threads [ [ thread : les threads [[thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *
: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 [Thread
:program_counter * : program_counter *
:stack * : pile *
:iter * : ITER *
:env * : ENV *
:args * : args *
:return * : retour *
:value * : valeur *
:trace * : trace *
:critics * : critiques *