home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #26 / NN_1992_26.iso / spool / comp / lang / pop / 25 < prev    next >
Encoding:
Internet Message Format  |  1992-11-14  |  6.8 KB
  1. Path: sparky!uunet!charon.amdahl.com!pacbell.com!decwrl!olivea!charnel!rat!usc!sdd.hp.com!hpscit.sc.hp.com!scd.hp.com!hpscdm!hplextra!otter.hpl.hp.com!otter!sfk
  2. From: sfk@otter.hpl.hp.com (Steve Knight)
  3. Newsgroups: comp.lang.pop
  4. Subject: Re: Re: help
  5. Message-ID: <116670006@otter.hpl.hp.com>
  6. Date: 13 Nov 92 17:32:04 GMT
  7. References: <1dtqn9INN7kk@hobbes.genrad.com>
  8. Organization: Hewlett-Packard Laboratories, Bristol, UK.
  9. Lines: 136
  10.  
  11. Mike Long asks:
  12. > guaranteed to be a FAQ, what is pop?
  13. > Please post, as this will be the initial FAQ, so someone might as well
  14. > start with that one.
  15.  
  16. Judging by the early posts, there are a quite a few people who would
  17. like an answer to this.  Well, here's my $0.02 worth on the topic.  Before
  18. I launch into it, I'd like to point readers in the direction of the 
  19. following book.  The first chapter of this book is written by Prof. 
  20. Popplestone, the "father" of the Pop-family, and contains the best 
  21. account of the early history of Pop that's available.
  22.  
  23.  %E Anderson, James
  24.  %T Pop-11 Comes of Age
  25.  %I Ellis Horwood
  26.  %D 1989
  27.  %O A collection of papers on the history of dialects of Pop, the
  28.  %O features and benefits of the language, and some applications using
  29.  %O Pop-11.
  30.  
  31. Question: what is pop?
  32. ----------------------
  33.  
  34. Pop is the name used to describe a family of closely related programming
  35. languages that are derived from POP-2.  (POP-2 itself was preceded by a 
  36. series of early versions (COWSEL, POP-1) that are only of historical 
  37. interest nowadays.)  This language was developed in the early 1960's 
  38. at Edinburgh University by Burstall and Popplestone as an AI programming
  39. language.
  40.  
  41. The family of languages can be charicatured as follows: Pop has a syntax
  42. that is reminiscent of Algol, a dynamic type and store management scheme
  43. like Lisp's, and passes arguments and returns results to procedure calls
  44. via an "open" stack in the same way as Forth.  To the tiny subpopulation of
  45. readers that know all three of these other languages, this is a nice
  46. summary of the salient features that gives you no idea of what it is like
  47. to use the language.
  48.  
  49. The most widely used dialect of Pop at the moment is POP-11.  POP-11 is the
  50. core language of the multi-language programming environment POPLOG.  POPLOG
  51. currently incorporates 4 programming languages: POP-11, Common Lisp, Prolog,
  52. and Standard ML.  POP-11 is also the most sophisticated of all the Pop
  53. dialects.
  54.  
  55. From the computer scientist's viewpoint, the most important qualities of
  56. Pop are :-
  57.  
  58.     *   Garbage collection (automatic store management).
  59.     *   The language is dynamically typed (cf. Lisp).
  60.     *   Arguments and results are passed and returned via a stack which
  61.         is open to the user to manipulate in any way.
  62.     *   Procedures are first class datatypes, can be arbitarily nested,
  63.         and provide full-lexical scoping.
  64.  
  65. Taking these points in order.  Garbage collection means that the programmer
  66. doesn't have to be concerned with how store is managed and is assured that
  67. store is deallocated efficiently, securely, and optimally on their behalf.
  68. Because the language is dynamically typed, the programmer does not have to
  69. explicitly contruct type unions and is secure in the knowledge that no 
  70. meaningful programs are disallowed by the type system.  On the other hand,
  71. the programmer has no systematic way of eliminating type errors from their
  72. program.
  73.  
  74. The most interesting aspect of Pop is the use of the open stack.  
  75. For example, because procedures return their results onto the stack, 
  76. there is no special syntax or concepts required for returning multiple 
  77. results.
  78.  
  79.     ;;; A procedure that returns two results given one input argument.
  80.     define duplicate( x ); 
  81.         x;     ;;; put the value of x onto the stack
  82.         x      ;;; do it again
  83.     enddefine;
  84.  
  85. When constructing lists, strings, vectors, arrays, or any other composite
  86. object, the results can come from the stack.  For example, the brackets 
  87. "[%" and "%]" will build all the items put onto the stack between them
  88. into a list.  Here's how to filter out all the non-prime elements from a 
  89. list of numbers to be left with the prime numbers of that list.
  90.  
  91.     ;;; Readers familiar with the ZF-list notation in Miranda will see
  92.     ;;; how to construct arbitrary (finite) list comprehensions from this
  93.     ;;; simple example.
  94.     define only_primes( list ); 
  95.         vars i;
  96.         [%  
  97.             ;;; iterate over the elements of the list.
  98.             for i in list do
  99.                 ;;; if the element is prime leave it on the stack.
  100.                 if isprime( i ) then
  101.                     i
  102.                 endif
  103.             endfor
  104.         %]  ;;; gather all the items put on the stack between here and the 
  105.             ;;; opening brackets and build a new list out of them.
  106.     enddefine;
  107.  
  108. Like modern Lisps, Pop supports (and encourages) the use of procedures
  109. to model all kinds of datatypes.  Furthermore, procedures are "first-class
  110. citizens", which can be constructed, passed as parameters, returned as
  111. results, assigned to variables, concatenated together.  Full lexical 
  112. binding is supported in POP-11, along with dynamic binding and a 
  113. generalised version of dynamic localisation (of which sys-unwind-protect is
  114. a special instance).
  115.  
  116. As an example, the portable I/O model of Pop relies on the use of 
  117. higher-order procedures.  The portable way to read from a file is
  118.     vars char_repeater = discin( 'my_file' );
  119. The result of "discin( <file> )" is a character repeater/generator.  This
  120. is a procedure that when called returns the 'next' character from the
  121. file.  When the input is exhausted the special item "termin" is 
  122. returned.  This gets interesting when you appreciate that there is a
  123. "promotion" procedure called incharitem that takes a character repeater
  124. and returns a token (item) repeater.
  125.     vars item_repeater = incharitem( char_repeater );
  126. The item repeater acts in the same way as a character repeater pulling
  127. in tokens or lexemes from the input stream.  Furthermore, an X-repeater
  128. can be promoted to a "dynamic" or lazy list by applying the procedure
  129. pdtolist.
  130.     vars item_list = pdtolist( item_repeater );
  131. Such a list causes the character repeater to be executed as it is
  132. examined by the head (hd) and tail (tl) procedures.
  133.  
  134. This, I hope, gives a picture of Pop as a (family of) high-level language
  135. that is suitable for complex programming tasks.  Its implementation 
  136. technology is very similiar to modern-day Lisp systems.  No current 
  137. implementations are suitable for "real-time" programming, by which
  138. I mean applications that are critically sensitive to unpredictable
  139. delays, since the demands of garbage collection and virtual memory are
  140. difficult to reconcile with real-time work.  However, Pop is suitable
  141. for general-purpose programming tasks since the typical run-time system
  142. is not excessive by the standards of today's technology.  For example,
  143. the richest and most complex implementation (POP-11) has a run-time 
  144. executable of approximately 500Kb.
  145.  
  146. Steve
  147.