A few hours ago, my network at home went down so I found a use for that personal hotspot feature sooner than I’d imagined (I got the beta of the iOS release as a developer). It’s… fast. I’m actually not noticing a difference in the speed web pages are loading. And me and my wife are both using my iPhone 4 to surf.

The battery is plummeting though but I’m in the house after all. Just need to plug it in, but was interested in seeing just how much pressure this’d put on the little thing.

Still, way cool.

Bored as I was, I typed in “sex” in the search and got a bunch of random looking results. I downloaded one, looked at it, noted (with no surprise) that it was retarded and then the machine beeped and I thought nothing more of it.

Fastforward a bit. Here you see me plugging my iPhone into my computer. It syncs.

Fastforward some more. Here you see me finding that app later. I delete it from the phone, thinking “phew, good thing I didn’t leave that around in case someone found it. How embarrasing.”

Fastforward again. Here I’m plugging the iPad into the computer. It syncs.

Fastforward a final time. Here’s my 12 year old niece playing, as she always does whenever she’s visiting, with my iPad.

And then later that day, I look at the first app page and what do I see? Yeah. iTunes synced that app in from my iPhone and out to my iPad. It’s a setting that I have control over, but geez, where are the privacy features on these bloody things? Where can I “hide” stuff I don’t want my 12 year old niece to stumble on?

Sigh. And now you guys know I downloaded a smut app. But the fact my 12 year old niece might have seen it is by far worse. Much, much worse. Ugh.

This was meant to be a reply to a question on Stack Overflow, but when I’d finally written this all up, the poster had deleted the question. Figured I wouldn’t let all this go to waste so posting it here, hoping some Objective-C wielder might run into it and be helped.

***

There are a number of options, all depending on the situation. I will keep referring to Sender, Receiver, and data as the class holding the information, the class which wants the information, and the information itself respectively.

Option 1 – Point Receiver to Sender at Sender init

Here we keep track of Sender internally. We also preferably do not store data locally in case Sender is updated — instead we use `Sender.data`. This of course requires that there is only one Sender, and that it is instantiated before the Receiver.

    // in Receiver.h
    @interface Receiver : .... {
        Sender *sender;
        // ...
    }
    - (id)initWithSender:(Sender *)aSender andBlabla:....;

    // in Receiver.m
    - (id)initWithSender:(Sender *)aSender andBlerf.... {
        self = [super init];
        if (self != nil) {
            // retain, if aSender may ever dealloc before us!
            sender = aSender;
            // other init stuff
        }
        return self;
    }

    // in Receiver.m, wherever we need "data" from the Sender, we now use
    // Sender.data

Same as option 1 but here we simply put in a Sender as a `@property`. This one actually allows us to have our Sender instantiated after the Receiver, since we can set the `Sender` property at a later point. The danger here is to make sure `Sender` is not used before we’ve actually gotten around to setting it.

    // in Receiver.h
    @interface Receiver : ... {
        Sender *sender;
        // ...
    }
    // ...
    // assign->retain, if Sender might dealloc before us!
    @property (assign) Sender *Sender;

    // in Receiver.m
    @synthesize sender;

    // Someplace in our program, where we're ready to tell the Receiver
    // about the Sender,
    //   myReceiver.sender = mySender;

Here we simply add a method to Receiver which has an instance of Sender as its argument. Receiver will then grab data from Sender. Here we’re pretending a bit, and the reason is that we may or may not want to get other information out of Sender at a later point in time, so we go the safe route. The alternative is more restrictive but less complex (option 4).

    // in Receiver.h
    @interface Receiver : ... {
        NSData *data;
        // ...
    }
    // ...
    - (void)setSender:(Sender *)aSender;

    // in Receiver.m
    - (void)setSender:(Sender *)aSender {
        // to make things simple, we're presuming that data is not
        // deallocated until we're given new data
        data = aSender.data;
        // potentially do other things with data
    }

    // Someplace in our program, where data has been updated in our
    // Sender and we want Receiver to update,
    //   myReceiver.sender = mySender;

This is the simplest but least expandable method we’ve got. In Receiver, we have an instance of our data that we set using a simple method or `@property`.

    // in Receiver.h
    @interface Receiver : ... {
        NSData *data;
        // ...
    }
    // ...
    // if data might dealloc before we're done using, assign -> retain
    @property (assign) NSData *data;

    // in Receiver.m
    @synthesize data;

    // Someplace where we want data to be updated
    myReceiver.data = mySender.data;

Code in objective-c works very much like a tree with branches with further branches. This has the fundamental flaw/effect that a branch can’t access the thicker branch to which it’s attached, and it can’t get to the tree trunk either. This can be solved using delegation. The most common case where a “thin” branch accesses a “thicker” branch is view controller / view. A view will tell its view controller things via delegate calls. This is only slightly different from giving its view controller updates to a data object. In our case, Receiver is a controller (delegate) of Sender.

    // in Sender.h
    @protocol SenderDelegate <NSObject>

    - (void)senderDidUpdateData:(NSData *)newData;

    @end

    @interface Sender : ... {
        NSObject <SenderDelegate> *delegate;
        // ...
    }
    // ...
    @property (assign) NSObject <SenderDelegate> *delegate;

    @end

    // in Sender.m
    @synthesize delegate;

    // in Sender.m, whenever we want to notify our delegate (if any)
    // about updates to data, 
    //    [delegate senderDidUpdateData:data];

    // in Receiver.h
    #include "Sender.h"

    @interface Receiver : ... <SenderDelegate> {
        // ...
    }
    // ...
    @end

    // in Receiver.m
    - (void)senderDidUpdateData:(NSData *)newData {
        // do something with newData, e.g. set data = newData;
    }

    // Someplace where we have both the Receiver and Sender instantiated
    //    mySender.delegate = myReceiver;

Using a singleton is sometimes beneficial. See other discussions on this topic for details. A singleton should be avoided unless you will have a single instance of a class throughout your code.

I’m sure there are other options as well, but these are the ones that come to mind right now.

-(NSString *)description

Add the above method to your Objective-C class and you’ll be able to NSLog it or get its string value anywhere using [OBNAME description]. In short, it will now respond with its ‘description’ to ‘%@’ in an NSString stringWithFormat expression.

Example:

@interface Person : NSObject {
  NSString *name;
  NSString *phone;
  NSInteger age;
}

-(NSString *)description;
[...]
-(NSString *)description
{
  return [NSString stringWithFormat:@"%@ (%d): %@",
        name, age, phone];
}

Then somewhere we have a Person object and we want to see its value.

NSLog(@"We've got %@", aPerson);
myLabel.text = [NSString stringWithFormat:@"Details: %@", aPerson];

(pardon any errors in code above — untested as is)

I’ve been a linux user for the last decade. More, even. I’ve had brief encounters with Windows, most of them horrific, all of them resulting in me eventually giving up and going back to linux, and none of them in the last 5+ years. I hear Windows is getting better, but as we say in Sweden, “bränt barn skyr elden*,” and I’ve come to the realization that I will most likely never use Windows again, even though I’m pleased to hear it’s shapening up after all these years.

One might say I’m a hard-to-please customer. Some might even accuse me of being the worst kind ever. I whine about things that don’t do their jobs, and even if they’re open source and free as in liberty, it doesn’t mean I won’t complain when they can’t do their jobs properly. I recently spew pus over PulseAudio and Ubuntu 9.10 — the worst experience since 1990 — and I stand by what I said, but in the end, I love linux, and it’s unfair to blame it all on the system, when there are so many factors out of the developers’ control.

Hardware manufacturers couldn’t give less of a fuck about linux, unless they’re making server-specific hardware.
Software manufacturers couldn’t give less of a fuck about linux, unless they’re making server-specific software.

It makes for a really ugly scene, sometimes, and people have to jump through living lions while spinning firey globes of radioactive customs officers through quality assurance managers. It’s messy, and it takes hours and pain, lots of both.

And this is an ongoing perpetual circle, where new hardware and new software clashes and collides over and over, year in and year out, in the uphill battle that is the linux desktop scene.

One of the most annoying things about being a linux user isn’t necessarily that hardware and software manufacturers piss in your corn flakes. It can be really frustrating when you’re struggling to get something working and someone goes, “Why are you using that piece of shit anyway. Linux sucks man. Just install Windows.”

Twitch. I mean, dude. Twitch. I don’t think there’s anyone out there as defensive and protective of their operating system as the linux user. We’re the first to take offense when someone tells us linux sucks. You tell a Windows user that Windows sucks and the most probable reply you’ll get is, “Uh-huh, I know that.**”

Sigh. So retarded. Well, I’ve gotten better about that, and these days I don’t have an agenda against anyone. I just know what works for me and what doesn’t, and whatever works for you, you should stick to. I still get picked on for my choice of OS though, playfully of course, and so the last couple of weeks my guilty pleasure has been to say things like:

“Damn, handbrake seems full of win. And it’s available for linux too. (And Windows, but who cares..)”

on Twitter. Which is fed to Google’s Buzz, which appears for some of the people who tend to poke fun at me. Now I’m poking back.

Joke aside, it’s interesting how the tables have turned. One of my best friends who’s a hardcore Windows user (and a skilled tech guy at that) and I have been discussing the whole linux/Windows deal for more or less ten years, and suddenly I’m waving my i*s around and talking about the innovative and prosperous market, while he’s pointing to Android and upcoming tablets that will potentially turn the tide on Apple’s tidal wave of domination. He’s suddenly wielding the open source cap and I’m wielding the closed source proprietary cap. And it happened overnight! Granted, his change isn’t as dramatic as mine — he’s simply opposed to the Mac experience, and will grab at anything that means not having to use a Mac (including some of the Win7 devices that are closing in on the market). In my case it’s a little more extreme, but in the end, I’m just excited about a rare opportunity. In the end, I do not believe the i*s will control the market, but I believe they will lead the way, and I’m excited to be a part of that process, even if it’s an unsignificant part.

—

(* “burnt child fears fire”)

(** except for that one guy in Wisconsin who got real offensive about Windows when *I* said it sucked; never mind me being a hypocrite, but I was completely taken by surprise by this reaction, and immediately labeled him a confused patriot thinking Windows somehow was connected to the pride of America)

Update: timely — MS cancels their “iPad killer”: http://gizmodo.com/5527442/microsoft-cancels-innovative-courier-tablet-project

Kendall Gelner, Noel Llopis, and many other hugely talented but yet pleasant to be around folks were inspiring.

Only thing I regret about the thing was eating those veggie burritos. Man they were grody.

iPadDevCamp was a super-intensive “hack something together a-zap and present it two days later” thing. Actually it was roughly 1 whole day of working, with only a few hours on the Friday eve and Sunday morning to do last minute fixes. I ended up with a group of 4 others doing a ‘multi-device game’ called (eventually) Tank or Die. The idea was to be able to add iPhones as game controllers and iPads as playing fields in this ‘control the tank and try to shoot the other tanks’. There were 3 developers (4 even) and one graphics designer. Everyone decided to start working on things on Friday, but due to transportation issues, I couldn’t actually join them until Saturday. My task ended up being the connectivity between iPads (the playing fields) and I just didn’t have enough time to figure out how to get it all working in time for the demo, so when we won “best game” award, I felt a bit like a cheater when I took that wireless keyboard from the prize pile.

Was a learning experience though, and I don’t regret participating. It’s a very nice feeling when you are convinced that “if I were tasked to do this with the things I know today, I would have succeeded”, and I am.

Now I’m going to be doing some work and relax until Friday, when I go up to Seattle for the last conference in my “conference tour”.

I still haven’t quite gotten used to things — or maybe it is that I won’t see things the same way I did before, I’m not sure — but in two days, I’m off to the United States to attend three conferences related to the iPhone and iPad:

• 360iDev in San Jose, Apr. 11-14.
• iPadDevCamp in the same place (same building even, it seems), Apr 16-18.
• Voices That Matter iPhone dev conference, in Seattle, Apr. 24-25.

If anyone else is attending either of the above, or if you’re simply in the area, feel free to let me know and we can grab a beer/coffee/whatever.

Going to be an interesting ride, though I’m not looking forward to the flights. I’ll be in an airplane first 9 hours, and then another 6 hours and, apparently, I’ll be sitting in Newark for 5 hours waiting for plane #2. I have no idea how I missed that when I booked the ticket but can’t be helped now — but yes, 20 hours of “traveling”. My trip to Japan (where I was stuck in Istanbul for EIGHT hours) is the only trip that beats this one. I think that one totaled at 24 hours or something.

Anyway, looking forward to it all. Now it’s just a matter of packing and getting mentally prepared for the intense few weeks ahead.

This is an unexpected turn of events. Apple with its “closed” approach versus Adobe with ITS “closed” approach leading to more openness. Two wrongs do not make one right, you say, and I point at this wonderful, glorious exception of where just precisely that is happening. The very nature of “closed” means you can shut out whoever you want however you want, and Adobe in all of its proprietary glory shuts pretty much everyone except Windows users out (yea, Flash runs horrible on the Mac apparently, it’s a resource hog, and crashes constantly).

And Apple shuts Adobe out. Do you hear my giggles as I wheeze for breath?

It reminds me of MSIE back in the day. It was THE browser. The alternative was Netscape Navigator and it was a disastrous piece of crap where Internet Explorer was a shiny piece of solid gold. So developers ignored everything else. Even when Firefox came around, they continued doing so, at least the short bus folks did. Fuck web standards. Then suddenly, their “dis sait rekirs intrnet exprdorerlolstfu” sites were hurting, badly.

But it took a long while. Banks in Sweden required Internet Explorer up until a mere few years ago. My mother’s stock market site (uh yeah, my mom’s dealing in stock, but that’s another story) even to this day requires Internet Explorer.

Now we have Flash, and we see people doing the same mistake all over again. Especially with the web as it is today, with video content and all that, it’s no wonder people are going for Flash, because Flash is pretty much the only alternative. Well, sort of, anyway. Ah-yep-. If you clicked the link you probably noticed that it said “HTML5″ and if that didn’t mean much to you, let me rephrase:

No Flash.

Actually, I can rephrase that even nicer:

No Proprietary One-Company-To-Rule-Them-All Plugins Required.

Did I mention that HTML5 video is supported by the iPhone?

As a developer, this is the part where you go look at the figures for exactly how many people own an iPhone. And the part where you take a stand on whether the iPad will sell to millions or if it’ll flop over and keel. This is the part where you get the numbers fed to you: 42.5 million.

Forty two point five million iPhones as of Q1 2010. And your cute, bunny-hopping Flash-site? It’s a fucking piece of Lego right now, for those 42.5 million users when they browse on their phone.

And I bought an iPhone. For anyone who speaks Japanese (or for that matter, Chinese or any other language which requires more than the average a-z), I can inform you that which I had wished somebody out there had informed me in a straightforward manner when I started digging into this over a year ago.

Yes, you can use Japanese and Swedish (or whatever combination) on the iPhone simultaneously. I can get my åäö’s which my Japanese cell couldn’t spit out for the life of it (me), and I can get 日本語 to slither out of it as well. You can send SMS’es within Sweden in Japanese, and in general, you can use them as you would in Japan, except that they also properly support Swedish.

In case you are confuzzled about how to do this, the Swedish (with presumed English translation in parentheses) menu alternatives for getting Japanese enabled is as follows:

Inställningar (Settings) > Allmänt (General) > Internationellt (International) > Tangentbord (Keyboard) > Japanska (Japanese) > QWERTY or Kana (whichever you prefer).