Post by Dave CrosslandAfter more googling around, I wonder if anyone here has any experience
and insights with www.amber-lang.net <http://www.amber-lang.net> or
www.lively-web.org <http://www.lively-web.org> or www.pharo.org
<http://www.pharo.org> ? :)
Hi Dave,
That's a big question. I'd encourage you to play with them all (and
more) and draw your own conclusions. My own thoughts on all that are below.
== More details
I have limited experience with all three of those, but ultimately,
taking a cue from Dan Ingalls and Lively, it seems like JavaScript in
the browser is a tsunami of change for the programming world. So, I've
been focusing on JavaScript for both client and server (currently mostly
with TypeScript and a vdom like Mithril or Maquette for the frontend,
and Node.js on the backend). JavaScript has many warts. JavaScript was a
language designed in two weeks as a scheme clone in drag (the best parts
are Scheme) and then hacked at by vendors with competing financial
interests. Compare that to Smalltalk designed for a decade by a small
team doing continual user testing of each language feature). JavaScript
has been called "better than we deserve". They key advantage of
JavaScript is that it is everywhere and webapps automatically install by
just visiting a URL (if you have JavaScript turned on in your browser,
which 99% of people do). As Alan Kay has pointed out in relation to
Lively, if people won't install your software, then it is of not much
value for them. However, rather than try to draw an entire GUI from
scratch like Lively, I use vdom and then also Canvas and SVG/D3. My most
recent significant FOSS project with that set of tools as a year-long
labor of love:
https://github.com/pdfernhout/narrafirma
Working this way is tremendously inelegant, messy, and frustrating
compared to using a good Smalltalk (it is sad VisualWorks got scooped up
for a song after being wrecked out of greed and then kept proprietary
while Squeak lost momentum form non-FOSS-compatible licensing issues and
such until it was straightened out years later). For example
JavaScripters are currently excited about finally getting proxies but
without knowing about "become", so the proxies are still relatively
useless (compared to what Smalltalk made possible for decades).
However, I can hope someday I might have tools that could reflect back
on themselves to (like Squeak's VM) create a better host for themselves.
And in any case, even if inelegant, it's a bit like when people write
games in C++ at 3X-10X the effort of some other options like Smalltalk
so they run faster for millions of people. In this case, I can write
JavaScript apps at 3X-10X the effort of Smalltalk, but installing them
is trivial compare to convincing them to download and install an app.
Amber Smalltalk provides another approach, but from when I last
seriously looked at it a couple years ago, is a niche thing would
require a bunch more investment to make it really comfortable for me.
And then it still faces everyone learning JavaScript and not Smalltalk
(and the jobs being in JavaScript and not Smalltalk). I have not tried
it recently though. I'd love to see it or something similar succeed big
time.
Wish I had time to, say, integrate WebAssembly with Amber...
https://en.wikipedia.org/wiki/WebAssembly
Pharo has helped bring Squeak a long way, but then you are back to the
install issue (unless you use it as a webserver like with Seaside, but
Seaside is still not a webapp and has all the usual serve issues vs.
webapp issues).
Still, while I like much about Smalltalk, including the keyword syntax,
Smalltalk the language might do well to modernize how comments and
strings and some other basic things are done. At this point, there are
needless barriers to using a Smalltalk-like architecture for someone
used to C or Java or JavaScript syntax where strings become comments,
and comments are syntax errors. Sure, they need to learn about keywords,
but much of the rest is kind of arbitrary. A Typescript-derived language
with an added keyword syntax and improved Smalltalk-like semantics might
be an interesting thing to explore...
And don't get me started on a proliferation of buggy unfinished
JavaScript libraries and frameworks that often reinvent the past badly. :-)
It's a very sad state of affairs. As someone who has been writing
software for over 30 years, it is disappointing. But, I can't control
the wind; I can only control the sail. I do not have much time for big
projects reinventing the web. I do know I can write really cool stuff
that is easy for almost everyone to run by working in
JavaScript/TypeScript and a vdom like Mithril or Maquette and using
Canvas and SVG/D3 -- even if it is much harder than it needs to be.
I pointed out aspects of this years ago on this list, talking about how
a programming system can be seen both as a telescope and a microscope
vs. reinvented purely from the ground up. See this chain going backwards
almost a decade:
https://developers.slashdot.org/comments.pl?sid=5444005&cid=47520095
https://www.mail-archive.com/***@vpri.org/msg01445.html
https://mail.python.org/pipermail/edu-sig/2007-March/007822.html
"There is once again the common criticism leveled at Smalltalk of being
too self-contained. Compare this proposal with one that suggested making
tools that could be used like telescope or a microscope for relating to
code packages in other languages -- to use them as best possible on
their own terms (or perhaps virtualized internally). Consider how the
proposal suggests scripting all the way down -- yet how are the
scripting tools built in Squeak? Certainly not with the scripting
language. And consider there are always barriers to any system -- where
you hit the OS, or CPU microcode, or proprietary hardware
specifications, or even unknowns in quantum physics, and so on. :-) So
every system has limits. But by pretending this one will not, this
project may miss out on the whole issue of interfacing to systems beyond
those limits in a coherent way."
Related humor: :-)
"Honesty in [Programming] Employment Ads"
https://soylentnews.org/article.pl?sid=16/04/18/0140255
https://soylentnews.org/comments.pl?sid=13162&cid=333864#commentwrap
"A job ad has appeared offering one lucky worker the chance to perform
"Meaningless Repetitive Work on the .NET Stack". ...
Sometimes you just need to mix it up. It can't all be Silicon Valley in
the Sunshine State. Someone has to keep the cogs turning on
mission-critical infrastructure in large enterprises where all hope has
been lost.
Grease the wheels of capitalism with your tears, secure in the knowledge
that we will pay you handsomely for your soul.
Multiple generations of legacy code that cannot be refactored without
destroying the entire house of cards.
Design anti-patterns as a design pattern.
Live, mission-critical system where you develop on the production instance.
Large sections of managed and native COBOL.
Easily top every development horror story at LAN parties."
When FONC can help with that sort of situation, it will be really
something... :-)
To be clear, I'm not against writing better systems from the ground up
as FONC aspired to. I think that is a lot of fun. And it may eventually
lead to great stuff. I have my own musings about that, like multicore
easy-to-understand Forth-ish hardware using message passing. But until
something succeeds in the marketplace of money and also ideas, that
leaves the rest of us with very little in dealing with the daily
difficulties of programming in the large.
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
Alan Kay talks about biological metaphors of cells and integrated
organisms (the baby that grows 10X while never being taken down for
maintenance) and FONC as I understand it seems to be about designing a
better meta-programmable baby. But, what we programmers seem to face in
day-to-day reality is more the biological metaphor of complex ecosystems
full of millions of years of weirdly ad-hoc-ly adapted co-evolving
program modules which we sometimes have to understand via a complex and
fragmentary fossil record while bushwacking through the jungle that
grows in again as we pass through it.
https://en.wikipedia.org/wiki/Software_archaeology
Anyway, this is probably not that well thought out a rant, and I should
probably sleep on it, :-) but that's my current (and past) perspective.
Maybe I will revise it in years to come. :-)
JavaScript (especially via TypeScript) is definitely growing on me. I'm
starting to move past meta programming to think that someone has to
really write real code that does real stuff sooner or later in all the
meta layers. It has been said (Brian Kernighan) that since debugging is
harder than programming, if you write the most complex [meta] programs
you can, how will you ever debug them? I'm starting to feel maybe we
need better tools for managing straightforward boilerplate code with
less levels of abstraction. Maybe we need tools to be able to help all
the programmers greasing or tweaking the wheels of whatever system we
have around us at the moment. Related:
"Modern times"
Or also:
https://en.wikipedia.org/wiki/Indirection
"A famous aphorism of David Wheeler goes: "All problems in computer
science can be solved by another level of indirection";[1] this is often
deliberately mis-quoted with "abstraction layer" substituted for "level
of indirection". Kevlin Henney's corollary to this is, "...except for
the problem of too many layers of indirection.""
Like balancing a pole on your hand, so much of what we do day to day in
programming (or helping others fix broken programs) is to try to keep
something within a narrow manageable zone where the task is doable. Once
a pole goes too far from vertical, it is going to fall no matter how
much you try to keep it up. Some metrics like cyclomatic complexity can
help us in seeing when the pole is falling, but there remain many
nuances such things don't capture -- excessive levels of abstraction
perhaps being one.
So, do complex meta systems really usually help with the fundamental
problems of computing when you get beyond toy examples of managing
complexity? Or do they help with other related daily programming
problems problems like dealing with ambiguous requirements and constant
change among dependencies ("bit rot") and so on? Maybe sometimes, but it
has to be the right meta system and it has to work so well it does not
get in your way.
See also:
http://gamearchitect.net/Articles/SoftwareIsHard.html
"Scott Rosenberg coins this as Rosenberg's Law: Software is easy to
make, except when you want it to do something new. The corollary is, The
only software that's worth making is software that does something new."
In any case, when I squint, I can kind of see all those
JavaScript-powered browsers and Node.js servers out there running a lost
of FOSS code hosted in git as running a badly-written Smalltalk VM
exchanging badly-formatted messages. And, compared to what we had
before, when I had to plunk down about US$9K to get a license to
VisualWorks plus Envy in the mid 1990s from ParcPlace where I could not
even ship most of the VisualWorks code I worked with like the Smalltalk
compiler for licensing reasons and almost no one else used Envy, that I
guess is progress. :-)
--Paul Fernhout (pdfernhout.net)
"The biggest challenge of the 21st century is the irony of technologies
of abundance in the hands of those still thinking in terms of scarcity."