2011 June - Singapore GTUG presentation. App Engine program update + intro to Go

GAE Program Update
Ikai Lan - @ikai
Singapore GTUG
June 12, 2011

Monday, June 13, 2011

About the speaker
• Developer Relations at Google based out
of San Francisco, CA
• Software Engineer at heart
• Singapore, Kuala Lumpur and Taipei on this
trip
• Twitter: @ikai


Agenda

• What is Google App Engine?
• What’s new in App Engine?
• What’s coming in App Engine?
• Go on App Engine


What is
cloud
computing?

3

SaaS

APaaS

IaaS

Source: Gartner AADI Summit Dec 2009


• Easy to build
• Easy to manage
• Easy to scale


“We wear pagers so
you don’t have to”


>90K Developers

>130K Apps

>700M daily pageviews


SDK & “The Cloud”

Hardware

Networking

Operating system

Application runtime

Java, Python

Static file serving

20


Duke, the Java mascot
Go Gopher Copyright © Sun Microsystems Inc., all rights reserved.


Extended Language support
through JVM

• Java
• Scala
• JRuby (Ruby)
Duke, the Java mascot
• Groovy Copyright © Sun Microsystems Inc., all rights reserved.

• Quercus (PHP)
• Rhino (JavaScript)
• Jython (Python)


(We’ll talk
about this guy
in a bit)

The Go Gopher

Core APIs
Memcache Datastore URL Fetch

Mail XMPP Task Queue

Images Blobstore User Service


Two+ years in review
Apr 2008 Python launch
May 2008 Memcache, Images API
Jul 2008 Logs export
Aug 2008 Batch write/delete
Oct 2008 HTTPS support
Dec 2008 Status dashboard, quota details
Feb 2009 Billing, larger ﬁles
Apr 2009 Java launch, DB import, cron support, SDC
May 2009 Key-only queries
Jun 2009 Task queues
Aug 2009 Kindless queries
Sep 2009 XMPP
Oct 2009 Incoming email
Dec 2009 Blobstore
Feb 2010 Datastore cursors, Appstats, Async UrlFetch


Two+ years in review
Mar 2010 Read policies, IPv6
May 2010 OpenID, OAuth, Bulkloader
Jun 2010 Python Precompilation, raised Task Queue limits
Aug 2010 Multitenancy
Oct 2010 Datastore Admin, query improvements
Dec 2010 Always on, Channel API, Task queue out of labs
Jan 2011 High Replication Datastore, datastore copy
Feb 2011 XMPP Presence, programmatic Task Queue deletions
Mar 2011 Files API, Prospective Search, Testbed API
May 2011 Backends, Pull Queues, massive bugﬁx release


App Engine
Roadmap
http://code.google.com/appengine/docs/roadmap.html

• App Engine out of Preview
• SSL access on custom domains
• Full-text search over Datastore
• Support for Python 2.7
• Support for running MapReduce jobs across App Engine datasets
• Bulk Datastore Import and Export tool
• Improved monitoring and alerting of application serving
• Logging system improvements to remove limits on size and storage
• Integration with Google Storage for Developers

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


Leaving preview ...

• Pricing changes towards a sustainable
model
• Guarantee that Google is investing in long
term future of App Engine
• Premium support available


Go on App Engine

• Go with most features intact on App Engine
• Goroutines
• Execution speed!


Why Go?
• Fast, modern language
• Strongly typed, very ﬂexible interfaces
• Functions as ﬁrst class objects
• Ridiculously fast compilation times
• Concurrency baked in
• Tooling

Fast, modern languages

• Standard library: JSON, websockets, web
server; more
• Garbage collection
• Multiple return values
• Unicode


Strongly typed

• ... but feels like a dynamic languages
• // Combo statement - We can infer type here, so no
Java style type declaration redundancy

s := “This is a String”


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)
}


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


Concurrency baked in

• goroutines - preﬁx a go in front of a
method and it will run concurrently! Similar
to appending & in *nix systems
• channels - blocking or buffered queues for
cross process communication


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)
}


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/


Mustachio


Summary

• Lots has been going on with App Engine!
• Lots more on the way
• Go (golang.org) - worth a look


2011 June - Singapore GTUG presentation. App Engine program update + intro to Go

More Related Content

Similar to 2011 June - Singapore GTUG presentation. App Engine program update + intro to Go

More from ikailan

Recently uploaded

2011 June - Singapore GTUG presentation. App Engine program update + intro to Go