For many reasons, I’m not going to commit on the political or business side of the decision. I don’t have any knowledge of why Apple — or any other company — has chosen to close or open what they have.
Instead, I’m going to point out a fact that Bray seems to largely ignore and Gruber only touches on in passing.
Open sourcing a large body of source that has always been closed is really damned hard.
It takes a monumental amount of effort to do so and, once open, it takes a whole bunch of ongoing effort to keep it open in a productive fashion (which Gruber does cover, actually).
At the lowest level, pretty much every line of code has to be reviewed to ensure that it isn’t offensive, doesn’t cross any number of lines (licensing, intellectual property, etc..), is formatted reasonably well, and every file must contain the appropriate header.
For any company that has a suite of products where some build on others — especially when the others are developer tools (think Sun’s JDK or IBM’s libraries or Microsoft’s DLLs) — it is quite likely that any given piece of code is going to contain stuff done “the wrong way”. It may have been “right” or “only way” when written and you may have intended to fix it later, but it just hasn’t happened yet.
As a result, you are likely going to have to break the project across potentially unnatural lines to separate the parts to be open sourced from the parts that need to remain closed for various reasons. And the reasons are many and not just because you want to keep something secret. Sometimes the code is so completely counter to the way developers should develop apps that you don’t want to run the risk of other developers doing the same thing (and there are very valid reasons for such a case to arise — bad engineering is rarely the reason).
Then there is the intellectual property. If there are any random patents embodied in the code — of which there likely will be in this day and age — you have to figure out exactly how open sourcing said implementation changes the whole IP landscape.
Example: Before joining Apple, I was involved in various IP related conflicts as they meandered through the court system. In one case, one party used open source to bolster their position. In particular, they used the openly available implementation to strengthen their particular position — had that source remain closed, that particular defense/offense would not have been available. (Suitably vague to protect the, uh, innocent? guilty? wasn’t really clear)
And once you have everything all cleaned up, have the license selected, and are ready to roll it out, you have to expend the engineering effort to actually set up a community portal of some kind. Bug tracking. Source repository. Some kind of channel for receiving patches. It is going to be an ongoing engineering investment.
There is no such thing as “just publish the source and be done with it”. Publishing source — be it under an open or closed license (like the GPL) — changes a product in unavoidably large ways. Sometimes good. Sometimes bad. Always a lot of effort to deal with.