Ironically after watching glamorous toolkit videos on youtube, I was recommended a talk by Geoffrey Litt about dynamic documents [2] and at the end of his talk I learned about bb [3], which has much better agent integration compared to GT. Like @thelazydogsback said, with agents, the programming language matters less.
I think Girba's really amazing idea of "language = ui = software = data" has a huge win in terms of AI that is not used anywhere else (maybe only in Chris Granger's Eve), but to work with data and build live on it, is something way better than BB.
But in practicality, at least at this point, bb wins out by sheer expansiveness of ecosystem. I was working on a mishmash of an editor interface that combined obsidian with heptabase, directly in GT. It kind of worked. And the amazing thing is, everything has just a single representation: window positions displayed as text automatically have 2 way bindings across widgets, because they are the same data. But even with agents doing everything, 2 things creep up.
First is in JS/TS, all these binding problems are solved 1000x already. You can fake shared memory with callbacks and the agent won't lose track. In GT you move the cursor around, and have to decide at what point do you convert a widget representation to source representation, and when to restore the widget: is it a delay? is it after changing lines? is it after you move off the text? before or after the whitespace? There's a package for that somewhere in npm that answered all these questions, and it has tables, and it's performant. It doesn't do the 2% stuff that GT does using its magical shared memory representation (which also makes TS->smalltalk porting not straightforward), but you can still tape over it with sheer optimized code.
The second thing is that GT got really slow with all the data structure re-interpreting and rerendering. As "dirty" as bb is in reloading dynamic code, the runtimes are so optimized, I wanted the markdown nodes to be GPU-accelerated in bb, and it turns out they already were.
I've been using it on and off for a while, but never got around to doing any major customisation mainly because I hate reinventing wheels (and also I was busy with other things). But I now am looking for something like a cross between Warp and Zed's Delta (which is a very nice design), and bb might be able to give it to me.
EDIT: OK, the plugin marketplace is much more browsable than the last time I looked. It'd be lovely to have a gallery where people can show off their own configs. Maybe I should make one...
Then I threw actually useful things at it: find this directory of pdf scans, and create an interface where I can browse the files, preview them, and query an lmstudio server, and auto-rename the pdf based on the content.
Another is to ssh to a remote machine that has a particular file organization structure, and give me a preview gallery.
Nothing is particularly complex, but I couldn't be bothered to making that myself. It's also something that I would've used in emacs (the preview function is like dired-preview-mode in emacs), but a graphical interface would perform better.
Sounds pretty cool. Never heard about Pharo before, but i will try it in spare time.
https://github.com/gavr123456789/Niva
An implementation of Boids for Niva:
Do the advances mean anything though? Alan Kay is a personal hero of mine, I love the aesthetic of Smalltalk, and the dream-that-was once upon a time of such a system was a real missed opportunity for the evolution of programming environments. But is it anything more than a neat hobby at this point?
It effectively already is. It may end up in the same domain as Haiku OS, Plant 9, or Squeak, but they are all still interesting domains of research.
When was it anything else? The 80s? I've can count the number of Smalltalk jobs I've seen in my career on my hand (but I have seen them)
The opposite. With LLMs you can now pick up any one of these obscure language and write a full blown AAA game engine in them. Or a database. Or a web framework. Or... anything you set your mind to. The language no longer matters. btw LLMs are exceptionally good at Smalltalk/Haskell/Perl/FORTRAN and other old/uncommon languages.
(Smalltalk is a religion, I will die on this hill!)
> A dynamic, pure, reflective object-oriented programming language in the tradition of Smalltalk
Why not call it a modern Smalltalk, which seems to be what it is?
Smalltalk is a great language and its ecosystem deserves to grow.
Clicking on this page, one finds:
> What is Pharo? > > Pharo is a pure object-oriented programming language and a powerful environment focused on simplicity and immediate feedback.
I really appreciate these one liner introductions on any project.
It could serve as the engine for new, fun, interactive websites!
https://lively-kernel.org/lively4/lively4-core/start.html
?
https://en.wikipedia.org/wiki/Amber_Smalltalk
or more like https://squeak.js.org/ ?
I don't know how to start Amber in the browser and couldn't find demos.
https://github.com/pharo-pulsar/pulsar
Almost "Pharo for Gnome".
Her answer, SmallTalk
Nothing found. Weird.
At this point, I think it's flipped. The people that might be attracted to it would probably enjoy the retro hat tip. The various language wars have all been pointlessly adjudicated, and lost in time, first to the dominance/explosion of JavaScript only programmers, and now due to LLM generated code.
Learning Smalltalk, and practicing it heavily for 20 years was probably the single best thing I learned in programming during 35+ years. It helped me get very good at modelling things. I work in Swift/Kotlin/Elixir/C now days, and I've learned some great things from those systems as well. But how to build representations of real world data as well as structure concepts/relationships more virtual, hands down to Smalltalk (for me).
One thing that AI programming has done is made me care much less what programming language is being used. This is slightly regrettable, but for the most part very freeing, as I don't need to worry about what language is easier for me (as a human) to use for a particular problem, or make me inclined to use one of my "pet" programming languages over one that may be a better fit for more pedestrian reasons.
Or at least this works wonderfully in Clojure via the nREPL.
Humans haven't given up playing chess just because computers are able to do it better, there is still a point in recreational programming.
I am fondly remembering actually using Smalltalk in production for a small web project. I think I used Squeak with the Seaside framework. The image based workflow made deploying it surprisingly easy.
I recently did a major move and had to restructure my bookshelf pretty dramatically. The only programming books I kept out of storage where the Common Lisp and Prolog ones. Spending time learning a language that doesn't directly impact how you think about computation itself seems to be more of misuse of time (of course really, when programming truly for fun it shouldn't matter one way or the other).
I'm right there with you. I really like programming in Python, the language. Now that I'm not writing much if any code, the rough edges in building and deployment have come to the forefront. Even "uvx run" has become a sticky wicket (I have some machines that don't have Internet access).