
Self-Contained Development Environments (2018) [pdf] - tosh
https://charig.github.io/assets/papers/SCDE-DLS.pdf
======
gumby
I spent the first 15 years of my programming life in these environments (CADR
and the Symbolics machines at MIT and other labs; Interlisp-D , Smalltalk and
Cedar/Mesa at PARC).

They are the most productive environments I’ve ever used for development, no
question in my mind. OTOH they were terrible for deployment: user hostile and
expensive.

Also a lot of programming is defensive: against poor or inexperienced
developers including oneself. When you can casually change anything you can
get into trouble, either by breaking things or by simply embedding unexpected
dependencies your code.

~~~
shalabhc
What do you think it would take to make such systems suitable for deployment?
Do you have to give up the productivity?

~~~
gumby
There is no separation between “application” and “system software”. While
super powerful it made it hard to update the system and the applications
separately. Multiple programs could make conflicting changes.

In addition, lisp programs (at least in these environments) don’t have “main”.
I think it’s no big deal to start a program as “(foo)” but that’s surprisingly
user hostile.

I worked with someone (who shall remain nameless) who ran in the same image
for several years. There were random state variables scattered in his
environment that affected the performance of his system in unreproducable
ways.

~~~
lispm
> In addition, lisp programs (at least in these environments) don’t have
> “main”.

But they have similar mechanisms.

In Symbolics Genera 'programs' are called 'activities'. They can be started by
keyboard shortcut, command, an application menu or by a general function,
where the activity is an argument. Usually each 'activity' runs a command
loop.

Additionally images have named lists containing functions, which are executed
on certain event. For example if an image starts, a 'cold boot' list will be
executed. If one has registered starting application programs (activity) -
remember activities have names like editor, listener, mail client - they will
be started by the operating system after a boot.

If a user logins on a Lisp Machine an init file gets executed. That init file
can also contain general forms which start activities.

------
vasergen
Out of the topic, but I was always wondering, where can I follow all new CS
papers like this one. Is there any sites I can follow like HN, any
suggestions?

Just yesterday I stumbled into `Out of the Tar Pit` which is turns out to be a
very life-changing for many people and was thinking, why I haven't seen it
before in my career

~~~
_0o6v
[https://blog.acolyer.org/](https://blog.acolyer.org/)

------
pensiveharsh
I wish we could have Lisp Machines for our desktops. Single language for the
whole stack, so easy to scope the source and reason about the choices made by
developers. No software bloat at all.

~~~
smichel17
Isn't this basically what people do in emacs? I'm a vim user myself, but I
regularly entertain the idea of trying emacs for basically that reason.

------
tosh
> This paper is an experiment in side-stepping operating systems, and pushing
> functionality into the runtime of high-level programming languages. The
> question we try to answer is how much support is needed to run an
> application written in, say, Smalltalk or Python on bare metal, that is,
> with no underlying operating system.

------
zeveb
We spent a lot of time these last 40–50 years chasing performance above all
else, prioritising it before safety, expressiveness & development time.

I think that modern computers are so amazingly fast that a little cleverness
can go a long way, permitting us to run more safely and write more quickly
with more powerful languages. Honestly, I wish we had been doing that for
decades at this point — computers were actually plenty fast even in the 90s!

~~~
cogman10
> We spent a lot of time these last 40–50 years chasing performance above all
> else, prioritising it before safety, expressiveness & development time.

I'm not sure I agree with this assessment. Certainly some developers have been
targeting performance (particularly compiler devs. Arguably UI devs). However,
in corporate development, performance has ALWAYS come second to development
time. The only time performance matters is.. well, when it does :). That is to
say, it only matters when slow things are causing unhappy clients or missed
deadlines.

~~~
AnIdiotOnTheNet
> Certainly some developers have been targeting performance (particularly
> compiler devs. Arguably UI devs)

Difficult to believe with how unresponsive modern UIs are.

~~~
nitwit005
We make the UIs responsive, and then we come up with a new way to make them
slow.

