O'Reilly book on Palm Pre's WebOS - First draft released. | Hacker News Reader

O'Reilly book on Palm Pre's WebOS - First draft released.

developer.palm.com

18 pointsgeeko8 comments

The question I have is, how do you build Super Monkey Balls in HTML/CSS/JS? And since the answer is quite clearly you don't, the next questions are, is there any alternative that gives you pixel-level control, and if not, how can the Pre hope to compete as a platform against the iPhone and Android?

Right. There's a name for locally run ajax web pages written in HTML/CSS/JS. They're called widgets. Now widgets can be cool, but Super Monkey Balls they are not.

Canvas gives you pixel-level control, but it doesn't do 3D yet.

All the wildly optimistic and unfounded claims of Palm having pulled off a "mini-revolution ... implementing a full SDK in HTML/CSS/JS" or of WebOS being more than "just a WebKit browser" can now finally be laid to rest. WebOS is exactly a webkit browser, and the applications one builds for it are indistinguishable from locally-run ajax web pages.

I don't know how you're getting that from this first chapter. It fairly clearly states that it's only talking about the underlying OS, and the Mojo Application Framework overview is in the next two chapters.

Granted, what they're talking about below isn't necessarily even revolutionary to web app development (SproutCore/Cappuccino), but considering it's an entire mobile OS built specifically to run applications written in this framework, I think that does change things somewhat.

From http://developer.palm.com/webos_book/book5.html

The framework provides a specific structure for applications to follow based on the Model-View-Controller (MVC) architectural pattern. This allows for better separation of business logic, data, and presentation. Following the conventions reduces complexity; each component of an application has a defined format and location that the framework knows how to handle by default.

You will get a more extensive overview of Mojo in Chapter 2, and details on widgets, services and styles starting in Chapter 3. For now, you should know that the framework includes:

Application structure, such as controllers, views, models, events, storage, notifications, logging and asserts;

UI widgets, including simple single-function widgets, complex multi-function widgets and integrated media viewers;

Services, including access to application data and cross-app launching, storage services, location services, cloud services, and accelerometer data.

"You can think of webOS applications as native applications, but built from the same standard HTML, CSS and JavaScript that you’d use to develop web applications."

"As shown in Figure 1-1, the original Palm OS has a typical native application model ... Ajax applications have some significant advantages over embedded applications."

"Architecturally, Palm webOS is an embedded Linux operating system that hosts a custom User Interface (UI) System Manager built on standard browser technology. The System Manager ... render[s] application HTML/CSS/JavaScript code."

"A webOS application is similar to a web application based on standard HTML, CSS, and JavaScript, but the application lifecycle is different."

"Applications are run within the UI System Manager, an application runtime built on standard browser technology, to render the display, assist with events, and handle JavaScript."

"The webOS APIs are delivered as a JavaScript framework."

"Although not formally part of the framework, the Prototype JavaScript framework is bundled with Mojo to assist with registering for events and DOM handling among many other great features."

"Outside of the built-in applications, webOS applications are deployed over the web."

"In addition, all applications will have an index.html file."

"Launching a webOS application starts with loading the index.html file and any referenced stylesheets and javascript files, as would be done with any web application or web page."

"Palm webOS supports the standard DOM Level 2 event model."

"Supporting webOS's user interface are UI Widgets and a set of standard styles for use with the widgets... you can also override the styles either collectively or individually with custom CSS."

"A widget is declared within your HTML as an empty div with an x-mojo-element attribute."

"Even limiting yourself to just webOS's System UI, application model and UI widgets, developers would have some unique opportunities for building web applications." Hear that? Up to this point, we've just been building web applications. But, "the Services functions complete the webOS platform, fulfilling its mission to bridge the web and native app worlds."

What are these magic functions that make webOS apps more than simple web apps? "You can access hardware features on webOS devices (such as location services, the phone, and the camera)." Oh. They're not web apps because they have GPS and can make phone calls. Great. Oh, and "there are functions to access data in some core applications", so I guess you can import addresses or something.

Yeah, I don't know what I was thinking.

> WebOS is exactly a webkit browser, and the applications one builds for it are indistinguishable from locally-run ajax web pages.

And the revolution is that these locally-run ajax web pages are in turn completely indistinguishable from what native applications on the Pre would look and feel like. The only thing they can't do is 3D and OpenGL. But then again, no Palm device could ever do that, and that didn't stop the Palm OS from having a games ecosystem.

I'm not sure what you mean by "what native applications on the Pre would look like."

If you mean that all applications on the Pre will be indistinguishable from one another -- that they are, in essence, all constrained by the same straight jacket of Ajax "web2.0" functionality -- then you might be right (though this document seems to hint that there's functionality only the blessed "core apps" have access to, so even this might not be true).

If, however, you mean to say that webOS apps will be indistinguishable from the native apps of any other smartphone platform (most notably the iPhone), well, I don't know how you can support that point in light of all the evidence provided in the article (highlighted in this thread). What precisely is so revolutionary about any of what we see here? The lifecycle? Access to GPS and the ability to launch apps? Theme-able widget libraries? An MVC development model?

Dashboard, Yahoo! Widgets, etc. give you lifecycle functionality. Dashboard, at least, lets you make system-level calls and launch apps. YUI, MooTools and ExtJS all provide theme-able tables, buttons and dodads for your web apps. Sproutcore covers MVC and then some. Despite predictions of some, these technologies have not united to overthrow native desktop applications. What makes you think they'll overthrow native smartphone ones?

Palm's clearly making a tradeoff, wooing web developers at the cost of application and toolchain robustness. Personally, I think that's silly (the AppStore and even the Palm Pilot software ecosystem of yore never had trouble finding developers) but maybe I'm wrong? Maybe people don't want more than widgets on their phones and the explosion of web2.0 "ports" to the Pre will secure it a place in smartphone history.

But to stick one's head in the sand and say "my webapp can do anything your objc or java app can because it's revolutionary..." Well, that continues to be untrue.

Reply on news.ycombinator.com