Jaime Yap is a developer for the Google Speed Tracer team. Google Speed Tracer is a Google Chrome extension that will help you debug and find performance bottlenecks in your Web applications. Google uses the utility internally for debugging and finding perormance bottlenecks in commonly used applications such as Gmail, Google Maps, and AdWords that millions of people use on a daily basis. Jaime Yap will be at the Velocity 2010 Web Performance and Operations Conference in San Jose, CA, on June 22nd through the 24th. Jaime Yap will be at Velocity giving demos and answering questions on Speed Tracer, as well as participating in a lightning talk, so you can learn more about Speed Tracer.

Jaime also spoke of the following insights on Speed Tracer and Velocity 2010:

Q: Please tell us a little about yourself and your involvement with the Velocity Conference

Jaime Yap: I’m an engineer at Google I started at Google working on the Google Web Toolkit Team. Steve Souders asked me to participate this year, which is pretty awesome. It’s my first time attending Velocity, so I’m pretty excited about that. I’ll be a part of the performance tools lightning demos, and I’ll also be manning the Google booth doing some one-on-one demos of Speed Tracer.

Q: What is Speed Tracer and what does it do?

Jaime Yap: Speed Tracer is a tool to help you identify and fix performance problems in your Web applications. We’re a chrome extension, and we’ve been working close with the Google Web Toolkit folk, giving some deep looks inside the browser to measure browser performance. We try to give a continuous picture of what the browser is doing when you run your webapps.

So most tools focus on startup latency, for modern Web applications like Google Maps, Gmail, Google Wave, you really need some tools to see exactly what the browser is doing as you run your app.

Q: What is Google Web Toolkit (GWT)? Does Speed Tracer require it to run?

Jaime Yap: GWT is a framework and a programming model for writing Web applications in Java. It actually just compiles Java to Javascript. So in the end, it’s just JavaScript, HTML, and CSS. We built Speed Tracer using the Google Web Toolkit. To use Speed Tracer on your Web applications, you don’t have to write your applications using Google Web Toolkit.

So if you run your Web application with just Javascript, HTML, CSS, and jQuery and so forth,

Q: How long does Speed Tracer to set up?

Jaime Yap: Speed Tracer is a Chrome extension, so all you have to do is go to the extensions gallery and install it. Speed Tracer uses some deep hooks inside of WebKit. To make that available to Chrome extensions and to Speed Tracer, you have to launch Chrome with a  command-line flag. All you have to do is install Speed Tracer is to install it from the extensions gallery in a single click. And once it’s installed, all you have to do is run Chrome with a command line flag.

We have 1 to 3 step instructions on our Getting Started Page. Once it’s running, it’s always running and you can use it by clicking on a single button in the Chrome UI.

Q: What unique features or metrics does Speed Tracer offer?

Jaime Yap: The Speed Tracer team is responsible for coming up with the initial implementation and instrumentation within WebKit, and we’ve been working very closely with the WebKit. And since then we’ve been working very closely with the WebKit inspector people. We both consume the same data, so the timeline panel that just launched with the WebKit inspector, thats a stock part of Safari and Chrome.

Both Speed Tracer and Inspector show timing data thats pretty deep inside the browser by timings we instrumented with native C++ code. These measurements are pretty much only available from this instrumentation. These measurements include layout times, repaint times, time to process scripts, DOM related dispatches, garbage collection passes in the JavaScript engine, etcetera.

We also have been working with AppEngine and Spring Insight, to provide server-side traces. We demoed this in the keynote at Google I/O. What this allows you to do is allows you to view server-side performance metrics, in a single tool, that you can use on a production application.

Also, we’ve designed the UI to draw attention around performance hot spots, and de-emphasizing things that are less important with respect to performance of your application. So I think that the Speed Tracer UI bring a lot to the picture.

Q: Is Speed Tracer able to differentiate between performance problems with your Web application and the browser itself?

Jaime Yap: Speed Tracer does benchmark the browser, but it benchmarks the browser, while you are in your application. So your application itself will have unique performance characteristics on Chrome. So if you application is doing something pathologically wrong in Chrome, you will see it in Speed Tracer.

Im gonna plug Kelly Norton, our tech lead, he gave a presentation at Google I/O called Measuring in Milliseconds Redux, that covers Speed Tracer.

Q: Whats the most interesting use case or problem that you solved using Speed Tracer.

Jaime Yap: There’s been a few ove the development of Speed Tracer. There was a large impact in addressing table rendering performance in AdWords. And they ran into some performance rendering issues in Adwords called layout thrashing. It was a very cool because it was a learning experience for us developing Speed Tracer, and a learning experience for AdWords.

Google Maps, for example, is a really fast, awesome application. It was kind of cool to see that they were using our logging API. I can’t say that we were working with them, so I don’t know what performance problems that they found, but we did notice that they were using our logging API. Thats an honor that a team with such low latency requirements was using our Speed Tracer for that.

Q: What do you have upcoming at Velocity 2010

Jaime Yap: I’m going to give a lightning demo session, where we’ll demo a bunch of performance tools in a 10 or 15 minute demo, and I’ll also be at the Google booth answering questions about Speed Tracer.

When I asked Andrew Rubin if Android would ever support Microsoft Silverlight or the open source implementation of Silverlight, Moonlight, he responded as follows:

Adobe put a lot of work into getting Flash to run on the Dalvik JVM.
If Microsoft were to develop Silverlight to run on the Android then we would welcome it.

- Andy Rubin, VP, Engineering (and Android Inventor), Google

Lars Rasmussen, one of the Lead Engineers who started Google Maps, and leading the Google Wave project, spoke with The Bitsource in this exclusive interview.

Lars Rasmussen (left), and Google Wave Panel at Google I/O 2010

Please tell The Bitsource’s developers a bit about yourself.

Lars Rasmussen: Sure thing, I’ve worked for Google for about six years. I came to Google in 2004 when they bought a little company, called Where2 Technologies that my brother and I had started and we did mapping software which we turned into Google Maps. I worked on Google maps for 3 years and then three years ago I started working on Google Wave.

Are there software development teams which are using Wave for facilitating and boosting efficiency in the various phases of the software development life cycle?

Lars Rasmussen: Yes, for sure. My own team, of course and there are a couple of teams at Google that use Wave for that exact thing. The Google Web Toolkit Team internally uses Wave for all of their work: tracking of their tasks, testing, processes, design documents, and discussing features.

There’s a story I really like, Google was recently asked to do a partnership with VMWare. Bruce Johnson was talking about this partnership during today’s keynote where they integrated the Google Web Toolkit with Spring Roo, which lets enterprise developers put together enterprise applications very quickly. Bruce was telling me how, when they started working with VMWare, they encouraged them to adopt Wave so that the GWT team and the VMWare team could Wave together. The VMWare team was actually in two other countries, and they all really loved it. It made their work much easier to coordinate in Wave and I spoke to one of the VMware guys who is here today and he is trying to get other people at VMWare to use it internally at VMWare as well.

How would one benefit by extending a continuous integration system such as Hudson or Atlassian Bamboo by integrating that into Google Wave?

Lars Rasmussen: Interesting you should ask. We’re giving a presentation tomorrow about Google Wave in the enterprise, the example I think the presenters for Google Wave and the Enterprise Environment are going to show an integration between Wave and the release system at Google with Robots and Gadgets. Every time you want to do a release, you start a Wave, which you use to do all of the coordination. Throw in a Gadget, and it goes and gets the current state [of the release] from the build system. By combining the two, you get all of the powerful discussion features [of Wave]. And when something goes wrong, something always goes wrong, you have all of the powerful discussion features, plus you have access to a control panel where you can manipulate the process right there.

In regard to Hudson and Bamboo, I don’t know if anyone is working on those particular systems, but I think Wave and development tools in general, there’s a lot of different areas where you can see some really cool integrations.

Also with coding itself. There is a team, I don’t recall they’re name, but they have this great thing where they used the Wave Federation Protocol to make programming collaborative inside of Visual Studio, and I know there’s a couple of folks at Google that are starting, too. We have a code review process, where a junior programmer will write the code and send it over to a senior programmer for review. The way it is currently, it is a serialized process. One person writes the code, they send it over here, it gets reviewed, comments go back, and the first programmer implements the comments, and it goes back for review.

Some of my colleagues are starting to play around with (they haven’t completed it yet), if you put those processes inside Wave it will go from being this very serialized, sometimes quite drawn-out process to being a much shorter and much more collaborative process. The code I write, can sit in a Wave, visible to the reviewer, and instead of sending back comments, they can just edit the code, and maybe even put comments in real-time if were online at the same time, and then I can understand what was done, and we can save ourselves a couple of round-trips.

Can Wave intelligently categorize Wave updates from an operations engineer differently than a software engineer?

Lars Rasmussen: Wave doesn’t do that on it’s own, but this something that extensions could do for you. In particular if you have a closed environment, you write Robots that has access to a database that has access to all of that information. Then a Robot could categorize what sort of person is writing what sort of thing.

Something I’ve seen developers working on a lot is working on Robots that will identify related content, which you can then choose to add to the Wave.

Please tell us a bit about the new Wave API’s that were announced today

Lars Rasmussen: Sure thing. The key thing is the top-requested features. In the past, Robots, which are web-application can interact with Wave just like human users, had to live on Google App Engine; which was mostly a security thing. We have now a system that you can authenticate a Robot that lives anywhere on the Web, which will make it a lot easier for programmers to do integrations. Like you were asking earlier about integrations with release management tools, for example. It’s a lot easier to do that integration if the Robot can live where the release management tool lives, instead of having to live in a third place; App Engine.

We also have a new API, a simple data API. A lot of people want to build notifiers and lighter-weigth clients for mobile devices. The sort of core API for collaborative editing can be a bit too much for some of the devices. And this API will allow you to build lighter weight clients.

We also added media and attachment features. Now, Robots has access to attachments on a Wave. For example, if you have a bunch of images in a Wave, you could have a Robot that [automatically] uploads images to a media sharing site, or vice-versa. If you have bunch of images on, say Picasa, and you’d like to share them on a Wave, you could write a Robot that does that.

For more information, follow @GoogleWave on Twitter, or subscribe to the Google Wave blog: http://googlewave.blogspot.com/

The Bitsource is at Google IO covering some of the latest announcements. We’ve compiled a list for those unable to attend the conference so that they can stay on top of all the news happening now at Google I/O.

Live Updates

Follow our @thebitsource for live updates from the conference.
Also follow @GoogleIO for other conference updates.

Photo Stream

Flickr Google IO Photo Stream

Google I/O Hot Topics

Android 2.2

HTML5 Support

WebM: Open Web Video Format

Google Wave Robots API

App Engine for Business

Google Chrome Web Store

Google Storage for Developers

AdSense for Ajax

Google IO Main Wave

Stay tuned for more updates from Google IO.

By Melissa Soriano

Go is Google’s new open-source, compiled programming language.  It’s release was officially announced in November of 2009.   I spent a few hours getting my feet wet with Go and exploring how it compares to C and Python.  This article describes how to install Go, how to compile a program, and some of Go’s unique features.

Installing Go

Go implementations are currently available for the Linux and Mac OS X platforms.
The following environmental variables are required and should be added to your ~/.bashrc or ~/.profile:

export GOROOT=$HOME/go
export GOBIN=$HOME/bin
export GOOS=linux
export GOARCH=386
PATH=$GOBIN:$PATH

In order to build the go toolchain, you need gcc, the standard C libraries, the parser generator Bison, make, awk, and the text editor ed installed.  You will also need mercurial, a free distributed source control management tool.  Once you have all this, you can check out the Go Mercurial repository:

$ hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Building go:

$ cd $GOROOT/src
$ ./all.bash

At the end of the build, you should see:
— cd ../test
N known bugs; 0 unexpected bugs

Compilation and Linking

Go includes a suite of compilers for different architectures.  8g is the compiler for the 32-bit x86.  6g is the compiler for the 64-bit x86.  For example, below is a simple hello.go program and its compilation:

package main

import "fmt"

func main() {
fmt.Printf("hello, world\n")
}

To compile on a 32-bit x86 platform:

8g hello.go

This will produce a file named hello.8.  To link the file:

8l hello.8

This will produce a file named 8.out.  To run it:

./8.out

Coding in Go

In general, Go code looks a lot cleaner than C or Python.  Go doesn’t have the same sensitivity to white space that Python does (which can be a pro or a con depending on your point of view).  Like C, Go uses semicolons to terminate statements but unlike C, the compiler puts these in automatically, resulting in cleaner source files.  Go’s compiler is very strict about dependencies; it returns errors for any package or variable that is not used.  This results in cleaner code with fewer dependencies, but can be annoying during initial development.  I tend to use the compiler as a tool and I compile often when I develop in C.  Go makes this harder by complaining about every loose end.  I wish it were possible to turn this dependency checking on and off (for example with a -strict flag) but I think Go’s designers made this choice on purpose as part of their philosophy that the language’s design should promote good programming practices.  This dependency checking might be something I would get used to if I worked with Go more.

As an example, I wrote a simple program that reads from an input file and writes to an output file.  I used the io/ioutil package, which provides ReadFile and WriteFile functions and the fmt package, which provides Printf.  Documentation of Go’s libraries can be found at http://golang.org/pkg/. All packages on this Web site are searchable using the “Go Code Search” box in the menu on the left hand side.

File IO in Go Example
Download file.go here

/* This example reads data from an input file,
prints the data to the screen, and
writes the data to an output file. */

package main

import (
"fmt"
"io/ioutil"
)

func main() {

/* declare input and output filenames */
input_filename := "data.txt"
output_filename := "stats.txt"

/* read contents of input file into array of type byte */
buff,_ := ioutil.ReadFile(input_filename)

/* print contents of input file */
fmt.Printf("%s\n", string(buff))

/* write contents of buff to output file */
/* use permissions 0x644 */
ioutil.WriteFile(output_
filename, buff, 0x644)

}

The brevity of the code and the lack of semicolons result in a clean, compact source.  The := operator represents a variable declaration.  Like python, Go can figure out the type of the variable implicitly based on the value you use to initialize it.  This feature speeds up initial development and makes the language friendly to work with.  Another feature of Go that I really like is its ability to returns multiple values.  This is demonstrated by ReadFile, which returns an array of type byte (buff), and an error code.  In C, I often write functions that need to return a value (for example, how many lines were read) that also may need to return an error.  This leads to the inelegant solution of defining a particular return value to signify an error (for example, -1).  While this solution works, it relies on the requirement that valid return values have a limited range (for example, >=0).  Another solution is to create a structure that contains multiple members with the information that is needed and to have the function return this structure.  Again, this works, but it is cumbersome and may end up requiring you to twist yourself around, defining all sorts of new structures just to enable a function to return the values that you need.  A third solution is to pass in a variable by reference and modify it within the function.  This works but obfuscates the function’s purpose.  Go’s ability to return multiple values provides a simple, elegant solution.  One weakness of Go seems to be its parsing abilities.  I used ReadFile to read an ascii text file of letters and numbers into an array of bytes, which ended up being difficult to work with.  I miss C’s fscanf and python’s readln and split functions.  Go’s novelty also means that far less example code is available than is the case for C and Python.  It would be nice if the documentation for each package included examples.  If Go becomes accepted by the software development community, this may change and more resources may develop.

As another example, I wrote a simple generic sort function that utilizes Interfaces and used this function to sort floats and strings.

Sorting in Go Example
Download sort.go

/* This example sorts arrays of strings and floats */

package main

import (
"fmt"
"rand"
"time"
)

/* define an Interface for an array of floats */
type FloatArray []float
func (p FloatArray) Len() int {return len(p)}
func (p FloatArray) Less(i int, j int) bool {return p[i] < p[j]}
func (p FloatArray) Swap(i int, j int) {p[i], p[j] = p[j], p[i]}
func (p FloatArray) List() string {
s := "{ "
for i:=0; i< p.Len(); i++{
s += fmt.Sprintf("%3.1f ", p[i])
}
s += "}"
return s
}
func (p FloatArray) String() string {
return p.List()
}
/* fill 1-n members of p with randomly generated floats between 0-100 */
func (p FloatArray) Fill(n int) {
rand.Seed(time.Nanoseconds())
for i:=0; i< n; i++{
p[i] = 100*(rand.Float())
}
}

/* define an Interface for an array of strings */
type StringArray []string
func (p StringArray) Len() int {return len(p)}
func (p StringArray) Less(i int, j int) bool {return p[i] < p[j]}
func (p StringArray) Swap(i int, j int) {p[i], p[j] = p[j], p[i]}
func (p StringArray) List() string {
s := "{ "
for i:=0; i< p.Len(); i++{
s += fmt.Sprintf("%s ", p[i])
}
s += "}"
return s
}
func (p StringArray) String() string {
return p.List()
}

/* Generic Interface to any sortable type */
type Interface interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}

/* generic sort function */
func Sort(data Interface) {
for i := 1; i < data.Len(); i++ {
for j := i; j > 0 && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}

func main() {

numbers := FloatArray{44.5, 67.3, 3.9, 17.8, 89.0, 10.2, 76.3, 9.4, 14.7, 89.1}
strings := StringArray{"kobe", "odom", "farmar", "fisher", "artest", "bynum",
"brown", "gasol"}

Sort(numbers)
fmt.Printf("%v\n", numbers)

numbers.Fill(10)
Sort(numbers)
fmt.Printf("%v\n", numbers)

Sort(strings)
fmt.Printf("%v\n", strings)

}

Running the program:

soriano@home:~/go/src$ ./8.out
{ 3.9 9.4 10.2 14.7 17.8 44.5 67.3 76.3 89.0 89.1 }
{ 11.2 27.8 36.0 49.1 73.2 86.3 88.5 94.1 98.2 99.0 }
{ artest brown bynum farmar fisher gasol kobe odom }

This example illustrates Interfaces, which are a feature unique to Go.  The generic sort function is defined using Len, Less, and Swap sub-functions.  The sort function can then be used by any type that defines Len, Less, Swap, and additionally List methods that are specific to that particular type.  For example, arrays of both floats and strings may be sorted and methods were defined to allow these types to utilize the generic sort function.  The sort function is dynamic because the usage of the sort function determines the type of the data variable.  At the same time, the individual Interfaces are parsed by the compiler, which prevents runtime errors as may occur in Python.  I added String methods to both types.  When Printf is called, it automatically checks to see if a String method is defined for the type and if so, uses it, as demonstrated above.

C, Python, and other languages provide support for concurrent programming in the form of processes and threads.  Go implements this using goroutines.  A goroutine is a Go function or method that executes concurrently in the same address space as other
goroutines.  Any function may be run as a goroutine by simply prefacing it’s call with “go”.  I write a simple example with two goroutines that run at the same time, in the same address space, and receive messages from the main program.

Goroutines Concurrency Example
Download goroutines.go

/* This example demonstrates usage of goroutines */

package main

import (
"fmt"
"time"
)

func handler(label string, mychan chan string) {
var message string

for i := 0; i < 10; i++ {
/* receive message from channel */
message = <-mychan;
fmt.Printf("%s: %s\n", label, message);
time.Sleep(100);
}
}

func main() {
/* allocate a new channel */
msgchan := make(chan string)

/* concurrent goroutines */
go handler("goroutine1", msgchan);
go handler("goroutine2", msgchan);

/* send messages */
msgchan <- "when"
msgchan <- "in"
msgchan <- "the"
msgchan <- "course"
msgchan <- "of"
msgchan <- "human"
msgchan <- "events"
msgchan <- "it"
msgchan <- "becomes"
msgchan <- "necessary"
msgchan <- "for"
msgchan <- "one"
msgchan <- "people"

/* let main sleep */
time.Sleep(1000)
}

Running the program:

soriano@home:~/go/src$ ./8.out
goroutine1: when
goroutine2: in
goroutine2: the
goroutine1: course
goroutine1: of
goroutine2: human
goroutine1: events
goroutine2: it
goroutine1: becomes
goroutine2: necessary
goroutine1: for
goroutine2: one
goroutine1: people

In this example, a handler function is implemented that accepts a label identifier and a channel as arguments.  A channel is a new Go type that is used to communicate between goroutines.  In this case, we declare “mychan chan string” which is a channel of type string called mychan.  This channel is used by the function to receive a message (message = <-mychan) and display it.  In main, a channel named msgchan is allocated and two handler goroutines are declared.  Messages are then sent using the channel.  By default, a send operation on a channel blocks until a receiver is available.  Therefore the first message is sent on the msgchan channel, and main blocks until either goroutine1 or goroutine2 receives it.  In this case, goroutine1 receives and sleeps for 100 nanoseconds.  In the meantime, main sends the next message on the msgchan channel and blocks again until it is received.  In this case, goroutine1 is still sleeping, so goroutine2 receives the second message and then sleeps for 100 nanoseconds.  Main sends the third message and goroutine2 is awake so it receives.  The channel makes it easy to communicate and synchronize between the two processes.  This example is a simple one but it demonstrates the simplicity and power of goroutines.  The Go approach to concurrency is significantly different from C and Python’s processes and threads and motivate a new way of thinking.  Of course, this is just the beginning.  Goroutines have a lot of potential and this is one of Go’s unique features that I would definitely like to explore further.

Thoughts

At first glance, Go is intriguing.  It includes some new innovative features that other languages such as C and Python lack, such Interfaces and goroutines.  Go code is also clean and quick to compile.  Go was designed with concurrency in mind; goroutines and channels have a lot of potential because pretty much any new computer has multiple cores and its is powerful to be able to take advantage of this parallel processing ability.  However, as with any language, there is a bit of a learning curve and since it Go is new, it lacks the established community and code base of other more established languages.  I did enjoy playing with Go and exploring its possibilities and I may consider using it for my next project.

More Resources

Go Video Introduction

Official Go Tutorial

Go is the property of Golang.org and used in compliance with the Creative Commons Attribution 3.0 License.
Google is the respective trademark of Google, Inc.

Steve Souders talks about the importance of tracking the latency of live user traffic before introducing Eric Schuman and Jake Brutlag’s talk on The User and Business Impact of Server Delays, Additional Bytes, and HTTP Chunking in Web Search at Velocity 2009.

Steve Souders talks about the importance of tracking the latency of live user traffic before introducing Erich Schuman and Jake Brutlag’s talk on The User and Business Impact of Server Delays, Additional Bytes, and HTTP Chunking in Web Search at Velocity 2009.

Recently, cloud computing has become a buzzword sort of phenomenon with many large vendors such as IBM, Amazon, Google, and Yahoo all touting that computing is going to the cloud. While doing a bit of research myself on cloud computing providers, I found that there is a lack of standards in terms of how cloud computing should be performed and what is a cloud. When any new technology emerges, it is important that the computing community start to formulate standards and best practices to adhere to so that the variances in implementations of cloud computing technologies are not so completely different that a new technology does not become completely convoluted and difficult to implement. Many commercial providers are jumping on the cloud computing bandwagon by offering their own platforms that may or may not necessarily adhere to the original vision of what cloud computing is supposed to be. Each commercial cloud platform vendor has their own flavor of what they claim is a cloud computing platform, even those resembling more of a grid computing implementation than a true cloud computing platform. This is to be expected to a certain extent, but there needs to be some common ground or forum where certain basic standards and best practices and be laid down for the computing community to be guided by so that cloud computing is not constantly re-defined.

Who would be most qualified to lay down the ground rules and standards for cloud computing? Would it be IEEE, ISO, W3C, or would it be a more consortium-based board consisting of the major cloud computing players such as Google, IBM, Amazon, and some of the smaller commercial providers and academic institutions?

Regardless of who implements such a standardizations body and board, it is imperative that such cooperation between the cloud computing community be established early on to foster efficient and healthy growth that will likely benefit the computing and technology community overall.