Joe Hellerstein (part of Berkeley Orders Of Magnitude: Of course it’s possible to write cloud software with existing programming environments and languages. That’s precisely what goes on inside large clusters at the big hosted services. The problem is that the environments at hand today were designed for single-node programming, and using them to write scalable, robust cloud services is incredibly difficult. As a result, there are very few programmers with the competency to write cloud services that take advantage of the platform’s potential. And even those programmers are only a fraction as productive as they could be. In general, the potential for creativity in developing new technologies on the cloud is being stymied by an inability to quickly write software, learn from the experience, and move forward.
Google App Engine
From Google App Engine:
Differences from other application hosting: Compared to other scalable hosting services such as Amazon EC2, App Engine provides more infrastructure to make it easy to write scalable applications, but can only run a limited range of applications designed for that infrastructure. App Engine's infrastructure removes many of the system administration and development challenges of building applications to scale to hundreds of requests per second and beyond. Google handles deploying code to a cluster, monitoring, failover, and launching application instances as necessary. While other services let users install and configure nearly any *NIX compatible software, App Engine requires developers to use only its supported languages, APIs, and frameworks. [...]
Differences between SQL and GQL: Google App Engine's datastore has a SQL-like syntax called "GQL". Select statements in GQL can be performed on one table only. GQL intentionally does not support the Join statement, because it seems to be inefficient when queries span more than one machine. [...] This shared-nothing approach allows disks to fail without the system failing. Switching from a relational database to the Datastore requires a paradigm shift for developers when modeling their data. Unlike a relational database the Datastore API is not relational in the SQL sense.
slide 3 -- App Engine Does One Thing Well:
App configuration is dead simple: No performance tuning needed
Everything is built to scale: "infinite" number of apps, requests/sec, storage capacity; APIs are simple, stupid (the KISS Principle)
slide 5 -- Scaling:
Stateless APIs are trivial to replicate
Datastore built on top of Bigtable; designed to scale well: Abstraction on top of Bigtable; API influenced by scalability (no joins, reccomandations: denormalize schema and precompute joins)
slide 6 -- Security:
Constrain direct OS functionality: no processes, threads, dynamic library loading; no sockets (use urlfetch API); can't write files (use datastore);
slide 8 -- Automatic Scaling to Application Needs:
You don’t need to configure your resource needs
The Application Environment:
An application can only access other computers on the Internet through the provided URL fetch and email services. Other computers can only connect to the application by making HTTP (or HTTPS) requests on the standard ports.
An application cannot write to the file system. An app can read files, but only files uploaded with the application code. The app must use the App Engine datastore, memcache or other services for all data that persists between requests.
Application code only runs in response to a web request, a queued task, or a scheduled task, and must return response data within 30 seconds in any case. A request handler cannot spawn a sub-process or execute code after the response has been sent.
The App Engine datastore is not like a traditional relational database. Data objects, or "entities," have a kind and a set of properties. Queries can retrieve entities of a given kind filtered and sorted by the values of the properties. Property values can be of any of the supported property value types.
Datastore entities are "schemaless." The structure of data entities is provided by and enforced by your application code. The Java JDO/JPA interfaces and the Python datastore interface include features for applying and enforcing structure within your app. Your app can also access the datastore directly to apply as much or as little structure as it needs.