FRESH
Hacker News
Hacker News Hacker NewsThe Unix Executable as a Smalltalk Method [pdf] - https://news.ycombinator.com/item?id=45623917 - Oct 2025 (21 comments)
The Lurking Smalltalk in Unix and Plan 9 [pdf] - https://news.ycombinator.com/item?id=7719685 - May 2014 (38 comments)
https://patents.google.com/patent/US5187786A/en
Method for apparatus for implementing a class hierarchy of objects in a hierarchical file system
Abstract
A method and apparatus for implementing a class hierarchy of objects in a hierarchical file system is disclosed, which does not require the support of additional file attributes by the hierarchical file system, and has particular application to object oriented programming in window-based computer systems. The class hierarchy comprises a root class, a plurality of classes and a plurality of class instances. The root class is implemented with a hierarchy of root class directory and root class files. Each class is implemented with a hierarchy of class directories and class files comprising the class methods, and the initial values of the class instance variables. Each class instance is implemented with a hierarchy of class instance directory and class instance files comprising the class instance variables. Each hierarchy of directories and files also comprises a path file. The content of these path files are logically related to each other, based on their class' relationships. By controlling the invocation of class methods, using these path files, inheritance is achieved. By accessing the class instance variables through the class methods, data abstraction is also achieved. Additionally, the method and apparatus also supports the pseudo class instance/class "Self" and " Super" when invoking another class method by a class method.
----
https://github.com/SimHacker/moollm/blob/main/designs/postsc...
The Linguistic Motherboard
"PostScript is a linguistic 'mother board', which has 'slots' for several 'cards'. The first card we built was a graphics card. We're considering other cards..."
— John Warnock (Adobe), as recounted by Owen Densmore to Don Hopkins
This document traces how the "linguistic motherboard" concept evolved from PostScript through NeWS to MOOLLM's CARD.yml — a 40-year thread connecting printers to LLMs.
[...]
Owen Densmore's Object-Oriented PostScript (1986)
At Sun, Owen invented the OOP system that made NeWS truly powerful. He realized that PostScript's dictionary stack could implement Smalltalk-style classes:
Push a class dictionary onto the stack
Method lookup walks the stack (multiple inheritance)
Instance dictionaries hold per-object state
See: "Object Oriented Programming in NeWS" (Owen Densmore, 1986)
http://bitsavers.informatik.uni-stuttgart.de/pdf/sun/NeWS/De...
Tom Stambaugh helped Owen see how to adapt Smalltalk patterns:
"Owen and I discussed his 'crazy' idea at a poolside table at the now-demolished Hyatt Palo Alto, on El Camino. I told him that it made sense to me, we scribbled furiously on napkins, and I helped him see how he might adopt some learnings from Smalltalk."
Filesystem as Object Hierarchy (1993)
Owen Densmore and David S. H. Rosenthal (both NeWS authors) patented a method to implement object-oriented class hierarchies directly in a hierarchical file system:
US Patent 5187786A: "Method and apparatus for implementing a class hierarchy of objects in a hierarchical file system"
Directories as class and instance containers
Path files coordinate inheritance and method lookup
Shell path as dictionary stack (!)
No new file attributes required
This formalized the NeWS/Smalltalk OOP patterns into filesystem semantics — shell scripts with OOP inheritance.
[...]
----
https://github.com/SimHacker/moollm/blob/main/kernel/DIRECTO...
Selfish COM: Directory-as-Object
The insight: Directories are objects. Files are interfaces. The filesystem IS the object graph.
The deeper insight: Every directory is an agent. Every file is an agent. Every YAML section can be an agent. Agents all the way down. See `ARCHITECTURE.md` → "The Universal Foundation".
[...]
----
David Rosenthal:
https://news.ycombinator.com/item?id=44045304
>He worked with James Gosling on Andrew at CMU and NeWS at Sun, and on X10 as well as X11 and ICCCM, and he implemented the original X10 compatibility layer that was in NeWS 1.0, before X11 was a "thing".
https://en.wikipedia.org/wiki/David_S._H._Rosenthal
A User-Interface Toolkit in Object-Oriented PostScript, Owen M. Densmore, David Rosenthal:
https://www.researchgate.net/publication/229706779_A_User-In...
>Only the diehards want to develop applications using basic window system facilities. The preferred approach is a higher-level “toolkit” of user interface components, such as menus and scroll bars. Experience with current toolkits shows the need for an object-oriented interface to these components. NeWS, the Network/extensible Window System, allows user interface components to be programmed in PostScript. Fortunately, object-oriented interfaces are natural in PostScript, and they have been used to create a toolkit with some novel properties. Among these are the use of concurrent processing and run-time inheritance of component methods. “Postscript is the future of words on paper.” Arthur C. Clarke
The Dawn Of Nvidia's Technology:
https://blog.dshr.org/2025/05/the-dawn-of-nvidias-technology...
>Objects & Methods
>One of the great things about NeWS was that it was programmed in PostScript. We had figured out how to make PostScript object-oriented, homomorphic to SmallTalk. We organized objects in the window system in a class hierarchy with inheritance. This, for example, allowed Don Hopkins to implement pie menus for NeWS in such a way that any user could replace the traditional rectangular menus with pie menus. This was such fun that Owen Densmore and I used the same technique to implement object-oriented programming for the Unix shell.
----
https://news.ycombinator.com/item?id=18696116
Tom Stambaugh described how Smalltalk inspired Owen Densmore's PostScript object oriented system in NeWS.
A point he didn't mention is that PostScript is directly descendent from Interpress, which was developed at Xerox PARC and reincarnated as PostScript at Adobe by Chuck Geschke and John Warnock:
https://en.wikipedia.org/wiki/Interpress
Brian Reid's deep detailed historic dive "PostScript and Interpress: a comparison":
https://web.archive.org/web/20180222163747/https://tech-insi...
I also think PostScript owes a lot to Lisp (it's dynamic, homoiconic, polymorphic, symbolic), even more so than Forth.
http://wiki.c2.com/?ForthPostscriptRelationship
Tom Stambaugh wrote:
It seems to me that Forth is to stacks what LispLanguage is to lists. Forth demonstrated the advantages of a stack-centric paradigm in which each pushed or popped item could be evaluated as an expression or a primitive. Postscript reflects the application of that paradigm to the world of typography, 2-d graphics, and page layout. My own recollection is that Postscript's primary contribution was the use of splines to describe character glyphs, allowing them to be effectively rendered at virtually any resolution desired. If anything, Postscript owes more to TexLanguage and DonaldKnuth than to Forth. I view the stack-based language paradigm as a convenient afterthought rather than a central organizing principle.
I also think we should note the contribution that OwenDensmore, at Sun, made in demonstrating how to use Postscript dictionaries to create a dynamically-bound object-oriented runtime environment. This was the fundamental premise of the Sun window server that ultimately became the NetworkExtensibleWindowSystem. Owen and I discussed his "crazy" idea at a poolside table at the now-demolished Hyatt Palo Alto, on El Camino. I told him that it made sense to me, we scribbled furiously on napkins, and I helped him see how he might adopt some learnings from Smalltalk. It was one of those afternoons that could only have happened at that time in that place in that culture. -- TomStambaugh
----
https://github.com/SimHacker/moollm/blob/main/designs/postsc...
The Definitive History of PostScript
Primary Source: Brian Reid's 1985 "laser-lovers" Post
This document preserves the definitive first-person account of PostScript's origins, written by Brian Reid on March 2, 1985 — just 11 months after Adobe shipped its first PostScript manual.
[...]