Visit Citebite Deep link provided by Citebite
Close this shade

School of Computer Science -- The University of Birmingham

In collaboration with The University of Sussex:
Informatics Department and Centre for Research in Cognitive Science

"The Free Poplog Portal"


Warning The web site seems to be defunct (June 2009)

NB Poplog is Free and Open Source. The Copyright Notice is very simple. It is based is based on the MIT/XFree86 licence and imposes no restrictions on what can be done with the system. However Poplog is made available "as is" with no warranty of any kind, and no acceptance of liability for any consequences of use.

How to run the latest Linux Poplog on Windows using andLinux
With Thanks to Christopher Martin

16 Aug 2009

The section on teaching has been considerably expanded, and possibly should be moved out to a separate file soon.

26 Jun 2009 -- 10 Aug 2009

This file has been much reorganised in the last few weeks. There is now a high level overview of Poplog and a summary of several of the teaching materials available. Please see the Table of Contents for more information, regarding systems available, and downloads.
Suggestions for further improvements (and offers of help welcome). Write to please.


NEWS 1 Sep 2009 (Version 15.6301)

NEWS 5 Aug 2009 (Version 15.6301): Minor rationalisation and Ved error fixed

NEWS 4 Jul 2009 (Version 15.63): Some rationalisation and reduction in system size


NEWS 21 Jun 2009

NEWS 28 May 2009: Poplog on a SliTaz LiveCD

Andrew Rydz has produced a LiveCD containing SliTaz with poplog ready to run. For more details look here.

NEWS 28 May 2009: The Popracer package
has been enhanced with a PDF copy of the project report.

Popracer was a second year undergraduate team project in 2005, using Pop-11, including its graphical tools, to design a package to evolve simulated racing cars with neural net controllers, able to compete and win on a circuit designed by the user. A graphical tool for designing new circuits was provided. For details see the project report (PDF) and the report by Mark Rowan in the Networks magazine. There is a gzipped tar file containing the contents of the popracer directory.

Older News Items



Poplog is an integrated toolkit providing a highly extendable collection of languages and tools for teaching, research and development. By default it includes incremental compilers for three powerful AI programming languages as well as

Other languages have been developed in Poplog by users, but are not part of the default system. There are also extensions to Pop-11, providing language features that are not part of the core language, but are immediately available to users, including

Most of Poplog is implemented in Pop-11, including the incremental compilers for all four languages and the integrated programmable editor.

Because the core language, Pop-11, makes use of incremental compilation, Pop-11 provides most of the flexibility of an interpreter and most of the speed of a compiler. (The main disadvantage is the general difficulty of porting an incremental compiler to a new platform.)

Poplog was already a well engineered, robust and highly successful commercial product in the 1990s, developed jointly by Sussex University and ISL (Integral Solutions Ltd), and marketed by ISL, who used it to develop the widely used Clementine data-mining system, until 1998, when ISL was bought by SPSS (for Clementine -- now extended and re-named PASW).

It was used to develop the original version of the SPARK toolkit by Praxis Systems, though they now use Sicstus Prolog, as that has features not in Poplog Prolog. (There is now a free Open Source version of the toolset here.)

Some information about academic and commercial customers and products based on Poplog can be found here. After the take-over by SPSS, Poplog became free and open source. Unfortunately, by then academic usage had dropped, partly because of the high price of Poplog during the mid 1990s, partly because the full system (including graphics) was available only on expensive servers and workstations, and only a subset was available on PCs running Windows. (ISL found that the costs of sales and supports to academics were not worth the benefits, so they focused on commercial customers. In those days it was not possible to sell and support such software via the internet.)

The Linux version of poplog, ported in his own time by Clark Morton while still working for ISL, did not become available until after SPSS bought ISL, and this website was started for Free Poplog. (Initially the port was somewhat incomplete and had a few bugs, but these were soon identified and fixed. However, changes in Linux and the C language specification, led to requirements for some further changes in in Linux poplog including some problems caused by Selinux.)

Considering that Poplog includes incremental compilers for four languages (Pop-11, Prolog, Common Lisp and ML), along with an integrated programmable editor, and a host of additional libraries and documentation, including teaching materials, the size of the system is surprisingly small: the complete 32-bit Linux download package is a little over 16MB (since about 19th July 1009 -- including all system sources, documentation and libraries, with a number of add-ons). The size was reduced for Version 15.63, partly by moving the 'contrib' package to a separate location (also in a zip file).

(The packaged self-installing windows version of Poplog described below is even smaller.)
The uncompressed Poplog installation directory, after relinking poplog and building saved images, requires about 79MB on Linux (since Version 15.63, of which a large subset can be removed if not needed). The normal minimum process startup size for Pop-11 including the editor and incremental compiler, is around 11MB. That can be reduced by using a version linked without some of the default components, e.g. without indefinite precision arithmetic, the editor, the X window interface.

The run-time startup size goes up of course if Prolog, or Lisp, or ML (or a combination) is included, though not by much because a great deal is shared between the four compilers.

Partly because of its compactness Pop-11 and the other Poplog languages are comparatively fast when running user code, out-performing interpreted versions of the languages, though not as fast as batch-compiled languages. (The versatility in supporting Pop-11, Common Lisp, Prolog and ML adds a small speed penalty compared with separate dedicated compilers.) The internals of poplog run very fast because they are implemented in a special dialect of Pop-11 with C-like extensions. For example, code compilation is very fast though this is partly partly because the compiler does not do a vast amount of optimisation. Moreover, at least one researcher at HP Research labs switched from using Lisp on a dedicated Lisp machine, to using Poplog Lisp on a general purpose unix workstation, because he found the poplog garbage collector so much faster. However, machines have speeded up so much since then that the difference would no longer be so noticeable!

Teaching materials for Poplog, Pop-11, AI, General programming
(A partial overview)

Poplog (with its core language Pop-11) is a mature and stable product, whose development initially for teaching, then for teaching and research, and later also for commercial/industrial development, involved some outstanding programmers as well as academics at Sussex University involved in teaching and research (mainly in AI and cognitive science). That included collaboration with Systems Designers Ltd starting 1983, followed by its offshoot Integral Solutions Ltd (ISL, until ISL was bought by SPSS).

Poplog became available as a free and open source package in 1999, thanks to the generosity of Sussex University. Since then it has been hosted at the University of Birmingham, with the permission of Sussex University. Pop-11 has been used for teaching and research at Birmingham since 1991, first on Suns with Solaris, then mainly on Linux, and before that at Sussex University since the early 1980s. The language Pop-11 was used there even earlier, starting around 1976. The spirit of the approach to teaching was similar to Peter Denning's ideas regarding "Great Principles". I.e. from the start, led by Max Clowes, the teaching was not about computers but about "the science of information processes", especially those occurring in human minds. (Denning mistakenly suggests that this started only around 1995.) We need to get students to understand the importance of diverse virtual machines suited to different functions. (Not only students -- Cognitive scientists too.)

Many of the commercial customers used Poplog and Pop-11 not only as a development tool, but also as a learning environment, because it was delivered with the same teaching materials as were provided for academics. This section describes some of those teaching materials and others added after Poplog became freely available. As remarked above, all of the teaching materials along with the compilers, editor and program libraries fit into an unusually small bundle for download, requiring a small amount of file space when installed, and with a comparatively small memory footprint when running. All of these, along with its robustness, favour its use in education, especially in developing countries and other areas with limited resources. The core language Pop-11 is not widely used, but it covers many of the widely used programming paradigms, with a syntax that is close to conventional pseudo-code used in computing publications. Its extended period of commercial and industrial use (e.g. in developing Clementine) as well as teaching, has ensured its reliability.

Sources of information about Poplog and its languages
The teaching materials summarised here are part of Poplog and are also available online at this web site. There is additional information in published books on Pop-11, most of which use the pre-1985 Pop-11 syntax, without lexical scoping -- e.g. using 'vars' for local variables instead of 'lvars'. Despite this, all the published examples should still work, possibly with a little tweaking in a few cases. Code examples from several books on Pop-11 are in the 'contrib' directory on this web site.

Robin Popplestone, the original inventor of the earliest form of the Pop language, who died in 2004, used Pop-11 in his last years for research and teaching at the University of Massachusetts, Amherst. He wrote a large book, available online here Paradigms of Programming. It usefully extends the introduction to Pop-11 in the Pop-11 primer here.

There are also contributions from users of Pop-11 to other web sites, including the Pop-11 section of the Rosetta Code web site, which describes itself as a programming chrestomathy site. It presents a large collection of programming tasks and for each task shows solutions in different programming languages.

Hakan Kjellerstrand has provided tutorial examples in Pop-11 on his web site "The Pop-11 programming language and Poplog environment"

Additional "external" links to information about Poplog and Pop-11 are below.

The full set of documentation distributed with Poplog is available here
(laid out as in the Poplog directory tree).

Teaching materials on this web site and included in Poplog
Poplog includes many tutorials and help files concerned with general programming and AI, especially using Pop-11, but also using Prolog, Lisp and ML. Although there are graphical tools and interfaces in Poplog, most of the teaching materials are purely text based: students read a file of text with examples that they can run, edit, re-run, copy, modify, run, and so on. In most cases the emphasis is on playing, getting ideas, trying them out, playing some more, thinking of a mini project, working on it, etc. All the examples described here work in the current Linux version of poplog (V15.63), and will work in later versions. The non-graphical examples should also work in Windows poplog, but the relevant teach and library files may have to be imported after installation of windows poplog. Some of the non-graphical examples may not work in Windows Poplog Version 15.5 mentioned below, if they depend on recent additions to poplog not yet available in V15.5. There is a more recent version of windows poplog (V15.53) with more recent facilities.

If anyone who is an expert at packaging software for windows would like to bundle poplog with tested versions of the latest teach files please contact A.Sloman

The "river world" -- an introduction for beginner programmers
An example very elementary introductory "teach file" on the river-crossing problem is TEACH RIVER (originally the brain-child of Max Clowes in the late 1970s).

This is based on a well-known puzzle:

how a man can get a fox, a chicken and a bag of grain from the left bank of a river to the right bank without the fox eating the chicken or the chicken eating the grain, given that the boat can hold only two things (including the man), and only the man can row it across the river, and only the presence of the man can prevent unwanted consumption.
Students can read the TEACH RIVER file into the poplog editor Ved, "mark and run" the code portions to see what happens. (Or they can read the file in another editor or browser and paste the code into the pop11 command prompt, after starting pop11 in a console window.)

For example, after the river library has been compiled, the 'start();' command produces an initial state of the world, and displays it

    ** Here is the state of the river-world:
    ** [chicken fox grain man ---\ \_ _/ _________________ /---]
after 'putin(grain);' the student sees
    ** Here is the state of the river-world:
    ** [chicken fox man ---\ \_ grain _/ _________________ /---]
The state of the world can also be shown by printing out the current Pop-11 database:
    database ==>
    ** [[grain isat boat]
        [boat isat left]
        [chicken isat left]
        [fox isat left]
        [man isat left]]
Then the tempting fatal mistake can be demonstrated:
    ** Here is the state of the river-world:
    ** [chicken fox ---\ \_ man grain _/ _________________ /---]

    ;;; INVOLVING:  fox has eaten chicken TOO BAD
    ;;; FILE     :  river
    ;;; DOING    :  river_mishap eat checkeat getin runproc
    ** Here is the state of the river-world:
    ** [fox ---\ \_ man grain _/ _________________ /---]
Confirmed by the absence of the chicken from the database:
    database ==>
    ** [[man isat boat] [grain isat boat] [boat isat left] [fox isat left]]

A benefit of the textual interface
This also demonstrates an advantage of textual over graphical learning interfaces: textual results produced by several textual commands can easily be preserved and compared, so that similarities and differences can be studied. Graphical interactions, with pictures of recognizable objects moving around on a screen, can be much more engaging, but since graphical displays constantly replace their contents, the task of thinking about and comparing the results of the last ten graphical commands (except in simple cases where the commands produce cumulative results) requires an extraordinarily good visual memory, or tools to replicate the interface on demand and repeatedly run the commands in slow motion in parallel so that two or more processes can be compared as they run.

(A partial solution for the case of turtle graphics is the Pop-11 polypanel interface shown here,) which allows parameters for a "polyspiral" command to be altered graphically and the program re-run faster or slower.)

Using textual input and output, both teachers developing teaching programs and documentation, and students making use of the materials, can copy commands and change parameters or lists of words in the code examples and then instantly re-run the code, with both the commands and the output saved in one or more text files or editor buffers, making it possible, and in simple cases easy, to look back at and compare different episodes (as in the "riverworld" example above.

For teachers, this makes development of teaching files littered with tested code examples very fast (at least compared with authoring systems that require the teacher's input to be compiled into some teaching engine which has to be restarted and then run). The interleaving of instructions with code that is editable by students can facilitate rapid exploratory learning -- by both teachers and learners, making teachers learners!

In particular, after testing examples, teachers can select portions of the examples to remove, presenting students with gaps in code fragments, so that students can try various ways of filling in the gaps, and run the commands to see what happens (put the fox, chicken or grain in the boat, get into the boat, cross the river, get out, take out what is in the boat, etc.). Gifted teachers will learn which "size" gaps are suited to learners of different sorts.

Putting repeated sequences into subroutines
After a full solution to the river problem has been constructed and run as a sequence of commands, 'TEACH RIVER' invites learners to combine the operations so as to build a specification for a process to solve the whole problem, namely getting everything to the right bank. That code sequence can be bundled into a named procedure.

They are then asked to look at recurring patterns in the solution, and to rewrite the code so as to make it clearer, more compact and more modular. An example would be the recurring sequence

That pattern could be used to define a procedure called cross(), thereby shortening the program to solve the problem.

A new pattern may then become obvious after that, in sequences like:

inviting the type of abstraction that requires use of a procedure with an input parameter:
    define move (thing);

Learning to see patterns in code that invite types of abstraction supporting increased modularity and reusability is an important kind of intellectual development. It can, of course, also be done with graphical programming, but there is a limit to the generality achievable that way.

TEACH RIVER is just one example among many
Of course, this example is very limited: there are only a few objects, a small number of actions, and little scope for ongoing interaction. That is because it was intended originally merely as a small exercise to introduce some fundamental programming constructs.

However the principle that it illustrates is that a teacher can define a micro-world making use of concepts that intended learners already understand, where every possible state of the world is represented by the state of the Pop-11 database and events and actions in the world can be represented by procedures that add and remove database items. In some case such a world is also representable graphically, as shown in the river example, and the use of two forms of representation of what the program does, with principled relations between them can be an important feature of the learning process.

Searching and combinatorics in simple microworlds
The pop-11 database package provides a collection of mechanisms for searching the database using patterns to select items, and for adding and removing things that depend on the results of searches as well as depending on explicit commands. It also provides simple pattern-based mechanisms for iterating over the database. E.g. after the start() command introduced in TEACH RIVER, this instruction

    vars x;
    foreach [?x isat left] do

        [The ^x is on the left bank] =>

could print out
    ** [The boat is on the left bank]
    ** [The chicken is on the left bank]
    ** [The fox is on the left bank]
    ** [The grain is on the left bank]
    ** [The man is on the left bank]
After one of the actions listed above has been performed the same command would print out different information.

It is also possible to iterate over combinations of database items. So, instead of a "foreach" loop with a single pattern (as above) a "forevery" loop can be used with a list of patterns to be matched consistently with database items in different ways:

    vars thing1, thing2, place;

    forevery [ [?thing1 isat ?place] [?thing2 isat ?place] ] do

        if thing1 /= thing2 then
            [The ^thing1 and the ^thing2 are both at ^place] =>

could print out something like this:
    ** [The boat and the chicken are both at left]
    ** [The boat and the fox are both at left]
    ** [The boat and the grain are both at left]
    ** [The boat and the man are both at left]
    ** [The chicken and the boat are both at left]
    ** [The chicken and the fox are both at left]
    ** [The chicken and the grain are both at left]

    .... and so on up to ....

    ** [The man and the grain are both at left]
Students could learn the need for the test in the "if" expression before the print command, by first trying it without that test. They could then think about how to prevent the duplication in information presented because, for example, the first and fifth pieces of output give the same information (because of the semantics of the example), and therefore should not both be printed:
    ** [The boat and the chicken are both at left]
    ** [The chicken and the boat are both at left]
It's not a long way from there to introducing some of the students to the mathematics of combinations and permutations (and also to logic programming). The items printed out might, instead, have been added to the database. So it is very easy to write programs that propagate consequences of changes initiated by a user -- and learning when such propagation should be controlled, and how to do it.

Many programming tasks can be devised that depend on such an interface, including the task of producing a chatbot with a memory.

An example mini-project based on this idea that, for some reason, many students have found interesting, is to develop a 'Conversational Drinks Machine', whose state consists of ingredients for various drinks plus a collection of coins available as change, and which allows questions about prices and supplies to be asked, requests for drinks to be given and change requested if the customer does not have the exact the exact sum required. This can be implemented with or without a flexible natural language interface, and with or without a memory for previous conversations and transactions. Variants could include making the vendor polite or rude! Which will be more fun for the learner?

For more sophisticated games it may be useful to use the Pop-11 Objectclass package providing object oriented programming with methods and inheritance, as illustrated here, or the SUPER database package that facilitates more sophisticated reasoning and problem solving in the style of Prolog.

Analogical reasoning
The uses of foreach and forevery can lead to the idea of a program that records descriptions of different objects or different situations in different databases, then uses various ways of examining each database to produce more abstract descriptions of the objects or situations.

It is then possible to compare two such descriptions (a) to see what they have in common, (b) to see how they differ, and (c) to find one or more ways of transforming one of the situations so as to be more like the other. As shown by T.G. Evans in the 1960s, this sort of technique can be the basis of analogical reasoning used in some intelligence tests. Pop-11 has library (created by Jonathan Cunningham) and a set of teach files that introduce these ideas using a mixture of pictures and symbolic descriptions. See for example TEACH EVANS. (For more on the analogy problem and Evans' work see Margaret Boden's 1978 book Artificial Intelligence and Natural Man, which not only expounds many of the early achievements of AI, but also discusses their relevance for psychology and philosophy. Evans' work is also discussed in other AI textbooks, and in this tutorial by Jocelyn Paine.)

The "forevery" construct is very powerful since it allows items to be compared two at a time, three at a time, four at a time, etc. However exploring these techniques can quickly expose students to one of the recurring problems in designing, or modelling, intelligent systems, namely how to control combinatorial explosions. That can introduce students to the need for a more powerful formalism, such as LIB SUPER, mentioned above, or a logic programming language such as Prolog.

An example run of the Pop-11 demo version of Evans' analogy program is here. A teacher who wished to illustrate the princples with simpler examples, could copy the file and replace the picture drawing procedures to use simpler pictures. (The library was written in 1983, using an older version of Pop-11, which is still accepted by the compiler in a special compatibility mode.)

Students are explicitly encouraged to do things that produce error messages (called 'MISHAP' messages in Pop-11, after we noticed that the word 'error' upset some beginners!). In a well designed teaching environment, the error messages have rich semantic content that helps with debugging, as shown above. Learning to test for things going wrong, identifying the nature of the problems and fixing them is an important aspect of cognitive development. (I was once told by a beginner student that she really enjoyed debugging her code when it did not work. Alas students who have been badly educated merely get depressed when their programs don't work. For such students the main job of a computing teacher may be to find ways to build up confidence until the student can drive his/her own learning.)

Introducing linguistic interaction
After becoming familiar with the 'riverworld' domain, learners are invited to switch to a different task. For example, they can play with the Pop-11 Eliza chatbot and then try to define their own simple chatbot based on pattern matching as explained in TEACH RESPOND. This introduces lists, patterns, conditionals, loops and thinking about an architecture to handle ongoing interaction. Some students have to be weaned of that task because it is always possible to go on adding more and more rules to a chatbot, and many find that enjoyable. But after a while no more learning happens.

After that they can try combining the chatbot techniques with the riverworld commands to provide a natural language interface to the riverworld, so that the typed in command

is replaced with requests like:
    please put the chicken in the boat
In addition, the use of the Pop-11 database to represent the state of the world allows questions to be added to the interaction:
    is the man in the boat?
    where is the fox?
And if the program records the history of events
    what happened to the chicken?
How programming leads to philosophy
The interaction with the Pop-11 database representation of the state of the world (e.g. whether the individuals are on the left or right side of the river or on the boat) gives semantic content to the verbal interchanges, even though strictly speaking the computer does not know anything about real rivers, boats, foxes, etc. That is a topic students can be invited to discuss, leading on to questions about whether machines can ever really understand what we say to them, whether cameras and motors will make a difference and whether human brains are usefully thought of as extremely sophisticated computers. (A draft paper proposing a syllabus developing these ideas is here (PDF).)

Towards more principled natural-language interfaces
After playing with and observing limitations of chatbot style pattern-based interfaces, students will probably be ready to meet the more principled grammar based approach to language, introduced in TEACH GRAMMAR. This uses a library that allows a grammar and lexicon provided by the user to be used either to create a parser for analysing sentences in accordance with the grammar or else to generate random sentences that accord with the grammar. As the teach file shows, the grammatical notation used for programming linguistic information into the computer is interestingly different from the notation used for specifying actions to be performed. That difference can be a subject for philosophical discussion, or discussion about how minds of language users work.

An exercise that students can try, suggested in the teach file, is generating railway station announcements. Other possibilities include opening sentences for a romantic novel, or rudely expressed complaints about service in a restaurant! (Stroppy chatbots are very popular with some learners.)

Typically, a student who has used the formalism to specify a grammar and lexicon will get some surprises when the random generator is used. For example, the specification for railway station announcements might generate things like

    platform 5 will depart from the 4.20 train to London

    express luggage must not leave slow passengers unattended
That sort of surprise can lead to deep reflection on how to add more categories to the grammar and the lexicon so as to control more tightly what is generated. Alas, for some students, this may be the first time they encounter concepts like 'verb', 'adjective', 'prepositional phrase' because of misguided educational policies in the last few decades. But it is never too late to learn such things, and what could be better than learning by using the concepts to design something that works?

An experimental package that might be developed differently by different teachers is TEACH GRAMMAREXAMPLES (still untested), which shows how, with the same set of words in the lexicon, two different grammars can produce unconstrained or constrained sets of "acceptable" sentences and sentence substructures, by "compiling" semantic distinctions into syntactic and lexical distinctions. This could be the basis of a number of student projects involving programming at the level of grammatical rules rather than at the level of the underlying programming language.

More examples are in TEACH STORYGRAMMAR, which shows how the same pop-11 library can be used to generate simple (poor) stories and strange haikus.

Are textual interfaces boring?
Although it seems to be an axiom of many people concerned with ways of teaching programming that textual programming is too dull and too difficult for young beginners, it is arguable that that merely reflects the ill-considered kinds of programming examples that teachers of programming and computer science have tended to use in the past.

In other words, what may be thought of as boring text-based programming tools can, when used by creative teachers, provide extremely versatile playthings that can be combined, extended, decomposed, re-organised, reinvented, and used as inspiration for deep and enjoyable learning about a variety of computing and non-computing topics. Many of the topics relate to the nature of human thinking, learning, perceiving and communicating. This contrasts with the emphasis on moving around, colliding, avoiding, shooting, killing, dressing-up, etc., in some other programming environments for learners.

Graphical vs textual programming interfaces
Although complex graphical programming interfaces are more fashionable for young learners, and are clearly able to engage them and foster both learning and collaboration, it is arguable that the learning achieved is not so deep. That may not matter in the earliest stages of learning to program. In any case, there are deep and enjoyable things that can be done without graphical tools. Learning to use textual specifications for structures and processes is in itself an important part of education for thinking and communicating about complex phenomena, including finding appropriate levels of abstraction for solving problems, and for describing how something complex works. (Many experienced programmers cannot do this well.)

Some important forms of abstraction are well suited to graphical formalisms (e.g. trees, graphs and maps). Others are more closely related to textual formalisms, including logical expressions and computer programs. Pop-11 supports a variety of styles, including the 'logic programming' style illustrated here and not well supported by most programming languages, and also the styles used for a variety of artificial intelligence techniques, in addition to most of the conventional programming styles. It is much less cluttered and more intuitive than Java. Aspects of Pop-11 overlap with Common Lisp, with Scheme and with Prolog.

Graphics in Pop-11
Graphical tools are also available in Pop-11 for learning that requires or at least benefits from them, as illustrated in this unusual introduction to turtle geometry and the more complex graphical examples using the RCLIB package, illustrated here. The RCLIB package is also used to provide a graphical interface for the SimAgent toolkit, as shown in some of the videos here.

Pop-11 TEACH files
In addition to the files mentioned above, there are many more 'TEACH' files, such as the 'TEACH ARITH' file, which introduces arithmetic operations, and encourages learning by doing, exploring, testing, and revising or extending programs. Examples of the use of a few of the procedures introduced there can be seen here.

A more subtle and challenging TEACH file, TEACHNUMS, encourages learners to investigate how numbers could be added to a programming language that does not already support them, using lists to represent numbers (in a 'unary' notation). This example illustrates how a teach file can start easy, or even trivial, and lead to deep and difficult challenges, in this case about the nature of negative numbers and what operations on them could mean. (This could be a possible link to philosophy of mathematics.)

Some of the teach files provide introductions to the core concepts of other languages, but using Pop-11's syntax, e.g. the TEACH SUPER_EXAMPLE, which introduces Pop-11's 'superdatabase' library, giving an introduction to the main features of Prolog, but in Pop-11 syntax. (Poplog also includes a full implementation of Prolog in its own syntax.) Another example is TEACH RULEBASE which introduces rule-based programming through an extension to Pop-11.

Using the same editor, students can also learn how to write proposals for projects (or mini projects) and also reports.

The programming examples in the 'teach' files can be run from within the poplog editor (Ved or XVed), by marking the lines and giving a 'doit' command. The learner can then modify the commands using the editor and run them again, or copy them and create new combinations and run them. The output of such commands, including error messages will go into an editor buffer where they are displayed, so that it is easy to look back at previous outputs and error messages -- something that is not so easy to provide with a purely graphical mode of interaction.

Users are not forced to use the Poplog editor. Instead they can edit programs in another preferred text editor and copy the code into a Pop-11 command window to be run. Or the whole file can be written and then compiled by Pop-11 (without restarting Pop-11, because it uses an incremental compiler, available at run time).

Using a simple pop-11 turtle, matcher and database to introduce problems about vision
Besides the turtle that as part of pop-11's 2-D graphics package, there is a much older turtle that can draw into a 2-D array, by leaving a trail of characters as it moves. This can then be printed out to examine the result. More importantly it can also be examined by a computer program. So the TEACH TURTLE file illustrates ways of drawing into the array and printing out the result, while TEACH SEEPICS introduces techniques for perceiving structures at different levels of abstraction in such pictures, and TEACH PICDEM illustrates ways of learning concepts by abstracting from the details of perceived examples. These are not intended to teach up to date sophisticated learning and recognition techniques, but to introduce young learners to the problems and to some ways of thinking about them that can be explored in a friendly AI programming language with helpful libraries.

Teachers can experiment with their own teach files
Teachers are not forced to use the existing teach files. They can produce their own (as many have done), or copy and modify the files provided, to suit the needs of their pupils or to fit better with local educational objectives -- or even the needs of individual students. The use of an incremental compiler makes it easy to test every new example, or every modified example very quickly, especially if using the integrated text editor.

Modified versions of the existing teach files could be used for younger learners as long as they can read and type -- a typing tutorial is included, invoked by typing just 'ttt' to Pop-11. Before keyboards were in every school it gave many first year university students their first introduction to typing, by providing strings to copy, which are then checked by the program. It was also used by some pre-school children, brought in by members of academic staff!

Poplog (especially Pop-11) comes with a lot of library programs with associated documentation that can be used as building blocks in student projects, or can be used as the basis for learning a set of techniques. Creative teachers can produce new 'teach' files, and, if necessary, corresponding new program libraries, that can be linked into search lists for different groups of learners. A set of teach files and corresponding code files can be grouped within a directory, and a command provided to add the files in that directory to documentation and program library 'search lists'. Different 'search lists' for documentation and code libraries can be given to different groups of students. The same mechanism can be used for students collaborating on a common project. Those local code and documentation files can be stored separately from the main poplog installation, and as they are all plain text files can easily be given to other schools or made available on the web for others to use -- unlike some programming environments that store user creations in special formats that can only be interpreted by running the package.

The educational philosophy behind all this is explained in this PDF paper 'Teaching AI and Philosophy at School?' and in the paper referenced below.

Why Pop-11?
The core language, Pop-11, is in some ways like Python (though it has built in support for more programming paradigms), in some ways like Lisp (though with a more conventional syntax), in some ways like Scheme (because it handles function names like Scheme rather than Common Lisp), and also like 'Forth' because it supports stack manipulation, and partly like Prolog because it allows list processing to be done with a pattern matcher, and provides mechanisms for storing and manipulating information in a structured database, instead of dealing only with values of variables. E.g. see the TEACH DATABASE file for some examples. Because the tutorial database mechanism is relatively unstructured -- every stored item merely has to be a list of some kind, students can easily explore different ways of structuring information for different problems -- instead of always having to use (or fight) the structure provided (e.g. [object attribute value] -- provided in some systems).

At a later stage, some students may start using the Poprulebase package, which introduces a more powerful framework for using structured databases in connection with condition-action rules, e.g. as often used in "expert systems". The TEACH EXPERTS tutorial gives a partial overview, with pointers to more things to try. Students can be led in a different direction by introducing them to the 'Superdatase' (SUPER), which introduces logic programming in a style close to Prolog.

In an interview reported here, Peter Denning was asked:
    How has the switch to C++ and Java brought new problems?
And answered:
DENNING: Students get consumed with trying to master the mechanics
of programs. They are so busy trying to make programs work, they get
sidetracked from understanding the underlying concepts of their
programs. Their perception is that "Computer Science 1" is really
"Programming" and not concepts of computing. The complexity of these
languages has become a monster that we don't know how to cope with.
One of the consequences is a high dropout rate from our first
courses - about 30 to 50 percent. Another is that plagiarism and
copying of programs is a major industry as students "do anything" to
pass those courses.

As the preceding comments illustrate, Pop-11 can be used to introduce, with relatively little counter-intuitive clutter, a variety of common programming paradigms, including use of looping constructs, recursion, standard arithmetic (and some unusual extensions, such as ratios, imaginary numbers, and arbitrarily large integers (bignums) -- more details here), arrays, strings, list processing facilities, pattern matching (with pattern restrictions) to simplify construction and analysis of list structures (partly like Prolog), rule-based programming, neural nets, Object-Oriented programming techniques with multiple inheritance, (using facilities similar to CLOS; though, the phrase "Object Oriented" means different things to different people, as explained here). It also has a "lightweight process" mechanism that supports learning about co-routines or threads, and is used in a tutorial introduction to operating systems. (Using the facilities in RCLIB this tutorial could now be given a graphical interface.)

Like Scheme and functional languages Pop-11 allows a "functional style" of programming, to be used, using higher order functions and closures, which can make some complex tasks very much simpler. (The Wikipedia entry gives more information about functional programming.) However, pop-11 does not have strong syntactic typing: it uses semantic types and run-time type checking.

Thinking about architectures
The importance of teaching students to think about the architecture of a complete program is not always emphasised, alongside designing ontologies, forms of representation to be used and algorithms for the various sub-systems. Even a beginner's introduction to a very simple chatbot can introduce ideas about architecture, e.g.

  *------*  --- > ---  *---------*  --- > ---  *----------------*
  | USER |             |INTERFACE|             |INFERENCE ENGINE|
  *------*  --- < ---  *---------*  --- < ---  *----------------*
Diagrams representing architectures are probably more important in the long run than flow charts, which cannot cope well with most kinds of structured programming (using call and return, with recursion), and do not cope at all with the design and use of different forms of representation (e.g. trees, graphs, pattern-based databases).

Turtle programming in Pop-11
A subset of Pop-11 with graphical facilities (available on Linux and Unix) provides much of the functionality of the LOGO Turtle, but with additional features available, illustrated here and in this tutorial introduction to making pictures of faces (among other things).

Learning about a variety of AI programming techniques
There are many 'teach' files developed at Sussex University, Birmingham University and elsewhere, introducing concepts and techniques, with exercises ranging from simple program completion to development of whole systems, some of them making use of packages provided by tutors to hide details for beginners: e.g. some basic programming and AI teach files here and here, including the previously mentioned tutorial on building a simple chatbot based on pattern matching which can be followed by the introduction to grammars, parsing. sentence generation (also mentioned above), and TEACH STORYGRAMMAR, which introduces generation of stories and haikus

Although Pop-11 is specially well suited for AI/Cognitive Modelling there are tutorials on many standard programming techniques, some mentioned above, including use of recursion for list-processing and both simple, and more complex exercises treating lists as sets (with answers available).

More advanced utilities
More advanced and specialised teaching materials introduce

Other sources of information about using Pop-11 for teaching
A book, Computers and Thought, by Mike Sharples and others, originally published by MIT Press, though now out of print, provides an introduction to Cognitive Science/AI using Pop-11. The text is online here.

A Pop-11 programming primer for people with previous programming experience, here.

Poplog also includes some tutorial exercises and online documentation on Prolog, Lisp, and Standard ML, though not as much as for Pop-11.

A web site with HTML versions of poplog documentation.
(Partly out of date, but mostly OK.)

Why teaching beginners requires powerful systems
This article Beginners need powerful systems explains the benefits of using a non-"toy" language for teaching beginners, to support variable rates of progression, to allow individual learners to go on developing and diversifying their expertise over an extended period, and to allow creative teachers to provide additional libraries and support tools. (A great deal of teaching using Poplog has been "team-teaching" where tutors build on one another's program library and documentation resources.)

The built in text editor Ved/XVed
The built in text editor Ved (or its multi-window version XVed), provides a general purpose interface between the user, the user's programming input, the output from the compilers, the teach files, other documentation files, and the program libraries. Users can write things into the Editor buffer and can read what is in the editor buffer. Similarly the compiler can read what is in the buffer (and obey instructions) and can write things in the buffer. So the editor's text buffer acts as a two-way communication channel between user and programs run, and has done for nearly three decades, just as many graphical interfaces now do.

It also provides simple actions to invoke documentation or tutorial files. For example, the Pop-11 command

    uses XXX
can get the editor (via the Pop-11 compiler) to make sure that the XXX library has been compiled in the current session, so that its facilities can be used, including the HELP and TEACH files provided by the package. In many cases that will also automatically load other packages and extend both program and documentation search lists for items accessible using Ved's hypertext facilities.

The command

    showlib XXX
asks the editor to read in and display the code of the XXX library file (that may contain cross-references to other documentation and code files). The command
    help XXX
will invoke documentation on XXX for people who already have some experience with XXX, whereas the command
    teach XXX
asks the editor to read in a tutorial on XXX for beginners, usually giving examples to play with, by editing and recompiling bits of text in the documentation window. (There is no need to copy the text to another window.) Moreover placing the text cursor to the left of an identifier in a program (e.g. next to the name of a system procedure or library procedure) and typing ESC+h will invoke a documentation file with information about the identifier.

These mechanisms can be used also by teachers to produce their own teaching materials for learners -- which is how all the teaching documentation was developed originally. On a shared server this makes it particularly easy for teachers to cooperate in building up cumulative layers of teaching materials. The integrated editor also allows students to produce documentation in which the examples are tested -- reducing the frequency of documentation bugs.

Since the same mechanisms can be used for code and documentation of many different levels of sophistication, the same system allows students at all levels (including both absolute beginners and very young children, as well as experienced programmers new to AI) to learn about many aspects of both general programming and Artificial Intelligence and Cognitive Science, by designing, implementing, testing, extending, analysing working programs, or program fragments. At an advanced stage they can use the same interface to develop projects, as several final year students, MSc students and PhD students have done.

Using the Poplog editor is not mandatory
There are several advantages in using the Poplog editor, Ved/XVed, but people who would rather use an editor with which they are familiar, then copy and paste text between their editor and the pop-11 command line can do so. There is also an Emacs interface to Poplog that provides most of the advantages of the integrated editor (though it requires far more memory!).

Extended learning trajectories
The provision of continuous learning trajectories from absolute beginner to advanced researcher within the same framework was a major design objective, enabling teachers and their beginner and non-beginner students to use the same system. A subroutine or package produced by an older student could then easily be invoked and used (or copied and modified) by a less advanced student. Of course, emphasising assessment more than learning can rule such collaboration out.

One of the advanced projects using Pop-11 was development of Poplog itself: because the developers were constantly using all its features for their own development work they found most bugs before they could reach users. This has made it an unusually robust package. Bugs reported in the years since 1999 are listed here. Many are concerned with installation procedures and libraries rather than the core system.

For more information on Poplog and its history see
A history of developments in e-learning using Pop-11 and Poplog, starting at Sussex University in 1976 can be found here.

Editor, documentation and libraries
The environment has many of the interactive features of interpreted languages, though the Poplog languages are all incrementally compiled to machine code for efficiency. The 'TEACH' files, and other documentation files, are accessible through its integrated visual editor (Ved/XVed), which 'knows about' the compilers, the program libraries and the documentation libraries, and is extendable since it is implemented in Pop-11. E.g. a tutorial file can have a hypertext link to other documentation or to program libraries. Programming examples can be run from inside the editor, then modified and run again, without restarting the editor or Poplog.

For Emacs users there is a conversion package that extends Emacs to support integration with the Pop-11 compiler. Another option, for people who do not wish to use a new editor is to type commands into the Pop-11 (or Prolog, or Lisp, or ML) prompt in a shell command line, while editing and reading documentation quite separate editor. This will add some inconvenience and slow down development a little. (To a 'normal' edit/compile/test loop.)

There are many libraries extending the core system to support various kinds of programming tasks. For example the SimAgent toolkit supports exploration of architectures for more or less intelligent agents. The library and documentation system make use of search lists, allowing packages and teaching materials developed by different teachers, students and researchers to be combined flexibly, strongly encouraging team teaching.

There is also a collection of libraries and tutorials related to computer vision, i.e. image analysis and interpretation, in David Young's "Popvision" Library including neural net, array manipulation, and linear algebra utilities.

Some of the Poplog/Pop11 graphical facilities are illustrated here, and there are movies showing some student AI projects, based on the the SimAgent toolkit.

Poplog/Pop-11 as a commercial product
For many years Poplog was an expensive commercial product, first sold commercially by Sussex University for use on VAX+VMS (for UK£3,000, and much less for academics) in 1982, and then continually developed, ported to other platforms, and commercially supported up to 1998, first by Systems Designers (from 1983) and later by a spin-off, Integral Solutions Ltd (founded in 1989).

At one stage the commercial price was UK£1,500 (+VAT) for workstations, though the educational price was always much lower. Poplog was a solid, reliable, commercial product, used mainly, though not entirely, for AI and Software Engineering research, development and teaching. By about 1992 sales had exceeded $5,000,000.

The most famous product implemented in Poplog (mainly Pop-11) was the Clementine Data Mining system, developed by ISL, as a result of which they were bought by SPSS, so that Clementine (now called "PASW modeller"), could be integrated with their other data-mining tools (after re-writing in Java and C++, with some loss of functionality). widely used (More on Clementine)

Another product based on Poplog was a software validation toolkit produced by Praxis.

Additional Information about Poplog and Pop-11
Further information is available on Wikipedia and other sites:


Origins of poplog

Note: "POPLOG" is a trade mark of the University of Sussex.

Poplog was developed in the School of Cognitive and Computing Sciences at the University of Sussex and at ISL (now part of SPSS), and is distributed free of charge by courtesy of both organisations. Between 1983 and 1998 Poplog was an expensive commercial product, sold first by Systems Designers Ltd., then ISL, though always with large discounts for academic users. Examples of commercial and academic customers, and some of the products produced using Poplog can be found in this directory

Additional code and documentation listed below were produced by members of the University of Birmingham and other organisations. All of it is now free of charge with open source.

Copyright Notice

The distribution terms and copyright notice (modelled on XFree86) are available in


The remainder of this file contains pointers (1) to a number of complete Poplog systems for various combinations of machine and operating system, (2) to sources, (3) to documentation about Poplog and Pop-11, (4) to various add-ons supporting teaching and research in AI and Cognitive Science, developed at Sussex, Birmingham, and elsewhere, including a package for research and teaching in vision, a powerful and flexible X window-based GUI package implemented in Pop-11, the SimAgent toolkit for developing sophisticated agent architectures, and Robin Popplestone's Scheme in Pop library. There are also (5) some "easy" to install complete packages containing the add-ons.

Readers who know nothing about the Poplog system or its languages may find it useful to look at this introductory overview and also the comp.lang.pop newsgroup informal FAQ.

Experts may find it useful to look at the draft User Guide to get a feel for the variety of facilities available in poplog.

The web site at was set up by two experienced users of Poplog and Pop-11. It includes archives of postings to comp.lang.pop, code libraries, and a partial mirror of this site, among other things. Unfortunately the web site is frequently down, and the mirroring of the Birmingham site has not proved reliable.



Use Google to search for information about Poplog or Pop-11

If you include in your search terms "poplog" or "pop-11" or "pop11" or "ved" or "xved" or some combination of those, the chances are that you will find what you want faster than finding it by browsing this or any other site!




More information about Poplog and Pop-11

Site for free downloadable version

A table summarising available versions of poplog is available here:

The latest version of poplog, currently packaged only for PC+Linux is now version 15.63(32 bit), 15.62(64 bit).

Poplog version 15.53 was the first version of poplog to be made generally available free of charge, including all sources, since about 1982, the year when commercial sales were taken over by Systems Designers Ltd.

Some older versions for other platforms listed below are also now available free of charge.
(They may be brought up to date later if facilities and resources become available for rebuilding them.)

V15.53 (produced in July 1999) included some additions to support recent versions of Linux, and a few minor bugfixes. Apart from that it was the same as the commercial version, used world-wide in the Clementine data-mining system.

Since then Poplog has undergone development and bug-fixes. New versions have been made available at the Birmingham Poplog site, and are announced elsewhere in this file. An older version, Poplog Version 15.5 was made available for use on Windows, but lacking the graphical capabilities available in poplog on Linux, Unix and VMS systems. The OpenPoplog project at Sourceforge aims to remove the difference.

Reduced versions supporting Pop-11 as a scripting language may become available later, e.g. at (June 2009: This site is apparently defunct, possibly temporarily.)

As explained below, A directory for bugreports and "bugfixes" has been set up for corrections to library and documentation files as well as system sources.

Coordination of further development work is managed through the comp.lang.pop newsgroup and the pop-forum email list. There is also a more specialised email list (poplog-dev) for those who wish to be involved in detailed technical discussions of development work. If you wish to join the poplog-dev email list write to

The free Poplog distribution directory

When Poplog version 15.53 first became available free and open source the main location for bundled versions was the directory. The contents are described below. Since then new bundled versions have also become available, not stored there. Go to the 'new' directory only if there is not another bundle (e.g. the standard Linux Poplog bundle) that suits your requirements.

There is a specially packaged, easy install version of Poplog for PC+Linux.

Information about Poplog for Windows is available.

A mirror site for Poplog, with some additional packages is at
(June 2009: This site is apparently defunct, possibly temporarily.)

Installation notes:

Detailed instructions for installing Unix and Linux poplog, are in the install.txt file. Most users can now ignore that as there are are special instructions for the packaged versions of linux poplog described below. In particular for the main PC+linux package there is now a very simple short-cut installation process.

Instructions for the Windows version of Poplog V15.5 are included in the windows poplog package (below), and separately available in the file new/pcwinpoplog.txt
(Windows poplog V15.53 is only for experts. For more details see this section below, or this directory ).

A User Guide is available, included with all the current bundled versions of poplog.

Documentation on rebuilding poplog can be found in sysdoc/rebuilding. Scripts for installing and re-linking are included with poplog.

Utilities to help with re-linking or rebuilding will go in the tools/ subdirectory, including a script which will be useful if you have difficulties re-linking unix versions of poplog. (Improved version now included in PC linux poplog since Version 15.6).

Documentation on Porting poplog can be found in sysdoc/ppg (Poplog Porting Guide).

Most of poplog is implemented in an extended dialect of pop-11 (SysPop-11), so porting poplog requires a running version of poplog to do the cross-compilation.

Obsolete package installation mechanism.
A shell script for installing "local extensions" received as gzipped tar files was previously available here: and documented here

Since version V15.6 This mechanism is now replaced by a new package structure in the Poplog directory tree.


OLDER NEWS (More recent news is above.)



A table summarising available versions of poplog is available here:

Some of the downloadable versions are "current" whereas others are older because we have not had access to machines on which to update them.

Current versions of Poplog for Linux and Unix:

At present the following implementations of Poplog are available, in gzipped tar file format:

Older versions of Poplog:for unix-like systems

Additional (slightly older) implementations for other platforms are available for download, as follows:

PC NT/XP/Windows versions of Poplog:

At present (September 2006) there are only partial implementations of Poplog for windows. In particular, although they are otherwise usable, they do not provide the Poplog graphical facilities that work on the X window system on Unix and Linux.

The Open Poplog project aims to remedy this eventually, but in the mean time anyone wishing to run the full linux PC version of poplog on windows can do so by using the VMWARE package available from VMWARE is free, and is reported to work very well. For instance the hybrid-sheepdog demonstration here was produced by an MSc student using Linux PC poplog, under Vmware on a laptop running Windows XP.

For those who do not wish to use Vmware the following options are now available.




The Poplog system was built around the integrated editor Ved (implemented in Pop-11), which includes facilities for rapidly accessing help files, teaching documentation and library sources through "hypertext links", and for transferring commands to the incremental compiler(s) and reading output from the compilers into an editor buffer. This makes learning, development and testing very easy, especially for novice programmers.

A number of Emacs users have developed a package that supports similar use of Pop-11 and other Poplog languages from Emacs, and includes utilities for reading the Ved "graphics enhanced" documentation files. The package can be downloaded here: emacs.tar.gz or browsed online here
This is already included in the larger "complete" packages.


Around January 2005 Poplog was reorganised. A sub-directory was introduced $usepop/pop/packages (with environment variable $poppackages to allow for its location to be changed).
Many of the extensions that had been available as special packages from Birmingham University, Sussex University, or elsewhere that had previously been separately down-loadable packages were moved into that directory, and some of the AI tutorial material that had been part of the core Pop-11 code and documentation libraries was moved into a 'teaching' package.

Each package has a top level directory containing a pop-11 program to extend the poplog search lists (popautolist, popuseslist, vedhelplist, vedteachlist, etc.) and subdirectories such as auto/, lib/, teach/, help/, ref/, data/ and others, if needed.

Some parts of poplog that were deemed not to be suitable for inclusion in the core of the system, e.g. items concerned with teaching AI rather than teaching programming in Pop-11 or Prolog, etc. were moved into the 'teaching' package.

NOTE: This process is not yet complete. The reorganisation will be continued, depending on available time.

The current default list of contents (in April 2007) is

lib: A directory containing links to the startup pop-11 file for each of the packages.
bhamlib: Extensions from the Birmingham $poplocal/local/directory
(Currently very little).
brait: A braitenberg simulator based on SimAGent
com: Some shell scripts used for poplog
contrib: Programs and documentation contributed over the years include portions of published books, e.g. the Computers and Thought book, and the Natural Language Processing books by Gazdar and Mellish.
emacs:Utilities to make Emacs talk to the Poplog compilers, emulating the poplog Ved editor
lockfile: programs for locking and unlocking files
master: Relics of the Sussex mechanisms for managing file headers and footers.
neural: The poplog neural library, providing some neural net functions implemented in C and invoked from Pop-11
newc_dec: Information provided by Anthony Worrall about extensions to the mechanisms for loading external libraries written in C.
newkit: The Birmingham SimAgent toolkit, containing Poprulebase and SimAgent libraries, and also making heavy use of RCLIB for graphics.
package_template: Template directory for constructing a new package.
popmatlab: A 'virtual' package which makes visible a subset of the facilities included in the popvision package, providing general purpose mathematical tools that are not restricted to being used for vision, including the well known BLAS and LAPACK toolkits, which are here made available from Pop-11.
popvision: David Young's Popvision library (including many C programs for image manipulation invoked from Pop-11). This includes the 'popmatlab' library.
prb: The Poprulebase subset of SimAgent, which can be used on its own, e.g. for expert systems.
rclib: The RCLIB graphical extension to Pop-11 illustrated here.
rcmenu: An extension to RCLIB providing the 'recursive hypermenu' package.
sim: The sim_agent library extensions, to be added to Poprulebase to provide the SimAgent toolkit.
teaching: AI teaching materials -- programs and documentation.
vedgn: An extension to the Ved editor for reading news (usenet).
vedlatex: Extensions to the Ved editor for use with LaTex.
vedmail: Programs for reading mail in a standard unix mail file, for sending mail, replying, unpacking attachments, creating and sending attachments, etc. All written in pop-11.
vedutils: Extensions to the Ved editor used in Birmingham.

gz: A directory for tar files containing packages supplied in compressed form only.
install_package: A shell script for unpacking and installing packages from tar files of the form package.tar.gz into a directory package
make_tarfiles: Shell script for creating tar files from the currently installed packages.
setup: various startup scrips


Bugfixes are recorded in this directory tree.
The BUGREPORTS file lists bugs and fixes (where available) in reverse chronological order. The file ALLFILES file lists all the files in the bugfixes directory, in reverse chronological order.

Other changes are listed in the CHANGES.txt file now included with poplog, along with revision notes included source code and library files.

Asking for help or submitting bug reports

Please submit bugreports to the comp.lang.pop newsgroup or the pop-forum email list, not to any individual. Before submitting a report on a problem it is worth looking at this form for bugreports. Following the instructions will make it more likely that someone can help you.



Browsable Poplog Documentation
(Pop-11, Prolog, Lisp, ML, AI teaching materials, and Rebuilding poplog)



Lisp packages available that have been tested in Poplog Common Lisp


The RCLIB and RCMENU X-based user-extendable graphical interface tools.
NB: This is already included in the latest Poplog package for linux on PC.

RCLIB provides powerful object oriented tools for building graphical interfaces, including control panels with sliders, dials, scrolling text panels, etc. It supports interactive graphical interfaces to the Agent toolkit described below. Some examples can be viewed in

The SimAgent toolkit, including Poprulebase
NB: This is already included in the latest Poplog package for linux on PC.

The SimAgent is a very general and flexible toolkit for exploring agent architectures, with graphical display facilities based on RCLIB described above. The core of SimAgent is a powerful forward chaining production system interpreter, Poprulebase, described here, which supports integration of symbolic and subsymboilic mechanisms (e.g. neural nets). Multiple concurrent instantiations of Poprulebase define a processing architecture for an agent. The SimAgent toolkit supports development of systems in which multiple such agents can co-exist and interact. SimAgent was described in the March 1999 issue of Communications of the ACM.

Some movies showing some of the features of SimAgent are here (with thanks to Mike Lees at Nottingham for the Boids and Tileworld examples):

For a detailed overview of the toolkit see and the slide presentation using PDF or Postscript at:

The toolkit is now included in the standard Birmingham Linux Poplog packages, but can also be downloaded separately:

David Young's Popvision library
NB: This is already included in the latest Poplog package for linux on PC.

David Young at the University of Sussex has produced some excellent teaching materials and tools for image processing and AI vision, and has given permission for these to be distributed. A large collection of mathematical tools and array manipulation tools, including interfaces to the BLAS and LAPACK packages, has been added, constituting a matlab-like facility in Poplog, which is free and open source.

An overview of the teaching materials in the popvision package is available here
The programs work fast because there's a mixture of Pop-11 and C. The package includes scripts for compiling the C sources on solaris, linux and alpha Unix systems. The programs and documentation can be browsed online in
(See especially the popvision/help/* files -- though you may have slight problems with the "VED graphic" characters in a Web browser.)

The whole package can be fetched from

This also includes David Young's teaching material on on multi-layer perceptrons.

The Array manipulation and Linear Algebra Packages in Popvision

The Popvision package includes three new libraries (added in 2004) that make available a very rich collection of array manipulation facilities and mathematical facilities including the BLAS and LAPACK linear algebra packages, all now accessible interactively from pop-11.
  • The ARRPACK package

    This provides an array processing package for Pop-11. It includes efficient procedures (implemented in C) to carry out arithmetic and logical operations on elements of real and complex arrays. A whole array or a subset of its elements may be processed in a single procedure call. ARRPACK is restricted to operations in which each array element is treated separately from other elements of the same array, such as the element-by-element addition of two arrays. (Operations where each element is processed along with its neighbours, such as convolution, Fourier transforms and matrix operations, are provided by other libraries.) A higher-level interface to these procedures may be provided in future.
  • The LAPACK and LAPOP libraries

    These libraries provide Pop11 interfaces to BLAS and LAPACK
      The BLAS (Basic Linear Algebra Subprograms) are high quality "building block" routines for performing basic vector and matrix operations. Level 1 BLAS do vector-vector operations, Level 2 BLAS do matrix-vector operations, and Level 3 BLAS do matrix-matrix operations. Because the BLAS are efficient, portable, and widely available, they're commonly used in the development of high quality linear algebra software, LINPACK and LAPACK for example.

      LAPACK is written in Fortran77 and provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems. The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision.
    Anyone who wants all this but does not have blas and lapack for linux (apparently included in some linux distributions --e.g. redhat 9) can get rpms for various architectures from

The popvision tar file can be installed using the install_package script, which will untar the package into the directory $poplocal/local/ where it will create $poplocal/local/popvision/ with appropriate sub-directories, and also $poplocal/local/lib/popvision.p for easy access using the Pop-11 command uses popvision;

David Young's Pop11 Libraries at Sussex

David Young's poplog web page at Sussex University includes some additional facilities that may be found useful, including

An older neural net library

David Young at the University of Sussex previously produced some neural net facilities which were considerably extended by Julian Clinton. A slightly modified version of the resulting package is available here. The system can be browsed online in
(See especially the neural/help/* files -- though you may have slight problems with the "VED graphic" characters in a Web browser.)

The package is now automatically included with linux poplog (32 bit and 64 bit).
However, it can also be fetched from
It can be installed using the install_package script

The Simworld package
is a demonstration package by Matthias Scheutz showing how to use sim_agent to explore evolutionary processes in fairly simple agents. Requires the SimAgent toolkit (included in the latest linux poplog package).
Introductory documentation can be found in this directory.
The tar file can be installed (in unix or linux poplog) using the install_package script.

See also

Contributions by Robin Popplestone

Robin was the designer of the language "COWSEL" which was redesigned and extended and first became widely known as POP-2, around 1971. Pop-11, the core language of Poplog, is a derivative of POP-2.

For many years he worked in the Artificial Intelligence laboratory at the University of Edinburgh, including making major contributions to the Edinburgh robot Freddy_II, the Alvey-funded Edinburgh DESIGNER system (which used Poplog), and other projects.

In 1985 he moved to The University of Massachusetts at Amherst where he continued doing research and teaching and making contributions at a distance to the development of Pop-11 and poplog.

He retired from UMASS around 2003(?) and moved back to Scotland, where he died in 2004.

There is a memorial web site for him at Umass

Book on Pop-11 and Programming

While at UMASS Robin Popplestone wrote a large draft book on Pop-11 Paradigms of Programming, available here, including a review by a reader, installed 11 Sep 2008. He died before completing it.

The PopScheme System
(Scheme implemented in Pop-11)

This system, providing an incremental compiler for Scheme, was developed by Robin Popplestone at UMASS, and used there for teaching for several years. It became freely available online in October 1999. A copy is available which has been re-packaged to make it more portable (the original tar file had absolute path names, for instance). This has not been fully checked, though it does work with the examples.scm test file provided in the package.

There are two formats for downloading, The second one will probably be easier to install on Windows, but I have not checked that this package works in Windows poplog.

If in doubt check out the version at Umass, described in


Robin Popplestone's lecture notes on programming paradigms are available and browsable here, and downloadable here (gzipped tar file about 1MB),

Austin Tate's Nonlin planning system

The influential Nonlin hierarchical partial order planning system, developed by Austin Tate in the University of Edinburgh is available in a browsable and downloadable from here: and also from the Edinburgh Nonlin Web site:

Austin has put a lot of effort into making it run as it used to in a much earlier version of Poplog, so that it works in both Windows poplog and Linux/Unix poplog (but not yet in the Poplog editor Ved, as it expects to interact directly with the terminal).

Further information is here

If you wish to play with Nonlin, fetch the zip file. Instructions and historical information regarding Nonlin, including a review of the package, are in the file.

Further information, including sample problem domain definitions using the Nonlin task formalism (TF) can be found in these directories:

Nonlin is also available in Edinburgh here:

The original 1976 technical report defining Nonlin has been scanned in and is now available as a PDF file (6.75Mbytes).

Tate, A. (1976) "Project Planning Using a Hierarchic Non-linear Planner", D.A.I. Research Report No. 25, August 1976, Department of Artificial Intelligence, University of Edinburgh.
It is also available from the Birmingham site.

Further information can be found by giving "nonlin+planner" to google.

An Online Eliza Chatbot in Pop-11 (Now with audio output.)

Eliza is a very famous very old AI program simulating a non-directive psychotherapist originally created as a demonstration of AI programming by Joseph Weizenbaum. (See this short Biography). A simplified version of Eliza, (a kind of Chatbot Eliza) implemented in Pop-11 is now online here
Between September 2002 and February 2005 this on-line Pop-11 Eliza had answered about 17,100 questions. It is just a toy, but is less repetitive than many of the online versions of Eliza (partly because of the variety of rules and partly because of the way rules are randomised on each cycle) and it has been of considerable educational value in introductory AI courses. A slightly simpler version of the code for the Pop-11 eliza is available for use with poplog.

A slightly revised version is used for the Poplog Eliza web site, available here: here).

NOTE: since the speak_espeak program was added to Pop-11, you can make Eliza speak as well as type responses to the user, provided you have the linux espeak package installed. Use google to find it for your system. On Fedora 10 it was installed simply by using the command:

    yum install espeak
A teach file introducing students to the task of building their own version of Eliza in Pop-11 can be found here

A different design, produced by Riccardo Poli, for a potentially much more sophisticated Eliza, because it can maintain and manipulate arbitrary memories of its interactions in the Poprulebase database, can be found in the middle of this introduction to Poprulebase

Several of the packages that started as separate add-ons
are now included in the latest distribution bundles.

Note: most of the packages will be in the form of a gzipped tar file or a zip file, e.g. bhamteach.tar.gz These should be unpacked in the $poplocal/local/ directory in order to be conveniently accessible. You can put them in a different place if you understand how to manipulate the search lists used by Ved and the Poplog compilers.
If you have fetched poplog from Birmingham you should already have a shell script in $poplocal/local/com/install_package that can be used to install most of the tar.gz files without hassle. If you don't have it you can fetch it from here (Don't forget to make it executable before using it. See MAN chmod.)

NB: This is already included in the latest Poplog package for linux on PC.

A collection of teaching files, help files, autoloadable utilities and demonstration libraries is available packaged for the convenience of Birmingham AI students who wish to duplicate the teaching environment on their own machines running Poplog.

There are two bundles available

The package provides AI tutorial files, help files and supporting libraries produced mainly at Birmingham for teaching programming and elementary AI, including some Ved/Xved tutorials. Some of these are updated versions of the teach files and libraries distributed with Poplog.

The package includes the pattern prefix "!" which allows the Pop-11 pattern matcher to be used with lvars variables (lexical locals). The complete list of contents can be found here. The Pop-11 code files and the documentation files can be browsed online.


Several of the files in the "bhamteach" package are later versions of the same files included in the older "standard" Poplog distribution (V15.0, V15.5, V15.53). The newer versions have been installed in Poplog V15.6.

In some cases they correct mistakes in the older versions. In other cases they merely include extensions or enhancements, such as the use of the pattern prefix, which reduces the scope for bugs arising from use of the pattern matcher with dynamically scoped variables.

Most of these revised versions of old files were developed at Birmingham before Poplog became available free of charge, and were not incorporated into the standard distribution. Consequently if installed they will often "shadow" the "standard" versions, and this can cause confusion. Some of the files come from Sussex University, not Birmingham and are made available with permission of the authors.

Since version V15.6, these have now been fully merged with Poplog, and the new versions replace the old files.

NOTE for Windows users:

the package for Windows/NT poplog does not include any of the graphical facilities since they are usable only with unix/linux/VMS versions of Poplog.


The Pop-11 and AI teaching and documentation files included in the bhamteach tar package can be browsed online in these directories:

Not all the files in those directories are included in the "bhamteach" package. Not all of them are concerned with Poplog and Pop-11. E.g. some are introductions to Unix facilities, such as teach/Unix.intro.

There are other online browsable files included in various packages some of which, though not all, are mentioned elsewhere in this file. E.g.

NB: These are already included in the latest Poplog package for linux on PC.

Several additional "packages" are available, mostly developed in the University of Birmingham. All these are compressed tar files, or simply tar files. These should be unpacked in the $poplocal/local/ directory in order to be conveniently accessible. You can put them in a different place if you understand how to manipulate the search lists used by Ved and the Poplog compilers.

Do not install them if you have Poplog version 15.6, 15.62, or later, as they are already included.


(All of this is in the latest linux poplog package.)

(The web site seems now to be inaccessible.)

Steve Leach and Graham Higgins have begun to develop a Global Open Source Poplog Library (GOSPL) site, at (currently not working - Aug 2009)

This contains some contributed programs not available elsewhere, provided by Steve Leach and Graham Higgins. However the 'gospl' code is available as a gzipped tar file here and as a browsable directory here.


The directory contains a number of packages and utilities made available to Poplog users. This includes source code from various books, including The complete contents of the contrib directory are available in a gzipped tar file: contrib.tar.gz.

A bundle of teaching and library files added after Poplog came to Birmingham.
Now included in current releases of Linux poplog.

This is available in a single 2 Mbyte (approx) file containing a basic collection of the teaching materials and pop-11 utilities in the bhamteach package mentioned below, and also the rclib and rcmenu packages, installation scripts, scripts for rebuilding saved images, and the "!" pattern prefix which allows the pop-11 pattern matcher to use lexically scoped variables.


It is expected that a number of mirror sites will be developed. (Currently defunct).

is the first of these. It duplicates some of the contents of this directory and also includes the GOSPL site described above.
WARNING: downloads of versions of poplog at may be out of date. It is best to use the downloads from this site, if at all possible. However there are useful additional resources and tools at the site.

Information for mirror sites

To facilitate this there is a directory containing links to material in this directory which is suitable for fetching to a mirror site. These are mostly symbolic links to gzipped tar files, or directories containing gzipped tar files and some documentation directories. Links not included here need not be copied to mirror sites.

OpenPoplog at Sourceforge



Lesstif Problems (Now fixed)

From Fedora Core 6, motif is no longer provided in Fedora (because of licensing problems of openmotif), so Lesstif is provided instead. This has been found to cause problems in Poplog. In particular, closing windows causes spurious warning messages to be generated by Lesstif code. Details of the problem and a fix are listed in
It is not necessary to link poplog with motif or lesstif in order to use most of its graphical facilities. In particular the RCLIB graphical tools do not depend on motif functionality.

Problems with Poplog on versions of Linux using Selinux
(Now Fixed, in Poplog Version 15.62)

The 'setarch' problem:
Problems with SELinux security mechanisms (Fixed in Version 15.62)
Users of Linux Poplog found problems installing and running Poplog on Fedora Core 4, 5 and 6, CentOS 5, and other versions of Linux using the SELinux security mechanisms by default.
For information about SELinux see SELinux/Understanding: SELinux for dummies or Security-Enhanced Linux (Wikipedia)
The symptoms include pop-11, xved or other saved images, not starting at all or intermittently producing 'segmentation fault', 'access violation' or 'stack empty' errors.

These problems turned out to be results of security enhancements introduced by RedHat and included in precompiled kernels for Fedora Core, even though recent kernels fetched from all work with Poplog if they are compiled and installed without the security enhancements. However, it seems likely that the security enhancements will increasingly be turned on by default. The version of poplog v15.61 made available on 11 Sep 2007 was designed to get round these problems, both during installation and after, by using the 'setarch' command described below, to run poplog. However this mechanism has been superseded in the latest version of Poplog.

Explanation of the problem
John Duncan drew attention to the warnings and suggestions on this web page, provided by Dag Wieers, which explains what is going on:

Previous solutions (not needed since Poplog v15.62):

For more information, please see the above compatibility web page.


Chronological Record of Contents

In order to help those developing mirror sites determine what is new in the Free Poplog directory, there is a file created using

    ls -FglRt | gzip

which gives a reverse chronological listing of the complete free poplog directory. This file is updated after all major changes.

Suggestions for improvement are welcome.

This file maintained by:
Aaron Sloman
Last Updated: 16 Oct 2009