Friday, August 20, 2010

[Gd] An Ingredients List for Testing - Part One

| More

Google Testing Blog: An Ingredients List for Testing - Part One

By James Whittaker

Each year, about this time, we say goodbye to our summer interns and bid them success in the upcoming school year. Every year they come knowing very little about testing and leave, hopefully, knowing much more. This is not yet-another-plea to universities to teach more testing, instead it is a reflection on how we teach ourselves.

I like to experiment with metaphors that help people "get it." From attacks to tools to tours to the apocalypse, I've seen my fair share. This summer, I got a lot of aha moments from various interns and new hires likening testing to cooking. We're chefs with no recipes, just a list of ingredients. We may all end up making a different version of Testing Cake, but we better at least be using the same set of ingredients.

What are the ingredients? I'll list them here over the next couple of weeks. Please feel free to add your own and I'll hope you don't steal my thunder by getting them in faster than I. Right now I have a list of 7.

Ingredient 1: Product expertise

Developers grow trees, testers manage forests. The level of focus of an individual developer should be on the low level concerns of building reliable and secure components. Developers must maintain intellectual mastery from the UI to low level APIs and memory usage of the features they code. We don’t need them distracted and overwhelmed with system wide product expertise duties as well.

Testers manage system wide issues and rarely have deep component knowledge. As a manager of the forest, we can treat any individual tree abstractly. Testers should know the entire landscape understanding the technologies and components involved but not actually taking part in their construction. This breadth of knowledge and independence of insight is a crucial complement to the developer’s low level insights because testers must work across components and tie together the work of many developers when they assess overall system quality.

Another way to think about this is that developers are the domain experts who understand the problem the software is solving and how it is being solved. Testers are the product experts who focus on the breadth of technologies used across the entire product.

Testers should develop this product expertise to the extent that they cannot be stumped when asked questions like "how would I do this?" with their product. If I asked one of my Chrome testers any question about how to do anything with Chrome concerning installation, configuration, extensions, performance, rendering ... anything at all ... I expect an answer right away. An immediate, authoritative and correct answer. I would not expect the same of a developer. If I can stump a tester with such a question then I have cause for concern. If there is a feature none of us know about or don't know completely then we have a feature that might escape testing scrutiny. No, not on our watch!

Product expertise is one ingredient that must be liberally used when mixing Testing Cake.

[Gd] Beta Channel Update

| More

Google Chrome Releases: Beta Channel Update

The Beta channel has been updated to 6.0.472.41 for Windows, Mac and Chrome Frame. It contains additional stability fixes, UI updates, and an updated set of translations. More details about additional changes are available in the svn revision log.

You can find out how to use the different Chrome channels at

If you find new issues, please let us know by
filing a bug.

Jason Kersey
Google Chrome

[Gd] Showing more results from a domain

| More

Official Google Webmaster Central Blog: Showing more results from a domain

Webmaster Level: All

Today we’ve launched a change to our ranking algorithm that will make it much easier for users to find a large number of results from a single site. For queries that indicate a strong user interest in a particular domain, like [exhibitions at amnh], we’ll now show more results from the relevant site:

Prior to today’s change, only two results from would have appeared for this query. Now, we determine that the user is likely interested in the Museum of Natural History’s website, so seven results from the domain appear. Since the user is looking for exhibitions at the museum, it’s far more likely that they’ll find what they’re looking for, faster. The last few results for this query are from other sites, preserving some diversity in the results.

We’re always reassessing our ranking and user interface, making hundreds of changes each year. We expect today’s improvement will help users find deeper results from a single site, while still providing diversity on the results page.

Written by Samarth Keshava, Software Engineer

[Gd] A Little Too Popular

| More

Android Developers Blog: A Little Too Popular

A couple of weeks ago, we arranged that registered developers could buy an unlocked Nexus One via their publisher page in Android Market. We think it’s a good development platform and a nice phone. Apparently, you agree. Somewhat too many of you, in fact; we blew through the (substantial) initial inventory in almost no time, and they’re back-ordered from HTC, who are doing a pretty good job of managing runaway success amid a worldwide AMOLED shortage. Everyone appreciates that it’s important to the platform to get phones in the hands of developers, so we’re working hard on re-stocking the shelves; stand by.


[Gd] Verification time savers — Analytics included!

| More

Official Google Webmaster Central Blog: Verification time savers —  Analytics included!

Webmaster Level: All

Nobody likes to duplicate effort. Unfortunately, sometimes it's a fact of life. If you want to use Google Analytics, you need to add a JavaScript tracking code to your pages. When you're ready to verify ownership of your site in other Google products (such as Webmaster Tools), you have to add a meta tag, HTML file or DNS record to your site. They're very similar tasks, but also completely independent. Until today.

You can now use a Google Analytics JavaScript snippet to verify ownership of your website. If you already have Google Analytics set up, verifying ownership is as simple as clicking a button.

This only works with the newer asynchronous Analytics JavaScript, so if you haven't migrated yet, now is a great time. If you haven't set up Google Analytics or verified yet, go ahead and set up Google Analytics first, then come verify ownership of your site. It'll save you a little time — who doesn't like that? Just as with all of our other verification methods, the Google Analytics JavaScript needs to stay in place on your site, or your verification will expire. You also need to remain an administrator on the Google Analytics account associated with the JavaScript snippet.

Don't forget that once you've verified ownership, you can add other verified owners quickly and easily through the Verification Details page. There's no need for each owner to manually verify ownership. More effort and time saved!

We've also introduced an improved interface for verification. The new verification page gives you more information about each verification method. In some cases, we can now provide detailed instructions about how to complete verification with your specific domain registrar or provider. If your provider is included, there's no need to dig through their documentation to figure out how to add a verification DNS record — we'll walk you through it.

The time you save using these new verification features might not be enough to let you take up a new hobby, but we hope it makes the verification process a little bit more pleasant. As always, please visit the Webmaster Help Forum if you have any questions.

Written by Sean Harding, Software Engineer

Thursday, August 19, 2010

[Gd] A developer preview for the Chrome Web Store

| More

Google Code Blog: A developer preview for the Chrome Web Store

Today, we released a developer preview of the Chrome Web Store. Besides brand new documentation, we now allow developers to upload their apps using the developer registration flow of the Google Chrome Extensions Gallery.

The Chrome Web Store will be launching later this year. In the meantime, we’ll continue to share news on apps and the store through blog posts on the Chromium and Google Code blogs. We also encourage you to join our discussion group for apps for updates on our efforts.

By Rahul Roy-chowdhury, Google Chrome Team

[Gd] Stable Channel Update

| More

Google Chrome Releases: Stable Channel Update

Google Chrome 5.0.375.127 has been released to the Stable Channel on Windows, Mac, and Linux.

Security fixes and rewards:
Please see the Chromium security page for more detail. Note that the referenced bugs may be kept private until a majority of our users are up to date with the fix.
Aside from the listed security bugs fixed in Chromium, we have also deployed a workaround for a critical vulnerability where the root cause lies in an external component. Credit and $1337 to Marc Schoenefeld for enabling us to work around another Windows kernel bug [51070].

  • [$1337] [45400] Critical Memory corruption with file dialog. Credit to Sergey Glazunov.
  • [$500] [49596] High Memory corruption with SVGs. Credit to wushi of team509.
  • [$500] [49628] High Bad cast with text editing. Credit to wushi of team509.
  • [$1000] [49964] High Possible address bar spoofing with history bug. Credit to Mike Taylor.
  • [$2000] [50515] [51835] High Memory corruption in MIME type handling. Credit to Sergey Glazunov.
  • [$1337] [50553] Critical Crash on shutdown due to notifications bug. Credit to Sergey Glazunov.
  • [51146] Medium Stop omnibox autosuggest if the user might be about to type a password. Credit to Robert Hansen.
  • [$1000] [51654] High Memory corruption with Ruby support. Credit to kuzzcc.
  • [$1000] [51670] High Memory corruption with Geolocation support. Credit to kuzzcc.
If you find issues, please let us know:

Jason Kersey
Google Chrome

[Gd] Get your apps ready for the Chrome Web Store!

| More

Chromium Blog: Get your apps ready for the Chrome Web Store!

Since our announcement of the Chrome Web Store at Google I/O, our team has been hard at work preparing for our launch later this year. Today we’re making the first step towards this milestone by making available a developer preview of the Chrome Web Store.

Developers can now start uploading apps and experiment with packaging them, installing them in Chrome (using the latest Chrome dev channel) and integrating our payments and user authentication infrastructure.

To get started, take a look at our recently updated documentation for installable web apps, which explains how to prepare and package your apps. You should also review some additional documentation we just released on the store’s licensing and user authentication features.

To upload your app, you’ll need to use the upload flow of the Google Chrome Extensions Gallery .

When the Chrome Web Store launches, it will replace the current gallery, featuring a completely new design for users to discover great apps, extensions and themes all in one place. Until then, only you can see the apps you upload - they will not be visible to other visitors of the gallery during this developer preview. In the meantime, you can continue to use the gallery for publishing Chrome extensions and making them available to Chrome users.

We look forward to sharing more news about the store and its features over the next weeks. Meanwhile, we encourage you to subscribe to our developer discussion group for apps and look for updates on the Chromium blog.

Posted by Michael Noth, Software Engineer

[Gd] Security improvements and registration updates for the Google Chrome Extensions Gallery

| More

Chromium Blog: Security improvements and registration updates for the Google Chrome Extensions Gallery

Since we introduced extensions in Google Chrome, we focused on making the platform more robust, by continuously exposing new APIs to developers. This has helped our extensions gallery blossom where more than 6,000 extensions are listed today and more than 10 million extensions are downloaded by Chrome users every month.

We designed security into the extensions system from day 1 but we’re always looking for more ways to protect users. So, today, we are introducing two significant changes in the Google Chrome Extensions Gallery: a developer signup fee and a domain verification system.

The developer signup fee is a one-time payment of $5. It is intended to create better safeguards against fraudulent extensions in the gallery and limit the activity of malicious developer accounts. Starting today, this fee will be required to publish extensions, themes and soon apps in the gallery. We are waiving the fee for developers who already registered with the gallery (specifically before 11am PST today), so that they can continue to update their extensions and publish new items without paying the fee.

Domain verification is another addition that we believe will protect users and developers alike. Developers will be able to associate their extensions (and soon their apps) with domains they own or manage using Google’s Webmaster Tools. This way, they can clearly associate their extension with their brand and website, which in turn will help users identify “official” extensions in the gallery.

We believe that these are important improvements to the security of the gallery. We understand that changes like these can create a lot of questions, so please reach out to us on our developer discussion group for extensions.

Posted by Gregor Hochmuth, Product Manager

Wednesday, August 18, 2010

[Gd] CSS3 Transitions and Transforms in Gmail for the iPad

| More

Google Code Blog: CSS3 Transitions and Transforms in Gmail for the iPad

The Mobile Gmail team recently announced a new stacked cards interface for the iPad. In this interface we make use of CSS3 transitions and transforms to provide a more intuitive interface that has a look and feel that is similar to native applications. In this post we will describe CSS3 transitions and transforms and how they were used to develop this interface. All of the CSS and JavaScript examples currently work only in WebKit-based browsers, such as Safari on the iPad. However, Mozilla-based browsers have their own versions of WebKit-based extensions that use the ‘-moz’ prefix, and that should behave similarly.

CSS3 Transitions

CSS3 transitions allow the browser to animate the change of a CSS property from an initial value to a final value. A transition is configured by setting four CSS properties on an HTML element:
  • -webkit-transition-property
  • -webkit-transition-duration
  • -webkit-transition-timing-function
  • -webkit-transition-delay
The -webkit-transition-property property identifies the CSS properties where changes to the property will trigger a transition between the old value of the property and the new value. The -webkit-transition-duration property specifies, in milliseconds, the length of time over which the transition should take place. The -webkit-transition-timing-function property describes the speed at which the transition progresses over the duration of the transition. For example, -webkit-transition-timing-function: ease-in-out describes a transition that will proceed slowly at the beginning and the end of the transition, but that will proceed quickly during the middle of the transition. You can also provide a custom, cubic-bezier function for a higher degree of control over the timing. The -webkit-transition-delay property specifies a delay, measured in milliseconds, before the transition begins.

The transition properties can also be set simultaneously using the -webkit-transition property, by simply specifying them in the above order. Once the transitions properties are set and up to the point where the value of -webkit-transition-property is changed, all modifications of the specified CSS properties will trigger transitions.

CSS3 Transforms

CSS3 transforms allow the rendering of an HTML element to be modified using 2D and 3D transformations such as rotation, scaling, and translations. Transforms are applied by setting the -webkit-transform CSS property with the desired list of transforms. Each transform takes the form of a transformation function, such as translate3d or rotate, and a list of parameters enclosed in brackets. For example, to move an object to the right by 100 pixels and rotate it by 45 degrees you can use the -webkit-transform property:

-webkit-transform: translate(100px, 0) rotate(45deg);

Using -webkit-transform as the transition property when moving an element is advantageous relative to using the standard top and left properties because transitions using -webkit-transform are hardware-accelerated in Safari. An exception here is that it seems that 2D translations are not hardware-accelerated. But, since any 2D translation is equivalent to a corresponding 3D translation with the same translations in the x and y and no translation in the z axis, it is easy to use a hardware accelerated translate3d(x, y, 0) transform instead of a non-hardware accelerated translate(x, y) transform.


There are a few terms here that begin with ‘trans,’ and they can easily be confused if you are not familiar with them. Here they are again:
  • Transition: An implicit animation of CSS properties between an initial and a final value.
  • Transform: A modification to the appearance of an HTML element by manipulating it in a 2D or 3D space.
  • Translation: A particular type of transformation that moves the HTML element in 2D or 3D space.
Stacked Cards Interface

In the stacked cards interface, cards representing selected conversations transition onto the screen when their corresponding conversation is selected, and transition off of the screen when it is deselected.

When cards are selected, they are transitioned out from underneath the conversation list on the left side of the application into the selected conversation area on the right side of the application. To move the card onto the screen, we set an initial transform, configure the transition, and finally apply the desired final transform to the element.

To simplify the layout, the un-transformed position of each card is its normal position in the selected conversation area. This allows the card to have no translation applied when in this position, although it will need a translation to animate the movement. Initially the card has a transform that translates it to the left. The z-index property is used to ensure that the card will render underneath the conversation list. The rotation of the card is also initially applied, since we chose not to have the card rotate as it transitions onto the screen. =
‘translate3d(-700px, 0, 0) rotate(5deg)’;

Since the particular translation and rotation can vary, we chose to apply this property using JavaScript rather than including it in the CSS class applied to the card. It is important that the CSS3 transition is not yet applied because we do not want this transform to be a transition. Moreover, it is important that the card is rendered at its initial transform before the transition is configured and the destination transform is applied. This is easily achieved by wrapping these next steps in a call to window.setTimeout with a timeout of 0 ms.

window.setTimeout(function() { =
‘-webkit-transform 300ms ease-in-out’; =
‘translate3d(0, 0, 0) rotate(5deg)’;
}, 0);

Completion of the Transition

It is useful to know when the transition is complete. In the stacked cards interface, we use this to improve performance by setting display:none on obscured cards so that they do not need to be rendered. Adding an event listener allows the application to be notified when the transition has completed.

element.addEventListener(‘webkitTransitionEnd’, listener, false);

Interrupting a Transition

In some cases, you may want to change a transition while it is in progress. For example, if the user unselected a conversation while the corresponding card was still animating onto the screen, we might apply a new transition to send the card back off of the screen again. When you apply a new CSS value while a transition is already in progress, a new transition will occur between the current value of the property in the transition and the new value that you apply. For example, suppose a card is halfway through it’s transition onto the screen, and we apply this CSS transform: = 
‘translate3d(-700px, 0, 0) rotate(5deg)’;

Since the transition properties are still configured, a new transition will occur. The initial value for the transition will be the halfway point - approximately translated3d(-350px, 0, 0) rotate(5deg). The final value will be translate3d(-700px, 0, 0) rotate(5deg). The full duration of the transition will still apply, so the card will move about half as quickly as it usually does. It is possible to determine the current transform applied to an HTML element using the WebKitCSSMatrix and to use this to recalculate more appropriate transition parameters, but this is outside the scope of this post.

I hope that this introduction to CSS3 transitions and transforms has been useful, and that the insight into the implementation of Mobile Gmail on the iPad has been interesting. Based on positive feedback, the Mobile Gmail team is looking forward to making more use of transitions and transforms in the future.

By Liam Asher Segel-Brown, Software Engineering Intern, Google Mobile

[Gd] Launched: New Google Analytics Management API!

| More

Google Code Blog: Launched: New Google Analytics Management API!

Many developers have asked for a faster, more powerful way to access Google Analytics account configuration data through the Data Export API. We’ve listened and today we’re releasing a preview of the new Google Analytics Management API.

The Management API provides read-only access to Google Analytics configuration data. It consists of 5 new Google Data Feeds that map directly to the Google Analytics data model.

Previously, the API returned all the configuration data at once, which in many cases was inefficient if you only needed a subset of data. Now with separate feeds, developers can request only the data they need. For example, it’s now easy to get the Profile IDs for a single account or the Goal configuration data for only a single Profile.

To help you learn more we created a new Management API section in our developer documentation. We also created new reference examples in Java and have a live working demo in JavaScript. Check it out, no coding needed!

The Management API is being launched in Labs as an early preview. The API will change, grow, and get better over time. We recommend developers who aren’t committed to making updates to their applications only experiment with the new API and continue to use the Account Feed as their primary source for configuration data. We will strive to give you at least one month advanced notice of changes to this API.

The Management API represents a significant new piece of the Google Analytics developer platform. We encourage you to come try it out and give us feedback in our new Management API Google Group.

P.S. - Please make sure to sign-up for our notify list to stay up-to-date on all the latest Google Analytics Developer updates.

By Jeetendra M. Soneja, Google Analytics API Team


[Gd] AdWords Downtime: August 21, 10am-2pm PDT

| More

AdWords API Blog: AdWords Downtime: August 21, 10am-2pm PDT

We'll be performing routine system maintenance on Saturday, August 21 from approximately 10:00am to 2:00pm PDT. You won't be able to access AdWords or the API during this time frame, but your ads will continue to run as normal.

- Eric Koleda, AdWords API Team 

[Gd] Multi-tenancy Support, High Performance Image Serving, Increased Datastore Quotas and More Delivered In New App Engine Release

| More

Google App Engine Blog: Multi-tenancy Support, High Performance Image Serving, Increased Datastore Quotas and More Delivered In New App Engine Release

Today marks the 1.3.6 release of App Engine for Java and Python. In this release we have made available several exciting new features, relaxed quota and datastore limitations, and added various issue fixes.

Multi-tenant Apps Using the Namespaces API

We are pleased to announce support for multi-tenancy for applications via the Namespaces API. With multi-tenancy, multiple client organizations (or “tenants”) can all run the same application, segregating data using a unique namespace for each client. This allows you to easily serve the same app to multiple different customers, with each customer seeing their own unique copy of the app. No changes in your code are necessary to use this API-- just a little extra configuration. Further, the API is also designed to be very customizable, with hooks into your code that you can control, so you can set up multi-tenancy in any way you choose.

Check out our application examples for Java and Python to demonstrate how to use the Namespaces API in your application. The API works will all of the relevant App Engine APIs (Datastore, Memcache, and Task Queues). Check out our docs for Java and Python to learn more.

High-Performance Image Serving

This release also includes a new, high-performance image serving system for your applications, based on the same infrastructure we use to serve images for Picasa. This feature allows you to generate a stable, dedicated URL for serving web-suitable image thumbnails. You simply store a single copy of your original image in Blobstore, and then request a high-performance per-image URL. This special URL can serve that image resized and/or cropped automatically, and serving from this URL does not incur any CPU or dynamic serving load on your application (though bandwidth is still charged as usual). It’s easy to use, just call the Python function get_serving_url, or the Java function getServingUrl and supply a Blob key (with optional serving size and/or crop arguments), and you can now serve dozens or hundreds of thumbnails on a single page with ease. To enable high performance image serving in your deployed application, you'll need to enable billing.

Custom Error Pages

Since launch, many developers have asked to be able to serve custom error pages instead of those automatically served by App Engine. We are happy to announce today we are supporting static HTML error pages that can be served for you automatically for over quota, DoS, timeout and other generic error cases, that you previously could not control. You can configure custom error handlers in your app.yaml or appengine-web.xml file. Check out the Java or Python docs for more information.

Increased Quotas

We have also continued the trend of lifting some system limitations that have been in place since launch. The Datastore no longer enforces a 1000 entity limit on for count and offset. Queries using these will now safely execute until they return or your application reaches the request timeout limit. Also, based on your feedback, we have raised nearly all of the burst quotas for free apps to the same level as the burst quotas for billed apps. Check out the docs for more information on quota limits.

Other features included in 1.3.6:
  • Java developers can now use the same app.yaml configuration file that App Engine uses for Python applications instead of appengine-web.xml (if preferred).
  • You can now pause task queues via the Admin Console interface.
  • Dashboard graphs in the Admin Console will now begin showing up to 30 days worth of data.
  • Content-Range headers are now supported with the Blobstore API.
You can read all about these features in the App Engine documentation for Java and Python. The new versions of the SDK can be found on our downloads page.

In addition to all of the new features, we’ve included several bug fixes which you can read all about in the release notes for Java and Python.

-- Posted by the App Engine team


[Gd] WebFilings streamlines SEC reporting using Google App Engine

| More

Google App Engine Blog: WebFilings streamlines SEC reporting using Google App Engine

Greetings App Engine Developers!

My name is Dan Murray. I'm a Founder and Managing Director at WebFilings In March 2010 my company launched a first-of-its-kind SaaS solution that dramatically improves the process of developing and filing financial reports with the Securities Exchange Commission (SEC). Google App Engine provides the foundation for our backend. Since our launch, my company is experiencing what can only be described as hyper-growth. Everyday, as our team manages the rapid growth of our user community, I am thankful we chose App Engine when we started WebFilings.

Our Challenge

Each quarter, thousands of public and private companies in the US report their earnings to the SEC. The SEC reporting process is complex, time-consuming, and expensive. Reporting requirements and accounting codes are in a state of constant flux. The effects of misreported finances can be extremely costly to a company both financially and in reputation.

Prior to starting WebFilings, my partners and I spoke with dozens of companies and listened to them describe their approach to SEC reporting. While each company has its own unique challenges and methods, the general theme was the same: today's word processors and email just don't cut it for financial reporting. SEC reporting requires more sophisticated collaboration and data management capabilities than current tools provide.

We formed WebFilings almost immediately after these meetings and started building our product. We knew our software would manage a large amount of very granular data for which history and revision control are important. Individual data entities would be interrelated and a change to one may require a cascade change to hundreds, thousands, or more entities. Our product needed rich collaboration capabilities to allow multiple authors to work on a single report simultaneously and communicate effectively throughout the reporting process. Finally, because our software would manage sensitive, pre-release financial information, our product had to be state-of-the-art when it came to information security.

Why Google App Engine?

We started working with Google App Engine right after it launched in 2008. Since we started, our development team has grown from a few guys in a basement to an extensive worldwide organization. From the beginning, the choice of using GAE for our backend was obvious. App Engine provides many benefits to a business building a large-scale, data intensive product on a short timeline.

App Engine gives us a flexible, object-oriented datastore that enables us to iterate in a way that is just not possible with traditional database and ORM software. When combined with the ease of deployment to the cloud, we are able to develop at a rapid pace and deliver timely, incremental solutions for our customers' emerging needs.

In addition, App Engine appspot gives us a secure place for our customers' data. It's been clear from the beginning that the App Engine Team works very hard to plug each and every possible security hole. Large organizations all over the world are switching to Google Apps. Real peace-of-mind comes with Google's reputation for data security. I can think of no other company in the world that takes security more seriously and actually walks-the-walk.

Finally, our costs with Google App Engine have been unbelievably low. In past ventures, I got used to huge startup costs and large expenditures each month for hardware infrastructure and support staff. That just isn't the case with App Engine. We don't need a large IT staff to support our product because App Engine scales automatically. Our costs have been and continue to be orders of magnitude lower than anything I've ever experienced.

How we built our implementation

I had always heard that building a word processor is one of the hardest things you can ever do as a software engineer. Well now I know for a fact that it is. In addition to building a word processor, we set out to create a spreadsheet editor as well. Both applications run in a web browser and are interoperable in a way that enables you to "link" very granular data between them. Add in the ability to share documents and track revisions among a large team of collaborating editors, and building WebFilings software has easily been one of the most challenging endeavors during my 20+ years in software.

Using WebFilings rich editor to file financial reports

Google App Engine has been absolutely key to our success in ramping up development quickly and building our product in a very short timeframe. We built our product using App Engine's python runtime environment. The combination of python and App Engine's datastore enabled us to take an iterative and incremental approach to building our backend.

WebFilings software is based upon a multi-tier, service-oriented cloud mashup as shown below.

WebFilings' architecture

Our presentation tier consists of three end-user applications. Our editor and reader applications are implemented using the Adobe Flex SDK and delivered to the users desktop using Adobe Flash Player 10. Our administration application is AJAX-based and implemented with HTML, CSS, Javascript, and JQuery.

Our editor and reader applications combine a traditional word processor with a spreadsheet editor. Each contains logic that controls the content, layout, and display of formatted text. The foundation of these applications is Adobe’s Text Layout Framework, an extensible, open source, ActionScript library that leverages the text engine in Adobe Flash Player 10.

Our administrative application contains logic that controls CRUD operations for accounts and users. Through our administration application one administers usernames, passwords and password policy, user account access, subscription levels, and various account and document permissions.

Our business tier is developed using Google App Engine. Web services are implemented using python and the django web application framework. Our Flex/Flash-based editor and reader communicate with the business tier by exchanging serialized binary representations of WebFilings business objects through a Django-based web services API. The AJAX-based administration application communicates with the business tier using JQuery. Service requests and responses are sent via HTTPS.

The business tier implements logic in two sub-tiers. The first of these sub-tiers is responsible for basic business logic that provides methods for foundation and often repeated operations such as creation of a new document. The second of these sub-tiers is responsible for business processes that chain together basic business services to accomplish larger, more complex operations such as sharing a users’ changes to a document.

Business service and process methods access data through the App Engine Data Services API. This API provides a python-based abstraction layer consisting of convenience methods that unify the data tier API with security sandbox methods designed to prevent unauthorized data access across Google appspot instances.

WebFilings end-user application interoperates with read-only search services and transient translation services hosted using Amazon EC2. These web services include an XBRL taxonomy search service, and XBRL validation service, an XBRL instance document viewer, and an EDGAR HTML translation service.

The XBRL taxonomy search service, and XBRL validation service, and EDGAR HTML translation service use Apache Tomcat and the Java Servlet API. In addition, the XBRL taxonomy search service uses MySQL and the Hibernate ORM SDK for storage, access, and indexing of the SEC’s public taxonomy data.

The XBRL instance document viewer is a Microsoft .NET Framework-hosted implementation of the U.S. Security Exchange Commission (SEC) XBRL reference viewer.

We've been fortunate that the App Engine Team continues to churn out innovations at a rapid pace. AppStats has helped us identify problem areas and fine tune performance. Task Queues have given us a good solution for processing large amounts of data and helped us reduce request latency. Memcache has provided us up to 10x performance increase for critical areas of our application. We've been able to absorb these innovations quickly without having to re-architect.

Future Apps on App Engine
As WebFilings grows, we will continue to expand our product and the web services that support it. When we find opportunities to build new applications there is no doubt that Google App Engine will be at the core.

Please visit to learn more about WebFilings software. Our team is growing very fast and we're always looking for top software talent. Check out our Careers page If you want a new and exciting challenge with one of the best software teams around.

Posted by Dan Murray, Co-Founder and Managing Director, WebFilings

[Gd] Understand errors with the new troubleshooting guide

| More

AdWords API Blog: Understand errors with the new troubleshooting guide

One of the most critical and complicated aspects of using an API is error handling. To help address this, we’ve included detailed information about each type of error in the reference documentation and posted articles discussing general error handling best practices. While these resources are great at helping to determine what the an error is, we’ve heard from you on the forum that they often don’t provide enough context as to why the error occurred and what you can do to prevent it in the future.

With this in mind, we’ve put together a new troubleshooting guide for the most common errors in the AdWords API. Each error includes a brief summary of what went wrong, some common causes, a recommended tip for handling the error when it occurs, and steps you can take to prevent the error from occurring.

We hope that this guide will be your first stop when you get an error you haven’t encountered before. We’ll continue to update it based on community feedback and the errors you run into most often. If after reviewing these resources you still have questions, please post them to the forum.

- Eric Koleda, AdWords API Team

Tuesday, August 17, 2010

[Gd] Dev Channel Update

| More

Google Chrome Releases: Dev Channel Update

The Dev channel has been updated to 6.0.495.0 for all platforms.

  • [r55669] Fixed some minor issues with css custom cursor rendering (Issue: 51709)
  • Re-enable the link to disable individual plug-ins in a group. (Issue: 51597)
  • [r55596] Fixed playback rate for WebM/VP8 on certain content. (Issue: 51014)
  • See All
  • [r56026] Opening downloaded items from the download shelf now behaves as expected (Issues 32921, 50263)
  • See All
Known Issues
  • Chrome Frame: fixed a crash during upgrade
More details about additional changes are available in the svn log of all revision.

You can find out about getting on the Dev channel here:

If you find new issues, please let us know by filing a bug at

Anthony Laforge
Google Chrome

[Gd] SlideRocket takes off on Google Apps Marketplace

| More

Google Apps Developer Blog: SlideRocket takes off on Google Apps Marketplace

SlideRocket launched a few months ago on the Google Apps Marketplace, and has already seen impressive results. Listen to this quote from Chuck Dietrich, SlideRocket CEO.

"We have seen a 500% increase in the number of seats being trialled by businesses since joining the Google Apps Marketplace. In 4 simple clicks, an IT administrator can get all their employees using SlideRocket within Google Apps - saving time and providing employees with a rich, integrated experience."
-Chuck Dietrich, SlideRocket CEO

InformationWeek recently published its picks for the 15 best business apps on Google Apps Marketplace. SlideRocket was first on the list.

InformationWeek says "SlideRocket lets you import presentations from Google or Microsoft PowerPoint or create them right within the program, and then access them from any PC, Mac, or Linux computers. You can add audio and share presentations with your Google Contacts. It also includes analytics for measuring audience engagement."

Integration with Google Apps
- "The new Google Apps Marketplace made it simple to leverage Google's existing set of extensive data API's to take SlideRocket's integration with Google to a new level for the millions of people already using Google Apps. The best part was that we were able to complete our initial integration for the Marketplace in only a few days thanks to the straightforward platform Google has built using various open standards." Chuck Dietrich, SlideRocket CEO.

If you would like to launch your app on Google Apps Marketplace send me an email (dondodge at google) and I will help you get it done. Check out the growing list of business apps at Google Apps Marketplace.

Posted by Don Dodge, Google Apps Team

Want to weigh in on this topic? Discuss on Buzz


Monday, August 16, 2010

[Gd] To err is human, Video Sitemap feedback is divine!

| More

Official Google Webmaster Central Blog: To err is human, Video Sitemap feedback is divine!

Webmaster Level: All

You can now check your Video Sitemap for even more errors right in Webmaster Tools! It’s a new Labs feature to signal issues in your Video Sitemap such as:
  • URLs disallowed by robots.txt
  • Thumbnail size errors (160x120px is ideal. Anything smaller than 90x50 will be rejected.)

Video Sitemaps help us to better crawl and extract information about your videos, so we can appropriately feature them in search results.

Totally new to Video Sitemaps? Check out the Video Sitemaps center for more information. Otherwise, take a look at this new Labs feature in Webmaster Tools.

Written by Jackie Lai, Video Search Team

[Gd] Beta Channel Update

| More

Google Chrome Releases: Beta Channel Update

The Beta channel has been updated to 6.0.472.36 for all platforms. This release contains the following updates:

  • More UI Polish
  • Stability Fixes
  • [r55562] Re-enable the link to disable individual plug-ins in a group. (Issue: 51597)
  • [r55585] Insert the Update Chrome item to existing Wrench menus when notified. (Issue: 50659)
Chrome FrameMore details about additional changes are available in the svn log.

You can find out about getting on the Dev channel at

If you find new issues, please let us know by filing a bug at

Jason Kersey
Google Chrome