I took these notes from the six videos found on the Google App Engine (GAE) page. I hope this quick coverage helps explain what GAE is all about though I am waiting on account approval to begin using the live site tools.

I will be playing around with local dev work in the meantime.

In short GAE is about building your own web pages to run on Google's provided infrastructure. To my understanding this infrastructure includes things like access to Google's account management for logged in user detection, sending emails, Google BigTable database access for creating your own db storage based on GAE's base Types and Property Classes.

GAE provides access to Google Scalable Infrastructure and enables web application development by leveraging core Google architecture elements. Here are some of those key pieces

Google Accounts for authentication
BigTable for database work
Google File System (GFS)

These same building blocks are interfaced into the GAE.

The stack as they called it in the video are the key components in GAE ----

1> Google's Scalable Serving Infrastructure
2> Python Runtime (first language supporting GAE App engine)
3> Software Development Kit (code and test locally)
4> Web based Admin Console (ties everything together)
5> Datastore (scalable persistence layer based on BigTable)

It appears that the SDK installer will support Linux, Mac and Windows and will stick the Python runtime environment on your dev machine and a web server and datastore that will work locally just like it would for an application running on a Google App server.

The demo shows building a first app in which they fired up a terminal running the local hosting environment to run the app. First they created a YAML application configuration file (app.yaml) and then some Python code using semi-broke-down version of the Python 2.5 runtime environment

Deploy your app using appconfig to Googles Servers was as simple as running the following like of code in the terminal window (the hi-res video was not very good to see what they actually typed though)

appcfg.py update [project directory]
but I found a more explicit reference for Uploading an App

Deep Dive notes...

1> Scalable Serving Infrastructure
Fault Tolerant (scale and moves load around in response to end user demand)

2> Python Runtime (first language supporting app engine)
Modular set of API's used by the Language (any other language can use as well)

3> Software Development Kit (code and test locally)
Release for Linux, Mac and Windows (Python Interperter)
Code, Compile, Test Locally before you deploy

4> Web based Admin Console (ties everything together)
In the videos they called it "A simpler alternative to the LAMP stack." although I personally don't find learning a new language like Python to be simple (being an old fart set in my ways.)
This tool provides
Look at the status of an application
Set who can control the application
Set who can upload new versions
Which version of the app gets most of the traffic
Provides additional tools like
Request Logs
Application Logs
Data Explorer (SQL Admin Like Tool)
Check, Modify data, schema etc
Ability to hook a Domain into your app
Near Realtime stats on you application/site usage

5> Datastore (scalable persistance layer based on BigTable)
Scheme-less object store that supports millions of entities
Uses BigTable for store (can and will move data around as load changes)
Model Class for db types is what is used to expose data. This suckers are used to hold base datastore types and other GData Types. For instance there are string and bool types but there are more complex types like Rating which are based on the the types foun in the GData API reference for that type
Datastore API
GQL Language is the SQL like syntax that is used for retrieving and storing data. -
Queries are allowed on a single property or multiple ones.
There is a Bulk Uploader tool
Transactions
Doesnt support JOINS! (Since DB is distributed and scalable it overrides the need for JOINS)
Blob type support example (dont surpass your Limits/Quotas in bandwidth or storage)

Send Email APIs'
Make HTTP Requests - OutGoing (URLFetch API,Call Pages,Services)
Authenticate with Google Accounts in the Users API
Frameworks (Django - part of the SDK but you can add your own other frameworks)

Things removed from the standard library (from the main Python Language I think to support the Google architecture)
1> Cant write to the file system
2> Cant open sockets and must use URLFetch API,MailSend API
3> Threads disabled are not allowed because the app is distributed (and I can think of some code in this arena that could bring a server to it's knees.)

Python is not the only language for GAE. The GAE infrastructure is language neutral and any language runtime that can be hardened can be ported to this architecture.

All in all I'm a bit excited about getting approved for the program but I did not apply till this morning and likely all 10k accounts are already taken unless they are rolling out registered users in a slower fashion.

I have some simple ideas that would be nice to put out there. Some involve my own work with HTML content parts and other commons services framework elements that I would like to see written are reusable services.

Well I hope this level of detail help for a quick overview.. I know just writing it all down cleared up a lot for me.

Kevin Pirkl