Modern software frameworks are so shockingly bad and uninteractive that we now have to rely another layer of bullshit with LLMs just to get us to be half as productive as these envs. : (
(okay okay REPL-based things are getting better, but still nowhere close to what Lisp even w/ Emacs can do.)
It would work if you had strict access control to each feature in a common code base. But Git hadn't been invented yet.
The other issue is performance. Compiled ST isn't particularly slow, but you lose the modifiability. Interpreted ST has a mixed profile - some features are slow, some are fast - but generally it was slow compared to C.
Today that doesn't matter so much, but it was a drawback at the time.
It's a seductive model and I totally get the appeal. But it's not quite as straightforwardly superior as it might appear to be.
I don't know that you need 'strict access control' as proposed, but you do need coordination, and a source code repository is a way to manage coordination.
Erlang doesn't have a different mode for fixed vs loadable code, although you may need to write code differently in order to be able to hotload changes, and that could affect performance; some code naturally fits the idioms needed though.
I find it amazingly valuable to be able to change the program without having to lose the program state; but it requires different thinking, and it is easy to mess things up in exciting ways that are different than many other systems. It's amazing to fix a bug and deploy it in seconds into a live system with millions of active connections; it's also amazing when you try to fix a bug and break millions of active connections in seconds, but in a negative way, because now you and your users have to pay the costs of reestablishing all of those connections.
OTOH, the key issue is interchange of state and messages between versions, and that's an issue that comes up in almost all distributed systems that update without downtime, so most people have to deal with that issue anyway, just usually not within the much smaller scope of a single task.
That level of performance was only achieved by PCs when we got 50MHz 486 (for purely interpreted Smalltalk-80 virtual machines, with JITs much slower computers could match the Dorado).
Git isn't the first or oldest DVCS. Smalltalk actually had multiple DVCSs, including ENVY (VA/Cincom), which dates back to the mid 90s, and Monticello (Squeak/Pharo), which dates to the early 2000s--both of which predating git.
True, but lots of people do not need to distribute software at scale.
IIRC Pharo has a way of exporting the current image to files for version control. That should solve the problem of multiple developers working on the code. You can modify while running to try things, and then commit the final result to version control.
It didn't exist at the time you're referring to however, so in that context the point does stand, mostly. I believe there was some form of flexible compiled optimization for Smalltalk (since Chambers's thesis references it as prior work) but I forget when that was and how commonly used it was.
I disagree – just make it read-only – but to illustrate my point, let me try to invert your point.
You're saying that the Lisp/Smalltalk software creation model doesn't scale and only mass-produced software can.
Instead of the traditional car analogy, let me use clothing instead. Even more people use clothes than cars.
"The idea of hand-making bespoke clothing stops working as soon as you try to distribute clothes at scale. There are billions of people and they're all slightly different sizes and shapes. You can't customise clothes for them all!
"The only way we can clothe billions of people is if they all wear the same thing. One-offs worked when we only had a small population and only the rich got a choice. There was no other way. But since then, we invented elastic and zips and belts.
This way we can give everyone a simple all-in-one coverall, a sort of jumpsuit, and using a few zips and elasticated bands and some straps to shorten or lengthen the arms and legs, it will fit everyone. At the worst we can make a few sizes and they will scale.
It's all about scale, and we have to make sacrifices if we want something that scales efficiently."
1984 "Smalltalk-80 The Interactive Programming Environment" page 500
"At the outset of a project involving two or more programmers: Do assign a member of the team to be the version manager. … The responsibilities of the version manager consist of collecting and cataloging code files submitted by all members of the team, periodically building a new system image incorporating all submitted code files, and releasing the image for use by the team. The version manager stores the current release and all code files for that release in a central place, allowing team members read access, and disallowing write access for anyone except the version manager."
https://rmod-files.lille.inria.fr/FreeBooks/TheInteractivePr...
~
https://www.google.com/books/edition/Mastering_ENVY_Develope...
https://archive.esug.org/HistoricalDocuments/TheSmalltalkRep...
I think it's generally better to aim for what the old C2 wiki called "Alternate-Hard-And-Soft-Layers": substrates that are less malleable with dynamic layers floating on top. We can do much better in terms of malleability than mainstream operating systems without descending into the complete insecurity and fragility of a classical Lisp Machine or Smalltalk environment.
Of course, you did make backup copies of the original image file and original sources file and original change log file.
Of course, you can restore your changes from your modified change log file, but not restore the changes that broke your IDE.
Distributed version control and CI makes it way more tractable to work on even a small team IMO.
I would be very curious to see someone stream a "real" workflow using something like Pharoh or other smalltalk-like envs though. There's a bunch of short clips showing "beginner" demos but for such a visual system I would expect there to be more detailed presentations of the actual workflow.
Git is also much more confusing than Monticello.
That seems odd, they seem easy enough to map to each other?
> Git is also much more confusing than Monticello.
Not my experience. Uni had us use Smalltalk for a bunch of courses, and Monticello was universally hated (and people caused their to-be-expected number of messes with Git too, but still got on with that much better)
Not unless you treat every method-level modification as a separate commit.
1984 "Smalltalk-80 The Interactive Programming Environment" page 46
"Within each project, a set of changes you make to class descriptions is maintained. … Using a browser view of this set of changes, you can find out what you have been doing. Also, you can use the set of changes to create an external file containing descriptions of the modifications you have made to the system so that you can share your work with other users."
https://rmod-files.lille.inria.fr/FreeBooks/TheInteractivePr...
~ workflowThe workflow link is v interesting. I will repeat my big ask: I want to see people recording themselves using the system! For visual systems often it's in movement that I realize how people actually take advantage of all the tiny components
(No, I didn't watch it.)
So throw away the modified image and go back to the original image (and sources file and change log file) which you still have "unmodified" ?
I agree with you to a great extent. For my Ruby development I often near live in Pry (a REPL that while nothing like Smalltalk, is at least loosely inspired by it, the same way Ruby in general has elements that are Smalltalk-ish under the hood), and often integrate Pry into the application so I can drop down into a REPL and modify the running system to debug things.
I also often make a point of implementing a "reload" method that will reload the main parts of the codebase into the running image, so I can make bigger changes "outside" and load them without losing current state.
It makes a great deal of difference.