README.txt
8-10-04


This package contains the source code and knowledgebase for RubyCon v0.8. You can
view the documentation online at http://www.geocities.com/ben_bongalon/rubycon/

 
What is RubyCon?
----------------

RubyCon is an open-source, rapid development toolkit for building concept processing and other intelligent reasoning systems. RubyCon builds upon the work of the ConceptNet project[1], implementing ConceptNet’s semantic network of 280,000+ assertions and graph-processing algorithms into a set of reusable objects in the Ruby programming language[2]. 

Ruby is a dynamic, object-oriented language that serves as an ideal medium to try out promising AI ideas, but also as the “glueware” to loosely integrate technology components from various sources including lexical databases, knowledgebases, inference engines, etc. Using the Ruby shell interpreter, you can interactively inspect and manipulate the ported ConceptNet objects and develop code modules to incrementally build a more intelligent system. This evolutionary system development approach offers a practical and promising way to reach the Holy Grail of AI: to craft a machine with intelligence that can reach or surpass human-level performance[3].



Key Benefits and Features
------------------------- 


The latest release of RubyCon comes with the following features and functions:

 * Includes over 170,000 node concepts and 280,000 assertions (called “links” in ConceptNet)    as the baseline knowledgebase 
 * Support for knowledge-level operations[4] on assertions and concepts. You can easily add     or delete facts in the knowledgebase using assert() or retract() respectively. For
   concepts, RubyCon provides the functions create(), fetch() and delete(). 
 * Retrieve assertions using powerful pattern-matching expressions. For example to find out
   what the system knows about monkeys, you use the command: match( "Do", "monkey", /eat/)
 * Add/Delete assertions and concepts 
 * Concepts and assertions are stored in database files, allowing user changes to be
   permanently saved 
 * Retrieve a concept by name or semantic ID 
 * Find assertions that refer to a concept (forward and backward links) 
 * Find a path between any two concepts 

In addition, the Ruby language and programming environment offers many capabilities including:

 * Interactive shell scripting environment for easily implementing and debugging machine 
   intelligence features 
 * Expressive and abstraction power comparable to LISP without the hassle of nested
   S-expressions (ie, no more putting up with (deeply (nested (parentheses))) 
 * Extensive set of built-in constructs: regular expressions, pattern matching operations,
   iterators, association lists, hash tables, dynamic arrays, etc. 
 * Automatic memory management through garbage collection 
 * Support for advanced programming techniques such as runtime evaluation of code,    
   reflection, marshalling, closures (continuations in Scheme parlance), ability to    
   dynamically modify objects/classes/methods 
 * And much more… 


Platform Support
----------------

RubyCon is developed and tested on Windows XP but should work without modification on other platforms where Ruby is installed including Windows 9x/NT/2000, OS X, Linux. 

In order to run RubyCon on non-Windows operating systems, you must first rebuild the concepts and assertions databases. This step is needed since Ruby stores the databases in native (ie, platform specific) file format. Instructions to rebuild the databases can be found in the User Guide.


Installing and Using RubyCon 
----------------------------

See the User Guide for step-by-step instructions.


Bugs and Limitations
--------------------

The current release only partially implements the set of graph algorithms available in ConceptNet and does not have a Graphical User Interface. In addition the RubyCon FindPath() function runs noticeably slower than other implementations. This may be due to the performance penalty introduced by using an interpreted language, or because of implementation differences (RubyCon uses depth-limited search[5]). These issues should be fixed in subsequent releases. 

Please send bug reports, questions or comments to: "ben"@enablix.com  (remove the quotes)


Author’s Comments
-----------------

I developed RubyCon to explore how commonsense reasoning behavior can be teased out from a semantic network of knowledge assertions. As such, only the ConceptNet features that are most essential for testing my theories have been implemented.

In addition I extensively reengineered the original ConceptNet design in order to understand more clearly how it works, at times sacrificing fidelity to the original design for simplicity and/or ease of implementation. For example the CMapLink structure was replaced with a simple (and built-in) dynamic Array. Despite these differences, I hope that you will find RubyCon useful.


Help Wanted
-----------

I would appreciate your feedback, suggestions or words of wisdom/encouragement :-)  If you are interested in contributing to this project, please contact me.


Some immediate things that can be done to make RubyCon more useful are:

 * rebuild the RubyCon concept and assertions databases in other platforms (eg, OS X, Linux)    so that they can be made available for download 
 * implement the other ConceptNet functions: FindContext(), FindAnalogous() 
 * figure out how to speed up FindPath() 
 * expand the documentation 


--------------------------------------------------------------------------------
FOOTNOTES

[1] The ConceptNet commonsense reasoning toolkit (also known as "OMCSNet") is a project from     MIT: web.media.mit.edu/~hugo/conceptnet/

[2] You can find out more about Ruby at www.ruby-lang.org

[3] This part is left as an exercise for the reader. 

[4] Following Allen Newell's approach, RubyCon provides functions for
working with concepts and assertions in a way that hides the implementation details. See http://www.cc.gatech.edu/~jimmyd/summaries/newell1982.html for
one definition of what "knowledge level" is.

[5] The depth-limited search algorithm is described in AI: A Modern Approach (2nd Edition)     by Stuart Russell and Peter Norvig.

