Funk2 is a free, open, programming language designed for causal reflective tracing and monitoring of complex control systems. This project is developed by the Reflective Commonsense Thinking group at the MIT Media Lab. Funk2 is primary meant as a novel artificial intelligence research tool for developing massive heterogeneous AI systems. We expect our novel ways of reflectively controlling massive parallel systems to be useful to many diverse fields of computational application and theoretical modelling.

Process triggers are a new Funk2 core object that allows for multiple parallel processes to wait for a specific trigger signal object to be triggered by a controlling process. The following is a simple example that defines a global trigger named my-trigger. Next, we enter a dotimes loop that loops ten times and creates ten parallel fibers (funk2 processes). Each of these parallel fibers enters an infinite loop that simply waits for our trigger, my-trigger, to be triggered. The last line triggers our trigger object, which allows all of our waiting processes to start running and they each end up printing a number from zero to nine.

[globalize my‑trigger [new fiber_trigger]]

[dotimes [i 10]
  [let [[j i]]
    [fiber [funk []
             [while t
               [wait‑for‑trigger my‑trigger]
               [print j]]]]
           nil]]

[have my‑trigger trigger]

While a fiber process is waiting for a trigger, it is paused, which means that it takes no system CPU resources. This allows us to easily allocate thousands of different parallel processes that are efficiently controlled in this way.

You can now export screen renderings to PDF, SVG, postscript (PS) or PNG files from within the Funk2 programming language by includinig the Cairo package (i.e. [require cairo]). An example Cairo application can be seen in the cairo-test directory included in the example directory in the source code. The cairo test example can be included and run by typing, [require cairo], followed by, [cairo-test], which should output a test file for each available file format. See the Funk2 Cairo package documentation for details about the Funk2 wrapper.

A basic natural language toolkit has been added to the Funk2 programming language. A basic English dictionary and parser have been included for defining verbs and argument structures that can be used for adding knowledge and natural language control to cognitive architectures. A new built-in package can be required with the [require natural_language] command.

A basic cognitive architecture has been included as an example package. This includes definitions for mind, mental_layer, agency, and resource objects. These basic mental primitives can be included by requiring the mind package (i.e. [require mind]). Also, when building a mind, using these architectural primitives, it is useful to see an overview of your mental model by using the new mindmon utility, which provides a graphical user interface to the mind.

You can now create graphical applications within the Funk2 programming language by includinig the GTK package (i.e. [require gtk]). An example GTK application can be seen in the gtk-test directory included in the example directory in the source code.

A new package manager has been added to the Funk2 programming language. A number of built-in packages are included in the default bootstrap image, and there is now a growing number of example packages that can be found in the example directory, included with Funk2 source code. You can now use the [require package-name] command in order to load a package and all of its dependencies.

All programs fail, so let us embrace this failure and write systems that react to failure through reflection:

“Reflection is the business of man; a sense of his state is his first duty: but who remembereth himself in joy? Is it not in mercy then that sorrow is allotted unto us?”—William Shakespeare

Human intelligence is a complicated control system for accomplishing complicated goals. Building artificial intelligence is a massive software engineering project that requires new ways for large teams of engineers to work together. Funk2 is meant as a collaboration platform that provides reflective tracing of resposibility for bugs in distributed interactive software systems.

The funk object is as universal to Funk2 as the lambda object is to Lisp or Python. Causally tracing funk execution and completion events allows us a powerful and intricate reflective tool. These numerous and intricate events are compiled into graphs and other representations for both debugging as well as planning in order to avoid software failures. Declarative and goal-oriented software systems that are not reflectively controlled are notoriously difficult to control and often attempt to solve problems by diving into an under constrained search. Building pattern recognition that deals not only with the problem space but with the reflective space of the solver itself is necessary for learning to solve more difficult control problems.

IsisWorld is another core research effort supported by the Mind Machine Project that we are using to collaborate in developing reflective social commonsense reasoning cognitive models of humans. Agents in IsisWorld are controlled through an XML-RPC interface. The most recent IsisWorld interface in now included in the default distribution of Funk2 in order that AI researchers around the world can contribute to this large open software development and research project.

Funk2 is written in pure C, which makes incorporating the fastest libraries easy. Xmlrpc-c is a lightweight implementation of this very abstract remote procedure call (RPC) protocol. The XML-RPC protocol is an XML representation communicated through HTTP and is supported by all popular languages. Python dictionaries, Java hashtables, and other hierarchical named complex data types from other languages can be easily communicated to and from Funk2's frame-based and directed-graph object representations. Also, for data-intensive algorithms, the XML-RPC protocol supports the efficient communication of large amounts of raw binary data between correctly implemented versions of the protocol.

Procedural traces in Funk2 are labeled directed graphs. These graphs are very large and difficult to visualize because of their size and complexity. We are developing algorithms for simplifying the process of finding and recognizing critical patterns in these reflective traces. Often, large and subtle but exact patterns must be found in order to correctly assign credit for a failure in a learning situation. We have developed a fast labeled directed graph representation in Funk2. See our graph matching example for a demonstration of a simple variable graph matching algorithm.

A port of Funk2 has been made to the CygWin platform, which now enables Microsoft Windows users to join the Funk2 distributed programming effort! We have not completed a binary distribution package for the Windows operating system yet, but developers should have few problems compiling and installing Funk2 from source. Please see the Funk2 download page in order to download the latest source package.

Binary packages for the Apple Macintosh operating system X (MacOS X) are now available! Please see the Funk2 download page in order to download the latest MacOS X binary package for Funk2.

GraphViz is an open, free and fast graph visualization tool for labeled directed graphs. We have included a very fast GraphViz compiler in Funk2 for generating and viewing our causal reflective traces. See our GraphViz example for how this new facility of Funk2 can be used.

Fibers are to Funk2 as threads are to a C or Java application. Funk2 is an abstract simulation of an operating system built out of Funk2 traceable memory. Each Funk2 processor is an abstract object representing each processor core in it's host machine. Each Funk2 processor is implemented as a POSIX thread (pthread). Funk2 processors each have a scheduler that handles scheduling Funk2 fibers that represent parallel procedures, implemented as funks (traceable functions) of compiled bytecodes. Because this entire operating system simulation is built out of traceable memory, this opens an avenue for easily building very intricate causally reflective traces. The ability to run 1000 parallel fibers for a complete day is one step closer to the ability of the Funk2 programming to simulate large distributed concurrent systems. See our parallel programming example for more details about how to create and control parallel fibers in Funk2.

Funk2 is largely inspired by Marvin Minsky's theory that the ability of humans to quickly adapt and switch between reflective representations and processes is a metacognitive problem of reflective control. His book, Society of Mind, organizes and describes in surprisingly both dense and understandable English the hundreds of different types of reasoning that a human performs. In his most recent book, The Emotion Machine, Prof. Minsky tells a story about how what we normally call “emotions” are actually self-reflective forms of control processes for switching between ways of thinking. We have built and demonstrated basic reactive and deliberative planning algorithms in Funk2 that demonstrate simple aspects of the lower layers of this theory. Thirty-five students completed two computer laboratory assignments within the Funk2 language that related the continuity between the contemporary fields of planning and reinforcement learning in relational domains to Prof. Minsky's theory for how to build a cognitive architecture.

Funk2 is the programming language that supports building large cognitive architectures, and a preliminary demonstration of the Moral Compass cognitive architecture was invited to be presented last week at Seed Magazine's head office in New York. Read more about our visit on Seed Media Group's blog!