Search                        Top                                  Index
HELP POPFAQ                                                   Ian Rogers
                                             Date: 3 Feb 93 12:06:57 GMT
                                       Updated Aaron Sloman, 8 Jan 2005




         CONTENTS - (Use <ENTER> g to access required sections)
               (You're using Ved to read this, right? :-)

 -- Is this the Post Office Protocol
 -- What *is* Pop then
 -- Can I get POP for my MS-DOS/Macintosh/Archimedes/...
 -- Is Glow like Pop11
 -- What's so good about an open stack
 -- What's so good about the Virtual Machine
 -- Acknowledgements

-- Is this the Post Office Protocol -----------------------------------

No it's not, sorry. If that's what you're looking for then try
comp.protocols.pop or comp.protocols.internet or something (but I don't
actually know if they exist). Here's the charter for comp.lang.pop:

    The group serves for discussions on the programming language Pop11,
    and related environments, libraries, languages and the Plug User

    Relevant topics, in this group, would cover all aspects of Pop11
    programming (from novice questions to expert efficiency issues) and
    the current BSI standards effort (Pop9x), and how it relates to
    other languages of this type (e.g. GLOW, Pepper).

    Also relevant would be conversations about the Poplog programming
    environment and its libraries. Eg.

    OOP in Pop11 Flavours, or objectclass etc. and how they relate to
        other OOP languages (C++, CLOS etc.)
    X windows hacking in Pop11
    Mixed language programming (eg. between Lisp/Pop11/Prolog/ML/C etc.)
        that is supported in Poplog but isn't relevant for discussion in
        other, pure language, groups
    Techniques for Artificial Intelligence programming (it is an AI
        language after all :)

    and so on.

Yes, there's a name clash because both had a thing called
POP2.  It doesn't matter.  The protocol is on POP3, the
language is at Pop11, the language system is called POPLOG.

If you want to know more about the protocol, please read
    1225  Rose, M.T.  Post Office Protocol: Version 3.  1991 May;
    16 p. (Format: TXT=37340 bytes)

To get this document, send a one-line mail message to
<> with no subject:
    SEND rfc1225.txt

I have an incomplete draft introduction to Pop-11 which is currently
available via anonymous ftp.

    <login as "anonymous" with password your email address>
    cd pub/dist/papers
    get primer.Z

    uncompress primer

-- What *is* Pop then -------------------------------------------------

From the computer scientist's viewpoint, the most important qualities of
Pop are :-

    *   Garbage collection (automatic store management).
    *   The language is dynamically typed (cf. Lisp).
    *   Arguments and results are passed and returned via a stack which
        is open to the user to manipulate in any way.
    *   Procedures are first class datatypes, can be arbitarily nested,
        and provide full-lexical scoping.
    * Incremental compilation
    * lightweight processes
    * extendable syntax and explicit virtual machine

-- Can I get POP for my MS-DOS/Macintosh/Archimedes/... ---------------

I only know of one implementation for the PC and that's one called
GLOW.  I've only seen this system reviewed once in (wait for it ...)
the UK section of Byte magazine & no one I know has tried it out.
Alas, I've lost the relevant article.  So, please please will someone
post the contact details for the GLOW implementation?

Incidentally, GLOW is a fairly major deviant from the "mainstream" of
Pop languages.

The Brighton based company Cognitive Applications Ltd produced an
implementation of Pop-11 called Alphapop, which was, I think, very
favourably reviewed in Byte around May 1986 by Dick Pountain.

I think the price has dropped substantially since those days, especially
for academics, though development froze some years ago, and it is now
only a small though very usable subset of Poplog Pop-11. For more
information contact:

    Cognitive Applications Ltd
    4 Sillwood Terrace
    BN1 2LR
    +44 (0) 273 821600

AlphaPop (Pop11 for the Macintosh) - the prices:

  The standard AlphaPop package includes:
   Language Guide book
   Reference Manual book

  A single user license costs L400; academic price L300.  Additional
  licenses are quite cheap, and the 25% academic discount applies
  across these also.

  There is a 'student edition'.  It includes:
   Electronic version of reference manual

   (it is intended for people who are being taught Pop11, and
   therefore don't need the full tutorial documentation)

  This edition costs L120, and is available to bona-fide students.

  (All prices exclude VAT).

AlphaPop - the version (also, AlphaPop - the Caveat):

  The current version of AlphaPop is 1.2.3.  We have never charged
  anyone for an upgrade; and have always tried to contact all known
  customers when there was an upgrade; if anyone still has an older
  version, please send me the disk (Ben Rubinstein at Cognitive
  Applications, address below) and we will upgrade you.

  This version of AlphaPop has basic graphics facilities.  It does
  not support colour, QuickTime etc.  It runs under System 7, but
  does not run with 32-bit addressing switched on.  It runs under
  every operating system from 3.4 to 7.1, and on every known
  Macintosh (current and discontinued), most of which have been
  introduced since it shipped.  It runs happily on a 512K Mac;
  and can take advantage of more memory, up to 8MB.

  Now the caveat: anyone buying AlphaPop should be aware that we
  have no plans to upgrade it further. As noted above, there seems
  every reason to believe it will continue to be compatible for
  some time to come; but we can't guarantee it, nor should you
  expect upgrades to take advantage of new features such as QuickTime.
  We do not actively market AlphaPop, but are happy to sell it to
  anyone who enquires, provided this is understood.

AlphaPop - the contact address:

    (In the US + Canada, please contact:
        Computable Functions Inc.,
        35 South Orchard Drive
        Amherst MA 01002
        Tel: (413) 253-7637

    Outside North America:
        Cognitive Applications Ltd
        4 Sillwood Terrace
        BN1 2LR

    Tel: 0273-821600
    Fax: 0273-722767

So far as I know, there are no FTP'able versions of Pop at all. Pop also
tends not to run on MS-DOS machines, historically (I think) because of
their pig-poor addressing and underpowered CPUs; this has changed
recently. (Poplog does run on Sequent Symmetrys, which are high-end
*86's. I think.)

Some person somwhere was rumoured to be doing a Pop look-fairly-like
called Saffron, or Karl, or Salt. Something like that. But I don't think
they've done anything with it recently. Lazy frogs.

So, Chris, when is Pepper going public?  (Karl??  Oh, Karl Popper.)

-- Is Glow like Pop11 -------------------------------------------------

The article on GLOW can be found in the UK May 1992 issue of Byte
magazine, page 84UK-8.

For those who haven't got access to this issue, I will give a very
brief summary, including quotes from the article:

    "Glow Comes Out of the Dark" (Dick Pountain)

Inspired by POP-11, Glow is a powerful list-processing language for

Glow, like its ancestor POP-11, is an interactive list-processing
language with a syntax that resembles Pascal or structured BASIC.
It supports loops as well as recursion, lists as well as strings, and
objects with multiple inheritance.

A major difference between it an POP-11 is that Glow employs strictly
lexical, rather than dynamic, scoping. This means that the visibility
of any object is governed by the program text (as in Pascal), rather
than the run-time environment.

MS-DOS Glow calls your own external text editor from inside Glow and
compiles directly from the editor, so long as it is not too large.

One difference is in definition of procedures: instead of POP's

    define ... enddefine

Glow uses

    def ... edef

Glow performs I/O via two streams called "source" and "sink" which you
redirect as necessary to real I/O devices, called IODEVS (e.g.
console,keyboard,stderr ...).

The first-release version of Glow that I have is stable, but has some
rough edges ...

Glow is the BASIC of AI languages.

Glow for Macintosh or MS-DOS with manual and user's guide, 69.95
pounds, from

    Andrew Arblaster
    NightOwl software
    Bollostraat 6
    B-3140 Keerbergen

-- What's so good about an open stack ---------------------------------


The key difference between Lisp and Pop's semantics (putting the
important issue of syntax aside for one moment) is the open stack.
.... Having the open stack at the heart of all programming
idioms gives the language family its distinctive character.

One idiom will illustrate my point nicely.  The task is (say) to add all
the numbers in a list.  One of the built-in routines is called "applist"
which takes a list and a procedure as arguments. It then applies the
procedure to each element of the list in turn. We can add all the
numbers in the list as follows:

    applist( 0, LIST, nonop + )    ;;; nonop disables infix-ness of +

Oh?  Did I say applist takes 2 arguments?  Well, I did but don't forget
that Pop uses an open stack, so there's no notion of argument checking.
All the arguments go on the stack and come off again.  This example
works because the iteration starts with 0 on the stack, then element 1
gets pushed, then the top two items get added and replaced by the single
result, and so on and so on.  At the end of the iteration, all that
remains on top of the stack is the answer.

Of course, the equivalent functional programming idiom (e.g. in Lisp)
would be to define a slightly different higher-order operator to
"applist" which might be called "fold".

define fold( sofar, list, op );
    if null( list ) then
        fold( op( sofar, hd( list ) ), tl( list ), op )

That's always true.  You can always do it in Lisp (or whatever) but you
just do it differently.  Here's another nice use of the open stack.
Suppose we want to flatten a tree (represented as a list of lists) into
(say) a list.  What's the idiomatic way of writing that?  The answer is
to use the stack as a temporary collection zone.

define flatten_to_stack( tree );
    if islist( tree ) then
        applist( tree, flatten_to_stack )

define flatten( tree );
    [% flatten_to_stack( tree ) %]

The virtue of writing flatten this way is that, for example, it might
turn out that we didn't want a list but we wanted a vector (1D array).
Well that was easy ...

define flatten( tree );
    {% flatten_to_stack( tree ) %}

Changed my mind.  I wanted to convert the vector into a string. Fine ...

define flatten( tree );
    consstring(#| flatten_to_stack( tree ) |#)

Note the use of count brackets "#|" and "|#" in the above example.
These simply count the difference in the length of stack before and
after the expression between them.  This makes sense when you know that
consstring expects a count of the number of characters on the stack as
its "topmost" argument.

This is probably far too long a post already but I could go on about the
open stack for another couple of hours.  It is the most wonderful thing
about Pop and defines the language family.  It is never the case that it
makes you able to do things that can't be done in Lisp-like languages
but it does make you want to say them rather differently!

-- What's so good about the Virtual Machine ---------------------------

The Poplog Virtual Machine extends the simple Forth-like
facilities of Pop-11 (push something onto the stack, pop the top of
the stack into ..., call procedure X, return from current procedure,
go to, branch if, etc. etc.) with quite a lot of sophisticated
constructs including mechanisms for handling abnormal exits,
interrogating the control chain, trapping procedure exit and entry
(and running user-specified set-up and re-set procedures), handling
both dynamic and lexical scoping, handling a stack of prolog
continuations, runtime creation of new procedures, etc. The PVM
makes it possible to implement incremental compilers for a variety
of high level languages, not all with efficiency comparable to
stand-alone implementations, but still quite tolerably fast, and
much faster than if they were interpreted. (E.g. you can build a
prolog interpreter in any Lisp system, but not an incremental prolog
compiler.) For more on the Poplog VM see

Robert Smith, Aaron Sloman, John Gibson
`POPLOG's two-level virtual machine support for interactive languages' in
Research Directions in Cognitive Science Volume 5: Artificial Intelligence,
eds D. Sleeman and N. Bernsen, Lawrence Earlbaum Associates, 1992
(Also Cognitive Science Research Paper 153, School of Cognitive
and computing sciences University of Sussex, Jan 1990).

See HELP * POPREFS for more papers on Poplog

-- Acknowledgements ---------------------------------------------------

    as   - Aaron Sloman, Birmingham University
    ir   - Ian Rogers, Sussex University
    jl   - Jonathan Laventhol, D. E. Shaw & Co.
    kers - Chris Dollin, HP Labs
    rl   - Rudi Lutz, Sussex University
    sfk  - Steve Knight, HP Labs
           Now known as Steve Leach, at:

--- C.all/help/popfaq
--- Copyright University of Sussex 2005. All rights reserved. ----------