Apple released the latest iPhone development license yesterday, and I suddenly find myself a lot less grateful.

In case you haven’t already seen, it contains the following provision:

Applications must be originally written in Objective-C, C, C++, or JavaScript as executed by the iPhone OS WebKit engine, and only code written in C, C++, and Objective-C may compile and directly link against the Documented APIs (e.g., Applications that link to Documented APIs through an intermediary translation or compatibility layer or tool are prohibited).

Among other things, that means no Object Pascal for the iPhone.  At Delphi Live last year, the Embarcadero folks talked about “Native Delphi everywhere.”  Everywhere but the iPhone and the iPad, apparently.  Oh, and not on any phone that runs on Windows Phone 7 either; only .NET apps that use Silverlight or XNA are allowed there.  Google’s Android is only slightly better.  You’re “officially discouraged” from using anything but Java, but not outright prohibited.  (Language choice is alive and well on Palm’s WebOS, but phones that run on it aren’t doing so well in the market.)

This also slams the door hard right in the face of all the folks at the Lazarus project and the fascinating work they’ve done on Objective-Pascal, and it calls the future of the Delphi team’s cross-platform work into question.  With all of the blog posts about Delphi for the Mac in the upcoming “Fulcrum” project, it’s clear that Embarcadero is putting a lot of effort into making Delphi work on the Mac, and does anyone doubt that they had the iPhone/iPad in their sights as part of the long-term plan?

I spent a lot of time thinking about what makes this new policy so offensive to me.  Apple has every right to build the iPhone however they want to.  The design of the phone is their own intellectual property.  And they have the right to build an App Store as a centralized place to buy and sell iPhone content.  And if they own the App Store, it logically follows that they have every right to decide what apps people can offer on it.  The store’s their property, after all.  I’ve seen plenty of brick-and-mortar stores with signs that say “we reserve the right to refuse service to anyone for any reason,” and this is just the electronic version of that.

But here’s where we come to a problem.  The design of the iPhone is Apple’s property.  The App Store is Apple’s property.  But the individual phones and iPads are not.  If Apple sells an iPhone to me, it is transferring ownership of the device from Apple to me in exchange for an agreed-upon sum of money, and once this transfer has taken place, they no longer own it.  It becomes my property, to do with as I please.  That’s a very simple, intuitive concept that anyone can grasp, and it’s been a fundamental principle of capitalism since before Adam Smith wrote the how-to guide:  as long as I do not use a personal possession in such a way as to cause actual harm to others, I can do whatever I want to with it.

This principle’s under attack now.  The only way to get a new app on your iPhone is through the App Store, or by uploading it directly from your Mac if you have a Mac and the iPhone SDK.  On my PC, I can go to some random website, download a new program and install it, but you can’t do that on an iPhone, even though it has a built-in Internet connection.  In effect, Apple has decreed you only theoretically own the iPhone; you don’t own the part of it that receives new applications.  That still belongs to Apple 100%.

Well, to be frank, that’s a bunch of crap.  Apple has no right to tell me that I can’t download an iPhone app from some random website and install it on an iPhone if I want to, and Microsoft has no right to say that I can’t write non-.NET apps for the Windows Phone 7 OS if I can figure out the bindings.  Any law that says they do have such a right is evil and needs to be repealed.

This isn’t just about the iPhone, or even phones in general.  This is about the future of personal computing itself.  What Apple’s managed to pull off with the iPhone looks a whole lot like Microsoft’s vision of the future, in which every computer contains a TPM chip that will place the ultimate control of the system’s functionality under the control of the owners of the software that runs on it, not the owner of the computer.  This isn’t some hypothetical bad future bogeyman that Richard Stallman is cooking up to scare people into using Free Software, folks.  This is what is really happening, right in front of us, today.

In any other context, taking control of the functionality of a computer away from the computer’s owner and using it against his will and against his interests is known as hacking that computer.  It’s universally regarded as a form of computer crime, and rightfully so.  But when DRM technology is involved, it’s not a crime; instead it’s a legally-protected “access control.”  That’s what the DMCA and similar laws in other countries are all about: they explicitly give copyright owners the right to hack your computer, at any time and for any reason, if your computer runs their copyrighted material.  And until this notion is reversed, and the use of DRM technology is legally recognized as the crime it is, we can expect to see the future of computing looking more and more like the iPhone.

It would seem that Apple has come full circle.  Thanks to Apple Macintosh, 1984 was not like “1984″. But thanks to Apple iPhone, 2010 might be.

As programmers, we often have near-absolute power on a computer.  We have access to everything that’s not specifically denied to us by system security, and with that much power comes great responsibility.  It’s important to remember what I consider the first principle of programming ethics:  When you write a program for someone else to use, the computer they are running it on is their property, not yours, and your program needs to behave itself accordingly.

There’s a negative corollary to the Golden Rule that applies here.  Do not unto others as you would not have them do unto you. Much like a surgeon whose power over a patient in his care is similarly near-absolute, we have the implicit responsibility to “first, do no harm.”  Your program needs to behave itself as an invited guest in someone else’s home.  You do not walk in and act like you own the place, and this has implications far beyond simply avoiding virus-like behavior.

For example, unless you’re writing for a very old computer, or for a few particularly backwards modern devices, such as the iPhone or most game consoles, your program is going to have to share the system with a bunch of other programs, and they need to execute too.  This means that you need to be careful to accomplish your task while using as few system resources as possible so you don’t end up hogging resources that another program may need.  If possible, keep your CPU and memory usage low.  This also means, for example, that it’s a very bad idea to use a garbage collector that’s designed to build up as much garbage as possible before collecting. That’s like never putting anything in the dishwasher until you have no clean dishes left in the house.  (And I’m sure some of you out there have kids that do exactly that.  Doesn’t it drive you up the wall?  Do you really want a program doing that on your computer?  If not, don’t do it to other people’s computers.)

Then there’s “protection.”  Most programmers tend to be pretty good about this sort of issue, until the idea of someone doing unauthorized things with their program comes up, and then all rational thought, not to mention consideration for ethics, goes right out the window, seemingly replaced by testosterone-driven outrage from coders who are usually rather mild and easygoing.  “What?!?  They’ll never get away with stealing my program!”  And then they proceed to do all sorts of blatantly evil things to other people’s computers.

Like most emotional knee-jerk reactions, this approach ignores the actual facts of the matter.  For example, empirical evidence suggests that, in the absence of any enforcement, almost 90% of people tend to be basically honest. That’s pretty darn good, even before you figure in the additional cost of actually providing the enforcement.

Also, copy protection simply does not work, due to a combination of two factors.  First, in order for the program to actually run, or for protected data to be read by a program, there has to be a “door” in the copy protection someplace.  Not a secret “backdoor,” just the ordinary variety that lets the authorized user through.  Thing is, if that exists in a computer-readable format, some user can find it and figure out how it works.  There are some coders out there who can read assembly as easily as you and I can read the language of our choice, and if one of them tries to find a hole in your protection, it won’t last long, and this is a very important point.

DRM proponents often say that a copy-protection scheme doesn’t have to be perfect; just good enough to discourage casual hackers and “keep honest people honest.”  The part about keeping honest people honest is nonsense, of course.  Either someone is honest or they aren’t.  But the thing is, so is the part about it not having to be perfect.  That might have been true twenty years ago, but today a copy-protection scheme has to be absolutely perfect, because if it’s cracked once, by anyone anywhere, it’s all over.  The crack will be posted online and any of those 13% or so of dishonest people out there who wants to use your program for free will have immediate access to it at the cost of just a little bit of searching.

And then there are the ethical issues involved.  In any other context, an external programmer taking control of the functionality of a computer away from the computer’s owner and using it against the owner’s interests is known as computer hacking, (or cracking if you prefer to use the term “hacker” in its original, positive context,) and is quite illegal.  Why all the special pleading in the case of DRM?  Because there’s lost revenue involved?  When did ensuring revenue become more a important consideration than not committing a crime?  Follow that line of reasoning far enough and you end up with Enron and Bernie Madoff, or the Sony rootkit.

We’re beginning a new year, and it’s traditional to set resolutions.  I hope everyone involved in programming will resolve to try to hold ourselves to the high standard of not writing code to do anything on another person’s computer that we wouldn’t want done on ours, and also to the even higher standard of actually thinking through the implications of what we try to do to figure out whether or not it would end up doing something bad.  Then maybe we’ll end up with a few less questions like that on StackOverflow, and I won’t have to keep posting the same answer to them.

Happy New Year, everyone!