Mobile Web Wars Videos: Does Anybody Care About Android?

A week ago, I put together a roundtable about the upcoming mobile platform wars between the iPhone, Google’s Android, and older platforms like Nokia’s. One thing I discovered as I was organizing the event was that it was really hard to find anyone developing Android apps other than the 50 people who won the Android Developer’s Challenge. (We tried to get someone from Android on the panel, but Google declined to participate).

Most of the 20 CEOs, developers and VCs on the roundtable were more interested in the iPhone, Nokia, and other platforms that actually exist as something other than a software emulation. Their attitude seemed to be: Show me the phones.

Pandora CTO Tony Conrad went even further, saying, “I need Android like I need a hole in the head.” To which Michael responded: “As soon as it launches, you are going to be kissing Google’s ass and you are going to be launching on their platform.” Here’s a clip with Tony and Michael going at it:

Another debate was whether the iPhone is really anything new. AdMob CEO Omar Hamoui (in T-shirt) argued that it indeed represents a fundamental shift because it is the first time most people are actually using the mobile Web, regardless of how long it’s been around. (This was basically the premise of the panel). Skydeck CEO Jason Devitt (in striped shirt) pointed out that the existing mobile Web is already a fairly large market, citing a figure of $700 million spent on mobile games alone. Devitt, though, is old-school (he previously founded Vindigo), and even he admits that he doesn’t browse the Web on most phones other than the Phone.

Source :

Copy and Paste Finally Coming to the iPhone

Copy and Paste has long been one of the most requested features on the iPhone, and its continued absence has been both frustrating and confusing for many. How can it be that the iPhone – running a finely tuned version of Mac OS X – is unable to perform functions that have been included in text editors since the 80’s?

MagicPad, a new application from Proximi that is currently waiting for approval on Apple’s App Store, is finally making copy and paste a reality on the iPhone. The application is essentially an improved version of “Notes”, and features rich text editing, allowing users to modify font type, size, and color. And best of all, it allows for copy and paste. Users need only drag their fingers over text to select it, and adjustments can then be made on a menubar that appears above the onscreen keyboard (see the video below).

Unfortunately, MagicPad isn’t going to bring true Copy-and-Paste to the iPhone, as there will be no way to copy text between applications (say, from Safari to the Mail client). You’ll be able to copy and paste between multiple notes within MagicPad, which will make it a step up from Notes, but in reality it serves as more of a proof of concept than a solution.

So when will we finally get true, systemwide, copy and paste? Earlier this month, Apple’s Greg Joswiak finally commented on the issue, explaining that it was on Apple’s to-do list but that it hasn’t been a priority. The lengthy wait is almost certainly due to issues with creating an intuitive interface for copy and paste on the iPhone’s buttonless touchscreen. MagicPad’s interface looks like it works well enough, but it takes up a large portion of screen real estate and is less elegant than what we’ll probably see from Apple.

Thanks to Apple iPhone Apps for the video.

First Look – MagicPad from Apple iPhone Apps on Vimeo.

Google Android vs. iPhone: Same as Microsoft vs. Macintosh ?

android_vs_iphone_thumb4.jpegBack in 1984, Apple was on top of the computing world with top-notch sexy hardware and it partnered with Microsoft for some top-notch [not so] sexy practical software. It was a winning combination for both Apple and Microsoft. Microsoft’s strategy in 1984 was hardware agnostic making its software available on any popular platform. Apple’s strategy in 1984 was holistic. We’ll call the period between 1984 and 2000, Round 1.

In Round 1, it turned out that Microsoft’s strategy was the clear-cut winner. By being hardware agnostic, hardware vendors competed with one-another to drive down the price of hardware much faster than anyone could have imagined. Clone prices fell so fast and so much lower than the price of a Macintosh that it simply became impractical to own a Mac. Software vendors also took note and quickly the non-Mac-PC became the standard. Apple nearly died.

2007 set off Round 2. This time around it’s in the cell phone business. Once again, Apple is on top of the Cell Phone game with top-notch sexy hardware and it has partnered with Google this time for some top-notch [not so] sexy practical software (think Google Maps, YouTube and other web-based Google Apps for the iPhone). Once again, it’s a winning partnership for both Apple and Google. And Once again, Google’s strategy is exactly the same to that of Microsoft in 1984: stay hardware agnostic. Apple’s strategy is also identical to its own strategy back in 1984: stay holistic. Round 2 has begun.

The similarities are eery. In 1984, while Microsoft was building the most popular application software on the Mac, it had begun a similar hardware-agnostic operating system (Windows) on its own. In 2007, while Google has some of the most popular application software on iPhone, it has begun a similar hardware agnostic Cell-Phone operating system (Android) on its own. Apple’s strategy has not changed a single bit. It refuses to license its operating system or any other technology while it continues to want more and more control over the entirety of the experience. The iPhone in 2007 has set off a brand new race much like the original Macintosh did in 1984. Interestingly, 24 years later, the strategies are still identical on both sides.

So will Round 2 end in the same way with Google’s Android prevailing due to exceptionally cheap phones that are sure to emerge using Android? Maybe not. There is one key difference between Round 1 & Round 2: Steve Jobs. Steve didn’t get to finish fighting the strategy that he helped establish for Apple in Round 1. He left Apple in 1985. So there’s no telling how things would have turned out. The fact that Apple lost round 1 may have taught everyone a lesson and it might falsely embolden Google to think Microsoft’s winning strategy was the better strategy. After all, Google’s chief, Eric Schmit, has been learning from (and losing to) Microsoft for 20+ years. Eric is now using Microsoft’s own strategy to successfully beat them. Google is the new Microsoft.

But this time around Steve is much smarter than he was in 1984. So smart in fact, that he’s resurrected Round 1 from the dead and may still pull off a win (the Mac is coming back). It’s possible that Steve & Apple’s holistic approach will still be the winning approach for Round 1, assuming you extend round 1 to at least 2015. But in Round 2 Apple’s chances are a lot better. Everybody is at the beginning of the race. There are no clear winners and just like in 1984, Apple has a major lead. It’ll be interesting to see what happens.

I’m curious to know your thoughts on:

  • Who you think will win Round 2: will it be Google with its Android or Apple with its iPhone?
  • Is Round 1 over in your view or will the Mac eventually beat out Windows-based PCs in market share?
  • Is Microsoft even a player in Round 2? (I would never recommend a current Windows-Mobile phone to my worst enemy – so do they even stand a chance?)

A developer’s perspective on Google’s Android

On Monday, November 12, 2007, Google released Android, a complete Linux based software stack aimed directly at the cell phone marketplace. I’ll let others talk about what it means for other players in the marketplace, the intricacies of GPL2 vs the Apache License, etc. This article dives straight into the heart of the SDK and API itself, summarizing some of the documentation provided by Google, then jumping into building an application using Android.

Android Emulator

(Click to enlarge)

So, what Is Android?

Android is a complete software stack for mobile devices such as cell phones, PDAs and high end MP3 players. The software stack is split into four layers:

  • The application layer
  • The application framework
  • The libraries and runtime
  • The kernel

Cell phone users obviously work with applications in the application layer. Android developers write those applications using the application framework. Unlike many embedded operating environments, Android applications are all equal — that is, the applications that come with the phone are no different than those that any developer writes. In fact, using the IntentFilter API, any application can handle any event that the user or system can generate. This sounds a bit scary at first, but Android has a well thought-out security model based on Unix file system permissions that assure applications have only those abilities that cell phone owner gave them at install time. The framework is supported by numerous open source libraries such as openssl, sqlite and libc. It is also supported by the Android core libraries — more on that in a second. At the bottom of the stack sits the Linux 2.6 kernel, providing the low level hardware interfaces that we all expect from a kernel. This is a Unix based system — that is, the Unix C APIs are available — but don’t expect to drop to a shell and start executing shell scripts with your old friends grep and awk. Most of the Unix utilities are simply not there. Instead Android supplies a well thought out API for writing applications — in Java using the Android core libraries.

That’s right, Android applications are almost exclusively written in Java. The Android core library is a big .jar file that is supported by the Dalvik Virtual Machine — a fast and efficient JVM work-alike that enables java-coded applications to work on the Android cell phone. This is similar to, but not the same as using Sun’s JVM directly.

Building your development environment

Google provides three versions of the SDK; one for Windows, one for Mac OSX (intel) and one for Linux (x86). They also provide two development environments — one is Eclipse based, and the other is a “roll your own.” The Eclipse based environment is quite feature-rich and should suffice for most developers. There is no reason that you can’t use both Eclipse and “roll your own.”

If you get stuck in eclipse (like I did), you may find yourself dropping to the command-line interfaces to see what’s really going on. However for this article, I’ll assume that you’re using the Eclipse IDE for your Android software development needs. Once you’ve downloaded the Android SDK, Eclipse and the Eclipse Plugin, you should work through the first few sections of Google’s install document (System and Software Requirements, Installing the SDK, Installing the Eclipse Plugin). I’d leave the rest of the document for later as it does get quite detailed quickly.

Read the Friendly Manual

Google has done a good job of writing a lot of documentation for Android. However, there isn’t a great way of knowing what’s important to read now vs. what can wait. Here are some links to documents that are important to understand what Android is and how to develop applications using it. If you read them in the order listed, then you’ll gain understanding more quickly as you read increasingly detailed documents. Note that a lot of the documentation is available both online and in the SDK_ROOT/docs/index.html directory on your machine. If you have a fast enough connection, I would suggest using the on-line versions since they will be more up to date.

Here’s the order in which I suggest you read the documentation:

  • What is Android? Explains what Android is and gives a high-level overview of its features and architecture. Don’t dive into the links just yet — just get a feel for this overall document.
  • Read the Anatomy of an Android Application page. This details the four building blocks of an Android app: Activity, Intent Receiver, Service and Content Provider. Again, don’t follow the links just yet — just get an overview of the architecture. You may want to reread sections on Activities and Intent Receivers — gaining an understanding of these concepts is critical to understanding how to build an Android application. If you don’t get it yet, you’ll see it again when you go through the Notepad Application Tutorial.
  • Next read the Development Tools document. Again — just get a flavor, don’t dive into the detail yet.
  • Read the Lifecycle of an Android Application page.
  • Now, finally, it’s time to get your hands dirty. Work through the Hello Android page. Make sure you actually do it using Eclipse.
Note: I had a problem here. The first time I ran the application, it worked fine. However on subsequent runs my application would not appear on the emulator. I killed and restarted the emulator, killed and restarted eclipse several times — no joy. Finally, somewhat frustrated, I was going to re-install everything. However before I did, I found an invisible instance of the Android Debug Bridge (adb) running. I killed it and everything worked again. I thought I had to close the emulator after each run of an application, but this turns out not to be the case. When I closed the emulator after my first run, it left the instance of adb running, which interfered with the subsequent instances.
  • Now go back and read the rest of the Installing the SDK document — the bottom half of it details some great debugging tips and features.
  • Next, go through the Notepad Application Tutorial. This is where the rubber really meets the road. If you spend the time to go through this series of exercises and really understand the code, you will be well on your way to becoming an Android expert.
  • Read the Developing Android Applications pages. This will take some time — these articles go into a lot of detail about several topics including how to implement the UI, data storage/retrieval and the security model.
  • Finally, go back through this list and follow the links in the previous documents as topics interest you.

There’s a lot of documentation, but if flows together nicely, reflecting the architecture of the environment.

Dissecting the SDK

Whenever I download an SDK, I like to take a look at the files I’ve installed. Often, there is a wealth of information hidden in the SDK itself that is not readily visible from the documentation. So here’s what you’ll find in the Android SDK on a Windows machine:

  • android.jar – The Android application framework. Unzipping this jar reveals the entire class structure and all of the supporting classes of the framework. Currently there is no source.
  • docs – 100 megabytes worth of documentation, samples, etc.
  • samples – Six different sample applications – ApiDemos, HelloActivity, LunarLander, NotePad, SkeletonApp and Snake
  • tools – the various SDK binaries such as aapt, acp, and emulator live here.
    • lib – various templates and supporting jar files live in this directory
      • activityCreator – the activityCreator python application lives here.
      • images – The Linux file system images are found in this directory: ramdis.img, system.img and userdata.img. They are YAFFS2 file system images, so I couldn’t open them without additional kernel support on my Fedora system.
        • skins – supporting emulator graphics for HVGA and QVGA screens in both landscape and portrait format.

Exercising the SDK

Now that you have read the documentation and set up and debugged a simple project, it’s time to look at some real code. Since Google has provided us with several sample applications, the best place to begin is by examining them.

  1. If you have not already done so, execute the first few sections of Google’s install document. Stop after you’ve installed the Eclipse plugin successfully.
  2. Now work through the Hello Android page if you haven’t already. This will get you started working with Android applications and the debugger. Note that it’s probably a good idea to create a new workspace for your Android projects if you already use Eclipse.
  3. Next we’re going to set up Eclipse projects for each of the sample applications. You can never have too much sample code. I’ll walk through setting up the Lunar Lander example and leave it as an exercise to the reader to set up the rest.
    1. Bring up the same Eclipse workspace that you used for the Hello Android, and close the project (Right click on the project in package explorer->Close Project).
    2. File->New->Android Project
    3. Project Name: LunarLander
    4. Click the “Create Project from existing source” radio button
    5. Browse to the samples/LunarLander directory in the SDK. If you find the right directory, the Properties fields will auto-fill with the correct information from the Package.
    6. Click Finish
    7. Bring up Eclipse’s Console window (Window->Show View->Console) if it’s not already visible in a tab at the bottom of the screen. It will show you the build process that Eclipse went through to create the application.
    8. Create a Run Configuration: Run->Open Run Dialog
    9. Highlight “Android Application” in the treeview to the left.
    10. Click the “New button”.
    11. Name: Lunar Lander
    12. Click the Browse button next to Project
    13. Double-click the LunarLander project and hit OK
    14. Click the down arrow for the Activity and choose the one and only Activity:
    15. Click Apply
    16. Click Run
    17. Switch to the Emulator and play a few rounds of Lunar Lander. Kinda fun.

Repeat for the other applications in the samples directory. This exercise should only take a few minutes — besides, the Snake game is fun too! If you’ve taken the time to go through the Notepad Application Tutorial, then you’ll be familiar with the NotePad sample — however, the NotePad sample is fully developed and has features beyond the NotePad developed during the Tutorial.

A File System Explorer Application

Finally, we’ll use our new understanding of the Android to develop a simple file system explorer. The version in this article is pretty simple, but it can serve as a jumping-off point for a more serious application down the road.


Before we start writing code, let’s think about what a reasonable file system browser should do. It should

  • Phase I features
    • Show a list of files and directories
    • Allow the user to navigate through the directory structure by clicking on directories
    • Warn the user that he has clicked on a file
  • Phase II features
    • Allow the user to display a dump of a file when it is clicked
    • Use a tree view instead of a simple list
    • Show a dialog box with the filesystem information (size, permissions, etc) when the user clicks on an icon next to each file
    • Give this application permissions to read any file on the file system
  • Phase III features
    • Do all of phase II with pretty graphics, such as thumbnails, instead of boring dropdowns and list boxes
    • Execute applications that we understand, such as mp3 files


This article will only cover Phase I of the project — but when we’re done, we’ll have a functional file system explorer in just a few dozen lines of code.

To proceed with this hands-on example, click here.

New Android Project
(Click to enlarge)
It works!

If you clicked above to follow the hands-on example, you found that in about twenty lines of Java, and a small amount of XML, you’ve created a useful little application that will allow you to explore the Android’s file system. For example, I found the ringtones in /system/media/audio/ringtones, as shown below.

Oooh, ringtones
(Click to enlarge)

As I mentioned in the design section, a lot can be done with this application, and we’ve hardly touched the surface of what you can do with the Android application environment. There’s three billion cell phones out there. I suspect Google will get their fair share of them, so start cranking out code!


Android is a well-engineered development environment. Writing an Eclipse plug-in was a smart move by Google — one that should be emulated by other SDK developers. Eclipse gives a developer and environment where he can really think about the business problem without worrying about the boring details. Adding the functionality of the plugin helps developers just sit down and start coding — without having to worry about all the ins and outs of configuration files and the like.


Android is brand new to the general developer’s world. As I write this, it’s Wednesday, and the SDK came out on Monday of this week. Since it’s brand new, there are some little problems that will have to be solved in the coming releases.

  • Many more examples for the APIs.
  • A more thorough explanation of what does and does not work under the emulator. My first example application was a simple MP3 player.
  • Release the source code. This will make it a lot easier to debug Android applications, as well as write them in the style that the Google developers wrote them.


Theres a lot to like about Android:

  • It’s by Google — so it has a company with some clout behind it.
  • Application Developers write their code in Java. Since the learning curve for Java is much less than that of C/C++/ObjectiveC, there will be many many developers who are eager to start writing applications for Android.
  • The SDK and API are well designed. There is some complexity there, and as I mentioned, the Documentation needs improvement — but a well designed system is easier to understand and learn, even without lots of great examples.

Schmap launches city guide web app for iPhone and iPod Touch

Schmap, publisher of over 200 free online travel guides, has opened access to their guides for iPhone and iPod Touch users by way of a remarkably nifty web application. The guides cover cities throughout the US, Europe, Australia, Canada, and New Zealand, and provide information on everything from the city’s historical background to the best places to get your drink on.

schmap.pngAs portrayed in the image, the web app utilizes the iPhone’s gyro sensors and a Safari specific JavaScript function to determine how the device is currently oriented, and swaps between two display modes accordingly. If the device is oriented vertically, points of interest are displayed as a simple list; if horizontal, the points are overlaid on a map of the area. This allows the user to jump back and forth between modes without having to dig through menus, and is an ingenious way to make the most of the available screen real estate.

In addition to the city guides available for many major cities, Schmap is working on implementing a local search feature to provide similar functionality for cities they haven’t charted out yet. While local search results obviously won’t be as in-depth as the custom written city guide entries, it provides enough to get by: the business name, street address, and phone number. It did a good job of finding coffee shops in my area, even pointing out a few I’d somehow managed to ignore. I was unable to get the local search to recognize any zip codes, so you may need to type out the city’s name for the time being.

My only dislike with the service thus far is the tiny size of some of the buttons. I definitely don’t have sausage fingers, yet I constantly found myself tapping just outside of the detection areas. This was especially true of the arrows at the top and bottom of the interface.

Overall, Schmap for iPhone/iPod Touch is an incredibly handy application, especially while traveling or getting to know a new area. I’d expect to pay a few bucks a month for the service; that it’s free is just the mega delicious icing on the cake.

Few cool iPhone SDK Features

iPhone SDK includes Web app creation tool

The iPhone SDK (software development kit) made available yesterday includes a new version of Dashcode (v. 2.0 Beta [126]) that allows creation of Web apps for the iPhone. When you click run, these Web apps launch in the Aspen Simulator. The tool also has support for bundling home icon images into the deployed Web app.

Preset styles include the standard sliding-style “Browser” interface. Code snippets include gauges, indicators, forward and back buttons, form elements and more.

Whether this means Web apps will be able to be stored locally under iPhone software/firmware 2.0 has not yet been determined

iPhone OS 2.0 will support locally stored Web apps

It appears that Web-apps can be stored locally under the forthcoming iPhone OS 2.0. The new OS iteration will include support for the client-side database API, which is part of the HTML 5 spec. Apple says this functionality goes “well-beyond cookies” and has robust support for offline data usage.

Apple says that properly designed with the client-side database API can be “totally functional even with the network disconnected.”

The version of Safari included with iPhone OS 2.0 will also include a full-screen mode in Safari. This means that Web apps can be displayed without the Safari address bar and other elements. With an appropriate meta tag, a Web app launched from the home screen can automatically be launched in full-screen mode.

As previously reported, the iPhone SDK (software development kit) made available yesterday includes a new version of Dashcode (v. 2.0 Beta [126]) that allows creation of Web apps for the iPhone. When you click run, these Web apps launch in the Aspen Simulator. The tool also has support for bundling home icon images into the deployed Web app.

“Limited number” to be let into iPhone developer program

An Apple press release accompanying today’s “software roadmap” announcements states that “a limited number of developers will be accepted into Apple’s new iPhone Developer Program,” which is priced at $99. As previously reported, the program allows access to pre-release iPhone software; technical support; the ability to get code onto iPhones for testing; and distribution of applications via the new App Store.

The “Enterprise Program” costs $299 per year.

“The iPhone Developer Program will initially be available to a limited number of developers in the U.S. and will expand to other countries in the coming months.”

Which means that we third world programmers in UK with official iPhones still get treated like second class citizens, so I guess we might as well soldier on with the unofficial SDK and not be limited by Apple’s marketing policy.

Now I’m sure that Apple thinks that the rest of us will wait 6 months while other programmers get a lead on us.

But software development just isn’t like that. So I guess its down to who can break the new application installation / launch system first. And once its broken, it’ll stay broken.

iPhone applications to be delivered via wireless download; Apple takes 30% cut

Much like the application used to install unofficial iPhone applications, official iPhone applications will be delivered wirelessly to the iPhone via “App Store,” a new program that will be added to the iPhone in the next software update.

All of the hosting, credit card transactions, etc. will be handled by Apple.

Developers will be able to set whatever price they want for applications, but Apple will take a 30% cut of revenues.

There will also be a mechanism to download applications onto your computer then transfer them.

For free applications, there will be no charge to the developer.

Software development kit for the iPhone is available to developers today as a free download (the iPhone Dev site is currently down for maintenance). Joining the iPhone developer program — which will provide technical support, code testing and allow distribution through the “App Store” — costs $99.

The iPhone 2.0 software update — which allows end-users to run iPhone applications and includes a bevy of enterprise-related enhancements, including Exchange support — will be released as a free update in June.

Xcode to be used for iPhone development; iPhone simulator included

Claiming to make accessible the same APIs that it uses for iPhone development, Apple today announced that the object-oriented application programming environment that will be used for the iPhone SDK. Accessible features include:

* Core Animation — letting developers build animations, ala CoverFlow
* OpenGL in an iPhone-optimized edition
* Core Audio
* SQLLite

The iPhone’s Core OS uses the same kernel as Mac OS X in a scaled-down, power-optimized version.

Apple also announced that Xcode will be the development tool of choice for the iPhone. A revised edition for the Mac OS X development environment will include an interface builder for the iPhone, performance testing tools and a remote debugger that can connect to an iPhone.

There will also be an iPhone simulator which runs on Macs and emulates the iPhone.

Apple’s SDK will eventually boost iPhone hype

Apple CEO Steve Jobs unlocked the iPhone’s true capabilities. Apple put out a beta version of an iPhone SDK, or software development kit, which allows third-party programmers to create applications for the iPhone.

The program will go live for the public in June, when Apple releases version 2.0 of the iPhone’s system software. The new capabilities will go out to all iPhones for free.

That is, in a few months’ time, everyone’s iPhone will be able to run programs made by a software developers across the world, not just those in Cupertino. Firefox for the iPhone — not to mention Quicken for the iPhone, 3-D games for iPhone, maybe even Skype for the iPhone — is no longer a dream. It’s a reality.

I have to admit, I’ve been skeptical that Apple would do the right thing here. Last year, it didn’t treat third-party apps — created without Apple’s approval — very kindly when it issued an iPhone software update.

Jobs, in defending keeping other people’s programs off the iPhone, often suggested that security was the problem — if just anyone could create programs for the iPhone, he said, AT&T’s cellular network would be made vulnerable to iPhone viruses.

This claim seemed specious: Surely Apple could find a way to keep malware off the phone while allowing useful apps an entry? So what was the real reason for the lock? Was it money? Was it Jobs being a control-freak — did he want to personally approve everything that got on to the phone?

There was also the worry that Apple would allow third-party apps, but would demand a huge licensing fee from anyone who wanted to create iPhone programs. This would limit developer interest: If they have to pay Apple to make software for the iPhone, the best developers were likely to choose a more hospitable mobile platform. Like, say, Google’s Android phone.

Though he didn’t mention the competition during his announcement at Apple’s headquarters today, it seems reasonable to guess that Google’s entry into the phone market helped prompt Jobs’ change of tune. Today’s announcement goes far in cementing the iPhone as the leading mobile platform — Apple’s SDK looks so powerful, and its licensing terms are so reasonable, that mobile developers would be crazy not to adopt the iPhone as their main focus.

Under the new system, Apple has created something called the iPhone App Store. The store, which you access through the phone itself, lets you browse through all third-party applications available for the phone. You can buy and start using them instantly. Developers will be able to choose the sales price; they’ll keep 70 percent of the revenues, and Apple will get 30 percent (which is similar to the the sharing model Apple uses for music sales on iTunes).

But here’s the best part: If you want to “sell” your program for free, Apple will charge no fee to developers. This is an obvious boon to free software projects like Firefox.

You can expect many big software companies to get into the iPhone applications business. At the presentation today, EA Games, Sega,, AOL, and others showed off some great iPhone sample programs they’d created in just a few weeks’ time.

Apple says that the SDK is the very same system that its own developers use to make iPhone programs, meaning that third-party developers will be able to do everything that Apple’s programs do. (There are some exceptions: Voice-over IP programs like Skype will only work on the iPhone’s Wi-Fi network, not its AT&T cellular network. Presumably, this limitation is an AT&T demand.)

But not only big companies will make iPhone programs. Today Kleiner Perkins, the huge Silicon Valley venture capital firm, announced a $100-million fund to invest in new companies looking to create programs for the iPhone.

At the Apple event, Kleiner partner John Doerr hailed Steve Jobs as the “world’s greatest entrepreneur.”

In making the iPhone accessible to other entrepreneurs — software developers everywhere with with bright, useful ideas — Jobs may have proven Doerr right. The iPhone, now that it’s open, could really be huge.

iPhone SDK exceeds developer expectations

Apple SDK should please three core constituencies: Developers, enterprise IT and consumers.

Here are few major things which goes towards happy devloper base:

Developers get a solid database and a familiar API tool set
What pleased developers was a set of functionality that will let them write native iPhone applications through access to the iPhone APIs.

In addition, Apple hit the right note by offering SQL Lite as the built-in database layer. SQL Lite, an open-source database, is widely used by the mobile developer community and runs well on small devices. “It will make it easy to store data”.

Cocoa Touch, the built-in set of APIs that re-creates the Cocoa tool set used to handle the user-interface-generated events in Mac OS X is targeted at the iPhone’s and iPod Touch’s unique touchscreen as well as their gesture-based UI. “It’s an elegant way to deal with the interface paradigm”.

IT gets better, more secure connections
Also garnering praise from mobile industry watchers is the planned inclusion of Microsoft Exchange ActiveSync, the technology required to synchronize mail, calendar, and other data directly with Microsoft Exchange rather than use third-party gateways or synchronization services. Apple licensed the technology from Microsoft and will include it in the iPhone 2.0 software planned for release this June. (All the additional features described here will be released with that software update, Apple said.)

The iPhone also will gain remote wipe and lock and on-device data encryption, two features that caused much IT criticism. Plus, Apple will enhance the VPN capabilities it added to the iPhone in late 2007, adding support for Cisco IPsec and two-factor authentication, certificates, and identities. Information Builders’ Kotorov said he was particularly enthusiastic about iPhone’s deepened support for VPNs. Apple will also provide a way for IT to enforce security policies on the iPhone, though the mechanism was not described at the Apple press conference.

Users get push messaging and desktop equivalency
The licensing of ActiveSync benefits not just IT but users in Microsoft Exchange-based environments. They not only can access the same calendar, contacts, e-mail, and other data as they can from their desktop, but they also gain push e-mail. In push e-mail, the iPhone gets a new message almost as soon as it is sent — a feature beloved by users of the BlackBerry, which pioneered the concept. Previously, the iPhone had to poll the server periodically, typically at 15-minute intervals, so unless users manually polled the server, an urgent message might not be seen for some time.

Still, IT won’t be completely happy
As welcome as the SDK and enhanced business-oriented features are, people still have more they want Apple to offer.

A common request is availability from more than one carrier. Currently, the iPhone only works on the AT&T network. “Companies don’t want a single carrier for voice and data” according to Forrester’s Yates.

Second, the iPhone isn’t supported by management tools like LanDesk and lacks a consistent set of management tools like those from Credant Technologies and LanDesk, which support BlackBerry, Windows Mobile, and Palm OS devices. This means that IT has to manage the iPhone separately from other devices as well as separately from PCs. “What [Apple] needs to do is natively integrate into management tools that companies already use for their other mobile devices,” Yates said.

Perhaps worse, the iPhone requires IT and developers to push applications to users through the Apple iPhone store. Apple says it is doing so in a way that will be IT-friendly, though it did not specify any details: “We’re working on a model for enterprises for them to distribute applications to their end-users, specifically with a program for them to target their end-users. We have a model we’re building for that,” said Phil Schiller, a product marketing exec at Apple.