PHP to Objective C, where are the parameters?

Thanks for pointing that out, nevertheless I guess using the similar concept to PHP/JS makes the user relate to the transition better.

I did read that Apple doc when I first starting out but it was overwhelming to me at that time and it backfired. I was more discourage to learn Objective C after seeing the doc.

I've always found it easier to just explain the messages by calling them functions, otherwise people will often get wrapped up in their previous conceptions of messages in programming.

i guess im abit overboard trying to make my point. but you are right, no error, just warnings.

> One thing though, if you spell a method name wrong, it will still compile. It's only a warning that "the object may not respond to that selector".

And it's important to understand that: while Objective-C's "C" part is statically typed, Objective-C's objective model comes from Smalltalk and remains essentially dynamically typed. That's in fact what `id` is: a purely dynamic type. This is quite unlike Java or OCaml.

thanks for the point. I have no background in Python so I didn't take Python into consideration. In my opinion, there are more people like me: coming from pure HTML/CSS/PHP background straight to Objective C

There are significant differences though:

1. It's not possible to mandate the usage of keyword attributes in Python 2, this function could be called with

    do_send_mail("some@email.com", "another@email.com", "Hello!", "hi!")

JS/Ruby's low-fi version of using hashes actually helps there as you have to provide hash arguments via the hash.

Python 3 lets you fix this issue (a great reason to switch, by the way) by using a ⭑[0] argument (not a ⭑-arg, which you can use in Python 2 but which will simply make your stuff fall into a black hole unless the creator of the function asserts no positional argument was passed via e.g. `assert not arg`; furthermore Python 2 would require that a default value — to check for — be given for each keyword argument):

    >>> def foo(*, a, b):
    ...     print(a, b)
    ... 
    >>> foo()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: foo() needs keyword-only argument a
    >>> foo(1, 2)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: foo() takes exactly 0 positional arguments     (2 given)
    >>> foo(a=1, b=2)
    1 2

2. the arguments are separate from the method name in Python, in your example the method is `do_send_mail`, in Smalltalk and Objective-C it's `doSendMailToRecipient:cc:subject:body:` which has advantages and inconvenients. Python is easier for default values (you need a new method in Smalltalk or Obj-C), but the Smalltalk/Obj-C method is simpler for behavioral differences (as the dispatch is done at callsite, Python will need internal soup)

3. There is no order in Python's argument (whereas changing the order in Smalltalk/Obj-C changes the method called), which means callers can lower the call's readability by swapping arguments around in... less than sensible ways.

(nb: I love Python, don't interpret my comment as a put down of it, just pointing out fundamental and important difference between Python's keyword arguments and Smalltalk's keyword messages)

[0] I hate HN's markup.

before I continue. Have you done any development in Objective C?

I'm sorry, but all of your comment is nonsense.

1. Static typing does not help with writability when you're passing 4 strings to a method (now that can be made into a debate over good usage of types, language cultures and many other things, point is when your arguments are "untyped" having a stricter type checking of nothing will not help you)

2. Static typing does not help with readability when you end up with

    do_send_mail("some@email.com", "another@email.com", "Hello!", "hi!")

anyway, there are many cases where keyword arguments significantly enhance the reading experience

3. IDEs are perfectly able to "tell you if you hover over the method with your mouse as well as when you're creating the method" for dynamically languages.

The only thing a statically typed language will help you with TFA's example is if you have extraneous or missing arguments, and there even a good IDE will do it in a dynamically typed language (Jetbrains's IDEs do, for instance).