
Lisp Symbolics Macivory 3 with loaded software - eecc
https://twitter.com/rainerjoswig/status/1213484071952752640
======
reaperducer
There is so much beauty in those screenshots. The more technology advances,
the more elegant old machines appear.

Even though the UI's are largely text, in some ways they make a greater effort
to communicate with the user than many of today's "best practices."

In this case, it's both big things like the verbosity of the command
responses, and little things like the beautiful font with its crossed sevens.
More information above the page scroll? The top of the window gets a jagged
edge like a torn piece of paper. (The anti-skeuomorphic crowd should avert its
eyes.)

Also notice how technical information is expressed in human terms. How much
memory is left? 11,334 "words." I know that a word can also be a technical
term, and I don't know if that's the context being used here, but there were
other programs of the era that translated bytes into human-thinkable words, so
it's possible that this is doing the same.

Along those same lines, notice how an unknown or unexpected time is expressed
as "forever" and not %NAN% like I see everywhere from airport status boards to
AppleTV. It reminds me of AmigaDOS, which in directory listings could report
file access as "Yesterday at 6pm" or "Tuesday at 1:35am." This could even be
extended. My friend's A1000 showed file dates like "Last Christmas."

It's a kind of attention to detail that is missing in higher systems today,
even though today's machines have far more horsepower to make it happen.

~~~
brudgers
It reminds me of Emacs. Which seems approximately a virtualized Lisp machine.
The pieces that are missing, like a typeface editor could probably be hacked
up (and the reason it hasn't is that most people can't design better
typefaces). Emacs calendar even has a human oriented interface.
[http://ftp.gnu.org/pub/old-
gnu/Manuals/emacs-20.7/html_chapt...](http://ftp.gnu.org/pub/old-
gnu/Manuals/emacs-20.7/html_chapter/emacs_33.html)

~~~
pjmlp
Back when I was an heavy UNIX user, in search of nice IDE like features, I
settled with XEmacs because the community was more open minded regarding the
integration of graphical capabilities.

How is modern Emacs in that regard?

~~~
na85
If you're running Mac, I suggest the railwaycat fork, which is basically GNU
emacs plus some quality of life features that RMS is against like
applescript/os integration, smooth scrolling and nice fonts

~~~
mgsouth
Railwaycat on github: [https://github.com/railwaycat/homebrew-
emacsmacport](https://github.com/railwaycat/homebrew-emacsmacport)

A list of differences: [https://bitbucket.org/mituharu/emacs-
mac/src/f3402395995bf70...](https://bitbucket.org/mituharu/emacs-
mac/src/f3402395995bf70e50d6e65f841e44d5f9b4603c/README-
mac?at=master&fileviewer=file-view-default)

> Official repository: [https://bitbucket.org/mituharu/emacs-
> mac/overview](https://bitbucket.org/mituharu/emacs-mac/overview)

> This is "Mac port" addition to GNU Emacs 26. This provides a native GUI
> support for Mac OS X 10.6 - macOS 10.15. Note that Emacs 23 and later
> already contain the official GUI support via the NS (Cocoa) port. So if it
> is good enough for you, then you don't need to try this.

> If you'd like to install with Homebrew, please
    
    
         $ brew tap railwaycat/emacsmacport
    
      and then
    
         $ brew install emacs-mac
    
      if you using cask
    
         brew cask install emacs-mac or brew cask install emacs-mac-spacemacs-icon
    
     To disable this tap, please:
    
        $ brew untap railwaycat/emacsmacport

------
dreamcompiler
This is what happens when very smart computer scientists and engineers sit
down and build a pure developer's computer from scratch, from the hardware up.
It's the most elegant IDE ever invented. It takes a while to get used to it,
but once you do, the separation between programmer and computer simply
vanishes and you "become" the computer. Describing the experience to a
programmer who has never used it is like describing an acid trip to someone
who has never done acid: It's always going to sound exaggerated or scary and
thus not very interesting.

The best IDEs today have incorporated bits and pieces of these ideas but
nobody has put it all together in one seamless box the way the Lisp Machines
did. I really miss that experience.

~~~
aidenn0
Most IDEs today should really drop the "I" as they tend to be a collection of
loosely connected tools rather than a truly integrated environment. In some
cases that's not a bad thing, but the "I" is vestigial.

------
lokedhs
The McCLIM project implements this user interface and can be used today:
[https://common-lisp.net/project/mcclim/](https://common-
lisp.net/project/mcclim/)

It's still a work in progress, but a lot of progress have been made recently.
What is really needed is more applications, and we invite anyone who's
interested to play around with it and perhaps build something for it.

I have implemented a user interface for Maxima that uses McCLIM, taking
advantage of many of the same features shown in the original post:
[https://github.com/lokedhs/maxima-client](https://github.com/lokedhs/maxima-
client)

If you just want to see what it looks like, here's a video:
[https://peertube.mastodon.host/videos/watch/df751bd5-5a26-44...](https://peertube.mastodon.host/videos/watch/df751bd5-5a26-44da-90d5-f47624161649)

~~~
reikonomusha
I think it’s wonderful to think McCLIM but it’s important to note that _so_
much of the value of the Lisp machine’s interface is derived from (1) the OS
level integration of the dynamic language, (2) the single-process aspect
(everything lives in the same memory space, all objects can interact without
serialization, and (3) the fact that developers thought that documentation and
interaction were a true part—a first class citizen—of the development of their
software.

I guess this blurs into the user _experience_. The interface, which McCLIM is
based on, gives a lot of the widgets and interaction modes you need for
something like a Lisp machine experience, but you really need your entire
development and end-user environment to be built up with the above points as
well.

~~~
lokedhs
If you run everything in your Lisp image, on top of McCLIM then you have that
experience.

I kind of try to illustrate that in the video I linked. Every object is that
is displayed is a Lisp object such as the individual parts of Maxima
expressions. You can see the underlying Lisp expression after the Lisp
listener window is opened.

One major component that is missing is a good editor that takes advantage of
all of this. There is Climacs, which is actually quite powerful but it has
issues. There is also other efforts, including one by myself but nothing is
really ready for production. This is an area where some interested developers
could make a huge difference.

~~~
reikonomusha
I would say you _could_ get it, but loading up a Lisp image doesn’t give you
it for free. Folks (like yourself!) need to build actual applications in CLIM,
or better yet, an operating system whose UI is driven by something like CLIM.

------
classichasclass
Got one of these myself (in a IIci with a Daystar accelerator and an 8-24-GC
video card, 8MW of memory, standard Genera patched for Y2K). It was quite
expensive to source and to rehabilitate. Lisp machines are a bit hard to get
used to, and I definitely don't claim to be a Lisp deity, but their interfaces
demonstrate a great deal of thought and orthogonality that's profoundly
missing from a lot of modern UI.

Under the hood the MacIvory implements a Front-End Processor to mimic their
workstations. It's a multistage boot: boot the Mac, start the FEP ("Breath of
Life"), start Genera. Oddly, while the FEP on real Symbolics boxes is a 68K,
the MacIvory CPU handles it directly, sort of like a bootloader.

There's a nice memory dump here:
[http://fare.tunes.org/LispM.html](http://fare.tunes.org/LispM.html)

~~~
jmorrison
I have one whose enclosing/host Mac II no longer boots (I changed the CMOS
battery, which was the cause last time, but no joy). No local Apple/Mac repair
shop I can find will even look at it. Does anybody know a boutique, antique
computer repair service?

~~~
progman32
In what general area do you live?

~~~
jmorrison
MA/NH, USA.

~~~
cbm-vic-20
You might want to reach out to the guys at the Rhode Island Computer Museum.
It's worth a trek down there anyway to get a tour of their warehouse.

[http://www.ricomputermuseum.org/](http://www.ricomputermuseum.org/)

------
TruffleLabs
For historical background, see Lisp Machine Wikipedia article:
[https://en.m.wikipedia.org/wiki/Lisp_machine](https://en.m.wikipedia.org/wiki/Lisp_machine)

I was introduced to the TI Explorer for a project in 1987 and really enjoyed
working in the environment.

------
agumonkey
When will this be released ? let's hope the prototype does not get shelved and
forgotten.

~~~
soapdog
I don't know if you're joking or being sarcastic, if this was the case sorry.
If this is a genuine question, then you'll have a lot of fun learning more
about Lisp Machines:

[https://en.wikipedia.org/wiki/Lisp_machine](https://en.wikipedia.org/wiki/Lisp_machine)

That has been release a long time ago.

~~~
agumonkey
Entirely sarcastic. You can even see that on my profile description.

It's yet another "past did it better".. I tried to make it poetically naive.

------
shalabhc
Here's another Lisp Machine demo showing some of these ideas in action:
[https://www.youtube.com/watch?v=o4-YnLpLgtk](https://www.youtube.com/watch?v=o4-YnLpLgtk)

------
lispm
Second thread:
[https://twitter.com/RainerJoswig/status/1213877752308350976](https://twitter.com/RainerJoswig/status/1213877752308350976)

------
shaunxcode
Two things I found cool while using mine:

a) hypercard integration (HyperIvory) b) the lisp cons cell icon where one
cell points to the apple logo

------
pjmlp
Great demo.

Now try that with Flutter.

------
somesortofsystm
I believe that the user experience from this system, and similar, can be
equally attained with other languages. Of course, Lisp all the things, and I
will agree there is no need of any other language, if that is to be argued ..
but!

We could surely build an execution environment (which is what this is) with
some other of the newer languages, broken as they may or may not be.

~~~
msla
The web browser has been trending this way ever since JS was added to it. It's
an active environment controlled by a dynamic language, it simply isn't done
as well, and it isn't done entirely consistently across web browser
implementations. The shortcomings and flaws don't negate the fact it is the
same kind of thing.

The Original Java Utopia, the world dreamed up by Sun where Java Applets would
abolish the Windows desktop and the JVM would obsolete platform dependence,
was a shadow of this idea with a fundamentally more static language, and one
more like Smalltalk than Lisp.

But with Java we've already lost the thread of an active environment, one
which is responsive to on-the-fly reprogrammability and deep inspection. Maybe
it could be done in terms of the JVM, but Java never seems to be used that
way.

~~~
somesortofsystm
There were Java environments in the very early days which attempted to make
the dream of Smalltalk-like execution/programming environments feasible ..
there was one called "Visix Vibe" which used Java to make fantastic GUI's for
easy deployment, and had the ability to ship source with all products, meaning
the components could be edited in-environment.

Dunno what happened to Visix, but there were a few other similar style IDE's
in the works in the 90's ..

