Alan Kay: What paradigm is the successor to OOP?
declarative.quora.com
declarative.quora.com
The Actor model can be good, and you should use the Actor model when it's needed. But the actor model is a decentralized approach, and centralized approaches will always be simpler. If it isn't needed, you shouldn't use it. When you go all-in on OOP or Microservices, you are adding accidental complexity to your stack.
UI design is object oriented. We manipulate objects. We click them and get pages of things we can do with them. Sometimes it's a bit more functional, often it's pretty directly an OOP experience.
What other paradigm can we use to directly model the actual application domain, without some constant need for mental translation?
If one accepts the constant translation, we already have functional programming.
If one doesn't... IS there any alternative to OOP, except domain specific visual languages like Excel, reactive bindings(Is that it's own paradigm), and declarative programming?
Declarative seems like the closest thing, but it doesn't seem like anyone has ever fully done away with the need for instructions in the general case.
Systemd is a marvel, because it's so declarative.
Perhaps instead of the next big paradigm, we should look for large classes of problems to unify under one declarative tool the way Excel and Systemd handle data and processes.
https://news.ycombinator.com/item?id=21833331
I haven't yet tried to tweak a Swift macOS program, but in OS X era you could inject extra message handlers (object "methods") to a binary executable at runtime.
So I don't know how well this year's Swift relates to a SmallTalk model.
Maybe I missed it, but I don’t recollect Kay using this generalization before.
As I digress, if you have to divide up a workload, you can start with a language based on message passing or you can implement message passing in some other language. The danger with implementing it is to not recognize that's what you're doing.
Have you heard of anything like that?
In computer terms, Smalltalk is a recursion on the notion of computer itself. Instead of dividing "computer stuff" into things each less strong than the whole—like data structures, procedures, and functions which are the usual paraphernalia of programming languages—each Smalltalk object is a recursion on the entire possibilities of the computer. Thus its semantics are a bit like having thousands and thousands of computers all hooked together by a very fast network. Questions of concrete representation can thus be postponed almost indefinitely because we are mainly concerned that the computers behave appropriately, and are interested in particular strategies only if the results are off or come back too slowly.
That's from the start of the HOPL paper, 1993. I would be surprised if he didn't use this image long before that.
This sounds about right. We should use more declarative constructs. My choice would be functional programming at the lower-levels and DSLs at the higher ones. When I say DSL I mean in the semantics rather than a popular left-to-right readable syntax. Though not mutually exclusive the latter can detract from the former.