[d-mason]

I would say the same thing (or more exactly, the dual) from a Smalltalk perspective: I just want to send a message to an object, I shouldn't have to figure out what function to call or what to parenthesize. The problem people get into with OO (particularly Java, C#, C++) is thinking in terms of method-function calls rather than message sends.

Although I do like Lisp generics - I did a bunch of programming in rscheme many years ago, and really liked it.

[lisper]

> I just want to send a message to an object

Why? Seriously, why is that something you want? Why do you want sending a message to be syntactically and semantically distinct from calling a function?

> The problem people get into with OO (particularly Java, C#, C++) is thinking in terms of method-function calls rather than message sends.

Well, IMHO the problem people get into with OO is thinking that there is something special about sending a message that is different from calling a function. Sending a message is an implementation technique, not a semantically distinct action that should be exposed in the language semantics, and certainly not in the syntax.

[abecedarius]

Where it matters 'who' gets what powers or responsibilities, sending messages is a powerful way to think about it, not an implementation detail.

In Java it is pretty much just a function call, because the code in the callee has the ability to wreak all kinds of havoc in real Java programs, so the pattern of "messages" is quite imperfectly related to the authorities you're bounding.

More at http://habitatchronicles.com/2017/05/what-are-capabilities/

[pjmlp]

It would be if virtual method tables weren't a thing, and Java didn't do dynamic dispatch by default.

Then there are Proxy objects, reflection, and invokedynamic as well, for those "doesNotUnderstand:" scenarios.

[xkriva11]

In most cases, it is really only an implementation technique, but it may be different. In my eyes, sending a message to a probe on Mars is very different from evaluating a function with the probe as an argument. It's sure that, in this case, a Lisp program would transform the function call to a kind of message send anyway with the expectation that the probe is a standalone computation system. OOP approach makes this assumption implicit for everything.

[lisper]

> sending a message to a probe on Mars is very different from evaluating a function with the probe as an argument

Sure. But why do you want that difference to manifest itself in the syntax of your language? What is the benefit of writing, say:

[probe message]

over

send_message(probe, message)

?

> OOP approach makes this assumption implicit for everything.

And that is exactly the problem IMHO because this model is not appropriate for everything. It makes sense when you are dealing with actual physical objects like a Mars probe, but that is rare. Much more commonly you are dealing with abstract objects. If I want to add two numbers A and B, who do I send the message to? A? B? The adder in the ALU? As a programmer, 99.9% of the time I don't care how the operation gets carried out. I just want to write (sum a b) or a+b and let the compiler sort out the details.

[xkriva11]

In Smalltalk, it is just

probe message

without any brackets, and you can write

a+b

which is the message + send to a with argument b. You just have message passing syntax for everything (Smalltalk has minimal syntax comparable to Common Lisp in size). IMHO it hit the sweet spot of simplicity/readability/expressiveness.

But you cannot judge Smalltalk only from the perspective of its syntax. You need to take into account the context in which it is used. The environment built around it. Then everything starts to make much more sense and forms a vital well balanced system. It is Lisp but different, and I strongly recommend downloading Pharo and to try to figure out how.

I stronlgy admire you; I read "Lisping at JPL" at least dozen times over the years. I really like Lisp, Forth and Smalltalk, and I know that knowing each of them well is worth every penny, even if it may not be obvious on first sight.

[lisper]

> which is the message + send to a with argument b

Yeah, I get that. What I don't get is why I should care that "a+b" means "send the message + to a with argument b" rather than just "add a and b". I see no benefit of the first formulation over the second.

(And thanks for the kind words!)

[ncmncm]

Message passing within a process and function calls are exactly, precisely isomorphic, so complaining about one or the other is just parochialism.

[pjmlp]

Smalltalk and Common Lisp are on my favourite languages list.

Yet I never got the point of arguing about implementation details regarding virtual method dispatch versus message passing.

Specially when many OOP GUI frameworks combine both approaches.

[ncmncm]

It's not even an implementation detail. Both use, ultimately, JSR and RET instructions.

It really comes down to fetishism, which is why I don't use either of them. I am not a Fetish-Oriented Programming enthusiast.

It is also why I am not all in on Rust. Memory safety is pretty important, but it is far from the only important thing in programming. The amount of attention Rust insists I devote to it is attention I don't have available for the other things that, frankly, deserve it more.

Considering that in the last 10 years I have spent strictly less time debugging memory usage errors than preparing compiler bug reports against Gcc, putting memory correctness guarantees front and center ahead of all else seems to me a mis-allocation of my extremely scarce attention.

Attention is by far the scarcest resource available to any programmer. Allocating and applying attention where it is most needed is the central problem of programming. A language that overrules your judgment as to where your attention must be thus interferes with the core business of programming.

C++ does demand just a little more attention to memory management than some other languages, but less all the time. It pays that back by eliminating most taxes on performance, a swap I agree to.