Category Archives: Apple

Apple Intelligence

As WWDC draws near, anticipation of Apple’s long-rumored VR headset is high. The company is widely expected to announce an impressive, albeit expensive new product at the June 5 Keynote event. In short: people expect Apple to make a strong showing in this field.

People are justifiably less confident about Apple’s prospective plans in the area of artificial intelligence (AI), and particularly in the realm of large language models: the technology behind such imagination-captivating products as OpenAI’s ChatGPT, and GitHub Copilot (which itself uses another OpenAI language model).

I zeroed in on ChatGPT and Copilot because it’s easy to imagine the functionality of these services shining in the context of two important Apple products: Siri, and its Xcode developer tools. In fact, technology is advancing so quickly that the absence of something like ChatGPT and something like Copilot in these products seems likely to be viewed as major shortcoming in the near future, if it isn’t seen that way already.

The industry-wide excitement around AI is so great that it’s hard to imagine any company of Apple’s stature letting a major developer conference come an go without at least mentioning the technology, if not enumerating the specific ways in which they are using it in their products. Most people I know are confident it will be mentioned in the Keynote, but less confident that any news will be Earth-shattering, or even Earth-tickling.

Which leads me to my somewhat far-fetched prediction for WWDC: Apple will talk about AI, but they won’t once utter the letters “AI”. They will allude to a major new initiative, under way for years within the company. The benefits of this project will make it obvious that it is meant to serve as an answer comparable efforts being made by OpenAI, Microsoft, Google, and Facebook. During the crescendo to announcing its name, the letters “A” and “I” will be on all of our lips, and then they’ll drop the proverbial mic: “We’re calling it Apple Intelligence.” Get it?

Apple often follows the herd in terms of what they focus their efforts on, but rarely fall into line using the same tired jargon as the rest of the industry. Apple Intelligence will allow Apple to make it crystal clear to the entire world that they’re taking “AI” seriously, without stooping to the level of treating it as a commodity technology. They do this kind of thing all the time with names like Airport, Airplay, and Airtags. These marketing terms represent underlying technologies that Apple embraces and extends. Giving them unique names makes them easier to sell, but also gives Apple freedom to blur the lines on exactly what the technology should or shouldn’t be capable of.

Apple Intelligence won’t be as good as ChatGPT or GitHub Copilot, at least not to start with. But it will be Apple’s. They can frame the pros and cons however they see fit, working their typical marketing magic to make its shortcomings seem less important, if not downright advantageous. And, being an abstraction on the already broad subject of “AI”, they can evolve its capabilities over time, gradually improving on it and increasing its brand recognition. In five years, when every other company is still talking about “AI”, or whatever other buzzword has taken its place, Apple may well have already incorporated the technology into its own A.I.

52 Floppy Pickup

On the latest Accidental Tech Podcast, John reminisced about the early days of the Mac, when a single 3.5″ floppy disk drive was typically used not only to boot a Mac, but also to run any applications, and to save any user data. He described the painstaking process of needing to insert a different disk whenever programs required access to specific executable code or data. Depending on the complexity of a workflow, you might be prompted to swap disks once, twice, or potentially dozens of times.

The conversation reminded me of one of my first jobs at Apple. I was hired to work as a QA tester with the engineering team that shipped Mac OS system software updates. The first release I worked on was Mac OS 7.5, which was released in 1994. By this time hard drives had become commonplace and the kind of floppy-swapping John described had become a lot less common for most users. But when it came to installing new software onto a Mac, some amount of removable media juggling was usually required.

Typically at that time, major OS updates were installed from CD-ROM discs. The system used the same basic strategy: it would eject one disc and prompt you to insert another, until the installation process was completed. It was a little tedious, but because CD-ROM discs had a massively higher capacity than floppy disks, it usually only required a few swaps.

One day during the lead up to finishing System 7.5, my boss brought a massive box full of floppy disks into the lab I worked in. The System 7.5 update was remarkably backward compatible, and supported computers as old as the Macintosh Plus and SE, which did not include a CD-ROM drive. In fact they did not even support the relatively higher density 1.4MB floppy disks of the era. That massive box was the System 7.5 installer, split across 50 or so (as best as I can recall) 800K floppy disks. I was supposed to make sure it worked.

Another thing John recalled on the show was how some folks got amazingly good at floppy-swapping process, developing a muscle memory for fluidly withdrawing and inserting disks on command. Suffice to say, after testing that 50-floppy install process more than a couple times, my muscle memory was pretty darned good.

Spelunking Apple’s Open Source

Since the earliest days of Mac OS X, Apple has complied with the licenses for the dozens of open source components it includes in the OS by posting (sometimes a little belatedly) updated versions of the source code to its Open Source at Apple web page.

This resource is useful primarily to developers, but may also interest curious technophiles who want to take a peek “behind the curtain” to see how much of the magic just beneath our fingertips is made.

If you visit the page today, you’ll see a new emphasis on Apple’s high-level projects, such as Swift and WebKit. At first glance you might wonder if the extensive list of all the open source projects has been removed from the site.

There’s no need to worry: the whole list, indexed by the pertinent platform and OS release to which they belong, is still available on a separate Releases page. Even better, each of these releases now has a corresponding GitHub repository, hosted in a dedicated organization reserved exclusively for open source distributions.

As great as the old list of distributions by release is, it can be tedious to pinpoint exactly where a particular component’s source code might live. Sometimes it’s easy: for example, the source code for the version of the Vim editor that shipped with macOS 13 is conveniently located in a distribution called vim-136. But other tools can be harder to find. If you were curious about the “banner” command, which was historically used to generate ASCII text suitable for printing huge messages at dot matrix printers (!), and which is remarkably still available as a built-in command on every Mac, you’d have to know to go looking for it in the text_cmds-138 release.

Apple’s decision to host these releases on GitHub, under a distinct organization, solves the problem. If you want to find the source code to an arcane tool like “banner”, just type it into a GitHub search of the organization. If there are too many false hits, as is the case for a common word like banner, try searching on something unique like a term from the command’s man page. The banner tool is credited as being authored by Mark Horton, and a search for “org:apple-oss-distributions Mark Horton” brings up more hits than I would have guessed (he also contributed to vim and vi, coincidentally), but a reference to the banner man page is the second search result.

I was inspired to write this blog post by a situation that came up in a programming Slack, where one person asked for “an API that could list the open ports and their owning processes.” Another replied that the command-line tool “lsof” is up to the task, only the person wasn’t looking for a command-line tool. Using the knowledge of Apple’s open source distributions, you could go look for, and find, the pertinent source code, and determine which API it was using.

When questions like these come up, many times the answer comes from a wise old sage who happens to know exactly what you’re looking for. Other times, Apple’s increasingly well-indexed open source distributions might be just the ticket.

Apple News Encourages Frequent Blogging

When Apple News debuted, I was intrigued to learn that virtually anybody can submit their own blogs for inclusion in the service. Why not allow Bitsplitting, the Red Sweater Blog, and Indie Stack to be part of this service? For reader who enjoy Apple News, it could serve as a kind of substitute RSS reader.

Apple did, in fact, accept my news sources, and for the past several years these articles have been available through the service.

I guess I’ve dropped the ball a bit as a blogger, though, because this week I received a terse email from Apple:

Dear Daniel Jalkut,

We noticed that you have not published to your Bitsplitting channel in three months or more. Your channel will be removed in one week.

Regards,
The Apple News Team

Regards, indeed. Apple will drop me in one week if I don’t publish something, or maybe even if I do; the wording is ambiguous. I’m a little annoyed at this, but I’m also a little annoyed at myself for not blogging more frequently, so I guess I’ll just say: “thanks, Apple News!”

Update: Manton Reece notes on Micro.blog that there may be a less encouraging rationale for Apple’s crackdown on inactive publications:

@danielpunkass If you hadn’t heard, Apple News dropped RSS support for new blogs, and it sounds like they rarely approve personal blogs anymore. Weeding out inactive blogs could be the first step to removing them altogether.

A Real Gatekeeper


In the years since Apple released the iPhone, with its “locked-down-by-nature” approach to application security, the company has progressively chipped away at the freedoms Mac developers have historically had to do, more or less, whatever the heck they wanted.

With the introduction of the Mac Application Sandbox in 2012, Apple applied an iOS-like mechanism through which applications are entitled only to access their own data, and must explicitly request permission from Apple to access any resources “outside of their own sandbox.” At the time, I wrote that while the technology was promising, it left much to be desired.

Around the same time, they introduced Developer ID, a system for certifying at runtime that a given piece of software has been cryptographically signed by a developer whose identity is known to Apple. Applications that are not signed with Developer ID are allowed to run in macOS, but by default are met with a foreboding warning about the safety of doing so. The component of macOS that is responsible for limiting the launch of software from unknown developers is called “Gatekeeper.”

Last year, in 2018, Apple introduced a new notarization service, an expansion of Developer ID functionality. Developers submit their applications to Apple, where they are scanned for known malware, and have their use of specific system technologies vetted. The “notarization” on an app allows the system to verify at runtime that a given application passes a baseline safety metric for downloaded software.

Finally, in 2019, Apple announced that software signed with Developer ID certificates, that is to say all non-Mac App Store software, must also be notarized. The Catalina 10.15 public beta identifies software that has not been notarized as potentially risky because it “cannot be scanned for malware.”

In effect: developers who ship software directly to end-users are now required to notarize their apps.

While working on the notarization process for my own apps, and a company I work for, I noticed an interesting error from “altool”, the command line program that is used to submit binaries to Apple for verification:

1 package(s) were not uploaded because they had problems:
Error Messages:
To use this application, you must first sign in to 
iTunes Connect and sign the relevant contracts. (1048)

The error is easily worked around by logging in to App Store Connect and agreeing to any updates Apple has recently made to their contracts. I’m so used to more-or-less blindly agreeing to these changes, that it didn’t sink in for me at first what a potentially major change this is.

My colleague Patrick Machielse noticed right away what the larger implication is: all Mac software, inside or outside of the Mac App Store, can now be held up by unsigned contract agreements with Apple. In a rush to fix a horrible bug and get it out to customers? Better review that new contract ASAP.

For the past 35 years, any Mac developer who wanted to ship an update directly to customers could do so by recompiling a binary and distributing it. When macOS 10.15 ships this fall, the status quo will change. Mac developers must register with Apple and sign their products. They must submit their binaries to Apple for notarization. And most significantly of all, they must agree to the terms of Apple’s App Store developer contracts, even if they don’t distribute their apps through the App Store.

Mac Sandboxing: Privileged File Operations

At WWDC 2018, Apple announced with great fanfare that two beloved Mac apps, Transmit and BBEdit, would be returning to the Mac App Store.

Each of these apps had departed the App Store years ago, citing various reasons, but chief among them the limitations of the Mac App Sandbox, which restricts the functionality of apps in the Mac App Store.

I was curious whether Apple made any specific concessions to these developers, and whether those concessions would be opened up to “the rest of us” or not.

Today, Panic launched Transmit 5 on the Mac App Store. It’s a free download, and costs $24.99/year after an initial 7-day free trial.

I downloaded Transmit even though I own a copy of the direct-purchase version. I wanted an answer to my question, which I got, at least partially, by dumping the application binary’s “entitlements”, which represent the sandboxing exceptions that the app has received.

New to me among the entitlements is “com.apple.developer.security.privileged-file-operations”, which is a boolean value set to true for Transmit. I don’t see any Google results for this key, so I’m assuming it’s something new that was added for Panic (and maybe BBEdit), and which may or may not be documented in the future for use by other developers.

Another interesting entitlement is “com.apple.security.automation.apple-events”, which is documented by Apple, but only in the context of the new “Hardened Runtime.” This technology is aimed primarily at developers who are not developing for the Mac App Store, but who want to provide enhanced security for their customers. In that context, I believe this entitlement provides unfettered access to sending AppleEvents, excepting that in Mojave and later the app is still subject to fine-grained system alerts that require user approval for each application that is targeted.

In short: it appears that Transmit possesses at least two “official” entitlements that could be made available, or are perhaps already available, to other developers. One way to find out: add them to your app and submit it for approval!

Update: Thanks to Jeff Nadeau for alerting me to the pertinent API that correlates with the privileged file operations entitlement. NSWorkspaceAuthorization can be used to request privileged file access from the user, and Apple includes a link for requesting access to the entitlement.

Update 2: It turns out my intrigue around “com.apple.security.automation.apple-events” was ill-founded. I assumed that a sandboxed app could use this entitlement to gain unfettered access to automating other apps, but in the case of a sandboxed app it turns out to work in conjunction with the existing “com.apple.security.temporary-exception.apple-events” entitlement, which requires enumeration of specific targets. Thanks to Jeff Johnson and Paolo Andrade for talking me through my misunderstanding of the situation.

Terminal Security Profiles

In macOS Mojave, Apple introduced a number of new security features that impact the day-to-day use of the computer. Activities such as running scripts, or using apps that access private information, are altered now such that users are prompted with one-time permission-granting requests.

One consequence of these changes is that you can no longer access certain parts of your home directory from the Terminal. Don’t believe me? Try opening Applications > Utilities > Terminal, and run the following command:

ls ~/Library/Mail

In all previous macOS releases, this would list the contents of Apple’s internal Mail files. As a privacy enhancement, access to these files is now restricted unless apps have requested or been proactively granted access.

If you really wanted to regain access to these files via the Terminal, you have to grant the app “Full Disk Access.” This is a new section of the Security & Privacy pane in System Preferences.

Well, that’s fine. Now you can “ls” anything in your home folder, but absolutely every other thing you run in Terminal can as well. To grant myself the ability to list files in ~/Library/Mail, am I willing to grant the same access to every single thing I’ll ever run in Terminal?

This isn’t earth-shattering: it’s been the case forever that tools you run in the Terminal have access to “all your files.” But the new restrictions in macOS Mojave shine a light on a problem: the bluntness of security restrictions and relaxations with regard to Terminal.

I’ve run into a variation of this problem in the past. I use the excellent TripMode to limit bandwidth usage when I’m traveling, and tethered to my phone. A consequence of this is that, unless I grant unlimited network access to Terminal, I can’t perform routine tasks such as pushing git changes to a server.

Ideally these permission grants would be applicable at the tool level, rather than at the application level. It would be better if I could say “let ls access my Mail” rather than “let anything I run from Terminal access my Mail.”

I don’t completely understand the limitations there, but I suspect that because commands in the Terminal are running as subprocesses of Terminal, there is some technical challenge to making the permissions apply at such a fine-grained level.

As an alternative, I wonder if Apple could introduce some kind of “Security Profiles” feature for Terminal so that individual windows within the app could be run when different permissions? This could build on Terminal’s existing support for “Profiles” which already support varying Terminal settings dramatically on a per-window basis.

With Security Profiles, a user would be configure an arbitrary number of named profiles, and security privileges acquired by Terminal would be stored separately for the active profile. Each profile would be considered by the system effectively as a different app. For example, given my uses of Terminal, I might set up a few profiles for the types of work I regularly do:

  • Personal: Everyday productivity tasks including running scripts, editing files in my home directory, etc.
  • Administrative: Tasks that pertain to the overall maintenance of my Mac: examining system logs, delving into configuration files, etc.
  • Collaborative: Tasks that involve installing and running third-party tools that I trust, committing to shared source repositories, etc.
  • Experimental: Tasks that involve installing or running third-party tools that I am not familiar with and do not have a high degree of faith in.

These are off the top of my head, and just to give an idea of the kinds of profiles that might make sense here. Switching between these modes would also switch the system’s active list of entitlements for Terminal. If I run a script that accesses my Calendar items from the “Personal” profile, the system would prompt me once to ask my permission, but never prompt me again in that profile. When I switch to “Experimental” and run some unfamiliar third-party tool that tries to access my calendar, it would ask permission again for that profile.

I filed Radar #45042684: “Support a finer-grained permissions model for Terminal”, requesting access for this or something like it.

More on Mojave’s Automation Sandbox

I wrote last month about macOS Mojave’s restrictions on automation, and how users can reset the database that controls them. In that post, I cited Felix Schwarz’s excellent article on the subject.

In recent weeks, Apple has made changes to the behavior of macOS Mojave, and added some API calls to help developers better handle the restrictions of the system. Felix is back with an updated post, describing the changes, and what he thinks can still be improved.

Reauthorizing Automation in Mojave

The macOS Mojave betas include a significant enhancement to user control over which applications can perform automation tasks. When we talk about automation on the Mac, we usually think of AppleScript or Automator, but with a broader view automation can be seen as any communication from one application to another.

One ubiquitous example of such an automation is the prevalence of “Reveal in Finder” type functionality. For example if you right-click a song file in iTunes, an option in the contextual menu allows you to reveal the file in the Finder. This is a very basic automation accomplished by sending an “Apple Event” from iTunes to the Finder.

In the macOS Mojave betas, you’ll notice that invoking such a command in an application will most likely lead to a panel asking permission from the user. The terminology used is along the lines of:

“WhateverApp” would like to control the application “Finder”.

If the user selects “OK”, the application sending the command will be thereafter whitelisted, and allowed to send arbitrary events (not just the one that prompted the alert) to the Finder. If you’re running macOS Mojave you can see a list of applications you’ve already permitted in System Preferences, under “Security and Privacy,” “Privacy,” “Automation”.

These alerts are a bit annoying, but I can get behind the motivation to give users more authority over which applications are allowed to control other applications. Unfortunately, there are a number of usability issues and practical pitfalls that come as side-effects of this change. Felix Schwarz made a great analysis of many of the problems on his blog.

I ran into another usability challenge that Felix didn’t itemize: the problem of denying authorization to an application and then living to regret it. I guess at some point I must have hastily denied permission for Xcode (Apple’s software development app) to control the Finder. This resulted in a seemingly permanent impairment to Xcode’s “Show in Finder” feature. I’m often using this feature to quickly navigate from Xcode’s interface to the Finder’s view on the same files. After denying access once, the feature has the unfortunate behavior of succeeding in activating the Finder (I guess that one is whitelisted), but failing silently when it comes to revealing the file.

OK, that’s fine. I messed up. But how do I undo it? Unfortunately, the list of applications in the Security and Privacy preference pane is only of those that I have clicked “OK” for. There’s no list of the ones that I’ve denied, and no apparent option to drag in or add applications explicitly. For this high level problem, I filed Radar #42081464: “TCC needs user-facing mechanism for allowing previously denied privileges.”

What’s TCC? I’ll be darned, I don’t know what it stands for. But it’s the name of the system Apple uses for managing the system’s so-called “privacy database.” This is where these and other permissions, granted by the user, are saved. For instance, in macOS 10.13 when the system asks whether to grant access to your Address Book or Contacts, the permission is saved, and managed thereafter, by TCC.

Resetting TCC Privileges

I knew from past experience testing Contacts privileges in my own apps, that Apple supports a mechanism for resetting privileges. Unfortunately, it’s pretty crude: if you want to change the authorization setting for an application you’ve previously weighed in on, you have to universally wipe out all the privileges for all apps using a particular service. For Contacts, for example:

tccutil reset AddressBook

This completely removes the list of apps authorized to access Contacts. (The AddressBook naming is a vestige of the app’s former user-facing name.) In fact, if you type “man tccutil” from the Terminal, you’ll find that AddressBook is the only service explicitly documented by the tool. Fixing my Xcode problem is not going to happen by resetting AddressBook privileges. So what do I reset? I tried the most obvious choice, “Automation,” results in an error: “tccutil: Failed to reset database”.

What’s the service called, and does tccutil even support resetting it? After a crude search of the private TCC.framework’s binary, I discovered I was looking for “AppleEvents”:

tccutil reset AppleEvents

After running this, I quit and reopened Xcode (the TCC privileges seem to be cached), and selected “Show in Finder” on a file. Voila! The Finder was activated and I was again asked if I wanted to permit the behavior. This time, I made sure to say “OK.”

You can get a sense for the variety of services tccutil apparently supports resetting by dumping the pertinent strings from the framework:

strings /System/Library/PrivateFrameworks/TCC.framework/TCC | grep kTCCService

The list of matching strings includes names like AppleEvents and AddressBook, as well other names for things I don’t recognize, and a seemingly useful “All,” which can presumably be used to wipe out all authorizations across all services.

Because the tccutil is far more useful than is advertised, and because users are undoubtedly going to end up needing to reset services more than ever in Mojave, I also filed Radar #42081070: “Documentation and command-line help for tccutil should enumerate services.” There are some items in the dumped list that appear likely to be private to Apple, but anything genuinely useful to customers (or more likely, the consultants who fix their Macs) should be listed in the manual.

Lighten Up, Eh?

While I support the technical and user-facing changes suggested by Felix Schwarz in the previously linked blog post, some issues would be avoided by simply giving apps the benefit of the doubt for widely used, innocuous forms of automation.

I mentioned earlier that the Apple Event sent by Xcode to “activate the Finder,” was apparently whitelisted by the system. Evidently Apple saw wisdom in the thinking that simply causing another application to become active is unlikely to be widely abused. I think the same argument holds for asking the Finder to reveal a file. I filed Radar #42081629: “TCC could whitelist certain widely used, innocuous Apple Events.”

I mentioned before that I can support Apple’s effort to put more power into users’ hands with this feature, but one side-effect of requiring the authorization even for innocuous events like “Show in Finder” is that apps that do not otherwise offer automation functionality to users will nonetheless require that users grant that power.

If the merit in the feature is to allow users to limit what kinds of automation apps can perform, then supporting a “Show in Finder” feature for an application should not require me to simultaneous permit it to do whatever kind of Finder automation it chooses to. For example, an application so-authorized is now empowered, presumably, to send automation commands to the Finder that modify or delete arbitrary user files.

These days Apple always seems to be pushing the privacy and security envelope, and in many ways that is great for their users and for their platforms. With a little common-sense and some extra engineering (“It should be easy” — Hah!), we can get the best of the protection these features offer, while suffering the fewest of the downsides.

Ersatz Free Trials

On Monday Apple announced that they are officially supporting so-called “free trials” for non-subscription apps. The reaction has been a breathless celebration that Apple has finally relented and given developers something we’ve been asking, no begging, for since the dawn of the App Store.

But what really changed? Not much. Apple announced no functional changes to the way the apps are categorized, how pricing is conveyed to customers, or how the physical transaction of downloading, trialing, and potentially purchasing an app takes place. What they did announce is a change to the App Review Guidelines, adding a bullet item to section 3.1.1 describing a kind of ersatz substitute for actual free trials, built on the in-app purchase system:

Non-subscription apps may offer a free time-based trial period before presenting a full unlock option by setting up a Non-Consumable IAP item at Price Tier 0 that follows the naming convention: “14-day Trial.”

This change to the review guidelines is fantastic, because it will give app developers greater confidence that such a workaround will continue to be approved by Apple. But the practice of offering free trials in this manner is not new, and is not particularly great by any stretch of the imagination.

The Origin of Ersatz Free Trials

To my knowledge, the first developers to come up with the idea of using in-app purchases to approximate free trials were The Omni Group. In September 2016 they wrote about a novel solution for the long-standing absence of free trials (and upgrade pricing) on the App Store, which is based on providing a baseline free download and unlocking premium functionality through in-app purchases:

With the original download free, we can implement any pricing options we want to offer customers through In-App Purchases. We can offer our standard unlocks of Standard and Pro, of course. But we can also offer a free 2-week trial which unlocks all of the features of Pro and Standard, letting you freely choose between them.

Many of us who had also been waiting for App Store support for free trials and upgrades waited in anticipation to see whether it would really work. Would Apple actually approve such a use? Would customers understand it? Would the App Store Infrastructure reliably handle the approach? The answer, as it turns out, was yes. Sort of.

Omni’s approach worked well enough that developers of other apps soon followed suit. MindNode 5, Acorn 6, and Sparkle all launched as “free” App Store titles that can only be substantially improved with in-app purchases ranging from free, timed trials to paid, permanent feature unlocks.

The approach seemed to be gaining momentum so in mid-2017 as I was looking forward to the release of MarsEdit 4, I decided that I would embrace the same idea. Since December, 2017, I have sold MarsEdit 4 as a free app with in-app purchases for free trials, free upgrades for recent purchases, discounted upgrades, and full-price upgrades. In many ways the change has been a revelation. It’s a great relief to be able to offer my customers nearly as many trial and pricing accommodations as I can offer directly through my own store.

The Problem with Ersatz Free Trials

While I’ve enjoyed many of the upsides of the Omni approach, I’ve also had the opportunity to appreciate the many downsides. You might say it’s “a pretty sweet solution” for offering free trials.

I think it’s particularly important, in the face of all the celebration this week about Apple’s perceived changes to the App Store, to understand the many ways in which this solution falls short of what many developers still hope for: bona fide support for real free trials in the App Store.

In summary: none of the mechanics of supporting ersatz free trials are substantially supported by the App Store. Every aspect of the solution is bolted on to a system which was not designed for, yet is somewhat admirably being used to simulate real support for free trials. Let me elaborate by listing several shortcomings and how they affect both users and developers in significant ways. Just off the top of my head …

  • Paid apps are listed as free, even though payment is required to unlock core functionality. This is confusing to many users and leads some to a feeling of bait-and-switch, and that they’ve been betrayed by the developer. This is particularly problematic with apps whose price points make them most suitable to free trials. MarsEdit is $50, so some users who download the “free app” are understandably annoyed when the first thing they learn is that it will cost a significant amount to unlock it.
  • Bulk purchase programs are unavailable. Apple’s Volume Purchase Programs for business and education are based on a system of allocating a certain number of “primary” App Store products to an institution. In the case of a free app with paid in-app purchases, there is no mechanism by which a school or company can for example purchase 500 copies of MarsEdit from the App Store. They can “purchase” 500 free copies and then proceed to unlock each copy individually through the in-app purchase dialog in each app. This is a particularly unfortunate limitation for apps that are uniquely suited either to education or to business uses.
  • Family sharing is unavailable. For the same reasons that bulk purchases are off the table, a developer who wants to allow families to purchase an app once and share it among their family’s devices and accounts is unable to do so unless they sell their app with a fixed, up-front cost in the App Store.
  • Not applicable to all app types. Although Apple doesn’t explicitly state it in their revised App Review Guidelines, I strongly suspect that a continuing requirement for ersatz free trials is that the app must continue to function in some way as a perpetually free, unlocked app. For document-based apps such as Omni’s, they went with an approach whereby the app becomes a read-only document viewer when it is not paid for. In MarsEdit, I took a similar tack by allowing all features to function except for publishing changes to blogs. In many cases it is possible to contrive a free/paid functionality divide, but for some apps it would be very awkward, or maybe impossible to do so.
  • Apps are ranked and featured in the wrong charts. A problem rooted in these paid apps being listed as free is that there is no natural place for them to be honestly ranked among the App Store’s two-tier division of apps into “Paid” and “Free” charts. An app that is $50 and sells very well will never make its way to the top of the “Paid” charts, and if it is lucky enough to beat out actually free apps in the free charts, it will only confound users who are surprised to learn that one of the top free apps actually costs money. The presence of a “Top Grossing” category provided a sort of compromise category for such apps, but Apple removed the ranking from iOS 11, and appears to be set to remove it from the Mac App Store in macOS Mojave.
  • Transaction mechanics are pushed onto developers. One of the primary advantages of the App Store to developers is being able to get out of the business of managing direct sale transactions. With the paid-up-front approach, users browse the store, conduct a transaction with Apple, and download the app. In exchange for taking on this work, Apple is rewarded with a 30% cut. With ersatz free trials, almost every aspect of this complexity is pushed into the app, where developers have to laboriously devise a mechanism for conveying app limitations to users, blocking pertinent functionality, transacting an in-app purchase, facilitating the unlock of app functionality, and so on.
  • Free trials cannot be easily reset. It is typical outside of App Store marketplaces for developers who offer free trials to periodically reset free trials so that users who, for example, enjoyed a free trial on version 1.0 of an app, can give it a fresh look on 1.1. The use of in-app purchases for accommodating free trials would, strictly speaking, require that developers perpetually add new SKUs to the App Store representing a different “free trial” product for each of the timeframes in which a developer wants to reset things.
  • Apps cannot be made to “just work” out of the box. One of the main rationales for offering free trials is to get prospective customers to download and start using the great features of an app as quickly and with as little effort as possible. With ersatz free trials a customer must first authorize Apple to allow the download of the free app, and then they must commence a confusing in-app purchase process during which they will be asked again whether they want to start a free trial.
  • Real Free Trials

    Now that I’ve listed a number of significant problems with ersatz free trials, let’s talk a little bit about what real support in the App Store might look like, and how it would alleviate the problems I’ve described.

    For starters, real free trials would allow developers who currently list their apps as “free” in the App Store to list them by their actual price. The App Store could convey that information both more honestly and more informatively to users. Instead of “Free with in-app purchases,” MarsEdit could be identified succinctly as “$49.95 with 14-day free trial.” These apps would no longer be erroneously featured among free apps, but would rank alongside other paid apps, where they belong.

    Having a bona fide price associated with the main App Store SKU would re-open access to the bulk purchase programs and family sharing. You know you want 500 copies of MarsEdit for your company? Go ahead and purchase 500 copies. The fact that the App Store happens to support free trials would be irrelevant to your conducting this transaction with Apple.

    Real free trials would open the functionality up to any developer who chooses to participate, regardless of their app’s functionality. Instead of forcing developers to come up with arbitrary lock-downs on functionality in the app, they would simply flip a switch in App Store Connect, ideally specifying a trial duration. When free trials are downloaded from the store, the receipt would have the trial information baked right in.

    Putting the logic in the store itself would also empower developers to start or stop offering free trials whenever they like, and to reset free trials across the board with major updates, in the same way they can choose to reset star ratings today. And all the tedious mechanics of offering, transacting, and enforcing free trial limitations would obviously be back in Apple’s court, where they can efficiently support such functionality in one place instead of requiring every developer to re-implement the same kind of support in every app.

    Finally, and probably equally importantly to users and developers alike, real free trials would enable users to effortlessly download and use all the features of an app without having to labor through any of the administrative tedium that is currently required by ersatz free trials. Happy customers trying excellent apps and ultimately paying for them is something that we can all get excited about.

    I hope this article has been helpful in illustrating why Apple’s review policy announcements, while very welcome indeed, do not constitute a major shift in their support for free trials in the App Store, and do not substantially change the status quo. Many of us are stretching the limits of the App Store to provide something that comes close to real free trials, but we would all be far better off if Apple announced a substantial change in supporting them. That didn’t happen this week.

Change Infinite Loop’s Name to Apple Playground

When Apple’s flagship “Infinite Loop” headquarters was built in 1993, the name implied many promises of eternal iteration. Regrettably, none of these promises are likely to be fulfilled.

While it’s impossible to predict whether _some_ characteristic of the landmark might one day meet the standard, none of the most obvious candidates have passed the test:

  1. The buildings form a connected loop, so you can technically walk from one building, to the next, to the next, etc. This gives a feeling of an infinite sequence, but it’s apparent to anybody that there are in fact only 6 buildings, labeled IL1 through IL6. Add in IL7 if the Peppermill (now BJ’s) is accounted for, and you get seven. Seven is nowhere close to infinite.
  2. Given the size of the building compared to Apple’s relatively modest Silicon Valley workforce, it seemed at one time that it might house infinite employees. As time wore on and Apple’s successes grew, the number of employees who could be packed into the buildings’ narrow confines was shown to be … decidedly finite.
  3. Lifers at Apple might have once expected to work a virtually infinite number of days (and nights) on the campus, but as time wore on it became evident that these people either retire or move on to other companies. Finally, the remaining hope for infinite workdays was dashed by the construction and opening of Apple Park, where many current Infinite Loop employees will now work.

In fact Apple Park exceeds, by every reasonable measurement, the “infinite” aspirations of Infinite Loop. The extent to which one can walk around it infinitely is grander. The number of employees it can shelter, while shying considerably from infinity, is nonetheless greater. And the career longevity of folks who call Apple Park home today is, I’ll concede, about the same as it was at Infinite Loop.

The pragmatism in naming Apple Park is evident. In corporate headquarters, nothing is infinite. Not even for Apple. In naming this major headquarters upgrade, it makes no such allusions.

So what’s the perfect name for a smaller hoop of a campus, residing a stone’s throw away from the mighty Apple Park? Apple Playground, of course. You’re welcome.

(Radar #38078647)