
Alan Kay Answers “Is There a Successor to Smalltalk?” - davelnewton
https://www.quora.com/Is-there-a-programming-language-thats-effectively-a-successor-to-Smalltalk/answer/Alan-Kay-11?share=1
======
nickm12
Kay starts off by citing Moore's law, but misses that Moore's Law hasn't been
kind to Smalltalk. Specifically, CPU power has grown at a faster rate than
memory bandwidth, to the point that going to main memory is hundreds of times
slower than the L1 cache.

I believe the pendulum is swinging back from dynamic languages to compiled
languages with stronger static guarantees. Languages that are parsimonious
with memory and give you control over the layout when you need it.

Don't get me wrong. Smalltalk is a hugely influential language and we're
better for having it, but it was designed in an era where hardware had very
different performance characteristics from today's hardware.

~~~
xfer
Citing performance (especially related to micro-optimization) everytime we
discuss language design is not a right thing to do. Most applications don't
require or benefit from such micro-optimization(tight control of layout).

> but it was designed in an era where hardware had very different performance
> characteristics from today's hardware.

Exactly, the era of 256k memory computers are over. Programmer time and
correctness is more valuable than making sure everything fits in L1 cache.

~~~
nickm12
You're missing my point. When we had 256k memory computers we didn't have
caches because memory access was uniform. As time goes on, fitting in cache is
getting more important, not less.

------
peterburkimsher
Smalltalk inspired the languages I grew up with. I'd say that they're worthy
successors.

I was introduced to programming at school using LOGO when I was 7 years old.
My dad found a broken Mac Plus and told me I could keep it if I could fix it.
So I learned basic hardware repair (swap out the motherboard). Having my own
computer gave me a sense of responsibility and independence that I never had
before.

When I was 11, he bought me an iBook. I also saved up my pocket money
(allowance) for an iPod.

I wanted more apps on the iPod, and was interested in the Notes feature. I
taught myself AppleScript to scrape websites and convert the HTML to
1000-character iPod Notes TXT files. This included my English textbooks - I
read Shakespeare on an iPod in 2003 so I didn't need to carry a heavy book. I
also wrote many scripts for iTunes.

All of this was self-taught, without textbooks or YouTube or tutorials online.
It was even before StackOverflow. How did I learn?

The syntax is easy. There's a single button to compile & run. The code is
auto-formatted in colour. And there are lots of APIs to every other app.

As a Computer Science class project, I spent months writing a database program
for SMS messages using Java. But for myself, I spent half a day coding a
converter AppleScript to put those SMS text files into blank MP3s and store
them with iTunes. All the fancy features (smart playlists, playlist folders)
were already done!

Programming is not scripting - you have to use libraries instead of leveraging
other apps. But I see the successor to SmallTalk being a scripting language
with a lot of APIs. Like AppleScript, but with better support for cross-
platform and GUIs.

~~~
crispinb
> The syntax is easy

That made me chuckle. I've tried Applescript from time to time but always
given up with it in frustration having failed after repeated attempts to find
whatever particular Englishey construction might do what I want (or anything
for that matter). Perhaps its approach doesn't work well for programmers (or
just for me).

------
bsaul
10000 lines for an os , plus gui, plus media player, plus... i suppose
smalltalk was used as a glue over an api written with a lower level language ?

I don’t understand how one could build just a kernel with the required
graphical drivers with that few number of lines... But maybe at that time the
requirements for each part of the system were orders of magnitude simpler
(memory protection, scheduling, fault isolation, graphical
functionalities,...).

~~~
jonjacky
The only API was the machine instruction set, the lower level language was the
microcode language used to define machine instructions. For example, the
bitblt operation used to move graphics around on the screen was a machine
instruction implemented in microcode. Ditto for network etc. At boot time, the
Alto and later Xerox machines that ran Smalltalk loaded a different microcoded
instruction set for each language: Smalltalk, Lisp, Mesa, BCPL ... Then the
whole system was written in that language. Details appear in the many papers
and reports linked here:

[http://xeroxalto.computerhistory.org/xerox_alto_file_system_...](http://xeroxalto.computerhistory.org/xerox_alto_file_system_archive.html)

I just noticed that site includes the code, apparently including the
microcode, in addition to papers and reports! (I'm not sure if the microcode
programs are included in Kay's 10 - 20,000 line estimate.)

~~~
bsaul
Thanks for the info !

I'm still having a hard time understanding how having to ability to program
your own "assembly" operation through microcodes could reduce the number of
lines for huge programs that drastically. At worst you could still code those
operations with the higher level language (smalltalk)... I can imagine how
that would make things slower, but that's another issue.

Another thing i wonder as someone that hasn't coded in assembly since school :
isn't the set of low level instructions required to build most regular
programs pretty much settled now ? I'm not talking about high performance or
3D graphics, or AI. Only things personal computers have been doing for the
last 30 years.

Put it differently: supposing intel gave use the possibility to reprogram a
large set of its assembly instruction using microcodes, would the linux
codebase be radically smaller ?

~~~
shalabhc
> the linux codebase be radically smaller ?

I believe Linux isn't built the same way the Smalltalk system was. One glaring
difference is the use of C - with that you can't get very high level and are
always programming at a very low level. You also force all integrations to be
at a very low leve, given how the ABI and syscalls work.

You can do quite a bit more if you use a higher level language with very good
meta programming, for instance Lisp or Smalltalk. E.g., you could imagine very
high level abstractions that get translated to lower level logic
automatically. Unfortunately, this is not an area that has been extensively
adopted IMO, and the mainstream thinking is we need to use lower level
languages for operating systems and such.

> supposing intel gave use the possibility to reprogram a large set of its
> assembly instruction using microcodes

Actually Alan Kay has been critical of Intel not doing this. It may not affect
Linux much but it will definitely open the door for systems using more
advanced techniques, specifically the ability to build high level emulators.
See
[https://news.ycombinator.com/item?id=15282739](https://news.ycombinator.com/item?id=15282739)
for more.

~~~
davelnewton
It sort-of depends on what you mean by "low level". You can play very
sophisticated games with C and present a high-level interface to
functionality.

------
ioddly
He didn't mention some of the stuff Viewpoints was working on which seems to
have petered out (although maybe "bad funders" was a dig at that). I'd like to
know what happened to those projects.

[https://en.wikipedia.org/wiki/COLA_(software_architecture)](https://en.wikipedia.org/wiki/COLA_\(software_architecture\))

~~~
loup-vaillant
The STEPS was more or less finished if I recall correctly. The last report
took forever to get public, but they did get a proof of concept out.

Many people asked for something usable, but that wasn't really the goal, so
they didn't do the polishing —it sure takes work, but it doesn't prove much.

We can still take the ideas, though. We could integrate some of them in the
current ecosystem to write simpler programs, or even simpler ecosystems. How
about something like squeak or pharo, only 10 times simpler?

