

O'Reilly book on Palm Pre's WebOS - First draft released. - geeko
http://developer.palm.com/webos_book/book1.html

======
jbarciauskas
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?

~~~
jemmons
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.

------
jemmons
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.

~~~
rufo
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.

~~~
jemmons
"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.

