Transcript
[ Applause ]
>> Good morning everybody, I'm
Vincent Hittson, Cocoa engineer
along with Rachel Goldeen, Cocoa
engineer and welcome to Cocoa
Development Tips.
Rachel is going to start us off.
>> Good morning, we have a wide
array of tips to show you this
morning, we're going to speed
through them.
And it was a little tricky to
figure out how to order them,
what kind of sequence or
numbering system to use, we
think we got something really
good.
I'm going to start you out with
a quick tip to get things going.
Number pi internationalization
because it's all Greek to us.
Just take a look at the Xcode
Scheme Editor and in the run
section you'll notice there's
this location debugging section.
You can check the show
nonlocalized strings checkbox
and see where your app is
missing localized strings.
But I'd like to focus your
attention on this application
language menu.
Down at the bottom there's a
list of pseudolanguages that you
can use before your translations
have been made and this will
show you if your app is ready
for those translations.
Okay that's it, back to Vince.
>> Okay tip number zero, user
defaults since zero makes a
pretty good default value.
So, you have your standard user
defaults and this is what you
use to get and set your user
preferences, but it's not just a
big bag of preferences it's
actually a set of domains and
each of those domains have their
own bags and here's a subset of
those.
And when you ask the standard
user defaults for a value it
checks each of these domains in
order returning the first value
it finds.
And you can set values in these
domains using their own
techniques and we're going to go
through them in reverse order.
So, starting at the bottom is
the registration domain, it's
last in the list and you use the
register method, passing in the
dictionary of the user defaults,
keys and values.
And it's temporary so it's only
available for the lifetime of
this particular process.
The next time your app launches
you'll have to call register
again.
So, use this to provide initial
values for your defaults without
setting them permanently.
Next up is the global domain.
This is shared by all
applications and it's commonly
used by system frameworks to
store systemwide preferences.
And you can set it using the
defaults command line tool, but
it's persistent so any changes
you make are going to be
permanent so be aware of that.
Next up is the application
domain and when you set a value
on the standard user defaults
using the set method it goes
here.
And this domain is persistent so
the next time your user launches
your app it'll have the value
that you set so you'll want to
use this when your user actually
changes a preference from the
initial value.
Last or first, but not least is
the argument domain and the
argument domain is really cool.
So, you can pass your user
defaults key as an argument to
your application along with the
value and you prepend your user
defaults key with a hyphen.
And it's first in the list, so
it overrides the values of all
those other domains.
And it's temporary, so it's only
set when your app is launched
with these particular arguments.
If you run your app and these
arguments aren't there the
values won't be there.
So, this is really handy if
you're trying to reproduce an
issue involving user preferences
and you don't want to actually
set them on your machine or for
just enabling a debug flag.
And speaking of debug flags,
AppKit has a couple, here's some
that you can use.
NSiewLayoutFeedback
LoopDebuggingEnabled, you can
set this to yes if your app is
getting stuck repeatedly doing
layout.
The feedback loop debugger will
help you track down that that
issue.
Next is NSApplicationCrash
OnExceptions and use this in
NSApplication if it catches an
exception it'll crash your app.
So, it's a good thing to have on
during development so you find
those issues.
And you probably want to use the
argument domain to set these so
you don't shift with them so
that's a good idea.
Here's a neat thing about the
standard user defaults, it
supports key-value observing or
KVO.
You just add your observer with
the user defaults key as your
keyPath and any time that value
changes even if it's from
another process you'll get
notified.
So, here's an example of what
that looks like.
We add an observer using the
addObserver for keypad options
context method and pass our user
defaults key as a sting.
And of course, when we're no
longer interested in watching
for these changes we remove our
observer.
And in the meantime, you'll get
an observeValue for keyPath call
out any time your defaults value
changes.
So that's about that, here's
what that looks like in diagram
form.
So, if your application sets a
user default and you have an
observer registered it will be
notified of that change.
And similarly, if another
process sets a value for one of
your user defaults that you're
observing, you will be notified
of that as well.
So, it's pretty straightforward.
Here's another neat trick.
So, if you want that new keyPath
syntax and that block-based
observe method that you heard
about in what's new in
Foundation you can do that with
user defaults.
You just need to add an
extension and add at an @objc
dynamic property that has the
same name as your user defaults
key and that's really important.
If the names don't match this
isn't going to work.
And you can as a convenience
implement your property getter
to return the value.
And then you can use the
block-based observe method along
with the keyPath literal syntax
that's new and it works just
like you'd expect.
So that's it for user defaults.
Next up is tip number 64, what
is that?
Oh, base 64 right.
So, for those that aren't
familiar base 64 is an encoding
that lets you represent any data
using a simple set of ASCII.
So, this is handy of you want to
have a test or an easy to copy
paste and share snippet of code
that includes some binary data
and you don't want to worry
about packaging that up and
having to look it up and all
that.
And NSData supports base 64 and
you can create a data from the
base 64 string using the base 64
encoded initializer on data and
you'll get back your data.
And then you can use it [sound
effect] for example, to play a
sound.
And now if you want to create
these base 64 strings you can
use the base 64 encoded string
method on data to get those
strings.
There's also a base 64 command
line utility that you can use in
terminal to get your base 64
strings and that's base 64.
Now back to Rachel.
>> Number 2X, we're going to
talk about asset catalogs a
little bit.
Many of you are already using
asset catalogs, you know that
they organizer your images,
speed up launch times, reduce
storage space.
And I'd like to talk about a few
things that were added last year
in macOS Sierra and iOS 10 in
case you hadn't heard about
them.
First, there's layout direction.
This action image is symmetrical
and it doesn't matter, it'll be
the same both left to right and
right to left so the direction
is fixed.
But here's a GoForward image and
in right to left languages
GoForward means to the left
whereas left to right means it's
going to the right.
So, we want it to mirror for the
other language.
And then a little more
sophisticated is when you have
an image that needs to be
different for the layout
directions, but isn't a mirror
image, such as this autofill
image where the dots indicating
what has been written are to the
left of the pencil in left to
right and to the right of the
pencil in right to left, but the
pencil still tilts to the right.
So, they're not mirror images
and the designer decided it was
worth it to provide two
different images, but asset
catalogs will handle this for
you.
Next, I'd like to talk about
display gamut and that's the
different kind of color
representations that are
available on different displays,
the older displaces use sRGB,
the newer ones with brighter,
richer colors use Display P3.
I've overexaggerated the
difference between these images,
but just to show you that asset
catalogs allow you to specify
specific images for the two
different display gamuts.
In iOS 11 and macOS Sierra we
added colors to asset catalogs.
So, you can make a named color
just my simple accent color here
and you can also if you need to
specify sRGB and Display P3
versions of that color.
To use it in code we want to use
this new API.
You can add your name to the
extensible NSColor.Name enum and
then use the color named
initializer with your name to
create your color it's as easy
as that.
Next up number one, unit tests.
Sometimes there's a
psychological barrier to writing
unit tests, it seems like it's
going to be hard, but I'm here
to show you how easy it can be.
Create a new file in Xcode, make
it a unit test case class, Xcode
will give you a template, you
can fill it in with something as
easy as this.
Here I've created my addCatImage
and I'm checking to see that
it's not nil.
It's just a sanity check, is my
asset catalog on and working.
And once you've got one unit
test written it's much easier to
write additional tests and
prevent bugs from getting out to
your users.
Back to Vince.
>> Okay tip number 27, NSBox.
Sometimes all you want is a
simple view that shows a
background color.
And you control it may be like
this, so you can implement one
and you can make it layered back
even and that's fine or you can
let AppKit do it for you.
We have NSBox all you need to do
is set the box type to custom
and then configure it setting
the fill color.
And this would be more dynamic
than just setting the background
color on a layer because if the
color's a system color that
changes dynamically based on
appearance or context NSBox will
update automatically.
And even better, you can drag it
out of Interface Builder and
configure it from there.
And there are several properties
that you can use to configure a
custom box.
There's border width, corner
radius, border color and of
course, fill color so use that.
And you can even set a content
view on a box to show another
view inside the box, so it's
really easy.
And that's not all, sometimes
all you want is a simple
separator and NSBox has you
covered there too.
All you need to do is create a
box with the separator type and
position it however you like.
And of course, it's available
from Interface Builder.
So that's NSBox it should make
creating your user interfaces a
lot easier.
Next up is tip number eight,
restorable state.
So, macOS has a feature where
you can restart your machine and
all your running applications
come back and using this
invaluable trio of methods on
NSResponder you can bring your
user right back to where they
left off.
And most AppKit controls will
have these implemented for you,
but if you have your own
controls or restorable state,
you can implement them
yourselves.
And this is what that might look
like.
So, you have your properties
that are your restorable state,
when they change you invalidate
restorable state.
And then at some point, the
system will call in code
restorable state so you take the
values from your properties and
put them in the coder and then
when your application is
relaunched we'll call restore
state with coder and you take
the values out your coder and
put them in the properties.
It's pretty straightforward and
pretty easy, but there is an
easier way.
NSResponder has this class
property restorableStateKeyPaths
and this can point to any
NSCoding conforming type and
AppKit will use key value
observing to watch for changes
to these properties.
So that means when restoring
will automatically set the
values for you, so it's really
easy.
Do note that these properties
are marked @objc dynamic and so
that's key value observing can
do its automatic notification.
And you can still use this with
the other state restoration
callouts.
You can use this for your simple
properties and then use those
other callouts for other bits of
restorable state you may have,
they work together.
All right, now back to Rachel.
>> Okay I'm going to tell you a
sequence of tips about Core Data
that build upon each other and
I'm starting with number 13
because you may have been
unlucky enough in the past to
have to set up a Core Data Stack
before the existence of
NSPersistentContainer that was
added last year in Sierra and
iOS 10.
Core Data Stack consists of a
managed object model and then
you have a persistent store
coordinator that coordinates one
or more persistent stores and a
managed object context.
And to set that up took a fair
amount of code.
This is a reduced version of the
code you needed to write to get
that going.
But last year with the hard work
of the Core Data team there's
the NSPersistentContainer class
setting encapsulates the stack
and it's easy now.
You just have to do this.
The key line is to initialize
your persistent container with
your model name.
Moving on to number 21, arrays.
I've got my Cat Wrangler
application, one of those Cat
management applications and I
have a cat entity in my data
model with a name and a photo
attribute.
And I realize cats also have
behaviors, such as attacking
dust particles, staring at
walls, and playing keyboards.
So, I'd like to add an array of
behaviors because I think a
string is a good representation
of a behavior and I just want an
array of strings.
But there's no array type here,
well I just transformable
because that can be anything.
So, I make an array that's not a
good idea.
There's performance issues,
there's overhead for serializing
and deserializing arrays and
their contents and also any such
requests are going to be a lot
slower if you do things this
way.
So, we recommend instead making
a behavior entity and making a
relationship to the behaviors.
This would be a too many
relationships because there's
many behaviors and I want to
check the ordered checkbox if I
care that they're in a certain
order.
In addition, this has the
benefit of allowing me to use a
richer data model for my
behavior, I can add a duration
for example.
And so, your data model will
become more representative of
what you're trying to do.
Tip number 34, core data
migration.
Migration is one of the real
strengths of using Core Data.
I shipped Cat Wrangler and then
I realized cats also eat food
like grass, cupcakes, meat, and
of course broccoli.
So, I need a new data model, I
copy my Cat Wrangler data model,
make Cat Wrangler 2 and I can
add my food entity to it.
In Xcode, I simply change the
current model version to Cat
Wrangler 2 and then lightweight
migration is handled
automatically if you've used
NSPersistentContainer.
If you set up your own stack you
have a couple of options that
you need to set to make the
migration happen and that's all
you have to do.
Tip number 55, error handling.
In a perfect world we'd handle
all errors, but everybody knows
it's not a perfect world, the
world itself isn't entirely
round.
So, if you can only handle
errors in one area in Core Data
the most important part is when
you've added a persistent store.
If things don't work there
nothing's going to go right in
your application.
If you use persistent container
you can see there's the
loadPersistentStores method and
some of the things that can
happen is you can run out of
storage space, you can have
permission issues or data
protection or you can have an
older file that can't be opened,
you don't have a proper
migration strategy for it.
And if you're wondering how to
present those errors to users
Vince has something to tell you.
>> All right, tip number 404,
NSError.
So, in the rare event that
something goes wrong in your
application you want to give
your users great error messages
and Cocoa APIs like Core Data
give you error messages that are
fully localized and ready to
present to the user and that's
really easy to do.
Any responder has a presentError
method, you pass in your error
and it'll go up the responder
chain, if anything NSApplication
will catch it and show a
dialogue.
And if you have your own
responder subclass that's
well-suited to presenting an
error you can override this and
present the error yourself.
And here's the trick about these
Cocoa API errors, you can create
them yourself all you need to do
is create an NSError, pass in
the NS Cocoa error domain, a
code that matches what went
wrong and then a user info that
might have some additional
information like the file URL
you're acting on.
And you'll get a nice localized
user presentable error just like
that, just like the ones we
return.
And we have a lot of error
codes, so hopefully you can find
something that matches what went
wrong.
This is a snippet of foundation
errors.h, the generated
interface, so feel free to look
through this, we're not going to
go through them all.
And if the error is close, but
could be better you can
customize them with the user
info.
There are several user info keys
that will let you alter pieces
of the error message.
Here we're altering the recovery
suggestion because we know that
this error occurred in the
context of a download and we can
tell the user that to help them
recover.
And by the way, if you're using
Xcode 9 you can use this new
Cocoa error method to make
creating Cocoa domain errors
even more convenient.
Now if you need an error that
Cocoa doesn't provide it's still
easy to make your own.
All you need to do is define a
domain, your error codes, and
then you create an NSError with
that domain, one of those codes
and a user info with keys that
describe the error message,
provide the error message.
And you don't need to give those
keys up front in your user info
you can call this NSErrorClass
method, set user info value
provider, and you get at your
domain.
And when an NSError with your
domain looks up at a info key
and it's not found it will call
this block.
And so, you can lazily return
values for those keys.
And what that means is now it's
super easy to create your errors
you just make an NSError with
your domain and code and that's
it.
Now there are a lot of
properties on NSError, check out
the header for more.
I do want to note that a lot of
them have user info keys that
correspond so you can use them
in your user info value provider
and return values lazily, so
give those a look.
Now next up is tip number six,
shared keysets.
So, if you were creating a lot
of dictionaries with the same
known keys you can use a shared
keyset and your dictionaries
will be more compact and
performant, thanks to proof of
hashing.
So, you create a shared keyset
using this NSDictionary class
function and it comes up with
the perfect hash and then you
can initialize your
NSMutableDictationaries with
your shared keyset.
Here's what this might look
like.
So, you create your shared
keyset, it is not trivial to
compute a shared keyset so it's
a good idea to stash it away and
reuse it and create as many
mutable dictionaries as you
want.
And you create your mutable
dictionary and then you can use
it like any other mutable
dictionary and even you can put
in keys that aren't in your
shared keyset they just won't be
as performant.
So that's shared keyset.
Now back to Rachel.
>> We've come to hexadecimal A
for accessibility, get AX
accessibility?
And Apple has many ways to make
your products accessible to all
users.
I'm just going to go over a few
small things.
VoiceOver is not small, but I'll
talk about it briefly.
It comes built-in on all Apple
products and it's easy to set up
in Interface Builder, I have my
add cat button and I just fill
in the accessibility description
add cat and then VoiceOver knows
what to say.
Also remember to test your apps
at low resolutions, low vision
users want to see things bigger
on the screen.
So, for example, here's my Cat
Wrangler/screen that I'm really
happy with.
I try it at a lower resolution
it goes off the screen, don't
let this happen to you.
Last, I'd like to point out the
existence of the Accessibility
Inspector that's available from
the Xcode menu.
Launch it, run it on your apps
and see where you can improve
your apps in terms of being
accessible.
Back to Vince.
>> Okay and now toward infinity
and documents.
So, users today are very
demanding, they expect a lot
from document-based apps.
They don't want to worry about
saving.
They want it to be easy to name
and organize their documents and
they want powerful version
control.
And they even want features like
iCloud document sharing that's
new in macOS High Sierra that
you will never even have heard
about until this week.
What's a developer to do?
Well you can use NSDocument and
NSDocument has a class property
autosavesInPlace.
By default, it returns false,
but you can override it and
return true and you get all of
those features for free, so it's
pretty great.
Check out NSDocument if you have
a document-based application.
Next up is number 42, the answer
to reporting exceptions.
For the most part, when
NSApplication catches an
exception it will just log it
and let your app continue
limping along.
But if you want to add
information or handle those
exceptions differently you can
override this NSApplication
method to do your own thing.
Now back to Rachel.
>> All right, to err is human
and to [inaudible] computer,
especially when the humans have
erred so we'll talk a little bit
about debugging.
You know here's many, many
debugging tools and I'm just
going to show you a couple that
are somewhat hidden in Xcode.
Right above the debug console
there's this row of buttons,
there's the debug view hierarchy
button, debug memory graph and
simulate location.
I'm just going to show you a
little bit about the view
debugger.
Here I have this simple browser
sample application and I can
expand out the views in order to
see what's going on, is there a
view that's hidden by another
one, which view is doing what.
I can see where the views extend
off when they're clipped views,
there's many other things with
auto layout that you can use in
this view debugger so check it
out and it'll simplify your
ability to debug your view
problems.
Sometimes the bugs are in our
code, in which case I've come to
tip 30512012 right, bug reports.
To make it easier for us to fix
the bugs include steps to
reproduce that's the very most
important thing.
We love it when you put sample
apps in your bug reports,
especially when they build and
show the problem on the platform
that you care about.
Include any resources that are
needed to reproduce your
problem.
And then logs, such as
sysdiagnose.
There's a page on
developer.apple.com that shows
how to collect logs for all of
our platforms and look through
there see whatever might be
helpful to the person who's
taking a look at the issue and
that'll help it all go faster.
Back to Vince.
>> Okay tip number 44.1, here's
a really easy way to add bells
and whistles to your
application.
NSButton has a property it's
called sound, it takes an
NSSound and it's really easy to
set.
And if you do when the user
clicks the button it will play
the sound and you can even set
it in Interface Builder.
So, use this to give your UI
that extra pop that your users
are clamoring for [sound
effect].
So now tip number 29, I'm going
to give a demo not of an NSSound
playing from a button that would
be a silly thing to demo, we're
going to show you a macOS app.
It's a daring entry into the
overcrowded market of cat
management applications it's
called Cat Herder and it's
completely unrelated to that Cat
Wrangler app you might have
heard about and we're going to
build it from the ground up.
Okay, so we have our project
already and here we have our
specification for our Cat Herder
application and it looks like we
have a list of cats on the
left-hand side and some add and
remove buttons.
And then for the selected cat we
can edit the name and photo.
Okay that seems pretty simple
and pretty straightforward.
Luckily, we have a designer that
already created a nib for us and
we can go ahead and look at that
and it looks pretty good.
We can run it.
And there we go, but nothing's
really hooked up, nothing's
working so nothing does
anything.
So, it's time to write some code
to get this all hooked up
together.
But what if I told you that
there's a way we can get this
user interface working without
needing any code.
And macOS has a technology
called bindings that will let us
do exactly that.
So, we can go ahead and go to
our storyboard and we have our
table view here and a table view
is going to show a list of cats,
which is probably going to be
backed by an array.
And it turns out we have a class
called array controller in the
object browser here and we can
go ahead and drag that into our
scene.
And an array controller lets you
create bindings to an array of
objects.
So, we can go to the attributes
inspector here in the upper
right and select attributes and
you can have your array
controller manage an array of
whatever class you like or a
Core Data entity.
And we're going to use an
NSMutableDictionary as a default
since that just lets us get
things up and running.
So, we want our table view to
show our list of cats and we can
do that by drilling down into
our table view until we get to
the table column.
And we can go over here to the
Bindings Inspector, it's in the
upper right it's that little
swirly boxy looking thing and we
can click on that.
And bind the value of the table
column to the array controller's
arranged objects.
And the arranged objects is a
property on the array controller
that is your array of cats
that's meant for the view side
of things.
So now our table view will
create a row for each cat in our
array and that means it will
create a table cell view for
each cat in our array and have
the object value of that cell
view set to that particular cat.
So, we can go into our table
cell view and we have an image
view, a thumbnail and the label
for the name.
And we can go ahead over back
again to our Bindings Inspector
and select bind to the table
cell view's object value and
that object value again is going
to be one of our cats.
And we can keyPath into that and
specify the name of the cat and
it will look that up in the
dictionary and show it.
Similarly, we combined the photo
of the cat to the image view
here just like that.
Now that's our table view that's
it, it's now bound and wired up
to the array controller and
it'll show its contents.
Next up we have these buttons
here in the corner, so array
controller actually has ID
actions for adding and removing
objects.
And the add method does about
what you'd expect, it creates a
new instance of the object it's
managing, in our case an
NSMutableDictionary and adds it
to the array so we can just wire
that up.
And there's also of course, a
remove action that does what we
expect, it takes the selected
items and removes them from the
array.
And of course, we need to add
some bells and whistles to our
application, that is what we're
known for.
Just like that and that's the
buttons.
All that's left now is the
detail view on the side.
So, we can go back to our text
field -- go to our text field
here that is the name that will
allow us to edit the name and we
go back to the Bindings
Inspector and we can bind to the
array controller selection.
And the selection of an array
controller it's a property and
it's a proxy object that
represents the currently
selected items in the array.
So, we can keyPath into that
selection to actually allow us
to edit and show the name of our
cat and similarly, we can do the
same thing with the selection
for the photo and that's it.
We've now wired up our
application with no code.
So, let's go ahead and run it.
And we can add our cats, give
them names, give them pictures,
add more cats, it's a really
amazing application it's so
handy.
And since we're using bindings
you can update these and they'll
get updated immediately in the
table view.
Just like that we can drag in a
new picture or a Quick Look and
drag in a new picture and it
gets updated in the table view
as well.
And of course, we need to make
sure our bells and whistles are
working [sound effect], great.
So that's bindings.
[ Applause ]
So, you can use bindings to wire
up your user interface to your
model without having to write
any of that glue code.
Next steps might be using a real
cat class instead of a
dictionary or even a Core Data
entity that way you'll get
persistent -- your list of cats
will persist.
But you'll never have to write
and for that you will have to
write some code, but you won't
have to write that glue code for
your user interfaces and that's
bindings.
And back to Rachel.
>> Okay, so number 29 may have
seemed like the end, but we have
tip and plus one, add your own
tips.
Some ideas for how to get
information and learn more.
We have new revised
documentation this year, topics
are grouped by task.
There's a hierarchical structure
that allows you to drill down,
such as this example of going
down and looking at NSView.
There's three different styles
of presentation, there's
reference documents, there's
conceptual articles and sample
code.
So, there's different ways of
approaching the material.
We also highly recommend that
people check out the release
notes on all of our platforms.
This is information straight
from the engineer's fingertips
about what's new in every
release.
Header files are always a good
source of information with line
by line comments about all of
our APIs.
On Wednesday in what's new in
Cocoa we asked people to tweet
their own Cocoa development tips
and we collected some of our
favorites from Twitter.
It was hard to choose, but
here's some of the tips that we
liked.
NSHashTable is like NSSet, but
it can contain arbitrary
pointers such as void star.
And also, you can weekly
reference objects from
NSHashTable.
Sometimes generics in
Objective-C are a little bit
cumbersome looking and you can
use a typedef to simplify the
way they look and clean up your
code.
In Swift, you can use typealias
to do the same thing.
And if you're coming to the Mac
from iOS you may remember that
NSWindowController is often a
class that you want to use
rather than NSViewController.
So, check it out and think about
it.
And our last tip from Twitter is
that in Xcode you can use Add
Expression to get Quick Look
previews for arbitrary
addresses.
So, here are some screenshots
showing how that would work.
I'm stopped in the debugger and
I print out the image, this add
cat image.
I grab the pointer here and I
can use the Add Expression menu
item and paste in my image
pointer.
And then if I hit the spacebar
I'll get a Quick Look preview of
my image.
There's documentation on how to
make your own classes Quick
Lookable, so check that out.
And we've come to the end.
For more information, you can go
to this page, we have several
related sessions that are all in
the past.
Check them out on video and, you
know, cats because we all want
to see them.
Thanks for being here.