> What makes Objective-S more general than other languages?
They describe that on the site. The notion is that most of our modern languages are more geared towards expressing algorithms and data structures, and not so great for expressing programs better suited to different architectural styles that don't necessarily follow a strict call/return type of semantics.
That's not entirely wrong. You can build a library/eDSL in a call/return language that will implement other architectures, but it will still look and behave like a call/return abstraction. Ostensibly Objective-S's goal is to make programs written in other architectural styles look like they are expressed natively in those styles, rather than an embedding of that style in a call/return architecture.
I'd like to see Objective-S implement Prolog or other logic programming to put that claim to the test. The other architectures they list aren't too far from call/return style, but logic programming certainly is.
Thank you for getting it and expressing it so clearly.
> You can build a library/eDSL in a call/return language that will implement other architectures, but it will still look and behave like a call/return abstraction
EXACTLY!
We can build, but we cannot express. So it will look like a weird/complicated call/return abstraction, because it isn't "native". So you get a tradeoff between architecture and simplicity, a tradeoff that shouldn't be there. (And all sorts of other 2nd order effects).
> Ostensibly Objective-S's goal is to make programs written in other architectural styles look like they are expressed natively in those styles, rather than an embedding of that style in a call/return architecture.
EXACTLY!
We need to be able to express those alternative styles natively and naturally, otherwise we are always going to be stuck in the tradeoff between architecture and simplicity, or as I call it The Gentle Tyranny of Call/Return.
> I'd like to see Objective-S implement Prolog
That's actually on the list, as a stretch goal. One of my (many) inspirations was this great 1988 article about adding support for backtracking to Smalltalk, without modifying the kernel: https://dl.acm.org/doi/10.1145/62083.62094 A tour-de-force. And yet...not really something you'd ever use. The other problem is that Prolog, in my understanding, is actually too "algorithmic" or "procedural" to expend too much effort on, at least when you consider its interface After all, the basic interaction with Prolog is to ask it a question and then it rummages around in its database of rules and facts and spits out an answer.
I am personally more interested in constraints, particularly (one way) dataflow constraints. Those I am now able to get out of the other architectural components, and without significant algorithmic intermediation.
You don't seem to know prolog well if you consider more "algorithmic" or "procedural" than, say, smalltalk. Sure, it's not 100% declarative, because even prolog is bound by such down-to-earth concerns as performance and termination. But there is no such thing as a "function call" in prolog.
I for one would like to see you put your claims to the test and implement a prolog in objective-S, indeed. Half of it is backtracking; the other half is unification as the main connector. Good luck.
> You don't seem to know prolog well if you consider more "algorithmic" or "procedural" than, say, smalltalk.
Actually: I do. Which is why I gave the precise reasons for what I wrote, which in turn your critique does not touch on at all.
So again: Prolog is very much a system that computes answers to questions. If you have a Prolog-based system that does not, please point it out to me and I will be happy to have a look.
"computes answers to questions" applies to any system with a REPL. That's really not a technical term at all.
If you want to be more precise, you could say prolog tries to satisfy the goal it's passed (via unification and resolution). That's not the same as the call/return paradigm. The only unifying concept (heh) for these two is, well, "computes something".
Anyway, for me, that confirms that your statements are not grounded in anything but vague terms you throw around, like "algorithmic". If you want to convince people that your flavor of smalltalk is actually, qualitatively _more expressive_ than all the hundreds of other languages, you're going to have to define a precise notion of expressiveness and show that only your system matches it. Since you've recognized that it's just about being more expressive, since you can write anything in any language; you probably also need to have cold numbers on how much more expressive objective-S is.
They describe that on the site. The notion is that most of our modern languages are more geared towards expressing algorithms and data structures, and not so great for expressing programs better suited to different architectural styles that don't necessarily follow a strict call/return type of semantics.
That's not entirely wrong. You can build a library/eDSL in a call/return language that will implement other architectures, but it will still look and behave like a call/return abstraction. Ostensibly Objective-S's goal is to make programs written in other architectural styles look like they are expressed natively in those styles, rather than an embedding of that style in a call/return architecture.
I'd like to see Objective-S implement Prolog or other logic programming to put that claim to the test. The other architectures they list aren't too far from call/return style, but logic programming certainly is.