1. Adam Jensen January 13, 2016 @ 8:37 pm

    Hi Scott,

    Have you considered building a description of Scone as a Scone knowledge-base? A self-hosting, interactive tutorial and reference system could be an impressive demonstration of the technology. Ideally, I would like to see such a knowledge-base extended to include the Common Lisp Standard and perhaps even the details of a CL implementation like SBCL (and the underlying computer-science/software-engineering concepts). A comprehensive tutorial/reference/help-desk system for the full technology stack might be a slick way to assemble a competent community.

    New education techniques seem to be a fairly hot topic in the modern world. There are probably grants to be had for such an project. Although, I suppose your current employer, a university, might be a little threatened by technology which has the potential to render them obsolete.

    Thanks for Scone and your work on Common Lisp!

  2. Scott Fahlman January 18, 2016 @ 4:41 pm

    The current Scone implementation does have some self-referential content — elements representing the various link-types and so on. However, descriptions of software systems are quite heavy on legalistic definitions (defined types) and require a lot of precise episodic description of what each function-call does in various situations. In a specification for something like Scone or Common Lisp (and not just one implementation), there has to be a lot of language/representation about what a call must do in various situations and the range of things it may do. I think we can eventually get to something like this, but it probably is better to get a lot more experience first in describing more common-sense actions, such as the steps in changing a tire. That’s the sort of thing Scone was designed to do.

  3. James Schiiller October 2, 2016 @ 6:44 pm

    Can’t wait for the book!!! Scone is in desperate need of a 101 type of tutorial. I think files are missing from the repo or an explanation about their contents would help,



  4. James Schiiller October 16, 2016 @ 1:25 am

    I got my local scone to work by changing a few small things.

    Change the following file to match the contents, substituting your info for mine,
    (defvar *version*)
    (defvar *default-kb-pathname*)

    (declaim (ftype (function (string &key (:verbose boolean))) load-kb))

    (defun scone (&optional (version “scone-git”))
    (setq *version* version)
    (load (format nil “/home/james/jgs/scone/engine” *version*))
    (load (format nil “/home/james/jgs/scone/kb/bootstrap”))
    (load (format nil “/home/james/jgs/scone/kb/core”))

    (format t “~2%;;; Call (scone \”some-version-name\”) to start Scone.~%”)

    Change this line in the following file to your path you cloned into.
    (pathname “/home/james/jgs/scone/kb”)

    Change all lines like these to your path and add .lisp extension,
    (load-kb “kb/core-components/upper.lisp”)

    I think, you
    are using SBCL 1.1.0 and
    I’m using SBCL 1.3.8,
    because this line in scone-loader.lisp is not working for me out of the box,
    (funcall (intern “LOAD-KB”) “bootstrap”)(values))

    Now, run scone with some example commands,

    $ emacs -nw
    m slime
    * (load “scone-loader.lisp”)
    * (scone)
    * (is-x-a-y? {person} {animal})
    * (show-ontology)
    Type: {thing} “thing”
    Type: {undefined thing} “undefined thing”
    Type: {tangible} “tangible”
    Type: {naturally occurring} “naturally occurring” “natural”
    Type: {natural object} “natural object” “naturally occurring object”
    Type: {animate} “animate” “active” “living” “alive”
    Type: {animal} “animal”
    Type: {flying} “flying”
    Type: {bird} “bird”
    Type: {canary} “canary”
    Type: {eagle} “eagle”
    Type: {crow} “crow”
    Type: {penguin} “penguin”

    * (quit)
    c x c

Tutorial Information on Scone (Updated)

Scott Fahlman,   September 13, 2015
Categories:  Scone    

Plans for a Tutorial Book on Scone

In an earlier post, From December 2012, I described my plan to put out tutorial information on Scone in a series of short installments, posts on this blog, and then at some point to gather these into a tutorial book on Scone. That has obviously not happened, and this blog has been dormant since then. There are two reasons for this:

  1. We received funding for a very intensive, large-scale, five-year research project from IARPA on the detection and understanding of metaphors. Scone was to play a central role in our efforts. That project crashed and burned after 18 months for reasons I will not go into here. But while it was running, that project was all-consuming for me.
  2. The more fundamental reason is that the idea of documenting Scone in a series of short stand-alone essays quickly proved to be a bad idea when I actually tried to execute it. Scone is a large, complex system that differs in many ways from other approaches to knowledge representation. I found that it was very hard to explain any part of the system in isolation from all the rest – the individual small parts just didn’t make much sense out of context. So each small essay had to go over a lot of the same introductory material before getting into its own subject matter.

So the revised plan is that I just have to find the time to focus on the creation of the tutorial book. It took a while to wrap up a lot of other obligations so that I could do this, but I plan to devote most of my effort for the next year (or as long as it takes) to this book-writing effort.

Concurrently, I will be working on a number of fixes, extensions, and improvements to the Scone engine code itself. I now have an embarrassingly long “to do” list of such tasks. There are many things that will be easier to fix than to document as-is.

The Scone engine code (in Common Lisp) and a set of “core” knowledge bases have been available on GitHub since August 2014, under the industry-friendly Apache2 license. See http://www.github.com/sfahlman/scone. However, we quickly learned that it was difficult for outside users – those without access to individual help from me or members of the Scone research group – to make effective use of Scone.

Each GitHub release includes its own edition of the Scone User’s Guide (SUG). This is the programmer-level documentation for that release, describing all the functions, arguments, control variables, and so on. However, this was never intended to be a tutorial document. If you want to create an is-a link from {Clyde} to {elephant}, the SUG will tell you the proper Lisp function to use, but it does not try to describe all the implications of creating that link.

So I now believe that the tutorial book is an essential pre-requisite to the widespread use of Scone. Without going into a lot of detail (which may change), my plan is to put the tutorial book out as a low-priced E-book, with a more expensive hardcopy edition for libraries or for those who prefer learning from a physical book. I have some ideas for new ways to use the E-book medium to overcome the problem of describing a large system in which every part depends on every other. We’ll see how that works out as the project develops.

Existing Scone Documents

If you want to understand or use Scone before the tutorial book is done, the best way to get into this is to read some existing papers, as well as the earlier posts on this blog. The most important papers are these:

  • Scott E. Fahlman: “Marker-Passing Inference in the Scone Knowledge-Base System”, First International Conference on Knowledge Science, Engineering and Management (KSEM’06), Guilin, China, August 2006. Proceedings published by and copyright by Springer-Verlag (Lecture Notes in AI).
    PDF format
  • Scott E. Fahlman: “Using Scone’s multiple-context mechanism to emulate human-like reasoning”,Proceedings of the AAAI Fall Symposium on Advances in Cognitive Systems, 2011.  PDF format
  • Scott E. Fahlman: “Eris: Episodic Representation and Reasoning in Scone”, Scone Project Tech Report 2014-1, 2014.  PDF format


For those interested in where the ideas came from, you might also want to look at my old Ph.D. thesis from 1977, which was published in book form but still is also available online, in scanned form, from MIT’s archives. Of course, there has been a good deal of progress in the 35 years since that was written, but it is remarkable to see how many of these ideas live on, in recognizable form, in present-day Scone.

Learning Common Lisp

The Scone engine is written in Common Lisp. The KB files are in Lisp syntax, and most of them contain some (usually small) Lisp programs as well as function-calls to build new knowledge structures.  It is not necessary to know how to program in Lisp just to develop KB files, but it can be very handy to know enough Common Lisp to be able to check the source code for various functions, to see what they are really doing. And if you get more deeply into Scone, you will probably want to extend the programs or write other Lisp code that interfaces directly to Scone.

For learning Lisp, I suggest that you do NOT try to learn the language from Steele’s “Common Lisp the Language” manual. It’s a useful reference, but was never intended to be a good tutorial.

When I can’t remember the details of some built-in Common Lisp function, I go to this website: http://www.lispworks.com/documentation/HyperSpec/Front/index.htm

The following two books are very good for learning:

Leave a comment

XHTML: You can use these tags: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>