1. Amy Worrall, KVO conidered awesome
Apple’s idea: controller sits between the Model and View. This is not necessarily the best. Massive View Controller - the problem (view controllers are too big).
KVO lets us go back to the original MVC pattern. Jejj, finally somebody likes KVO :)
Amy is practically giving an introductory talk to KVC and KVO.
KVC can be used to get the min/max/count/sum/avarage of an array/collection. This is something new I haven’t seen before.
[array valueForKeyPath:@“@count”];
KVC supports auto boxing/unboxing between int - NSNumber etc.
nil needs special treatment (setNilValueForKey)
KVC supports to-many relationships too: both ordered and unordered.
KVC also supports validation and coercion (example: i want to store a string in all capitals, if somebody calls the setter with lowercase i can convert it)
The she talked about KVO and an interesting observer pattern (self is the controller):
[self addObserver:self forKeyPath:@“modelObject.InterestingProperty” …]
With this pattern we don’t need to re-register is the model object changes under the controller.
Interesting: KVO works when ivars are set directly (so its not a for loop in the setter for observers). Its done via isa-swizzing, by creating a subclass of your class dynamically.
Dependent key registration: full name is not backed up by an ivar, but rather derived from first name and last name. In this case for KVO to work we need to describe explicitly that changes in first/last name should trigger the change of full name.
Change dictionary: you can ask for the kind of changes, the value of a property before and after the change.
APIs on built on top of KVO: reactive cocoa, MAKVONotificationCenter, Cocoa Bindings
“Bindings are great”
2. Damian Sullivan, Legal considerations for contractors (Blitz talk)
This was a talk about Damian’s own experience of working on a project without a contract and the “fun” he had :)
3. Rich Siegel, Red meat and gin
Rich talked about his company and how they made is successful (work on ideas that are future proof etc).
Good engineering disciplines: no compiler warnings, etc.
They don’t use processes that are not needed: they have few processes form hard learned lessions, but he does not like agile, scrums etc. “If you create process just to have a process you are doing it wrong”.
4. Markos Charatzas, debugging with sounds (Blitz talk)
Xcode allows you to create voice notifications for tracepoints. This could be useful during debugging because the feedback is much quicker and natural than checking Xcode output window. Sounds are used almost like asserts.
Example: noting when a hash table resizes.
5. Scott Little, wiring plugins for Apple’s mail application (Blitz talk)
No real APIs to write plugins. It’s all about swizzling, KVO etc. Reverse engineering.
6. David Smith:
This was a really interesting talk. “Unexpected delight” - understand the users need and make your application behave like that.
Normal design: asking what your user need. But this is insufficient, because we need to understand the user’s context and the respond to it.
Understanding context requires “detective work”. There is explicit and implicit context. User doing an action is an explicit context - application has to react to this otherwise its not doing its job.
But implicit context is more difficult to detect. Easy to build 99% of the application (functionality part), but difficult to put on the cherries on top.
Examples:
- games add power management settings (lower graphics settings to save on battery) rather than doing it automatically (am I plugged in, do I have lots of battery left?)
- Night mode vs day mode (based on screen brightness etc)
- if I am running (or using the device in a car) with my phone it should have Huge buttons for easy access; hints: specific bluetooth device attached, motion sensors etc.
- Knowing the user is not looking at the screen so we do something different (audio alerts)
Of course the problem is: what if you guessed the context wrong? Needs to provide easy way to turn off the functionality or disable it completely.
iOS 8 (hopefully) will have even more things which can be used to infer the context.
7. Sean, meetup videos (Blitz talk)
Sean was talking about how to make good video coverage at conferences. One video stream from the presenter, one about the presentation and one about to show both when the presenter points to the screen.
Audio is most of the time more import than video, so its important to capture it properly.
8. Charles Parnot (Blitz talk), Kitchen sink database
This talk is about how to cope with the fact that your database schema evolves over time due to new requirements etc. Also, specifically “core” data and pieces of data in the DB to drive UI behaviour should be separated. Also, there is persistent vs cache data. Critical vs disposable etc.
The point is: we are using one DB to store them all (which part to sync then? should we migrate everything? ...).
Proposal is to separate these parts. Then you can optimise then separately (core data is optimised for backward compatibility for example, but the other part could be optimised for speed, can be kept sorted in oder to make the presentation easier etc).
9. Marcus S Zarra. Not invented here.
This was a controversial talk about how to develop software, particularly whether to rely on external components, 3rd party libraries vs re-implementing everything from scratch (which he prefers). “Don’t reinvent the wheel” - its a broken concept according to Marcus.
He believes adding external frameworks to a codebase is “black box” and “voodoo magic” and should be avoided.
To be fair he had some interesting points (like calling Apple itself a risk because Apple’s own libraries are black boxes) and he definitely triggered a big discussion at our table (and everywhere else) after his talk.
However, since I disagreed with many of the things he said, so I decided not to recap more from his talk :)
- Tobias Klonk, Another approach to observation (Blitz talk)
KVO, NSNotification center, delegates: approaches for notifying observers for changes. All of these have pros and cons. He like delegates because there are compile check safety associated with them, but delegates are good for 1:1 relations only.
Tobias went through some of the 3rd party approaches that help hiding some of the repetition code which you have if you implement observers yourself (for loop, iterating through observers, call method on them etc).
- Karsten, Building the next ten programming language (Blitz talk)
He talked about why is it that we still use text files to store source code. Why do we put breakpoints on the lines instead of statements etc.
- Luc Vandal, Land or Slam
This was a talk about Luc’s experience and history in mac development (what apps he was writing and when, anecdotes etc). It was interesting and entertaining (but difficult to summarise the messages).
- Daniel Pasco, Bil-Centric view of product development (Blitz talk)
These guys do Kaleidoscope and Versions (Black pixels).
Our CTO (Bill): background in Smalltalk development, appreciated inside/outside of the company
Messages:
- Building prototypes is important to try out new things.
- Don’t fight the frameworks (use NSArray, etc)
- Don’t overcomplicate your code
- talks about Designers, QA (very important to hire strong people, same qualifications and experience as developers),
- Michael Lopp, The engineer the Designer and the Dictator
This talk was really-really awesome :)
