Why did Apple choose to design its programming language with future and past tense method names?

Question

There are a lot of methods like this in iOS/Objective C:

- viewDidLoad
- viewWillAppear:
- applicationDidFinishLaunching

I've just been having a discussion with some colleagues about this design choice and why they would choose to be so verbose in preference of the more "standard" ways of event propagation for instance:

- onViewLoad
- onViewAboutToAppear
- onApplicationFinishLaunching

I didn't have an answer and rather put it down to just personal preference of the team designing the language. However, I'm wondering if there's more to it - whether this is a preferred option. Or whether the team just wanted to differentiate themselves from other languages, or from the norm.

If anyone has any insight that would be very interesting.

Thanks

Answer 1

I think the rationale is that in Objective-C, selectors are supposed to be messages sent to the objects. Sending [viewController onViewAppear:] makes it sound like you're going to pass it a lambda telling it what to do, whereas [viewController viewWillAppear:] is better under the "I am sending this message to that object" paradigm. (I find it weird that the animated flag isn't in the selector in this case though.)

From there it makes sense to reduce length and extraneous particles by preferring future tense -viewWillAppear: over -viewAboutToAppear:.

Answer 2

Or whether the team just wanted to differentiate themselves from other languages, or from the norm.

First, I'll point out that the names in question come from frameworks, not from the programming language (Objective-C) itself.

It's impossible to say what the team was thinking unless you were part of it, but I'd imagine that the names come from the fact that the methods are called before or after a given event has happened. For example, -viewWillAppear is called just before the view is shown on the screen, and -viewDidAppear is called just after the view is shown. Together, these methods let you prepare for something that's about to happen and respond to something that just happened. I don't think these names were chosen just to be different from other frameworks (indeed, the frameworks from NextStep that became Cocoa predate many of today's object frameworks), but more likely were just meant to be descriptive.

Note that the ...Did... and ...Will... methods aren't the only ways that events are communicated to your code. For example, touches have a more complex lifecycle, so you have methods like -touchesBegan:..., -touchesMoved:..., -touchesEnded:..., and -touchesCancelled:....

Answer 3

The only comparison to go on that I have experience with is Microsoft's event patterns.

Microsoft frameworks use two styles for these events one in Windows Forms and ASP.NET Web Forms, the other appears in WPF/Silverlight/WinRT.

In Forms based applications, the framework uses imperfect tense for (something's happening) and perfect tense for (something happened). One example is INotifyPropertyChanging/INotifyPropertyChanged interface pair (which provide the PropertyChanging and PropertyChanged events, respectively).

For WPF et al, the framework uses Preview[EventName] and EventName. No past tense is used here for example PreviewMouseClick and MouseClick are the event pair for a mouse click event.

I think the choice between the three naming methods is subjective as long as they are consistently used within a given framework.