Hacker News Reader

Comment by phtrivier | Hacker News Reader

On a related note - it's a common concern among performance-oriented programmers that OOP, pointer-chasing, polymorphism, etc... are not adapted to modern CPU, and cause terrible performances.

Has there ever been "OOP-machines" developed that would optimize / work around those problems, similar to (as I understand it) what "LISP-machines" were trying to do for LISP ?

View on HN

Lisp machines were object-oriented from the beginning, and their architectures included e.g. optimisations for method dispatch.

There was also SOAR, “Smalltalk on a RISC” architecture specifically designed to run Smalltalk efficiently.

That was really not the case, there are many misconceptions about the architecture of the Lisp Machine. The CADR for example is a very simple machine, and has no knowledge of OO or methods, likewise for the Lisp Machine macrocode.

You keep pretending that the CADR is the only Lisp machine, while it’s basically a throwaway prototype for the real deal that was being implemented at Symbolics. ;)

There are no misconceptions in my post. The CADR software already included Flavors, which is what I meant. The Ivory definitely had the method dispatch optimisations.

There was nothing "prototype" or "throwaway" about the CADR, it was heavily used at the AI lab for over 10 years, with both the Lambda and 3600 heavily based on it, to the point that the Lambda was microcode source and Lisp FASL compatible with it.

The CADR "software" does not include "Flavors" -- that is part of the Lisp Machine operating system (which for a large of its life was shared between the CADR and Lambda, and even partially for the 3600 series), which is just plain Lisp and unrelated to hardware.

None of TI or Symbolics machines had these type of optimisations that you mention. The Ivory did not have any special method dispatching optimisations. The Explorer was basically a Lambda.

Yes, it’s a throwaway prototype that overstayed its welcome for over 10 years, as it tends to happen in computing all the time. You said it yourself elsewhere that it’s a grad project.

You are nitpicking here as usual. The point is that OOP was something expected to be available on Lisp machines.

Okay, I will spoon-feed you. Open the specification on Bitsavers and search for “4.7 Generic Function and Message Passing”.

I'm quite familiar, I've restored and written simulators and implemented FPGAs for almost all of them in various states of disarray. Your claim was that they had special architecture optimisations, that was not the case, and a common misconception -- your quite condescending tone notwithstanding. OOP was indeed available, but it was software -- just like in CL, and not backed by hardware, and essentially the same way it is done today.

And we never actually got the LMI K-Machine, which was planned to have some of the special hardware people think they all had

The K-Machine would be a super interesting retro-computing project to get going. The schematics, the Lisp Machine system associated for it, are available (I'm unsure of legal status). If anyone is interested in driving that, I'd be really interested to help (but my primary interest is just the CADR due to lack of hours in the day :-) )

Here is a wonderful article about the K-Machine: http://fare.tunes.org/tmp/emergent/kmachine.htm

Rekursiv [1], though I'm not sure how viable it really was. Edit: it's been discussed [2] here a few times before, and had an extremely colourful history.

[1] https://en.wikipedia.org/wiki/Rekursiv

[2] https://hn.algolia.com/?q=rekursiv

I have an old list of Smalltalk computers (most links probably won't work):

http://www.merlintec.com/swiki/hardware/26.html

I also mention the list of Java processors in that page.

iAPX 432 [1]

[1] https://en.wikipedia.org/wiki/Intel_iAPX_432

Reply on news.ycombinator.com