You're welcome! OOPS (Object Oriented PostScript ;), I meant to say that PostScript and Lisp are homoiconic, but Forth is not. The PSIBER paper on medium goes into that (but doesn't mention the word homoiconic, just describes how PS data structures are PS code, so a data editor is a code editor too).

https://medium.com/@donhopkins/the-shape-of-psiber-space-oct...

Also, here is a metacircular PostScript interpreter, ps.ps: a PostScript interpreter written in PostScript! Since PostScript is homoiconic and so much like Lisp, it was as easy as writing a metacircular Lisp interpreter (but quite different in how it works, since PostScript and Lisp have very different execution models).

https://donhopkins.com/home/archive/psiber/cyber/ps.ps

And here is an explanation of why I wrote it:

https://donhopkins.com/home/archive/psiber/cyber/ps.ps.reaso...

    Obvious Question:
      Why would anybody ever write a PostScript interpreter in PostScript?

    Possible Answers:
      To use as a debugging tool.
      To trace and single step through the execution of PostScript code.
      To serve as a basis for PostScript algorithm animation.
      To gain a deeper understanding of how PostScript works.
      To try out some ideas from Structure and Interpreteration.
      To experiment with extensions to the PostScript language.
      To demonstrate that PostScript isn't just for breakfast any more.
      To make PostScript run even slower (but thicker).
      To avoid programming in C (the portable assembly language of the 80's).
      To use to interpret its self.
      To have something nerdish to talk about at parties.
      [...]

Some Forth systems like Mitch Bradley's OpenFirmware have a metacompiler that can compile the same or different versions of Forth for the same or different architectures (or even word sizes or threading methods), which is a totally different thing than a metacircular interpreter, but also very cool and useful.

https://www.bradrodriguez.com/papers/moving4.htm

https://github.com/MitchBradley/openfirmware/blob/master/for...

Also here's some stuff about LispScript, which is a Lisp to PostScript compiler developed by David Singer and Rafael Bracho at Schlumberger around 1987, and some discussions about the joys of using the same scripting language on the client and on the server and sending JSON-like data structures (polymorphic PostScript arrays and dictionaries) back and forth over the network as events. What we were trying to do with NeWS PostScript between both the NeWS client and server eventually finally happened with JavaScript/JSON between the web browser and server with node.js, and is now called "AJAX".

https://donhopkins.com/home/archive/NeWS/NeScheme.txt

>PostScript is often compared to Forth, but what it lacks in relation to Forth is a user-extensible compiler. You can write your own PostScript control structures and whatnot, like case and cond, to which you pass procedures as arguments on the stack, but the PostScript scanner is not smart -- but there is no preprocessing done to the PostScript text being read in, like the way immediate words in Forth can take control and manipulate the contents of the dictionary and stack while the text source is being read in and compiled, or like the way Lisp macros work. This is one of the things I would like to be able to do with something like LispScript.

    Date: Sun, 7 Jan 90 10:36:44 PST
    From: Russell Brand <wuthel!brand@lll-crg.llnl.gov>
    To: don@cs.UMD.EDU
    Subject: wuthel wisp klote

    >Somebody quoted you as saying something along the lines of "Lisp is
    >the language for people who want everything, and are willing to pay for
    >it." Is that how you put it?

    The quote is exactly right.  It is from a panel I led on the
    differences between Lisp, C, Ada, Pascal, Forth and Rex.

https://en.wikipedia.org/wiki/NeWS

>NeWS was architecturally similar to what is now called AJAX, except that NeWS coherently:

>used PostScript code instead of JavaScript for programming.

>used PostScript graphics instead of DHTML and CSS for rendering.

>used PostScript data instead of XML and JSON for data representation.

Also, check out NFS Version 3 aka NeFS, which was NeWS for files -- PostScript in the kernel.

https://news.ycombinator.com/item?id=9271578

>You might get a kick out of Sun's proposal for "NFS 3.0" aka "NeFS". The basic idea was to put a PostScript interpreter in the kernel for extensibly and efficiently executing distributed and even local file system operations. It not only cuts down on network transactions for the same reason NeWS and AJAX does, but even locally you can avoid billions of context switches by executing "find" and tasks like that in the kernel, for example.

The Network Extensible File System Protocol Specification 2/12/90

http://www.donhopkins.com/home/nfs3_0.pdf (pages in reverse order)

https://news.ycombinator.com/item?id=17077721

>Here's some old but interesting discussion about NeFS that I saved from Comp.protocols.NFS. (they were SHOCKED I say SHOCKED!!!)

http://donhopkins.com/home/archive/NeWS/Comp.protocols.nfs.N...

    From: brent@terra.Sun.COM (Brent Callaghan)
    Newsgroups: comp.protocols.nfs
    Subject: NeFS Protocol Spec Available
    Keywords: NFS version 3
    Date: 13 Feb 90 01:57:31 GMT

    NeFS is not NFS.  It started out as an NFS protocol rev
    (NFS version 3) but its protocol is a radical departure
    from the NFS's remote procedure call model.  In order
    to avoid confusion with NFS we're calling it NeFS for
    now - Network Extensible File System (the similarity of
    the name to a window system protocol is entirely intentional).

https://news.ycombinator.com/item?id=17482780

And later on around 1990-1993, Arthur van Hoff wrote PdB at the Turing Institute in Glasgow, an object oriented C to PostScript compiler called PdB (for Pure dead Brilliant), which is kind of like TypeScript, conceptually. We used PdB to develop HyperLook (Networked PostScript based HyperCard for NeWS), which I used to port SimCity to NeWS on Unix. (A few years after that, Arthur wrote the Java compiler in Java at Sun in 1995, and lot of other cool stuff since then!)

https://en.wikipedia.org/wiki/Arthur_van_Hoff

https://medium.com/@donhopkins/hyperlook-nee-hypernews-nee-g...

https://news.ycombinator.com/item?id=10088193

>Arthur van Hoff wrote PdB, and we used it for to develop HyperLook (nee HyperNeWS nee GoodNeWS). You could actually subclass PostScript classes in C, and vice-verse!

https://compilers.iecc.com/comparch/article/93-01-152

>Subject: PDB -- ANSI-C to PostScript compiler arthur@turing.ac.uk (1993-01-21)

>From: arthur@turing.ac.uk (Arthur van Hoff)

>Organization: The Turing Institute Ltd., Glasgow, Scotland

>Date: Thu, 21 Jan 1993 12:52:14 GMT

>Hi PostScript Hackers, [...]

>There is no more need to write PostScript! Start using PdB right now! PdB is an optimizing compiler to compile ANSI-C (like) code into Adobe compatible PostScript. It includes executables, examples and many useful header files. Note that it is not dependend on NeWS.