Archive for January 2015

Saturday, January 31, 2015 [Tweets] [Favorites]

iTunes Connect Bug: Logs You Into the Wrong Account

Joe Rossignol:

Instead of seeing their own apps, iTunes Connect is mismatching users and displaying other apps from completely different developers. MacRumors has been able to duplicate this issue, which appears to be widespread and has been going on since at least 8 AM Pacific.

Andrew Cunningham:

We don’t yet know whether the outage was caused by some error on Apple’s end or by a security breach like the one that brought all developer systems down in the summer of 2013.

Nick Heer:

I’ve noticed tweets from a few different people that ended up in BlackBerry’s iTunes Connect example, though, which makes me think that some accounts were shown more often than others. That’s kind of weird, and it makes me wonder what kind of weird session management issue caused this.

This occurred right when I was submitting EagleFiler to the Mac App Store. First, my account seemed to log in normally, not showing someone else’s apps. Then logging in failed for half an hour or so, all while Apple’s status page showed green. It eventually updated to show that iTunes Connect was down for several hours.

John Gruber:

If you’re a developer, I suggest logging in and making sure nobody monkeyed around with your apps while this was going on.

I would also make sure that no additional iTunes Connect user accounts were created.

Cédric Luthi:

Incredible! Apple wrote a post-mortem on the iTunes Connect incident on their Press Info page.

Mac OS X 10.10.2

The Mac OS X 10.10.2 update fixes the Thunderstrike exploit, among other security bugs. (Good luck if you have a Thunderbolt-equipped Mac but aren’t running Yosemite.)

It claims to fix Wi-Fi issues, but Macworld and MacRumors both report that Wi-Fi problems persist.

It does fix the nasty Core Data relationships data loss bug, though this is not yet fixed in iOS.

Launchpad’s sparkle for new applications has been removed.

Lloyd Chambers is still seeing problems with dual displays. I’m still seeing problems with the login screen, Mail, etc.

Update (2015-02-03): Edward Marczak:

To call [Thunderstrike], “fixed,” is absolute fantasy. A good chunk of the boot process would need to change to fix this.

FileVault 2 Deferred Enablement in Yosemite

Rich Trouton:

Apple recognized that there would be situations where Mac admins would need to set up FileVault 2 for a person where the admin would not have the password for that person’s user account. To avoid the immediate need to enter a password, fdesetup has a -defer flag in Mountain Lion, Mavericks and Yosemite that can be used with fdesetup’s enable verb to delay enabling FileVault 2 until after the current (or next) user logs out. With the -defer flag, the user will be prompted for their password at their next logout or restart. The recovery key information is not generated until the user password is obtained, so the -defer option requires a file location where this information will be written to as a plist file.


In Yosemite, Apple added new options for fdesetup’s -defer flag. These new options now allow Mac admins to set a deferred enablement with the following options:

  1. Enforce FileVault 2 enablement at logout
  2. Enforce FileVault 2 enablement at login
  3. Enforce FileVault 2 enablement at both login and logout

Update (2015-02-02): Rich Trouton:

fdesetup in Yosemite has the authrestart verb, which allows a FileVault 2-encrypted Mac to restart, bypass the FileVault 2 pre-boot login screen, and goes straight to the OS login window.

Improved FogBugz Cases Menu

Dane Bertram:

No more need for weird prefixes to help keep your personal saved filters organized! You can now create as many personal filter groups as you like and freely drag your filters between them.


You can also drag-and-drop the groups themselves to determine the order in which they’re displayed, while the filters within each group are automatically sorted alphabetically.


Still have too many saved filters to look at all at once? Well, filter groups (including the built-in “My Filters” and “Shared Filters” groups) are now collapsible and will remember their collapsed-ness no matter what browser or computer you might be using.

Good stuff.

I remain a happy FogBugz customer, though unfortunately Fog Creek seems to have other priorities these days. FogBugz still doesn’t support the multipart/mixed e-mail format that Apple Mail (among other clients) uses, leading to extra steps and embarrassing mistakes when I can’t see the entire message that my customer sent. [Update (2015-02-18): The current version of FogBugz no longer loses the text in these messages, however it still puts all the images at the end, messing up the interleaving.] [Update (2015-06-30): Actually, it is not fixed. I just received another message where FogBugz made it look as though there was no text.] It also still has trouble with certain e-mails that contain images, inserting unsightly strings like:


into the reply.

The performance upgrade, which came out of beta in October 2013, has included a steady stream of smaller interface improvements. However, it still doesn’t officially support Safari, isn’t as keyboard-navigable as the old version, and takes minutes instead of seconds to bulk-mark messages as spam.

Most seriously, the performance upgrade still has a bug where a customer will reply to a case, and FogBugz will receive the reply and re-open the case, but the case will not appear in the inbox filter showing open inquiries. I guess there’s some sort of issue with the new indexing engine because the inbox shows the correct cases with the performance upgrade disabled. In any case, the customer won’t get a reply unless I notice the message in my e-mail backup or until a periodic check of turning off the performance upgrade to look for lost cases. I actually have a recurring task in OmniFocus to remind me to do this.

[Update (2015-02-12): There is also still a bug where it corrupts some .plist files received as attachments.]

Lastly, I still have a nagging concern about keeping such important data in the cloud. FogBugz On Demand originally had a backup data center, but this was shut down sometime before Hurricane Sandy. In the aftermath of Sandy, it sounded like the goal was to again have two data centers, but this has not come to pass yet.

Meanwhile, I am trying to make my own backups: manually BCCing every e-mail I send, running a URL trigger to log case changes, and manually creating backups in CSV format (in four chunks, because otherwise it gives me a single-line file without reporting an error). I once wrote a tool that used the API to back up my cases as XML, but years ago this stopped working—the server would time out and return an HTML error page—and I haven’t had a chance to rewrite it using a smaller batch size. There is still a way to request a SQL dump, and this has been improved so that it works for larger databases; they e-mail you an FTP link a few hours later when the ZIP archive is ready.

Like I said, I am overall a satisfied customer. I just wish the basics would get more attention than whizzy new features.

Update (2015-04-02): Another issue is that URL triggers don’t work for cases with lots of text because FogBugz puts the parameters in the URL itself (even if you use POST instead of GET).

Update (2015-04-24): I’m still getting missing messages with the Performance Upgrade. Switching it off is annoying because the old user interface has different keyboard shortcuts and doesn’t support the same snippet placeholders.

Never Trust a Corporation to Do a Library’s Job

Andy Baio (via Rich Siegel):

For years, Google’s mission included the preservation of the past.


In the last five years, starting around 2010, the shifting priorities of Google’s management left these archival projects in limbo, or abandoned entirely.

After a series of redesigns, Google Groups is effectively dead for research purposes. The archives, while still online, have no means of searching by date.


The desire to preserve the past died along with 20% time, Google Labs, and the spirit of haphazard experimentation.

Windows 10: Re-Crappifying Windows 8

Lukas Mathis:

Windows 8 was a bold attempt to fix this, and to throw out much of that accumulated debris. And, surprisingly, it has worked to a pretty respectable degree. Windows 8, particularly when running Metro apps, is an operating systems that is much simpler than any other desktop OS. And Windows 8, unlike iOS, has managed to achieve this without losing much, if any, of the power of a traditional desktop operating system.


Windows 10 shows that Microsoft has lost that courage, pummelled into submission by the same kinds of vocal users who, back in the 80s, decried Windows itself, and demanded that people keep using DOS. In hindsight, I doubt anyone still thinks that this would have been a good idea.


But instead of fixing the things that are genuinely wrong with Windows 8, and providing some additional amenities for people who came from earlier versions of Windows, and improving the experience on mouse-driven systems, Microsoft took away many of the things that made Windows 8 work, and brought back Windows 7’s UI clutter wholesale.

The Unethical Business Practices of eFax

Matt Henderson:

Some companies can’t be satisfied by simply earning their revenue through the provision of a service. For these companies, a part of their business strategy depends on making it as difficult as possible to leave, and even unethically continuing to charge you after you’ve cancelled your account.

Craft Apps

Ben Thompson:

Stepping back, in one of my favorite episodes of Exponent, James Allworth and I coined the idea of The Internet Rainforest (although, now that I think about it, we mostly refer to it as the Internet jungle). The idea is that the economics of the Internet work for two types of businesses:

  • Massive businesses that can take advantage of the Internet’s scale to reach a huge number of people very cheaply and efficiently
  • Niche businesses that can take advantage of the super low costs involved in running an Internet business to reach a very narrow niche of people all over the world very cheaply and efficiently

Joe Cieplinski:

I find it odd that so many indies want to make “opinionated” software, which by definition limits the audience, and then price it as if trying to reach the widest audience possible. This strikes me as trying to have it both ways. Either you want to target a niche, or go for scale. If you target a niche with your design and features then try and price the app for the mainstream, you’re going to have a very hard time being sustainable.

The mainstream simply doesn’t care about your high-quality, artisanal approach to app making. They want what’s free and what’s popular. To get their attention, it takes millions of dollars an indie doesn’t have.


So you have to let go of this notion of making up for it in volume. You can’t easily convert people who don’t pay for software with your amazing hand-crafted experience.

iTunes 12.1’s Info Window

Kirk McElhearn:

This corrects one of the elements of iTunes 12 that I was critical of in my Macworld review:

“I find the lack of borders around the text fields make it a lot harder to visually scan the window, like trying to use a spreadsheet with no borders. It’s also hard to tell which fields are editable. I’m also disappointed that not all available fields appear by default. To add extra fields you have to click Add Field at the bottom.”

All the fields are now visible, with borders, making it easier to navigate this window. However, for some reason, Apple felt it wasn’t necessary to have the window display all the tags, and has it set to be scrollable. This is unfortunate. You can resize the window, if you wish. In my first tests, the new size wasn’t retained when I re-opened the window, but I changed it again, and it was saved.

John Gordon:

Looks like Apple removed the hidden multi-edit feature in iTunes 12.1. Open right click get info no longer shows the good/old multi-edit dialog, just the new/crap one.

Kirk McElhearn:

This means that, for most users, tagging will no longer involve typing and pressing the Tab key a few times, but looking closely at the window to find where the fields are, and manually clicking in different locations.

Why would Apple decide to put the Album tag near the bottom of the window? This is one of the most important tags for music. And why would they promote the Composer, and even the BPM tags? This design was clearly made by people who don’t tag music in iTunes.

Update (2015-02-01): Jamie Zawinski:

This is a new one. This time it randomly decided that only most of my music is now Other.

Friday, January 30, 2015 [Tweets] [Favorites]

Swift: No Macros, No Compromises

Using Swift with Cocoa and Objective-C (via Andrew Bancroft, emphasis added):

Complex macros are used in C and Objective-C but have no counterpart in Swift. Complex macros are macros that do not define constants, including parenthesized, function-like macros. You use complex macros in C and Objective-C to avoid type-checking constraints or to avoid retyping large amounts of boilerplate code. However, macros can make debugging and refactoring difficult. In Swift, you can use functions and generics to achieve the same results without any compromises. Therefore, the complex macros that are in C and Objective-C source files are not made available to your Swift code.

This is the sort of thing that really bothers me about Apple and Swift. I think Apple oversold how ready it was this summer, but it’s understandable that the compiler is buggy and that debugging and performance are problematic. And there is certainly a case to be made (though I would disagree) that macros should not be in the language or should not be used in most cases. But the emphasized sentence is so laughably, obviously false that one wonders why Apple bothered to include it. The results are not the same, and there most certainly are compromises. There’s a lot that you just can’t do in Swift because it lacks macros. Do Swift’s designers really believe this? Does the author not know what he or she is talking about? Or is Apple being deliberately misleading in order to “sell” the language? Either way, this sort of writing does not belong in technical documentation, and it’s especially jarring considering how Microsoft has used those same words.

Update (2015-01-31): Christoffer Lernö:

Given how many warts we could’ve fixed in Swift with even rudimentary macros, the statement in the docs become even more ludicrous.

Sunday, January 25, 2015 [Tweets] [Favorites]

An Example on How to Use NSProgress

Jaanus Kase (via Ole Begemann):

The best I can tell, there is no way to do this in Swift that does not look insane and ridiculous. See, -[NSWindowController initWithWindowNibName:] is a convenience initializer on NSWindowController, and Swift is much more restrictive about its initialization behavior in this case. You can’t call the parent’s convenience initializer from your own designated initializer.


Now, I was able to fix my demo project because it is a small, tightly controlled thing. I can be pretty sure that no other unwanted stuff is running after I fixed the above (first show window, and only then become the current progress object). But this might not be feasible for bigger projects where more things are happening at the same time and you don’t have tight control over all of them. Like, during the time where you are the current progress object, can you guarantee that nobody in your app is going to read anything from disk?


I suppose another solution is what Ole describes, to forgo the whole “current progress object” business and just pass the parent around between objects, and you can then become a child of that particular one and not just a child of whatever happens to be “current” at that point. This defeats the “loose coupling” aspect, though.

Too bad—it seemed like such a promising API. He says it’s also crashy.

MPW, Carbon, and Building Classic Mac Apps on Yosemite

Steven Troughton-Smith (via Thomas Brand):

mpw is an m68k binary translator/emulator whose sole purpose is to try and emulate enough of Classic Mac OS to run MPW’s own tools directly on OS X. MPW is unique in that it provided a shell and set of commandline tools on Classic Mac OS (an OS which itself has no notion of shells or commandlines) - this makes it particularly suited to an emulation process like mpw attempts to provide, as emulating a commandline app is a lot easier than one built for UI.


With the same source file, and only a handful of #ifdefs, I could build the same app for 1984’s System 1.0 all the way up to the current release of OS X, Yosemite.


Right now [mpw is] a fully usable tool that makes Classic Mac OS compilation possible and easy to do on modern versions of OS X, without requiring emulators or ancient IDEs or the like. To my knowledge, this is the first time this has been possible (excluding legacy versions of CodeWarrior).

Update (2015-01-31): Pierre Lebeaupin:

And in fact, it is a very interesting exercise because it allows a better understanding of what makes the Macintosh the Macintosh, by seeing how it was originally programmed for. So I encourage you all to try and play with it.


QuickDraw is, by some aspects, more approachable that Quartz (e.g. no object to keep track of and deallocate at the end), but on the other hand the Carbon transition added some hoops to jump through that makes it harder to just get started with it; for instance something as basic as getting the black pattern, used to ensure your drawing is a flat color, is described in most docs as using the black global variable, but those docs should have been changed for Carbon: with Carbon GetQDGlobalsBlack(&blackPat); must be used to merely get that value. Another aspect which complicates initial understanding is that pre-Carbon you would just directly cast between a WindowPtr, (C)GrafPtr, offscreen GWorldPtr, etc., but when compiling for Carbon you have to use conversion functions, for instance GetWindowPort() to get the port for a given window… but only for some of those conversions, the others just being done with casts, and it is hard to know at a glance which are which.

Audio Hijack 3

Paul Kafasis:

We’ve been developing products under the Audio Hijack name since 2002, when Mac OS X 10.1 was cutting-edge! Over the years, users have found incredible ways to adapt Audio Hijack for their needs, leading us to make many updates and improvements. Eventually, however, these changes caused Audio Hijack to outgrow our original designs. We’ve incorporated over a decade’s worth of experience and feedback into Audio Hijack 3 to improve the process of recording and enhancing audio. Every aspect of our previous Audio Hijack products has been thoughtfully examined and considered, with enhancements made across the board.

The new interface looks really neat.

Update (2015-02-06): Christa Mrgan:

Having used the node-based applications Quartz Composer and Shake, I imagined Audio Hijack users dealing with a hairy web of randomly-placed, text-heavy rectangles connected by fiddly, intersecting lines and a general sense of chaos.

Even if this style of interface made the application more flexible and powerful, this was not my idea of an improvement. Fortunately for all involved, my protests were ignored. “We’re doing nodes,” Paul said. “We’ll just have to make nodes easier to use.”

And so we worked our way through many different designs. We eventually settled on four basic types of blocks which would automatically snap together when dragged to a grid. The blocks themselves went through many iterations, with various methods for connecting and showing the flow of audio. We finally arrived at the idea of blocks auto-connecting via “pipes”, which would then show a live spectrogram as audio moved through the pipeline from left to right.

Deleting Folders Using the “find” Command

I’ve seen lots of Web pages about how to use the Unix find command to delete files or directories with a certain name. I do this pretty frequently. For example, the Makefile for deploying my apps deletes the Headers folders inside of the embedded frameworks. It also has legacy lines for deleting CVS and .svn folders. The standard advice seems to be to write something like this:

find -name Headers -type d -delete

This looks inside the folder for items named Headers that are directories and deletes them. This works with GNU find, but in the BSD version of find (which ships with Macs) the -delete option only works with files and empty directories. Confusingly, it won’t report failure for a non-empty directory; it will just leave it there. The common solution is to use a command like this:

find -name Headers -type d -exec rm -rf "{}" \;

This executes the rm -r {} command for each found item, with the {} replaced by the item’s path. The \; marks the end of the command and is escaped so that the shell sends the ; to find instead of interpreting it as a command separator. The problem with this version is that it can result in “No such file or directory” errors. find will execute the command for a folder (thus deleting it), then try to recurse into that folder and complain that it doesn’t exist. find succeeded in that all the directories did get deleted—it doesn’t stop when it encounters the first missing directory—but it reports a failing exit status that can halt your shell script or Makefile.

A common way to work around this is to silence the errors. You can use:

find -name Headers -type d -exec rm -rf "{}" \; || true

to make sure that the combined command exits with success. Or, in a Makefile, you can use:

-find -name Headers -type d -exec rm -rf "{}" \;

to tell make to ignore errors. In both cases, the command will succeed, but it will still print “No such file or directory”. So sometimes people silence the error:

-find -name Headers -type d -exec rm -rf "{}" \; 2>/dev/null

My preferred solution is to prevent the error in the first place. You can tell find to do a post-order traversal instead of a pre-order one. In other words, it will recurse first and delete later. This is done by specifying the -d option:

find -d -name Headers -type d -exec rm -rf "{}" \;

You also optimize this somewhat by using + instead of \;. This causes find to send multiple items to a single invocation of the rm command. I’ve also found that, at least with Bash, it is not necessary to quote the braces. This command looks cleaner and works well:

find -d -name Headers -type d -exec rm -rf {} +

Another way to do essentially the same thing is to use xargs:

find -d -name Headers -type d -print0 | xargs -0 rm -rf

In practice, it seems that if you use xargs you don’t need -d. Perhaps this is because a certain amount of find output is buffered before xargs begins deleting. However, I think it is more correct to leave it in.

Update (2015-01-26): As noted in the comments, you can use -prune (instead of -d) to tell find not to recurse into the matching folders that will be deleted anyway:

find -name Headers -type d -prune -exec rm -rf {} +

Saturday, January 24, 2015 [Tweets] [Favorites]

Swift Capture Lists

Russ Bishop:

The Language Guide claims you should use unowned if the closure and containing object reference each other and will be destroyed at the same time. Presumably that’s to avoid the cost of safely nil’ing out a weak reference in an object that’s about to dealloc anyway.

Most people aren’t aware that you can create new named values here as well[…]

Documents in the Cloud: bird and brctl

Apple’s site doesn’t yet document them, but bird is the system daemon behind iCloud documents, and brctl is the corresponding control utility (via Zachary Drayer).

Accessibility Showdown: iPhone 6 vs. iPhone 6 Plus

Steven Aquino:

In this context, bigger truly is better: it allows for more content to be shown, and the 401 pixels-per-inch (ppi) screen is so bright and crisp that I find myself rarely squinting to read text. The screen is so good, in fact, that text is easily viewable for me at normal size (my preference, though it can also be set to show less content at larger sizes). The advantages of the iPhone 6 Plus’s screen are such that I experience less eye strain and fatigue than on my iPhone 6, whose screen is “only” 326 ppi.

Alas, the sheer physical size of the iPhone 6 Plus hardware makes for a polarizing user experience. As wonderful as the screen is, the dimensions of the iPhone 6 Plus make me yearn for my smaller iPhone 6. The iPhone 6 Plus is a monster, making it cumbersome both to hold and carry in my pocket. Even getting it in and out of my pocket takes more effort than the iPhone 6, and it’s much more obvious in my pocket as well.

This isn’t just personal preference. Sure, my hands are small, but my cerebral palsy makes holding the iPhone 6 Plus awkward and uncomfortable, forcing me to adjust my grasp constantly to maintain control over the phone. Holding it to my ear during phone calls is hard too, because it’s so smooth and hard to grip, and the size makes it weird to hold against my ear.

The Imitation Game

Scott Aaronson:

OK, so for those who haven’t yet seen it: should you? Here’s my one paragraph summary: imagine that you told the story of Alan Turing—one greatest triumphs and tragedies of human history, needing no embellishment whatsoever—to someone who only sort-of understood it, and who filled in the gaps with weird fabrications and Hollywood clichés. And imagine that person retold the story to a second person, who understood even less, and that that person retold it to a third, who understood least of all, but who was charged with making the movie that would bring Turing’s story before the largest audience it’s ever had. And yet, imagine that enough of the enormity of the original story made it through this noisy channel, that the final product was still pretty good. (Except, imagine how much better it could’ve been!)

Geoff Knauth:

I liked The Imitation Game, despite its problems. Here’s a better list of its inaccuracies than I’d have produced.

Gitlet: Git Implemented in JavaScript

Mary Rose Cook:

Over the last six years, I’ve become better at using Git for version control. But my conceptions of the index, the working copy, the object graph and remotes have just grown fuzzier.

Sometimes, I can only understand something by implementing it. So, I wrote Gitlet, my own version of Git. I pored over tutorials. I read articles about internals. I tried to understand how API commands work by reading the docs, then gave up and ran hundreds of experiments on repositories and rummaged through the .git directory to figure out the results.

I discovered that, if approached from the inside out, Git is easy to understand. It is the product of simple ideas that, when combined, produce something very deep and beautiful.

Creating the Natural Numbers From First Principles

Brandon Williams:

Turns out, natural numbers can be constructed from two basic objects. First, we start with the “smallest” member of the naturals, called Zero. Then we have a function Succ (the successor function) that takes a natural and returns the next natural.

Update (2015-01-31): The solutions to the exercises.

Back to the iPhone 5s

Jeff Hunsberger (via John Gordon):

The iPhone 6 screen always felt a bit like it wasn’t made for my hands like the iPhone 5S was. The iPhone 4 and 4S were tiny and I could easily reach any area of the screen. My resistance to the iPhone 5 gave way to the fact that I could still reach the top left corner while holding my phone in the right hand. The iPhone 6 requires you to shift the phone in your hand, balance it on your fingertips and then stretch across to hit the top left of the screen one-handed. The whole time you are courting disaster.


Moving back to the iPhone 5S has reaffirmed my feeling that it is the current high point in smartphones. It is the best balance in speed, battery life, size and durability.

When testing an iPhone 6, I found that it was much less comfortable in my jeans pocket. It simply wouldn’t fit in the breast pocket of my ski jacket. I’m hoping that the iPhone 6S will come in a smaller size. Meanwhile, I’m still happy with the 5s.

The Future of No Thirst Software

Kevin LaCoste (tweet):

First off, you can rest easy that updates are already being worked on and roadmaps are being discussed. We have a lot planned for 2015 and beyond starting with some minor updates to get things up-to-date with the latest and greatest on iOS and OS X.

Great news. I had been worried, as I use MoneyWell every day and it had been more than six months since the original developer, Kevin Hoctor, announced his move to Apple. New Kevin’s Twitter is here, and he explains a bit about his bio here.

Friday, January 23, 2015 [Tweets] [Favorites]

Let’s Build Swift Notifications

Mike Ash:

NSNotifications are both simple and powerful, which is why they show up so often in the frameworks. Specifically, they have a few distinct advantages:

  1. Loose coupling between notification senders and receivers.
  2. Support for multiple receivers for a single notification.
  3. Support for custom data on the notification using the userInfo property.

There are some disadvantages as well:

  1. Sending and registering for notifications involves interacting with a singleton instance with no clear relationship to your classes.
  2. It’s not always clear what notifications are available for a particular class.
  3. For notifications which use userInfo, it’s not always clear what keys are available in the dictionary.
  4. userInfo keys are dynamically typed and require cooperation between the sender and receiver that can’t be expressed in the language, and messy boxing/unboxing for non-object types.
  5. Removing a notification registration requires an explicit removal call.
  6. It’s difficult to inspect which objects are registered for any given notification, which can make it hard to debug.

My goal in reimagining notifications in Swift is to remedy these problems.

He runs into an interesting case where casting is necessary to satisfy Swift’s type system. I didn’t expect this, and it’s instructive to think about what is going on here. Also note how it transparently handles observer functions with different numbers of parameters.

The Design Philosophy of the DARPA Internet Protocols

Adrian Colyer:

Understanding the underlying principles behind something can turn what might on the surface seem to be simply a collection of facts into a chain of causes and consequences that makes it much easier to see how those parts fit together. Clark provides us with some of those insights for the design of the Internet Protocols, working from the goals towards the implementation consequences.


The only error the communicating parties should ever see is the case of total partition. If the application(s) on either end of the connection are not required to resolve any other failures, then the state necessary for recovery must be held in the lower layers – but where? One option is to put it in the intermediate nodes in the network, and of course to protect it from loss it must be replicated. I think the knee-jerk reaction of many system designers today might be to distribute the state in some such manner, maybe using a gossip-protocol. But the original designers of the internet had a insight which enabled a much simpler solution, and they called it ‘fate sharing.’

Modern Login Items

Cory Bohon:

Login Items have previously been a way for OS X apps to provide this service to users, but is not compatible with the sandbox requirements of the Mac App Store. Fortunately, there is a much more modern way to handle this, and I’ll walk you through setting it up in your own projects.


In order to launch our application at login, we’ll create a separate application that is included in the signed main application bundle. The sole purpose and function of this separate application will be to launch our main application at login, if it is not already launched.


This code uses the ServiceManagement framework’s function called SMLoginItemSetEnabled. The first parameter in this method is a CFString containing the bundle identifier of your Helper application. The second parameter is a BOOL indicating whether the Helper should launch at login or not.

The helper app is required because SMLoginItemSetEnabled() only works with paths inside of the app’s Contents/Library/LoginItems folder.

Tim Schröder:

Consider further that you have successfully implemented such a feature and shipped your application, but now want to update your application to not run in a sandbox anymore. Sounds like a strange turn of things, but this may happen, e.g., if you designed an application to be distributed in the Mac App Store (and shipped it), but now there are compelling reasons to remove the sandbox functionality and to switch to direct distribution outside the Mac App Store.

It is then sensible to provide launch at login functionality no longer via SMLoginItemSetEnabled (and a helper app), but via a shared file list as provided by the Launch Services Framework, which has the distinctive advantage that your application will be visibly marked as launching at login in the System Preferences and that the user can edit this behaviour from the System Preferences (which is not the case with the launch at login functionality providing via SMLoginItemSetEnabled).

Update (2015-01-27): Stephane Sudre says that you may need to call LSRegisterURL() before SMLoginItemSetEnabled().

Dallas Brown reminds that you need to create a separate App ID in the Developer Portal for the helper application and that it should not have the same entitlements as your main application.

How iOS Has Changed

Khoi Vinh:

I don’t link to a lot of infographics here but I like this one, and I’ve always been fascinated by the incremental, barely noticed way some interfaces can change, even when we look at them all day long. This extensive graphic from presents a pretty comprehensive overview of how iOS has evolved.

Organ Banked

In response to my roundup about Apple’s software quality, a former Apple CoreOS person writes:

A lot of us felt we were being “organ banked”, and late in Lion, on the iDevice release cycle, we were pulled away from desktop work in order to do iPhone and iPad work, which was on a 3 month release cycle, instead of alternating desktop with non-desktop, which we had formerly done on a 6 months on/6 months off cycle (release one in fall/release the other in the spring).

The desktop vastly suffered because of this, and we felt that Lion and later were more or less “phone it in” releases for the desktop.

The comments from Apple insiders underscore that there are many factors that affect software quality. It is not simply a matter of dropping the yearly schedule or of deciding to do “another Snow Leopard.” The development schedule and cycles matter. It also matters who the engineers and managers are, how they are treated, whether they are shuffled between projects, etc.

There was a lot of resentment because when the initial iPhone came out, almost no one on the second floor of IL2 was allowed to look at the internal SDKs; even after the SDKs were finally released (a lot of Apple engineers by that point were on the “iPhone Dev Team”, and compiling their own apps for jailbroken phones, providing compiler and assembler fixed, and so on).

Then we had to wait 6 months after they started external classes before we were allowed on the platform, or in the classes. We all suspected that that was because there was incredible demand for iPhone programmers, and we’d get hired away from working on boring old crap like Finder and Mail and AddressBook, because Apple couldn’t hire people willing to work on boring crap any more.

This reminds me of three things:

Wednesday, January 21, 2015 [Tweets] [Favorites]


Peter Cohen:

But the real problems with MacKeeper that I can see is that it provides questionable value to most users, can destabilize an otherwise stable Mac, and embeds itself so thoroughly into the operating system that removing it is an uncomfortable and weird process.

Update (2015-05-06): Jeremy Kirk:

MacKeeper, a utility and security program for Apple computers, celebrated its fifth birthday in April. But its gift to U.S. consumers who bought the application may be a slice of a $2 million class-action settlement.

Update (2015-05-09): Thomas Reed:

In non-tech-speak, a hacker can create a link that will, if clicked, result in MacKeeper executing code embedded within the link! Such code could do things like wiping your hard drive clean, uploading data to a remote server, or downloading and installing malware.

Update (2015-08-21): Shawn King:

Half a million US customers are eligible to get at least some money back. If you know anyone who bought this crapware, please let them know about this settlement.

Tuesday, January 20, 2015 [Tweets] [Favorites]

WKWebView, Sandboxing, and Searching

Brent Simmons:

But the new replacement for WebView — WKWebView — doesn’t have this bug. Which is great. Let’s adopt the new thing! I’m all in. Love new things.


I did some research, and I learned that WKWebView won’t show local content — that is, files that are loaded from the app’s bundle. Files from the app bundle ought to be a-okay, ought not be a sandbox violation, but apparently they are.


In an ideal world, WKWebView would work with files from the app bundle, and, as a replacement for WebView, it would have the same functionality as WebView (a searchFor or equivalent method). Anything else means running as fast as I can while I slip backwards.

Update (2015-01-21): Chromium (via Martin Schurrer):

Unfortunately, despite the advantages of WKWebView, it has some significant technical limitations that UIWebView does not, which means we can’t simply drop it in as a replacement.

Update (2015-01-24): Dan Fabulich:

There is a workaround, demonstrated by shazron here to copy files into /tmp and load them from there.

Update (2015-04-23): The bug is still present in iOS 8.4b1.

Backing Up Discontinued Apps

Electronic Arts (via John Gordon):

EA is removing several of its older titles from the App Store, but if you already own these games, you will still be able to play them without interruption.

As always, we encourage our players to back up their app purchases in iCloud. If you uninstall the app without backing it up on iCloud or iTunes, you may not be able to redownload your game.

My understanding is that iCloud only backs up App Data. So if you want to restore an app that has been removed from the store you would need to have a backup in iTunes. And that app will probably never work with Family Sharing.

The Shape of the App Store

Charles Perry (tweet):

I expected a “hockey stick” curve that’s characteristic of power law models, but I didn’t expect one like this. The hockey stick breaks upwards at around position 870 on the U.S. Top Grossing list. With about 1.2 million apps in the App Store at the time the data was collected, that arguably puts 99.93% of apps in the “long tail” of the App Store. The “head” of the App Store, those 870 top grossing apps that make up 0.07% of the App Store population, collect over 40% of the App Store revenue that’s paid out.

Luckily, there’s a lot of money to be made in that long tail. At the top of the long tail, in position 871 on the U.S. Top Grossing list, an app still makes over $700 in revenue per day. That’s almost $260,000 per year. Even number 1,908 on the U.S. Top Grossing list makes over $100,000 per year.

His chart is based on the sales data from Marco Arment.

Filip Radelić:

Seems like a very optimistic approximation. I’ve seen apps around top 870 grossing with much, much less than $700/day.

Charles Perry (tweet):

I’ve gotten some feedback from readers asking how valid my extrapolated data is. Some have pointed out that I’m working with a limited data set from only one app that might not hold for all apps.


While the the exact revenue figures that I cited in The Shape of the App Store may be off little, it seems likely that they are at least in the right ballpark. They may even be somewhat conservative estimates if Manual’s revenue figures are to be believed.


Nate Cook:

We can easily access any values we’ve created in our context using subscript notation on both JSContext and JSValue instances. JSContext requires a string subscript, while JSValue allows either string or integer subscripts for delving down into objects and arrays:

Swift doesn’t support the subscript notation, though.

With a JSValue that wraps a JavaScript function, we can call that function directly from our Objective-C/Swift code using Foundation types as parameters. Once again, JavaScriptCore handles the bridging without any trouble[…]


There are two main ways of giving a JSContext access to our native client code: blocks and the JSExport protocol.


Since blocks can capture references to variables and JSContexts maintain strong references to all their variables, some care needs to be taken to avoid strong reference cycles. Avoid capturing your JSContext or any JSValues inside a block. Instead, use [JSContext currentContext] to get the current context and pass any values you need as parameters.

Monday, January 19, 2015 [Tweets] [Favorites]

Clearing the Icon Services Cache in Yosemite

Craig Hockenberry:

If you’re seeing any weird behavior with icons in Yosemite, the chances are good that the Icon Services cache is corrupted and needs to be reset. Here’s how you do it using the Terminal[…]

He’s right that Apple should have a built-in command for doing this. Icon cache problems have plagued Mac OS X for a long time, and the precise way to reset the cache keeps changing.

Kindling Projects

Ned Batchelder:

New programmers often need small projects to work on as they hone their skills. Exercises in courses are too small, and don’t leave much room for self-direction or extending to follow the interests of the student. “Real” projects, either in the open-source world or at work, tend to be overwhelming and come with real-world constraints that prevent experimentation and pure coding practice.

Kindling projects are meant to fill this gap: simple enough that a new learner can take them on, but with possibilities for extension and creativity. Large enough that there isn’t one right answer, but designed to be hacked on by a learner simply to flex their muscles.

Update (2015-01-20): Tim Schmitz:

Ned is mostly talking about new programmers, but this is quite similar to what I had in mind when I started my current app project. The idea was to get some experience working with Swift as well as a few other technologies that I haven't worked with extensively in the past. Even though I'm not new to programming, we're all relatively new to Swift.

Sunday, January 18, 2015 [Tweets] [Favorites]

MacUser UK Closes

Dennis Publishing (via Charles Arthur):

Since its launch in 1985 MacUser has provided its readers with authoritative buying advice, world exclusive reviews, breaking news and practical features. Inspired by the late Felix Dennis’ purchase of an Apple Lisa in 1983, the magazine started life as a bi-monthly magazine but soon upped its frequency to fortnightly as readers and advertisers poured in. The magazine was launched in the USA in 1985 where similar success followed.


The decision to cease publication of MacUser was very tough and one that was not taken lightly. Unfortunately, due to challenging market conditions, the closure was unavoidable.

It’s a tough business.

Update (2015-01-20): There’s also a blog post (via John Gruber).

Matt Gemmell:

It was from MacUser that, variously and over the years, I developed an interest in typography, colour theory, video editing, and a host of other subjects. I’ve been a subscriber, a reader, and even a contributor, and the closing of the magazine is a great loss to the Mac community.

Update (2015-02-01): Also closing are AOL’s TUAW and Mac+, Brazil’s only Apple print magazine.

MMWormhole: Message Passing Between iOS Apps and Extensions

MMWormhole (via Marco Arment):

MMWormhole creates a bridge between an iOS extension and its containing application. The wormhole is meant to be used to pass data or commands back and forth between the two locations. Messages are archived to files which are written to the application’s shared App Group. The effect closely resembles interprocess communication between the app and the extension, though true interprocess communication does not exist between extensions and containing apps.

The wormhole also supports CFNotificationCenter Darwin Notifications in an effort to support realtime change notifications. When a message is passed to the wormhole, interested parties can listen and be notified of these changes on either side of the wormhole. The effect is nearly instant updates on either side when a message is sent through the wormhole.

See also: iOS IPC via NSFileCoordinator and NSFilePresenter.

How Amazon Tricks You Into Thinking It Always Has the Lowest Prices

Jason Del Rey (via Hacker News):

In one example, Boomerang observed Amazon testing price reductions on a $350 Samsung TV — one of the most popular TVs on Amazon — over the six months leading up to Black Friday. Then, on Black Friday, it dropped the price to $250, coming in well below competitors’ prices.

But when it comes to the HD cables that customers often buy with a new TV, Amazon actually pushed up the price by 33 percent ahead of the holidays.


“Amazon may not actually be the lowest-priced seller of a particular product in any given season,” the report reads, “but its consistently low prices on the highest-viewed and best-selling items drive a perception among consumers that Amazon has the best prices overall — even better than Walmart.”

Yosemite’s FileVault 2 Pre-boot Recovery Options

Rich Trouton (tweet):

One of the changes that Apple has introduced with Yosemite is a more straightforward way to recover from login problems at the FileVault 2 pre-boot login screen.


In the Reset Password wizard, there are currently three options available.

  1. I forgot my password
  2. My password doesn’t work when logging in
  3. My keyboard isn’t working when typing my password to login

Saturday, January 17, 2015 [Tweets] [Favorites]

Vintage Mac About Boxes

Riccardo Mori:

I started going through them one by one (the applications, at least; the games are more than 200!), and invoking their About boxes to find out exactly which version they were. I found some very old versions of popular applications and — equally interesting — there were also not-so-old versions of popular applications but in French and even German. I thought this exploration was worth capturing, so I took a few screenshots. Here’s a selection of the most interesting findings.

100 Years of Computer Science

Chris Ford (via Ole Begemann):

I came to appreciate academic papers relatively late. While a student, I can only specifically remember reading two papers, one of which (by Claude Shannon) appears below. As a professional programmer without a strong theoretical background, papers seemed difficult and unapproachable, and it took me a long time to realise what I’d been missing.

Some colleagues, responding to my new-found enthusiasm, asked me for recommendations on where to start. Inspired by similar lists by Michaels Feathers and Fogus, I’ve compiled a timeline of papers that (for me) represent something of the spirit of the development of computer science over the past 100 years.

He chose one paper from each decade.

Mergeable Persistent Data Structures

Benjamin Farinier et. al. (PDF) (via Adrian Colyer):

Distributed version-control systems (DVCSs) are widely used to manage the source code of software projects. These systems are at the core of any workflows to produce and maintain large software stacks that involve many branches of development and maturity. DVCSs are used to keep track of change provenance and help to relate newly discovered bugs in the software to the context of the modification of the source-code which caused it.

We wish to see the same kind of workflow applied to data as well as source code. What if you could version-control a (mutable) persistent data structure, inspect its history, clone a remote state and revert it to a previous state? We find that using the existing tools around source-code DVCS and applying them to application data results in significant benefits to developing distributed applications. Instead of structuring our system like a conventional database, we instead provide the functionality as a library that can be linked and customised directly by the application logic.

Real World Swift

Chris Surowiec (via iOS Dev Weekly):

Our biggest gripe – and source of frustration – with Swift is probably not the language itself, but the tooling around it. Xcode (Apple’s Objective-C and Swift IDE) does not yet feel solid with Swift code. During development of our app, the IDE would often slow down noticeably or crash. There was no (or very slow) code completion most of the time, basically no debugger, unstable and unreliable syntax highlighting, a slow text editor (once the project reached a certain size), and no refactoring tools.

Additionally, compiler errors are often incomprehensible and there are still quite a few compiler bugs and missing features (e.g. type inference sometimes goes awry).


The number one crash group (at ~30% of all crashes) comes from an external Objective-C library. In fact, four of the top five crash groups come from Objective-C land (the fifth being a failing assert, which we leave enabled in production builds).

Also of note, the seventh most common crash comes from the previously mentioned Apple-provided Objective-C function that will sometimes @throw exceptions without being documented as such (-[AVAssetWriterInputHelper markAsFinished]).


You can certainly tell that some of Xcode’s features become slower and slower as your project grows, and we are not the only ones noticing. Iteration time (the time it takes after making a code change, hitting CMD+R, and having your app run in the simulator) is also worse than in Objective-C. A quick test shows that adding a single line brings the wait up to 14 seconds, and this varies greatly depending on what you do. Making a similar change in our Objective-C based app takes about two to three seconds.

iOS App Sales Data

Dan Gray shares the sales numbers for the Monument Valley (App Store) game.

Marco Arment (tweet) shares the numbers for his Overcast (App Store) podcast client.

William Wilkinson (tweet) shares the numbers for his Manual (App Store) camera app.

Skip the FFI: Embedding Clang for C Interoperability

Jordan Rose:

Most languages that aren’t a superset of C provide a Foreign Function Interface (FFI) that allows one to interface with existing C libraries. FFIs are often an afterthought, requiring manual or source-to-source translation from C header files to a subset of the target language, resulting in complicated build processes, frequent manual tweaking, and numerous implementation challenges.

This talk will discuss an alternative approach that embeds Clang into an LLVM-based compiler front end to provide C compatibility without the traditional FFI. Embedding Clang provides seamless access to C APIs, moving the translation of APIs from external tools into the compiler itself. Moreover, one can leverage Clang’s deep knowledge of C record layout and calling conventions to simplify the C interface and make both bring up and porting of a new compiler front end simpler.

The Stunning Scale of AWS

Todd Hoff (via Steven Sinofsky, comments):

All 14 other cloud providers combined have 1/5th the aggregate capacity of AWS (estimate by Gartner in 2013)


The cost of networking is escalating relative the cost of all other equipment. It’s anti-Moore’s law. All other gear is going down in cost, networking is getting relatively more expensive over time. Relative monthly costs: servers: 57%; networking equipment: 8%; power distribution and cooling: 18%; power: 13%; other: 4%.


Amazon’s solution 5 years ago was data driven and radical: they built to their own networking designs. Special routers were built. A team was hired to build the protocol stack all the way to the top. And they deployed all this themselves in their network. All services worldwide run on this gear. […] source of the improvement was simplicity. The problem AWS was trying to solve was simpler than the problem enterprise gear tries to solve. Enterprise gear must adhere to a lot of complicated specs that go unused and only make the system more fragile. By implementing just the functionality that was required meant a much simpler system which lead to higher availability.

Something Slightly Less Terrible

Loren Brichter:

It’s not like a boat with a couple of holes that we can patch; it’s more like trying to sail across an ocean on a pile of accrued garbage. Sure, some of the stuff floats, and it keeps some other stuff from sinking. A better question might be: which parts are good? And you can only answer that if you look at a thing in isolation. Like, I could say that Rust is good. But even that enshrines the Von Neumann philosophy, and so you can crawl your way down the stack questioning everything, which isn’t practical.


Personally, I’m tired of the trivial app stuff, and the App Store isn’t conducive to anything more interesting. I think the next big thing in software will happen outside of it.

Video and iOS Rotation Lock

Tim Schmitz:

In fact, I leave auto-rotation enabled for one simple reason: video. Most video fits far better in landscape orientation than in portrait. The iPhone's screen is perfectly shaped for wide-aspect video in landscape. Unfortunately for me, iOS won't rotate video into landscape orientation unless it can rotate the whole OS into landscape. Put another way, if I use rotation lock to keep the phone in portrait orientation, that applies to video as well. That means video gets letterboxed into a postage stamp-sized area in the center of my screen.

I wish it would show video in landscape and everything else in portrait.

Update (2015-01-25): Garrett Murray:

There are, however, two cases in which I want the option to use landscape mode: playing games and watching video. Tim’s suggestion of video ignoring rotation lock would be perfect (applied to games as well, obviously). If I had my way, I’d remove landscape from iPhone in iOS entirely but for these two scenarios.

Wednesday, January 14, 2015 [Tweets] [Favorites]

Swiftifying Apple’s Framework APIs

Mattt Thompson:

And yet, after just a few months of working with Swift, Cocoa has begun to lose its luster. We all saw Swift as the beginning of the end for Objective-C, but Cocoa? (It wouldn’t be the first time an Apple standard library would be made obsolete. Remember Carbon?)

Andy Matuschak:

I don’t actually have insider knowledge here, so this is just speculation, but I think it will be a long process. At least when I was there, the teams spent the majority of their time not maintaining and improving frameworks, but really supporting market features like new screen sizes or support for new hardware. That’s what takes most of the time. So it will take a conscious decision to do anything non-trivial, and I don’t see that forthcoming.

Cocoa Thread Utilities

Todd Ditchendorf’s Cocoa Thread Utilities offers semaphores, bounded buffers, synchronous channels, thresholds, and triggers.

Switching From Core Data to Realm

Tim Oliver (tweet):

Tim Oliver, creator of the iComics app, gave a talk featuring Realm in his project at the Perth iOS Meetup. His talk covered gave a quick background of his transition to and experiences using Realm in place of Core Data, a switch he made in just one evening.


When I was working on iComics, I’d have problems when a background thread would import a comic, tell the main thread the comic imported, then send an object with entirely empty fields. When I tested installing a new version of the app over an older version, I found that Core Data’s auto-migration was corrupting half the database and making the app very unstable. A manual Core Data migration would have required a ridiculous amount of code, and I decided to switch to Realm.

Siri Improvements

John Gruber:

I’ve noticed over the past year that Siri is getting faster — both at parsing spoken input and returning results. I use iOS’s voice-to-text dictation feature on a near-daily basis, and it’s especially noticeable there.

Mostly what I have noticed is that Siri is a lot more reliable than it used to be. I had stopped using it because for years it would essentially throw away what I’d said. It was either unavailable (most of the time) or it didn’t understand me properly (less often). Now I regularly use it to make reminders while driving, and it pretty much always works.

Update (2015-01-17): Garrett Murray:

Watching Siri translate word-for-word as you speak give you the confidence to keep speaking and also makes it clear the moment she loses you. It completely changes the feature from “interesting tech demo” to “I’ll use this on a daily basis”.

Tuesday, January 13, 2015 [Tweets] [Favorites]

Dependent Key Paths

Jonathon Mah:

If user defaults can change separately from this code (and you should probably assume it can), providing correct KVO change notifications can be accomplished by having the singleton observe NSUserDefaults with NSKeyValueObservingOptionPrior; posting willChangeValueForKey:@"mySetting" on the prior callback and didChangeValueForKey:@"mySetting" on the post callback. But this sucks — it’s wordy and you pay a (small) performance cost even if mySetting isn’t observed.


It’s valid for dependencies to be specified in either the dispatching or specific methods, all the way up the inheritance chain. Correctly overriding +keyPathsForValuesAffectingValueForKey: requires some tricky code, which I’ve wrapped in a function MLHOverrideKeyPathsForValueAffectingKey in MyLilKeyPathHelpers.

Proof in Functions

Brandon Williams (tweet):

Swift’s generic functions allow us to explore a beautiful idea that straddles the line between mathematics and computer science. If you write down and implement a function using only generic data types, there is a corresponding mathematical theorem that you have proven true. There are a lot of pieces to that statement, but by the end of this short article you will understand what that means, and we will have constructed a computer proof of De Morgan’s law.


The rigorous statement of the relationship we have been grasping at is known as the Curry-Howard correspondence, first observed by the mathematician Haskell Curry in 1934 and later finished by logician William Howard in 1969. It sets up a kind of dictionary mapping terms in the computer science world to terms in the mathematics world.

Update (2015-01-24): [Solutions to Exercises] “Proof in Functions”.

BBEdit Codeless Language Module for .pbxproj Files

Aidan Dysart (via @bbedit_hints):

This is a BBEdit Codeless Language Module for Xcode project files. It provides some amount of syntax highlighting and code folding for project.pbxproj files inside .xcodeproj file bundles. It also works with TextWrangler.

I end up having to directly view and edit these files more than I’d like. The CLM seems to work pretty well.

The Morning Paper

Adrian Colyer’s The Morning Paper highlights “an interesting/influential/important paper from the world of CS every weekday morning” (via Edge Cases).

Functor and Monad in Swift

Javier Soto:

We’ve seen what map can do when implemented on a container type, like Optional, Array or Result. To recap, it allows us to get a new container, where the value(s) wrapped inside are transformed according to a function. So what’s a Functor you may ask? A Functor is any type that implements map. That’s the whole story.


In the earlier example, we used the transformation function to return another value, but what if we wanted to use it to return a new Result object? Put another way, what if the transformation operation that we’re passing to map can fail with an error as well?


And with that, we turned our Result type into a Monad! A Monad is a type of Functor. A type which, along with map, implements a flatMap function (sometimes also known as bind) with a signature similar to the one we’ve seen here.

Old MS-DOS Games

The Internet Archive:

Software for MS-DOS machines that represent entertainment and games. The collection includes action, strategy, adventure and other unique genres of game and entertainment software. Through the use of the EM-DOSBOX in-browser emulator, these programs are bootable and playable.

There is a 1990 version of The Oregon Trail that is text-based and reminds me of the Apple II version. There is also a 1992 version that has Mac-like fonts and widgets.

Why DNS in OS X 10.10 Is Broken

Iljitsch van Beijnum:

For 12 years, the mDNSResponder service managed a surprisingly large part of our Mac’s networking, and it managed this task well. But as of OS X 10.10, the mDNSResponder has been replaced with discoveryd, which does the same thing. Mostly. Here are some strange networking problems we’ve observed since installing 10.10[…]


If discoveryd isn’t doing its job properly, sometimes it helps to restart it. However, even this doesn’t always work, and restarting discoveryd gets old fast. If you’re not scared of a little command line hacking, there’s a better solution: you can reinstall the OS X 10.9 mDNSResponder on a 10.10 system. And after that, all the problems listed above magically go away.

I wouldn’t do that; go back to a full 10.9 system if 10.1 isn’t working for you.

Update (2015-01-13): Paul Horowitz on “How to Flush DNS Cache in OS X Yosemite with discoveryutil”.

Update (2015-03-31): Craig Hockenberry:

Why isn’t there a tech note about all of these DNS issues in Yosemite? Does Apple not care? Or do they not know?

Chris Parker:

It’s known. And the teams care. Don’t know why there isn’t a reunite though.

Craig Hockenberry:

There are A LOT of people burning A LOT of cycles on this stuff. Communication would go a long way…

Using HSTS to Track Incognito Users

Sam Greenhalgh (via Yan⚠):

A security feature of modern web browsers called “HTTP Strict Transport Security” (HSTS) allows a website to indicate that it should always be accessed using a secure connection. If you visit a site that has HSTS enabled, your web browser will remember this flag and ensure the connection is secure any time you visit the website in the future. Subsequent visits to the site without using a secure connection get automatically redirected by the web browser to the secure variant of the web address, beginning https://

This automatic redirecting protects your access to the site from being intercepted but could also be abused by a malicious site to store a unique number to track your web browser. A number can be encoded as a series of bits (true and false values) and stored by accessing a set of web addresses. Each web address responds with HSTS enabled or disabled depending on the address. Once the number is stored it could be read by other sites in the future. Reading the number just requires testing if requests for the same web addresses are redirected or not.


However, unlike cookies, existing HSTS flags are still shared with sites when using “incognito” or “private” windows. The impact is that it’s possible for a site to track you even if you choose to use “incognito” or “private” browsing features in an effort to avoid such tracking.

Considerably more worrying is the behavior displayed by Safari, the default browser for iPad and iPhone. When using Safari on an Apple device there appears to be no way that HSTS flags can be cleared by the user. HSTS flags are even synced with the iCloud service so they will be restored if the device is wiped. In this case the device can effectively be “branded” with an indelible tracking value that you have no way of removing.

Hubble Space Telescope Desktop Pictures

Rob Griffiths:

Last week, I used the just-released Hubble Space Telescope images of the Andromeda galaxy to create a couple of desktop images for my Retina iMac. I liked the results so much that I spent some time collecting other suitable images from the Hubble site, and then cropping and/or scaling them to create interesting high-res desktop images. (I used Acorn for all the edits; it had no troubles, even with TIF images as large as 20,323×16,259!)

Undefined Behavior in C

Mike Ash (via Daniel Jalkut):

It’s possible to invoke undefined behavior in your function. Undefined behavior can mean something never terminates. Thus, it’s possible for your function to never terminate.

If you don’t believe me, I pose the following challenge: give me an implementation of this function. I will then provide a chunk of code that calls it and causes it to enter an infinite loop.

Ember and iCloud Core Data

Dan Counsell:

One of the biggest challenges we faced last year with Ember was sync. Once you start using Ember, it’s incredibly easy to build up a substantial library - and customers upgrading from LittleSnapper have sometimes many thousands more images imported! Multi-gigabyte libraries are not uncommon, and combined with (in particular) iCloud customers have found sync to be problematic. It especially doesn’t help that iCloud is a very hard-to-inspect black box, and there’s no progress shown to you as to the uploaded (or not) state of your library. It’s tough to say it, as iCloud’s robustness has continued to improve each year, but right now iCloud isn‘t a good fit for apps like Ember, and our future product direction will reflect that.

Last year they were optimistic that iCloud Core Data would improve. Now—three plus years after iCloud Core Data shipped—it sounds like they are giving up on it.

Wikipedia Adopts HHVM


Cunningham named his software after a Hawaiian word for “quick.” That’s why the Wikimedia Foundation is happy to report that editing Wikipedia is now twice as quick. Over the last six months we deployed a new technology that speeds up MediaWiki, Wikipedia’s underlying PHP-based code. HipHop Virtual Machine, or HHVM, reduces the median page-saving time for editors from about 7.5 seconds to 2.5 seconds, and the mean page-saving time from about 6 to 3 seconds. Below, I’ll explain the technical background for HHVM on MediaWiki and some of the far-reaching benefits of this change that will go beyond the recent performance gains.


Resolving fidelity issues required some effort, but it turned out well. After we had already been working on the conversion for several months, Facebook approached us offering to donate some developer time to help with this task.

Marco Arment:

A large investment in HHVM or Hack today seems to be worthwhile only if you’re paying much more for PHP CPU usage than engineering salaries, you have a lot of unused engineering capacity to migrate to and maintain the new setup (which takes more effort than official PHP because it’s so bleeding-edge), and your codebase is so large that it’s infeasible to start migrating away from PHP.

Monday, January 12, 2015 [Tweets] [Favorites]

Spotlight Suggestions and Web Bugs

Dan Goodin:

Using the Spotlight search feature in OS X Yosemite can leak IP addresses and private details to spammers and other e-mail-based scammers, according to tests independently performed by two news outlets.


Mail allows users to block remote images for precisely this reason. But even when remote image viewing is disabled in Yosemite-based Mail app settings, the images will be opened by Spotlight, according to two recent media reports. The feature is used to search a Mac for files or e-mail containing a specified search term. When spotlight returns a preview of e-mails containing the term, it loads the images, overriding the option. Images are loaded even when the previewed message has landed in a users’ junk mail folder.

Rene Ritchie:

As described above, email can be turned into a pseudo webpage by requesting server-side images — including tracking pixels — be loaded into them. Instead of attaching an image, which embeds the image in the email, they pull it from a website: If “load remote content” is enabled, that image will be pulled as soon as you open the email, and the website will get your IP address and other information just as if you visited the site directly.

As I recall, the same bug has always been present in Quick Look. Quick Look thumbnails seemingly try to load the images but are thwarted by the sandbox. Quick Look previews load the images regardless of the setting in Mail.

See also: Spotlight Suggestions and Privacy and SpamSieve’s documentation on Web bugs.

Using the Hypervisor Framework: A Simple DOS Emulator

Michael Steil:

Since Version 10.10 (Yosemite), OS X contains Hypervisor.framework, which provides a thin user mode abstraction of the Intel VT features. It enables apps to use virtualization without the need of a kernel extension (KEXT) – which makes them compatible with the OS X App Store guidelines.


There is no real documentation, but the headers contain a decent amount of information. […] So let’s create a virtual machine that runs simple DOS applications in 16 bit real mode, and trap all “int” DOS system calls – similar to DOSBox.

Apple Introduces App Store Refunds

Jordan Kahn (via Rosyna Keller):

Apple has recently introduced a new 14-day no questions asked return policy for iTunes, App Store and iBooks purchases in Europe including the UK, Germany, Italy, France, and many other EU countries.

Apple’s terms and conditions for the stores previously stated users had the right to withdraw from a transaction “without charge and without giving any reason until delivery of the product has started.” That meant purchases were all but final apart from some exceptions handled by Apple support.

Now, Apple has updated its terms to include a specific no questions asked 14-day return window that includes all purchases apart from gift cards.

The menu item in question does not seem to be available in the US store. But it seems that EU customers now have a limited form of trials. With a normal refund, the customer will get the money back, but Apple will keep its 30%, so the developer ends up in the red. It’s not clear to me whether this is also true of purchases canceled in this manner.

Update (2015-01-12): Rosyna Keller:

So it appears Apple does detect abusers of their new 14-day return policy for digital items and revokes the ability.

Update (2015-01-17): Dave Mark has more on how Apple doesn’t want people to use the refunds for trials.

Overcast Rejected for Listing Competing Podcast Apps

Marco Arment:

Well, Overcast linking to competing apps is over. I knew it would get rejected eventually.

I always knew the feature was living on the edge of this rule’s interpretation.

This is what the list in question looked like. I think it was genuinely useful.

Overcast was rejected for violating Rule 2.25:

Apps that display Apps other than your own for purchase or promotion in a manner similar to or confusing with the App Store will be rejected

There is also Rule 2.26:

Apps may display and recommend apps other than your own only if the collection is designed for a specific approved need (e.g. health management, aviation, accessibility, etc.) or provides significant added value for a specific group of customers, or they will be rejected

He’s not going to appeal the rejection, though:

I might “win” on appeal, but it would always be a risk for future updates, and it’s simply not worth delaying bugfixes any further.

Update (2015-01-18): Kirk McElhearn:

This is pretty surprising. I don’t see why Apple would not allow a developer to link to other apps; I’m pretty sure I’ve seen apps that try and get you to buy other apps by the same developer. The only difference here is that Arment was helping you find the best podcast app for you by sharing links to apps that aren’t his.

GoodReader and iCloud Drive

Fraser Speirs:

I can’t even compose a coherent tweet about iCloud Drive any more.

Richard Padilla:

PDF reader app GoodReader has removed a number of operations related to iCloud Drive to comply with Apple’s guidelines. Specifically, developer Good.iWare has disabled GoodReader’s ability to create and delete new folders inside iCloud along with the ability to move iCloud files. The developer called the iCloud usage policy “mandatory” and also included VoiceOver compatibility along with a big fix for opening iCloud containers.


Apple has quickly reconsidered its decision and allowed GoodReader to restore iCloud Drive functionality with version 4.8.1.

As with the Transmit case, I don’t think there was ever a written guidelines that was being violated.


Norihiro Sakamoto’s SwiftFilePath provides Path objects with methods for functionality from NSFileManager (via Swift Toolbox). I’ve long used a similar pattern, creating Objective-C categories on NSString and then NSURL. The idea potentially works even better in Swift, although Sakamoto’s code regrettably converts all the NSError objects to strings.

Does Using Swift Save Development Time?

Paul Haddad:

For developers that jumped head long into Swift how much time have you saved coding vs. lost fighting with tools, learning, bugs?

This got some interesting responses on Twitter.

Lenient Date Parsing

Mike Abdullah:

As far as I can see, [NSDateFormatter.lenient] doesn’t support anything like the range of the older APIs. Indeed as best I can tell the leniency only comes into play as far as separator characters are concerned. So for example, if dates are expected to be in the format YYYY/MM/DD, then strings of the form YYYY-MM-DD will also be accepted. But that’s about it.

NSDataDetector is a possible solution.

Finite States of America

Soroush Khanlou:

The benefits of using state machines are myriad. First, explicitly storing the states and transitions that are valid in your system leaves fewer nooks and crannies for bugs to hide out in. It is said that bugs are just states that you haven’t defined yet. If your object is defined by four booleans, it can be in 16 different states, all of which require testing. Imagine how many states it can have with integers, or strings! A state machine limits the number of possible configurations your object can be in, and defines them formally.

Having all of the transitions in one place will help you see the user’s flow through the system. What happens if this step takes longer than expected? Clearly-defined transitions make it painfully obvious what happens if an event happens out of order. Since every transition flows through one point, it is trivial to log all of the transitions. You can use that information to determine how your object went off the rails.

Update (2015-01-13): Soroush Khanlou:

As awesome as state machines are, they can often be very high-ceremony to set up. A typical Objective-C library requires a lot of code to set up. I wanted to explore combining a few techniques from the this blog to try and make a low-ceremony state machine, one that doesn’t require setting up all of your states, transitions, and events ahead of time.

Lowering the Project Threshold

Tyler Hall:

One part of GTD and OmniFocus that I’ve always struggled with is the idea that any action that requires more than one step is actually a project. It sounds simple, and I agree with that definition in theory, but I’ve never followed through in practice. My OmniFocus project list has always been relatively sparse – really just containing my three areas of focus each with 5-10 medium-to-big-sized projects plus a catch-all single action list for miscellaneous tasks.

The problem with this approach is that it’s stopped me from adding piddly, little multi-step tasks to OmniFocus because I don’t believe they count as a captial-letter PROJECT, and they don’t fit into my single-action lists. Instead, they stay in my brain, forgotten or causing anxiety.

Thursday, January 8, 2015 [Tweets] [Favorites]

We Love This Stuff Too, and Honor What You Do

Brenden Mulligan:

Our iOS app was rejected from the App Store because a support link goes to a web based FAQ where we mention having an Android app available.

App Store Review Guidelines:

Lastly, we love this stuff too, and honor what you do. We’re really trying our best to create the best platform in the world for you to express your talents and make a living too. If it sounds like we’re control freaks, well, maybe it’s because we’re so committed to our users and making sure they have a quality experience with our products. Just like almost all of you are, too.


3.1 Apps or metadata that mentions the name of any other mobile platform will be rejected

Update (2015-01-10): Tyler Hall:

My iOS app was rejected because I linked to an FAQ which had a header which linked to my site which had a non-MAS OS X App.

Update (2016-04-20): Avatron:

Air Display 3 Upgrade submission rejected AGAIN for “mentioning third-party platforms.” This said, “Only compatible with Mac-based hosts.”

Tuesday, January 6, 2015 [Tweets] [Favorites]

The 2014 Panic Report

Cabel Sasser:

My gut says no, that full price every single time is rough, but then we’re setting the precedent that maybe not all of our major upgrades are paid upgrades, which we’ve been pretty consistent about in the past. If we could offer traditional discounted upgrades via the App Store, this paragraph wouldn’t exist. This is one area where the App Store feels like one of those novelty peanut cans with the snake inside.


To be honest, I was pretty nervous to be pulling Coda from the Mac App Store. But when we finally did it, I felt an incredible, almost indescribable sense of relief — mostly because as we began to wrap up bug fix releases, we were able to immediately post them to our customers within minutes of qualifying them. My god. That’s how it should be. There’s just no other way to put it — that’s how you treat your customers well, by reacting quickly and having total control over your destiny. To not be beholden to someone else to do our job feels just fantastic. (Also to not pay someone 30% in exchange for frequent stress is a fine deal.)


The results were interesting. We sold a couple hundred fewer units of Coda post-App Store removal, but revenue from it went up by about 44%.


I can’t comfortably say “the system worked”. It’s still an awful and nerve-wracking feeling to know that, at any minute, we could get thrown into a quagmire of e-mails, phone calls, code removal, and sadness, just by trying to ship something cool.

There’s a little more history here than I’m letting on. We had a very long, very torturous situation with Status Board almost being pulled that we’ve never written up out of sensitivity to our relationship with Apple. I only mention it here because it proves that it is possible to fix these awkward rejection situations without Apple suffering negative PR in the public eye — we did that “offline”. But it took an absolutely massive amount of mental energy and time to work through — positively Sisyphean. I would never want to do it again — I’ve run out of patience, I guess. I can say for certain that the “bad PR” version of the app dispute process is monumentally more effective. Which is a shame.


This is the biggest problem we’ve been grappling with all year: we simply don’t make enough money from our iOS apps. We’re building apps that are, if I may say so, world-class and desktop-quality. They are packed with features, they look stunning, we offer excellent support for them, and development is constant. I’m deeply proud of our iOS apps. But… they’re hard to justify working on.

First, what a great piece of writing this post is. Second, Panic’s low iOS revenue is a terrible indicator for the health of the platform. If top-quality apps, a solid customer base and brand, and marketing support from Apple aren’t enough, what does one need to succeed? Apple clearly likes Panic-style apps, so you would think it would try to encourage their development. Instead, Apple has designed the App Store to do pretty much the opposite. Why? This strategy seems to make no long-term sense unless one believes that quality apps don’t matter.

Milen Dzhumerov:

It escapes my mind why a premium hardware company would want to run a software store that’s equivalent to a dollar shop (or worse). Yes, people will buy phones because there’s tons of free apps but we’re slowly reaching a point (or already there) where the quality of those apps is so bad, that all other platforms have them as well. The number of apps is no longer a competitive advantage like it used to be in 2008. In the long term, it wouldn’t matter what phone you buy, if all the software is available on all mobile OSes.

Due to the un-sustainability of the App Store policies, the premium software that will keep people in the iOS ecosystem just won’t get built - that’s a recipe for disaster. Just look at the Panic 2014 report (and multitude other reports as well). It’s precisely those developers that have built the ecosystem, have been innovating and creating superb 3rd party software and have been advocating Apple products for decades. And now Apple have turned their backs on them.

Update (2015-01-08): Wil Shipley has some suggestions for the App Store.

Apple’s Software Quality, Continued

Marco Arment (comments, follow-up) continues on the theme of my post from October:

Apple’s hardware today is amazing — it has never been better. But the software quality has fallen so much in the last few years that I’m deeply concerned for its future. I’m typing this on a computer whose existence I didn’t even think would be possible yet, but it runs an OS with embarrassing bugs and fundamental regressions. Just a few years ago, we would have relentlessly made fun of Windows users for these same bugs on their inferior OS, but we can’t talk anymore.


I suspect the rapid decline of Apple’s software is a sign that marketing is too high a priority at Apple today: having major new releases every year is clearly impossible for the engineering teams to keep up with while maintaining quality. Maybe it’s an engineering problem, but I suspect not — I doubt that any cohesive engineering team could keep up with these demands and maintain significantly higher quality.

A former Apple engineer:

With Bertrand, we would move in giant monolithic releases where every group would just dump in whatever they had ready and the whole thing would get released with nightly builds. With SnowLeopard in particular, I remember three dozen releases in a row where Xcode was unusable due to obj-c garbage collection issues. Random stuff you didn’t expect like CoreGraphics would have showstopper issues and then we’d report it and it would get fixed by the next week.

This resulted in extremely late releases that had a ton of bugs that we piled patches onto as time went on.

Craig moved the organization onto a sprint system, where we would develop new features for 2 weeks and then spend a week fixing bugs. After 10 or 12 or 16 of these cycles, we would deem it ready and ship it out.


What has changed is that releases and features happen more often. Tiger and Leopard had a good 2 years to mature and get patches while their delayed successors missed target dates. […] They felt stable because they were just old, sort of like Debian stable. Meanwhile, the development versions of Leopard and Snow Leopard (the two I spent most of my career at Apple developing) were downright horrible and unreleasable. […] It’s just that you remember them better because they had a longer history as a stable legacy OS than the modern versions.

[Update (2015-01-12): There are more comments about this change in development styles here.]

A current Apple engineer:

the sprint (milestone) development system is still in place... it’s not the problem though, it’s the problem is the focus on new useless [imo] features at the expense of core functionality and quality

Another former Apple engineer:

The good thing about the nightly builds was you didn’t have to use them, and people could respond quickly to showstoppers rather than wait for a sprint. There was a quicklook team to catch bugs which stopped nightly builds from release to general dev, and unless you really needed that build ( to test a new API) you didn’t install until quality was restored. The xCode bug was therefore unusual, as they could have fixed it the next day ( and with enough heat they would have).

With fortnightly builds which are only then released to Engineering, if that is now what is happening, there will be massive instability every 2 weeks, until the final round of bug fixing cycle stops all features being added.

Which can’t finish in time because the OS has to be released at an Apple event.

Geoff Wozniak (tweet, comments):

There are lots of other little things that irk me: mds being a hog, distnoted being a hog, lack of virtualization, other system services mysteriously Wring up, bogging the system down. It doesn’t help that the Macbook Pro I have is one of those lemons that overheats easily, thus kicking the fans into “rocket taking oX” mode. At this point, my default position on Apple software in OS X has moved from “probably good” to “probably not OK”. They seem more interested in pumping out quantity by way of more upgrades. It’s death by a thousand cuts, but it’s death nonetheless.

Daniel Jalkut:

The current state of Apple’s software does not particularly concern me. Are there embarrassing blemishes? Yes. Does the annual schedule for major OS updates seem rushed? Of course. Are there Apple employees in positions of power who do not share Marco’s and my enthusiasm for software that “just works?” I regret to surmise that, indeed, there are.


Over the years I have never been at a loss for identifying problems big and small with Apple’s products, or with the way it conducts its business. I’m sure I had plenty of complaints starting in 2002, but I didn’t start blogging in earnest until 2005. Here are some highlights to remind you that things have never been fine with Apple[…]

John Gruber:

Apple hasn’t (yet) lost any ground in the market, but they’ve created an opportunity for that to happen, because they’ve squandered a lot of trust with their users. It’s not that Apple has lost the “it just works” crown to a competitor, but rather that they’ve seeded a perception that Apple’s stuff doesn’t work, either.


Overall, Apple’s legendary stability and reliability have suffered some major blows.

For the time being, Mac OS X and iOS are effectively feature complete. The one thing we’ve repeatedly heard from users is a cry for stability. We’d like to see OS X 10.11 and iOS 9 be “Snow Leopard” updates that — just as 10.6 Snow Leopard did for 10.5 Leopard — remove cruft, clean up problems, and polish existing features so that we have a stable base going forward.

Dr. Drang channels Tim O’Reilly:

We are Apple’s best customers. By “we,” I don’t mean fanbloggers in particular, I mean power users in general. Those of us who learn the deep details of the software we use, or who write scripts and Automator actions to speed up our work. We’re not Apple’s best customers because we buy lots of Apple products (although some of us do). We’re its best customers because of our leverage.


Are you as enthusiastic about demonstrating recent versions of OS X as you were about Leopard? Have you avoided family members who keep asking you why their iPhones don’t have enough free space to install iOS 8? Do you think it might be better if your friends stick with Android because then you won’t feel responsible if some of their data doesn’t sync?

Casey Liss:

It was Apple that chose to establish this cadence, and chose to stick with it. Now, for better or worse, they may have backed themselves into a corner. When you’re that ox of a man standing in the boxing ring, the last thing you want to do is show weakness. To give the plucky little guy hope.

Lukas Mathis:

I get the same impression: Apple doesn’t see what’s happening.

It seems to me that the media covering Apple is partly to blame for this. There seem to be two main factions covering Apple: people who dislike Apple, and whose opinions can thus be disregarded. And people who like Apple, but would rather talk about how wrong the first faction is, and how badly Samsung and Google are doing, than discuss the problems Apple’s own products have.

Kirk McElhearn:

I no longer want to be the first to install an update to iOS or OS X, because I simply don’t trust that Apple will get it right.


Apple is losing its trust among long-term users. The company may be gaining plenty of new users, who, for now, are willing to accept this kind of problem, since they’re used to platforms where things may be even worse. But if Apple loses the loyalty of their oldest users, the company’s reputation will change from the company that we trusted, to just another computer and device manufacturer.


Neither I nor the many others who echoed his feelings did so because of any desire to trash Apple; it was rather because we are genuinely concerned that this company with which we have a long relationship is showing signs of decreasing quality in its software.

Guy English:

What I’d like to call out is this particular paragraph I’ve quoted. We don’t. We don’t. We need.

Marco may be passed off as a developer here and dismissed as expressing developer thoughts. The truth is, at least the truth I’ve known from supporting and dealing with people who aren’t technical who use these devices every single day — “we don’t” isn’t about developers.

Update (2015-01-06): Craig Hockenberry (tweet):

Our concerns come from seeing the start of something pernicious: our beloved platform is becoming harder to use because of a lot of small software failures.

It’s literally a death by a thousand tiny little cuts.

Apple may not be aware of the scope of these issues because many of these annoyances go unreported. I’m guilty of this when I open a Finder window on a network share. While the spinner in the window wastes my time, I think about writing a Radar, but a minute later it’s forgotten. Until the next time.


But I have a pretty simple metric for the current state of Apple’s software: prior to the release of Yosemite, I could go months between restarts (usually only to install updates.) Lately, I feel lucky to go a week without some kind of problem that requires a complete reset.


Every holiday season, my wife and I make sure that everyone’s computer is up-to-date and running smoothly. This year, for the first time ever, we didn’t install the latest version of OS X. The problems with Screen Sharing are especially problematic: it’s how we do tech support throughout the year.

Garrett Murray:

This, a million times over[…]

Jason Snell:

This is a complicated issue, and one difficult to assess without knowing the facts about what’s happening inside of Apple. An avalanche of bug complaints and misty water-colored memories about the stability of Snow Leopard aside, I do think that there’s a problem here.

Federico Viticci:

When I started MacStories in 2009, two pillars sustained the narrative around Apple: its “attention to detail” and the “just works” aspect of its software. Since iOS 7, it feels like those pillars have begun eroding at a quicker pace.


What it comes down to, really, is balance. I believe that Apple used to be more disciplined at balancing its desire for new features and commitment to refinements.

My problem with most commentary to Marco’s piece is the binary interpretation of Apple’s software releases: that they should either do new stuff or fix bugs. That’s too simplistic and shortsighted. Software is never bug-free, but there’s a threshold where it’s good enough to be shipped. I want to see Apple get better at releasing updates like iOS 8 and Yosemite with a better balance between novelty and stability. They shouldn’t be mutually exclusive.

Joe Cieplinski:

I bring this up not because I disagree with Marco Arment’s post from last night about the recent decline in Apple’s software quality, which is undeniable. I just think it helps to remember that mass market success and decline in build quality pretty much go hand in hand. And that we’ve been here with Apple before. Many times.


The only question now is how does Apple balance the speed of innovation against the need to maintain quality moving forward? As the Apple Watch starts shipping later this year, and the critics of Cook finally quiet down about Apple’s inability to have a hit new product, will Apple shift gears a little? Will the organization realize that it’s out of whack and start to feel the need for a Snow Leopard moment? I think it probably will.

Victor Agreda Jr:

Apple’s longtime brand promise of “it just works” applies to fewer and fewer products the company makes.

David Chartier:

Conversations I overhear in public have gone from “hey Apple’s new thing looks pretty great” to “meh, just wait until they work out all the problems.”

Shawn King:

I hate agreeing with Arment but sometimes, he’s bang on. I believe in this case he is. From embarrassing software updates to apps that simply don’t work properly or well – Apple’s poor quality and functionality of the being just one of many examples – the assessment that “We don’t need major OS releases every year” is something many of us hope Apple listens and pays attention to.

Nick Heer:

For every dumb bug or feature regression, I also find something that works far better than it ever has, and often far better than its competition. Perhaps the big thing Apple needs to do in 2015 is reassert its unique skill in creating unique, easy-to-use software that — hyperbolically — “just works”. Not necessarily with new features, but by making the features that already exist truly great.

Lloyd Chambers:

MPG has been writing about Apple Core Rot for a year now, and longer before making it explicit. Lately, there are so many dozens of specific issues that could be documented in OS X Yosemite that weeks could be spent documenting them. While adding the numerous examples to Apple Core Rot would strengthen the piece tremendously, MPG has useful work to do.

BTW, my Apple Mail VIP list has been deleted about fifty times now. Uncle.

Graham Lee:

So there are plenty of alternatives, many of which are good in some ways and bad in others, and all I know is that I don’t want things to be like this, without being able to say I want one of those instead. I don’t even think there will be one of those, at least not in the sense of a competitor to Apple on laptop operating systems.


In fact I don’t even think that Apple’s systems are bad, they’ve just lost the “it just works” sheen. It’s just that when you combine that with the lack of credible alternative, you realise the problem is probably in expecting some corporation to put loads of resources into something that’s not going to have a great value, and merely needs to be “good enough” to avoid having any strategic penalty.

Update (2015-01-10): Ashley Nelson-Hornstein:

I know a ton of smart people work at the mothership, so I’m betting these incredibly intelligent people have already noticed the problem and moved to make the proper adjustments. I think what we likely can’t see from the outside are the projects that have already been cancelled to allocate resources for bugs.

Update (2015-01-11): Riccardo Mori:

When a new OS X version introduces issues that were absent in the previous one, that doesn’t go unnoticed, especially when such issues — like Wi-Fi reliability — are taking two minor OS X releases to be fixed. When a new OS X version makes your Mac feels more sluggish than it was in the previous version, that perception clouds whatever new exciting features the new OS X version brings to the table.

John Gruber:

But in avoiding the problems of stagnation and hubris, it feels like Apple has run into a different problem: nothing ever feels settled and stable. If the pattern Apple has established the last two years holds, by the time the loose screws get tightened in iOS 8 and OS X 10.10, we’ll be getting developer betas of iOS 9 and OS X 10.11 at WWDC. And as Guy English has keenly remarked numerous times, the annual schedule means that by now — that is, January — a lot of engineering talent in Cupertino is being directed to next year’s OS releases, leaving less talent on the task of tightening the remaining loose screws in last year’s.

Bogdan Popescu:

  • Last year I spent at least 30% of my development time fixing Apple bugs.
  • I spent 4 days just to get the lovely new search field in Yosemite to work properly. In the end, I just found a hacky way of reverting it to how it was before Yosemite.
  • I always check if an Apple framework or class is at least 2 years old before using it. If it’s not, I assume it’s full of bugs and I try to use something else.

Update (2015-01-12): Glenn Fleishman:

Many of us have been grumbling quite publicly since iOS 7 and Mavericks shipped that the fit and finish we expect either on release or shortly afterwards for Mac OS X and iOS has slipped. That we spent a lot of time dealing with bugs or, if we write about Apple, teaching people how to avoid them or work around them. That software and OS problems, once they occur, are rarely fixed in part or full; features we need are removed rather than matured; and new features are added that aren’t fully baked.


Part of what makes these sorts of statements reasonable, though, is to enumerate the problems, whether they’re long-running or unique to Yosemite or iOS 8 (or to the last two releases of each system). Here’s a list of regularly recurring issues or fundamental problems I’ve seen supplemented by those provided by others.

Chuq von Rospach:

This isn’t an “Apple is doomed” scenario, but to me, the trendlines are negative — there is no cliff, but the beginning of the same kind of worry for a trip into the future that ends up looking like SGI (remember them? No? Ask your dad). A couple of people put up the claim that Apple was nowhere near as bad as Microsoft, and I agree, but to me, that’s irrelevant. What we’re comparing is not Apple compared to any other company, but to the Apple that should be, and the existing Apple and the possible Apple are starting to diverge.


My evidence for the prosecution is the quality of iCloud, the absolute disaster that is today’s iTunes (a tool that’s three or four years overdue for a complete overhaul) and the woeful quality of many of the Apps and how those have been changed significantly in non-compatible ways without any real recourse for existing users and no real warning to let them prepare for the update. That’s just not understanding or caring for the end user, and to me unacceptable.

Update (2015-01-14): Nick Heer:

So many of these reactions are simultaneously true. Yes, there are extremely stupid bugs and regressions littered throughout Apple’s software products. Yes, there’s the impression of a downward slide in quality assurance. And, yes, there have previously been really stupid bugs and regressions. I think Apple is cognizant of the fact that their software quality needs to improve faster than they gain new users; if it’s slower, it feels significantly worse than it really is.

Update (2015-01-17): John Gruber found a 2004 article, “Apple to Slow Down the Pace on Mac OS X.”

John Gruber and Marco Arment discuss Apple’s software quality on The Talk Show.

Update (2015-01-18): Jean-Louis Gassée:

For the past six months or so, I’ve become increasingly concerned about the quality of Apple software. From the painful gestation of OS X 10.10 (Yosemite) with its damaged iWork apps, to the chaotic iOS 8 launch, iCloud glitches, and the trouble with Continuity, I’ve gotten a bad feeling about Apple’s software quality management. “It Just Works”, the company’s pleasant-sounding motto, became an easy target, giving rise to jibes of “it just needs more work”.


The other view is that the quality lapses we observe are the beginning of a slide into satisfied mediocrity, into organizations and projects that “run themselves”, that are allowed to continue for political reasons without regard for the joy of customers.

I know what I hope for. I don’t expect perfection, I’ve lived inside several sausage factories and remember the smell. If Apple were to spend a year concentrating on solid fixes rather than releasing software that’s pushed out to fit a hardware schedule, that would show an ascent rather than a slide.

Update (2015-01-22): Rene Ritchie:

It’s arguable whether or not it’s any more pain than last year, the year before, the year before that, the year before that, and so on. But it’s inarguable that there’s been pain. People at Apple know that. They and their families and friends use the same hardware and software we do. Whether or not the right people were paying attention to the right measures, recent events have at the very least made even those who might not have realized the sentiment aware of it now.

Marco Arment, Casey Liss, and John Siracusa discuss Apple’s software quality on the Accidental Tech Podcast.

Dave Heinzel:

But for the past year or so, I have noticed so many little things that drive me absolutely insane, that I would actually be happy to jump ship, assuming there was another ship to jump to (there’s not, yet).

Last November, I started keeping a list of all the things that bug me. Some of them hinder productivity. Some are lost opportunities. They cover the full range of Apple products in my life: Mac, iPhone, iPad, Apple TV.

Lloyd Chambers:

Virtually all of these issues persist months after OS X Yosemite was released. And no doubt will never be fixed, or perhaps will be replaced by new bugs as Apple arbitrarily breaks things and rips out good useful features by increasingly disrespectful-to-users judgment. A few of these issues are very serious (security), and inexcusable.

Gus Mueller:

And that is probably the biggest difference between Apple and Microsoft. Apple knows when it’s time to show a new product. Apple knows when something is ready for real world use, and Apple won’t rush something out the door because of market pressures.


And I think that is why we’re seeing so many people reacting to Apple’s software quality lately. You expect Microsoft not to deliver. But we expect Apple to. And lately, it really hasn’t felt like they’ve been doing it.

Update (2015-01-23): Guy English:

If you’d like to know how the sausage is made, how people who have been in positions to make these quality control calls think, and get a sense of the camaraderie tune your compu-radios to Debug 60.

Update (2015-02-05): Nitin Ganatra hypothesized that the Apple bugs follow the Pareto principle, i.e. that there are probably about 8 P1 bugs that, if fixed, would address 80% of the problems people are seeing. I’m more inclined to Marco Arment’s viewpoint that the problem is more like 6,000 P2 bugs that have been building up because (as Ganatra and Don Melton described) there is never time in the schedule to fix them.

Update (2015-02-06): NitinGanatra:

Just listened to @atpfm 102. Good stuff! One thing I obviously forgot to mention. Perennial internal discussion: how many P2s = 1 P1

Overall quality is tied to state of P2s, and 6000 P2s is definitely felt by users. Agree with host who said that on @atpfm

John Siracusa:

@nitinganatra You didn’t say “X P1 bugs,” you just said “X bugs.”

Sunday, January 4, 2015 [Tweets] [Favorites]

Quitting Family Sharing

David Sparks (tweet):

The promise behind Family Sharing was that it would get us away from that problem. In theory, we’d all be able to have our own accounts but still share purchases as long as all the accounts are on the same credit card. If at some point, one my children moves out or pays with her own credit card, she retains her library and we stop sharing. I am okay with that particularly if it lets me have my 2 Macs, iPad, and iPhone all work without running into above-mentioned DRM walls.

What I didn’t realize was the fine print. There are a few bits that are potential deal breakers.


Three months ago I turned Family Sharing on for my wife and one of my daughters to see if this additional expense would be worth it. The transition has not been easy. Indeed, my family, that is normally game for just about any new nerdy thing I bring in, has rebelled. They’ve all told me how much they don’t like Family Sharing but not because of the above limitations, the problems are in execution.

David Chartier:

Like many couples, if you’ve been sharing a single Apple ID in order to share iTunes Store purchases (which Apple has long recommended), you may have run into a problem with iOS 8 and Family Sharing where you can’t download or update some apps. I’ve been troubleshooting this with my wife since iOS 8 landed, and I think I know what’s going on.

Update (2015-01-11): Jason Snell:

The story is much the same in the Snell household. Family Sharing is a good idea, but between the limitations and the bugs, it’s making my family agitate for a return to sharing a single Apple ID.

The Benefits of Selling Software Outside the Mac App Store

Dan Counsell (comments, tweet):

Now lets look at a real world example, RapidWeaver has been on the Mac App Store since it opened in 2011 and has generated over $2,000,000 in revenue. Apple has taken $600,000 (USD) of that in fees. Ouch!


I’m specifically talking about bundle deals run by StackSocial, MacUpdate, and MightyDeals. I used to love bundles, then I got convinced they were bad for our customers. I stopped participating in them for awhile and missed out on a lot of revenue because of it. I’m now fully behind bundle deals again and am glad I changed my mind.


When you have a new product coming out you’ll want to let your existing customers know. They’ve already bought from you once and trust you, so they may be interested in buying from you again. If you’ve only ever sold on the Mac App Store you have no details for any of your customers. When you sell directly you can simply email them and say “Hey, we know you bought X and we’d love you to check out Y, you’ll even get 20% off because you’ve purchased from us before”. This is a big deal.

Here’s another example, when App Store customers email me asking for a refund I have to say “I’m really sorry but you’ll need to contact Apple directly, we can’t issue refunds”. However, Apple doesn’t always give refunds, and this often results in unhappy customers and bad App Store reviews.


I’m not suggesting you pull out of the Mac App Store and only sell direct, I’m recommending you sell in as many places as possible.

A Dozen Things Tren Griffin Learned From Steve Jobs About Business

Tren Griffin (via John Gruber):

Dates of quotes are important in trying to understand Steve Jobs so I have included them in this post. A good friend of mine, who knew Steve Jobs very well, said to me: “He was a chameleon. And a really good one.” So when Steve Jobs said something really does matter in understanding what he meant.