was actually referencing this video in my previous thread and was just reminded of how ahead of its time the self programming environment was:

Even in 2019, error messages in Visual Studio still don't slowly walk themselves off-screen when you fix them.

reckon they should explode in fireworks/confetti 😂

cc @Geoffrey Litt there aren’t booleans in this video but there are some very cool proto-metaphors for making things like variable assignment and refactoring more visual

The video abundantly demonstrates why OOP is a dead end; horribly abstract concept of building a prototype to just reuse a formula. Trying to keep track of which prototype is for the class vs. for the specific object makes this a nightmare.

i mean: the entire editing environment is written in self, so someone’s figured out how to live with it

@Edward de Jong / Beads Project we have such entirely different ways of viewing this that it makes me wonder if the programming model one is most productive in is highly user specific

@Steve Dekorte Having made software for dumb people a good part of my career, i can easily tell that the Self system would baffle a majority of end users who are beginning programmers. Only a person with the concept of class hierarchies strongly embedded in their skull could possibly use it. That it allows override of a method for a single instance of a variable vs. for the class is such a huge "gotcha" he has to mention it in the first tutorial. That you have to warn users from the get-go about a giant pit of bafflement that awaits you is not a good sign. It isn't a question of personal taste, it is a question of ease of learning and use, and to require pre-requisite knowledge as this system does, would make it an instant fail. There are plenty of smart people who do can handle abstraction, and those people naturally gravitate to LISP, FORTH, Haskell, etc., but when you hand over a large code base written in this system to someone else other than the author, what happens then? What are the chances that the new maintainer can modify and extend that system? This is the big issue companies face every day, when software lasts 20+ years yet people move around every few years, so multiple generations of hand-offs have to execute smoothly, like a relay race. The relay race is the sport that is being run in our industry, and if i was given a large Self product to maintain (like the editor itself) I wouldn't have a clue as to how to discover how it works.

@Edward de Jong / Beads Project I’d agree that there are concepts a new programmer needs to grasp. Which existing system do you feel most have fewer issues in this respect?

i mean, there aren’t even classes in self so i think your comment is actually illustrating the degree to which you have to learn a whole new way of thinking about what code is in order to grok self at all (which might be less of a burden for end users?). but i stand by the idea that being able to for example drag and drop methods from one object to another embodies a way of thinking about code that we’re nowhere near realizing yet

Whether you use Java classes, or prototypical inheritance to describe the meta-information location where methods are stored that apply to a larger set of objects, these concepts are highly abstract, and a barrier to a beginner understanding the program. That a drag and drop gesture does some magical thing does not make it easy to understand the semantics of what is happening.

I don’t think I’d want to maintain a Self project (nor a Smalltalk one), but the level of introspectability of these tools is pretty amazing, and something I’d like in other languages. I think we can learn from the good stuff, and praise them without needing to have these rants about how terrible inheritance and OOP is all the time. That’s an unrelated issue.