Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
In Objective C you have the concept of sending messages to other objects, and, well this is very similar to method calling in languages like C# and Java.
But what exactly are the subtle differences? How should I think of messaging when thinking about my code?
Note: Just a bit of background here, I'm a C#/Java developer trying to understand some concepts about Objective C.
A message is the name of a selector, and the parameters for that selector.
A selector is a symbol.
A method is a piece of code in a class identified by a selector.
In other words, [foo bar: baz] says "send the message called @selector(bar:) with parameter baz to object foo. You could send that message to many different objects.
In contrast, the method bar: for a Foo might look like
-(int)bar:(int)n {
return n + 1;
}
but for a FooTwo might look like
-(int)bar:(int)n {
return n + 2;
}
(I hope I have the syntax right; it's been a while since I last touched Objective-C.)
When you send the message, the Objective-C kernel dispatches the message to foo which decides whether it understands the message. It decides this based on whether it can find a method identified by that selector.
Two methods with the same name, and one message.
It's also possible for an object to simply forward a particular message (or set of messages) to another object for processing. In this case, you send a message to this proxy object, which has no methods to match that message, and the proxy forwards the message to its wrapped object.
From a purely theoretical viewpoint, there's no difference between the two at all -- there have been a number of formal proofs showing that the two are completely equivalent, and either can be implemented entirely in terms of the other.
From a slightly less theoretical viewpoint, there is one possible difference: in a typical implementation, the virtual function table is statically allocated and the content of each vtable is fixed at compile time. Message lookup, by contrast, is typically done with some sort of map-like object, which is typically dynamic, meaning you can modify it at runtime. This makes it relatively easy to add a new response to a message in an existing class. Unfortunately, in most cases this remains mostly theoretical. First, you're basically dealing with self-modifying code, which most people decided was a pretty bad idea a long time ago. Second, to make it very meaningful, you pretty much need to be able to compile new code into the existing class to respond to the new message you support. Without that, about all you gain is the ability to dynamically add a new name for an existing method.
As implied by the end of the previous paragraph, from a truly practical viewpoint, there's very little difference between the two at all. They're simply two (very slightly) different ways of supporting late binding. Although message-based lookup is generally a bit slower, it would be pretty unusual for the difference to be truly significant. For most practical purposes, they're just two different ways of accomplishing the same thing.
In Objective-C, messages are late-bound. That is they are resolved at runtime. C# supports a similar construct through the Dynamic keyword which declares an object as being late-bound as well.
Usually method calls are resolved at compile time (unless you use reflection in Java), while messages in Objective C are dispatched at run time.
struct as first parameter. Late bindung is an essential part of polymorphism and therefore of OOP.
Messages are either handled by the kernel or by the language itself (for ObjC for example, there is a very small assembly code that does it).
In the linux kernel for example, messages are done with system calls/function: you can find about them if you search about unix system programming.
The core difference between a method call and a message is this:
a method call only happens in your code: in ASM it's translated by a PUSH of the passed arguments.
a kernel message is mostly something sent to the kernel which is tracked and send back to a certain processes. I may mistake them for pipes, but whatever: know there already is a mechanisms that allows you to run several programs at the same time and let communicate at the same time. Of course, don't hope that this will work the same way on windows or other OS.
