The document summarizes a presentation given by Ikai Lan about Google App Engine. The presentation covered what Google App Engine is, its features, how to get started, an introduction to the Go programming language, important tools for App Engine, and some tips. The speaker worked for Google in developer relations and focused on cloud products.
Introduction to Google App Engine talk delivered 2010 Jul 16 at EuroPython in Birmingham, UK and 2010 Jul 22 at the GTUG in London by Wesley Chun, Developer Advocate for Google.
This document discusses Gaelyk, a Groovy toolkit for Google App Engine. Gaelyk allows developers to use Groovy scripts instead of Java servlets and templates instead of JSPs. It provides enhancements to the App Engine Java SDK to simplify development when using Groovy's dynamic features. The recently released Gaelyk 0.7 adds support for new App Engine services and upgrades dependencies. Groovy is advocated for because it is a dynamic JVM language with a Java-like syntax that simplifies development through powerful APIs.
The document discusses JRuby on Google App Engine, including key features of App Engine, quotas and billing, limitations, the current issues with JRuby on App Engine, App Engine gems, the development environment, deployment process, APIs, and milestones in the development of JRuby on App Engine. It also includes a short biography and discussion of learning experiences from building an iPhone app that uses App Engine and JRuby as a backend.
This is a presentation on Google App Engine for Java given at Devfest 2009 in Buenos Aires Argentina on Nov 17, 2009 by Google Developer Advocate, Chris Schalk and Google Software Engineer, Ignacio Blanco.
This document summarizes a presentation about developing desktop applications using Adobe Integrated Runtime (AIR) with Aptana Studio. The presentation demonstrates building a Twitter client application called YafTc that retrieves and sends tweets using AIR features like accessing the filesystem and network. It discusses installing Aptana Studio and the AIR SDK, creating an AIR application, adding a user interface with controls, retrieving external data via AJAX, and saving data to the local filesystem. The goal is to show how developers can create rich desktop applications using the web development skills and technologies they already know like HTML, JavaScript and jQuery.
This document summarizes a presentation about developing desktop applications using Adobe Integrated Runtime (AIR) with Aptana Studio. The presentation demonstrates building a Twitter client application called YafTc that retrieves and sends tweets using AIR features like accessing the filesystem and network. It discusses installing Aptana Studio and the AIR SDK, creating an AIR application, adding a user interface with controls, retrieving external data via AJAX, and saving data to the local filesystem. The goal is to show how developers can create rich desktop applications using the web development skills and technologies they already know like HTML, JavaScript, and jQuery.
This document discusses JRuby and Duby for running Ruby and Ruby-like applications on Google App Engine. It introduces Google App Engine as a platform-as-a-service that handles scaling and infrastructure. JRuby allows running Ruby applications on App Engine by compiling to Java bytecode. Duby is a new language that compiles to Java and has Ruby-like syntax, avoiding runtime issues. Examples show how to create a simple blog application in Duby using App Engine services and data modeling.
Patrick Chanezon and Guillaume Laforge are presenting Google App Engine Java and Gaelyk, the lightweight groovy toolkit on top of the GAE SDK, at the Devoxx conference
Create a Professional Blog with WordPress: Chapter 6 Customizing Your Sites w...Atit Patumvan
This chapter discusses how plugins can be used to customize WordPress sites. It explains that plugins are bits of code that extend site functionality and provides examples of popular plugins like Google Adsense, Advertising Manager, and plugins for Twitter and Facebook integration. The chapter also describes how to find, install, activate, deactivate and manage plugins to enhance WordPress sites.
This document discusses deploying Ruby on Rails applications to Google App Engine using JRuby and a servlet container. It outlines reasons to use JRuby, Rails 3, Sinatra, and DataMapper, and how they can run on App Engine. It also provides an overview of the App Engine architecture, development server, deployment process, APIs available to JRuby applications, billing quotas, and resources for learning more.
This slides give you an overview of the technical challgens that Java EE application servers have faced to reinvent themselves. From monolithic to jigsaw puzzles, app servers are not the burden developpers use to use anymore
Javascript Views, Client-side or Server-side with NodeJSSylvain Zimmer
The document summarizes a presentation on building applications that can render on both the server and client using a single codebase. It discusses how traditional server-side and client-side apps are structured, then shows how server-side JavaScript allows building a single app with a shared core that can adapt for the server or browser through the use of adapters. It demonstrates this approach with a sample app and discusses benefits like serving HTML versions for search engines or legacy browsers. Key aspects covered are rendering on the server/client with a View class and handling browser history across environments.
Google Cloud Computing for Java Developers: Platform and Monetization was a presentation given by Chris Schalk at TheEdge 2010 conference in Tel Aviv, Israel on December 16, 2010. The presentation introduced Google App Engine and other Google cloud technologies, discussed monetizing applications, and provided an overview of the Google Prediction API and BigQuery.
The document provides an overview of Google App Engine, a platform that allows developers to build and host web applications without having to manage servers. It discusses the challenges of building scalable web applications, describes App Engine's features such as automatic scaling and integrated services, and covers how to develop, test, and deploy applications locally and on App Engine. It also reviews App Engine's programming languages, data storage, quotas, and billing model.
Android is an open source software stack for mobile devices that includes an operating system, middleware and key applications. It allows developers to write managed code in Java for the Dalvik virtual machine. The Android application framework provides components like activities, services and content providers that can be reused. It also supports hardware like cameras, GPS and accelerometers.
Similar to 2011 june-kuala-lumpur-gtug-hackathon (20)
Slides for a talk at the Colorado Software Summit in 2008 that I did about growing Bumper Sticker, a Ruby on Rails Facebook app to over a billion pageviews.
Funny thing is ... I had to bail on the conference. Had to ship product.
This document discusses REST, JSON, and OAuth. It provides an overview of each technology and how they work together. REST uses HTTP verbs like GET, POST, PUT, and DELETE to invoke remote methods. JSON is a lightweight data format that is easy to parse and generate. OAuth allows third party applications to access user data from another service, like Google, without needing the user's password. It works by having the user grant an application access during an "OAuth dance."
Ikai Lan presented about Google App Engine's High Replication Datastore. He began with his background and an overview of App Engine. He then discussed how the High Replication Datastore provides strongly consistent reads for queries with an ancestor and eventually consistent reads for other queries. He explained how entity groups and transactions allow for strong consistency, discussing concepts like optimistic locking, distributed writes, and catching local data stores up to the latest changes. He concluded with advice on entity group design and questions.
The document is a presentation slide deck on why the presenter likes the Go programming language. It summarizes some key reasons as: Go is a fast, modern language with a standard library for common tasks like JSON and web development. It is strongly typed yet flexible with interfaces. Concurrency is baked into the language with goroutines and channels. Go also has quick compilation times and runs on Google App Engine.
The document summarizes a presentation given by Ikai Lan on July 27, 2011 about Google App Engine's High Replication datastore. The presentation covered what App Engine is, the benefits of the High Replication datastore like strong consistency and high reliability, and how entity groups allow for transactional reads through ancestor queries. It also briefly discussed how Paxos is used underneath to provide strong consistency across datacenters.
Intro to App Engine - Agency Dev Day NYC 2011ikailan
The document summarizes a presentation given by Ikai Lan about Google App Engine. The presentation covered what App Engine is as a platform as a service, the anatomy of an App Engine application including core APIs, and demoed an open source blog application called Bloggart that runs on App Engine. The presentation also discussed App Engine's scalability, high replication data storage, and encouraged attendees to try building applications on App Engine.
Rapid web development using tornado web and mongodbikailan
The document summarizes a presentation about rapid web development using Tornado Web and MongoDB. The presentation introduces Tornado, a Python web framework, and MongoDB, a non-relational database. It discusses how Tornado and MongoDB provide freedom and flexibility for fast development. It also provides examples of using Tornado and PyMongo to interface with MongoDB.
The document discusses a talk given by Ikai Lan about the App Engine Datastore. The talk aimed to provide an understanding of how the datastore works under the hood and conceptual background for a persistence coding lab. It covered topics like the underlying Bigtable infrastructure, indexing and queries, entity groups, and different layers of the datastore including Bigtable, Megastore, and the App Engine Datastore API. It provided examples of saving an entity using the low-level Java API and performing queries on properties using the built-in indexes. Complex queries can be resolved through a zig zag merge join strategy across multiple indexes.
This document provides an overview and introduction to Google App Engine. It discusses how App Engine addresses the scalability challenges of traditional web application stacks and allows applications to automatically scale on Google's infrastructure. It outlines the core App Engine services and APIs for data storage, caching, mail, messaging and background tasks. Finally, it covers getting started with App Engine, including downloading the SDK, writing a simple application, deploying locally and live, and next steps for learning more.
OSCON Google App Engine Codelab - July 2010ikailan
Slides for the App Engine codelab given on July 20, 2010. Note that a more verbose version of this codelab is available at:
https://sites.google.com/site/gdevelopercodelabs/app-engine/python-codelab
Ikai Lan gave a talk about building cloud applications using Google App Engine. They demonstrated TweetEngine, an open source Twitter application built on App Engine, to explain key concepts. These included OAuth for secure authentication, internationalization (i18n) for localized versions, AppStats for application profiling, and Task Queues for background processing. The talk aimed to show how App Engine handles infrastructure concerns so developers can focus on code, and whet the audience's appetite for building cloud applications.
1. Google App Engine
Ikai Lan
Kuala Lumpur, GTUG Hackathon
Twitter: @ikai
June 18, 2011
Saturday, June 18, 2011
2. About the speaker
• Developer Relations at Google based out
of San Francisco, CA
• Primarily work in Java and Python
nowadays; lots of experience with Ruby,
JavaScript, PHP <5.3
• Focus: Cloud products
• Twitter: @ikai
Saturday, June 18, 2011
3. Agenda
• What is Google App Engine?
• Various features of GAE
• How to get started
• Introduction to Go
• Important tools + some tips
Saturday, June 18, 2011
4. Software
Platform
Infrastructure
Source: Gartner AADI Summit Dec 2009
Saturday, June 18, 2011
5. Software
Platform
Infrastructure
Source: Gartner AADI Summit Dec 2009
Saturday, June 18, 2011
6. Software
Platform
Infrastructure
Source: Gartner AADI Summit Dec 2009
Saturday, June 18, 2011
7. Software
Platform
Infrastructure
Source: Gartner AADI Summit Dec 2009
Saturday, June 18, 2011
8. • Easy to build
• Easy to manage
• Easy to scale
Saturday, June 18, 2011
9. “We wear pagers so
you don’t have to”
Saturday, June 18, 2011
12. SDK & “The Cloud”
Hardware
Networking
Operating system
Application runtime
Java, Python, Go
Static file serving
20
Saturday, June 18, 2011
13. Development Cycle
• Write code locally
• Test, push to Google Servers
• Administer via a web interface - http://
appengine.google.com
Saturday, June 18, 2011
17. Core APIs
Memcache Datastore URL Fetch
Mail XMPP Task Queue
Images Blobstore User Service
Saturday, June 18, 2011
18. High Replication
• Strongly consistent, multi-datastore, multi-
data center serving solution
• Write once, have your data be available in a
highly consistent manner
• No data loss, no datastore outages
Saturday, June 18, 2011
19. Other APIs
• High performance image serving
• App Engine Map Reduce
• Prospective Search API
• Pipeline API
• OAuth provider
Saturday, June 18, 2011
20. Prospective Search
• Matches a high rate of incoming documents
• 100,000 matches a second
• Think: How might we build something like
Google Alerts?
• http://code.google.com/appengine/docs/
python/prospectivesearch/
Saturday, June 18, 2011
21. A basic Python app
• 2 files: app.yaml and main.py
• Easier to use when Python SDK is in your
system path
• Start server with dev_appserver.py
• Deploy via appcfg.py
Saturday, June 18, 2011
24. Getting started with
Java
• Servlets API
• Google Plugin for Eclipse will generate a
skeleton project: http://code.google.com/
eclipse/beta/docs/download.html
Saturday, June 18, 2011
25. Go: why I like it
• “The next version of C, brought to you by
the guys who didn’t bring you C++”
• Modern, type safe compiled language (stdlib
includes: json parsing, web server)
• Functions as first class objects
• Concurrency baked in via goroutines and
channels
• Very fast compilation times
Saturday, June 18, 2011
26. Flexible interfaces
// This is an interface declaration
type myInterface interface {
set(i int)
}
// This is a Type declaration. Note that it is a type, not a class
type myType struct {
i int
}
// This is how we define a function where myType is a receiver
// With an instance of myType we can call myType.set(123)
func (p *myType) set(i int) {
p.i = i
}
// Because myType defines a function with the signature set(int i) method,
// we can use it anywhere myInterface is accepted!
func setToThousand(x myInterface) {
myInterface.set(1000)
}
Saturday, June 18, 2011
27. First class functions
package main
import "fmt"
// Make a function that returns a new function
func makeAdd(increment int) (counter func(int) int) {
return func(v int) int {
return v + increment;
}
}
func main() {
fmt.Printf("value of makeAdd(100)(1) is %vn", makeAdd(100)(1));
fmt.Printf("value of makeAdd(200)(2) is %vn", makeAdd(200)(2));
}
// Outputs:
// value of makeAdd(100)(1) is 101
// value of makeAdd(200)(2) is 202
Saturday, June 18, 2011
28. Goroutines and
package main
Channels
import (
"fmt"
"time"
)
func doLotsOfWork(until int, ch chan int) {
c := 0
for i := 0; i < until; i++ {
c += i
time.Sleep(1000)
}
ch <- c
}
func main() {
ch := make(chan int)
// First the work off into the background
go doLotsOfWork(5, ch)
// Do more work here while we wait for this process to complete
// Block until doLotsOfWork sends data back on this channel
i := <- ch
fmt.Printf("Final value: %vn", i)
}
Saturday, June 18, 2011
29. It runs on App Engine!
• Currently requires whitelisting
• Experimental status
• Goroutines allow for concurrency within
request; concurrent requests coming
• Demo app: http://moustach-io.appspot.com/
• Source: https://code.google.com/p/
appengine-go/source/browse/example/
Saturday, June 18, 2011
31. General tips
• The datastore is built on top of BigTable. It
is non-relational!
• Be aware of limits: 30 second requests, 10
minute tasks queues/cron jobs, whitelisted
classes
• Python 2.5 compatible (but can use 2.6 or
2.7 locally)
Saturday, June 18, 2011
33. Java tips
• Use low-level datastore API or third party
API: http://code.google.com/p/objectify-
appengine/
• Start with servlets API - will have to do
some work to make your favorite
framework work. Slim3 is a good GAE
specific framework
Saturday, June 18, 2011
34. Summary
• Hopefully people here are interested in
hacking on App Engine
• Java, Python and Go
• Ask me if you have general questions, I will
be around all weekend
Saturday, June 18, 2011