Sometimes I wonder if small talk had thrived how different the world might be.
For example, we’ve experienced a trend over the last decade of building platforms out of micro services. They have interfaces, which are sometimes statically typed and serialized with rpc libraries, and ultimately they send messages to each other, because they are isolated.
Now imagine small talk. It’s virtually the same thing, but 50 years ago (and not networked). Still each object is isolated, and they only communicate by sending messages. Everything is an object that’s inspectable and can “independently deployed” by editing it in real time.
This seems really nice.
Are we living in a worse version of the world (technologically) than what we could have had?
I don’t know a lot about small talk though so perhaps someone here can chime in and say why it wasn’t that great. To me though it seems like it was a serious system that was more than just a good demo. I can only imagine how it could have developed over 50 years if it was embraced.
To me it still looks futuristic.
I did work in Smalltalk in the university and I must say that in practice it was horrible to work with.
It was very common to have the image corrupted -- imagine that you by mistake add a bug to your code. Now the live version you're dealing with is just unworkable and you have to find the last version that worked (because in practice the code you add is live with the code of your whole system in just a single place, so, anything bad you did affected not only your target env it also affected your dev env).
-- version control was basically saving the whole image and no, you didn't have a way to diff 2 different images.
I think that the current state where you edit text files and run your code based on those (and which you can sanely version control) and edit with a separate IDE is a much saner approach.