The officially sanctioned method is NSNull sample code, but this will generate a warning in clang (BOOO HISSSS).

So here are the options as I see them:

- (void)someMethod
{
    NSString *aString = @"loremipsum";
    
    // This will complain: "Comparison of distinct pointer types ('NSString *' and 'NSNull *')"
    if (aString != [NSNull null])
    {
        
    }
    
    // This works (at least for strings), but isEqual: does different things 
    // for different classes, so it's not ideal
    if ([aString isEqual:[NSNull null]]) 
    {
        
    }
    
    // If you cast it to the class you're comparing against
    // then you're good to go
    if (aString != (NSString *)[NSNull null])
    {
        
    }
    
    // But we can also just cast it to id and
    // that works generically
    if (aString != (id)[NSNull null])
    {
        
    }
    
    // The thing that would be really cool,
    // would be [NSNull null] returning
    // id (like in the sample category below).
    // Wouldn't count on that one though.
    if (aString != [NSNull idNull])
    {
        
    }
}

@interface NSNull (idNull)
+ (id)idNull;
@end
@implementation NSNull (idNull)
+ (id)idNull { return [NSNull null]; }
@end

Casting to (id) seems like the simplest way to handle this one, so that’s the one I’m using right now.

Update:

One of my coworkers @pgor pointed out that he uses NSNull’s isEqual, which seems like a sensible enough thing to do. (I’m guess Apple isn’t going to toss anything to screwy into an isEqual on an object that’s basically single purpose.)

if ([[NSNull null] isEqual:aString]) 
{
        
}

Also forgot to mention in the original post: it’s worth filing a bug against the documentation on NSNull to see what Apple’s official position is in this post static humiliator world we inhabit.

Radar

2001-07-04T12:08:56-07:00

supplied by xml and json feeds.

I’m pretty sure this is because one of the relatively common date formats supported by Java is

yyyy-MM-dd’T’HH:mm:ssXXX

and as we all know, Java and the internet are besties.

Thing is, NSDateFormatter doesn’t know what to do with XXX time zone formats, because it’s based on unicode date formatting and XXX is ISO 8601.

Yay for standards!

Lucky for us we know two things worth knowing

• there aren’t half time zones
• time format string can escape segments with single quotes

so our date format string for our formatter becomes

yyyy-MM-dd’T’HH:mm:ssZZ’:00’

and we’re off to the races.

Everybody’s happy. Except possibly all those people writing Java.

(Insert your own joke about porn in the app store and XXX time, or maybe something about how our evil Cupertino overlords are censoring our time formatters!)

This is a balancing act of git configuration and ssh configuration, but it’s not as bad as it might seem, once you’re set up.

Setup your accounts

Create and/or configure the two github accounts you wish to configure

We’ll refer to them as

• GithubPersonal
• GithubWork

and make sure they’ve each got their own ssh keys configured. (Github has great tutorials on how to generate keypairs and associate them with your account.)

We’ll assume the keys are

• ~/.ssh/id_rsa_personal & ~/.ssh/id_rsa_personal.pub
• ~/.ssh/id_rsa_work & ~/.ssh/id_rsa_work.pub

Configure SSH

If you don’t have one already create a file called config at ~/.ssh/config

I use textmate, but you could use any text editor.

mate ~/.ssh/config

We’ll be setting up config to use aliases when connecting to github using an alias. For example I can setup an alias called work to turn

ssh -i ~/.ssh/id_rsa doug@server.example.com

into

ssh work

Our goal is to use aliases to tell git what keypair to use when connecting to github.com

There’s some flexibility in how you setup the config, you need to set up an alias for at least one of the accounts. I like to alias work and leave my personal account untouched, but a more thorough invidual might do both. This will become clearer as we proceed.

Host personal
    Hostname github.com
    User git
    IdentityFile ~/.ssh/id_rsa_personal
Host work
    Hostname github.com
    User git
    IdentityFile ~/.ssh/id_rsa_work

Now we’ll get the keypairs loaded so the system will use them

# Clear out currently stored identities
ssh-add -D
# Add in personal key (you may be prompted for your keypairs password)
ssh-add ~./ssh/id_rsa_personal
# And work
ssh-add ~./ssh/id_rsa_work
# Print a list of loaded keys to make sure both are loaded
ssh-add -l

Now you’ve got your keys in place, let’s poke github and see if it recognizes us

ssh -T personal

Should give you

Hi GithubPersonal! You’ve successfully authenticated, but GitHub does not provide shell access.

Same for work

ssh -T work

Should give you

Hi GithubWork! You’ve successfully authenticated, but GitHub does not provide shell access.

So now we’re up and running and doing the ssh tango, onto the next one.

Configure Git

Git can be configured with a username, email address and custom fields. Github recommends using the custom fields to add in your github username and your github token.

# Check your current globals
git config --global -l

They should look something like

user.name = Some Guy

user.email = someguy@example.com

core.excludesfile = /Users/someguy/.gitignore

mergetool.keepbackup = true

github.username = GithubPersonal

github.token = 123456789asdjfhlkjhdflkh8598

I choose to configure my globals to use my personal account, becaues I have a lot more active repos in my personal account than my work account.

You can configure any of the setting with the following syntax

git config --global user.name "Some Guy"

by swapping out the name of the property and it’s value.

I recommend setting user.name, user.email, github.username, and github.token.

Now you’re configured for general use. We’ll revisit local configs after we cover cloning repos.

Getting your code

Normally you’d go to the github project site and grab the clone URL and be off to the races.

Something like

git clone git@github.com:username/repo.git

and if you have permission you can push/pull/etc from that repo.

In this case we need to tell github what we’re doing so we change the syntax some

git clone ssh://work/username/repo.git

would pull down the repo using the ssh keypair for you work account.

The logic is the same to use your personal account

git clone ssh://personal/username/repo.git

Git Config Local

Now that you’ve got some code to work with, the last thing to fix is making sure that your commits show up on github accredited to the right account. Git will automatically use the global config for any keys you don’t override on a per repo basis.

You do have to do this for each repo you clone, but only once per repo.

cd repo
# Check your current local config
git config --local -l

core.repositoryformatversion = 0

core.filemode = true

core.bare = false

core.logallrefupdates = true

core.ignorecase = true

remote.origin.fetch = +refs/heads/:refs/remotes/origin/

remote.origin.url = ssh://work/username/repot.git

branch.master.remote = origin

branch.master.merge = refs/heads/master

Again I recommend setting user.name, user.email, github.username, and github.token, but this time use your work account.

You’ll end up with a few new lines in your local config when you’re done

user.name = Some Guy

user.email = workemail@example.com

github.username = GithubWork

github.token = 3235435468413asdsfdasdfsfs

All Done

That’s the whole show. You can now configure aliases and local configs to make sure the right projects are using the right accounts and right metadata.

Hope this is useful.

Luckily this is pretty easy to fix by logging the function instead of the object:

#if !defined(NS_BLOCK_ASSERTIONS)

#define BlockAssert(condition, desc, ...) \
do {\
if (!(condition)) { \
[[NSAssertionHandler currentHandler] handleFailureInFunction:NSStringFromSelector(_cmd) \
file:[NSString stringWithUTF8String:__FILE__] \
lineNumber:__LINE__ \
description:(desc), ##__VA_ARGS__]; \
}\
} while(0);

#else // NS_BLOCK_ASSERTIONS defined

#define BlockAssert(condition, desc, ...) 

#endif

This new macro behaves the same and will compile out with the same flags as NSAssert.

Easy, Peasy.

OSAtomic

One of the things it does best is make integer math really easy to do without the weight of a general purpose lock.

Here’s a dead simple counter that just bumps an integer on each access:

#import <Foundation/Foundation.h>
#import <libkern/OSAtomic.h>

static int32_t _count = 0;
static inline int32_t MonotonicCounter(void)
{
    return OSAtomicIncrement32(&_count);
}

OSAtomic is worth spending some time with, there’s lots of goodies.

Some preliminary reading if you’re interested:

• Matt Legend Gemmell - Accessibility for iPhone and iPad Apps
• Accessibility Programming Guide for iOS

I’d like to offer a short take on one of the most common mistakes that iOS developers make when they’re not thinking about accessibility, Buttons.

UIButton instances can be a configured a lot of ways:

• With text
• With text and an image
• With just an image
• With custom drawing
• Etc

I’ve created a sample project that you can grab to see how buttons can be configured to make sure that iOS’s Voice Over framework can see what that buttons content and purpose is.

Grab the code, give it a look, and remember these takeaways:

• Set the buttons title any time you can
• If you can’t set the buttons title, set its accessibilityLabel
• A picture of text, is not the same as text if you’re not sighted

SomeModelObject *model = [[SomeModelObject alloc] init];
model.someProperty = [someDictionary objectForKey:@"someProperty"];
//etc

or a little better

@implementation SomeModelObject
- (id)initWithDictionary:(NSDictionary *)dictionary
{
    self = [super init];
    if (self)
    {
        self.someProperty = [dictionary objectForKey:@"someProperty"];
    }
    return self;
}

and then there’s transformations, like turning a string into a date, etc.

While I was at Bottle Rocket, we decided to formalize this process and write something that would make it easy and consistent to turn dictionaries into model objects and back into dictionaries.

When I left Bottle Rocket, I had gotten so used to having this tool at my disposal I decided, with BR blessing, to build my own.

ESObjectMap is my 2.0 take on this problem:

• Easy configuration from a dictionary for native model objects and core data objects
• Mismatched field name mapping
• Built in basic data transforms for common data types and an easy path to build custom transforms
• Mapping of native model objects back into dictionaries

Couple of non-feature side notes:

• Written for ARC
• While the samples are of rendering to and from JSON, this is really just about dictionaries to objects and back
• Uses my property introspection logic, so you have lots of meta data to work with when performing mappings and transforms.

Check out the sample project, let me know what you think. I’m pretty happy with where it is now, but there’s always room for improvement.

NSObject+PropertyDictionary

The values in the dictionary are ESDeclaredPropertyAttributes objects that should give you most of the data you’d want for most kinds of properties most of the time. (A comprehensive object that gives you all the possible data stored into a declared properties would be a complicated kitchen sink and only marginally more usable)

typedef enum {
    AssignStorage, // assign is the default declared property setter type
    StrongStorage,
    CopyStorage,
    ReadOnlyStorage
} PropertyStorageMethod;

// Not going to try to support
// enum, struct, union, int *, void *, long, short, signed, unsigned, etc
typedef enum
{
    IDType,
    ObjectType,
    CharType,
    DoubleType,
    FloatType,
    IntType,
    UnsupportedType
} PropertyStorageType;

@interface ESDeclaredPropertyAttributes : NSObject

@property (strong, nonatomic) NSString *classString;
@property (strong, nonatomic) NSString *name;
@property (nonatomic) PropertyStorageType storageType;
@property (nonatomic) SEL getter;
@property (nonatomic) SEL setter;
@property (nonatomic) PropertyStorageMethod storageMethod;
@property (nonatomic) BOOL readOnly;
@property (nonatomic) BOOL nonatomic;
@property (nonatomic) BOOL dynamic;

@end

ESMutableDictionary.h

ESMutableDictionary.m

This isn’t an NSMutableDictionary subclass as you might expect, it’s a very simple wrapper around a CFMutableDictionary which presents only the most basic interface to manipulating membership in the collection and retrieving current members of the collection.

@interface ESMutableDictionary : NSObject

- (id)init;
- (void)setObject:(id)obj forKey:(id)key;
- (void)removeObjectForKey:(id)key;
- (id)objectForKey:(id)key;

- (NSDictionary *)copyDictionary;

@end

What it is:

• An easy to use, reasonably performant, key value store that can have values added, removed and retrieved from multiple threads simultaneously.

What it is not:

• A wholesale replacement for NSMutableDictionary.
  • The concurrency considerations make this collection significantly less performant than a plain dictionary in any situation where there isn’t need for concurrency.
  • Many of the functions that make NSDictionary so useful are not available, because making them concurrent and still being performant would be challenging.
• Protection against mutating members of the collection. If you toss an object into this collection and then two threads try to changes it’s properties simultaneously, it’s on you to handle that, not this collection.

Copy Dictionary:

This is offered as a way to pop out the current collection so that it can be manipulated or enumerated or etc. It’s a shallow copy, but it should do the trick for most applications.

“You have to use (OSAtomic || NSRecursiveLock || @synchronized() || FloppyRubberChicken or you’re doing it wrong” - The Entire Internet (AKA Stack Overflow)

1. If your logic is written in a way that resource contentions are really a serious ding to your performance, then maybe you need to step back and think about solving things other than how fast your code locks and unlocks.

2. I do it with dispatch_sync, not because it’s the (Best || Most Perfect || Infallible || Unquestionable) approach possible, but because it’s simple, reliable, and in my experience fast. This may change, and when it does I’ll change to. For now this is how I do business: GIST

[newObject retain];
[object release], object = nil;
object = newObject;

or this:

- (void)dealloc
{
    [object release], object = nil;
    [super dealloc];
}

I always see people who set things to nil right before they set them to something else or right before they cease to exist as people who just want exc_bad_access to stop punching them and they’ve adopted irrational coping mechanisms.

This is that frustrating kind of wrong where it doesn’t crash or leak, so it can sometimes make for a hard sell.

If the object has a setter, use the setter, except in init and dealloc. It hinders your flexibility to change memory semantics and it violates owning naming conventions, you’re getting back an autoreleased object, not a +1 object. It’s probably going to work like 99% of the time, but it’s not ok.

Don’t do it.

It’s very easy to make an app that works great in your office on Wi-Fi………

When they quote Calvin, he’s quoting me, which I’m pretty sure makes me more famous than Oprah.

Popular Mechanics