Saturday, April 7, 2012

[Gd] ttfautohint reaches its $30,000 funding target!

| More

Google Web Fonts: ttfautohint reaches its $30,000 funding target!

The Google Web Fonts team would like to congratulate Werner Lemberg on reaching his $30,000 funding target for ttfautohint.

Here is a fun video that explains what the project is about:

As a true open source project, it has sought contributions from across the industry. Google Web Fonts, FontLab and many individuals have given the project financial support. This week the Extensis WebINK team announced they have enabled Werner to reach his goal:

You can download a graphical user interface for GNU/Linux and Windows today, a command line tool for Mac OS X, and of course the source code, from the project homepage:

Posted by Dave Crossland, Font Consultant, Google Web Fonts Team

[Gd] Fridaygram: 3D graphs, battling bacteria, viewing art

| More

Google Developers Blog: Fridaygram: 3D graphs, battling bacteria, viewing art

Author Photo
By Scott Knaster, Google Developers Blog Editor

Back in December we added graphing capability to Google Search. That was pretty cool, but only 2D graphs? Come on! Most of the people we know are three-dimensional, so it only made sense to add 3D graphing to Google Search as well.

To see a 3D graph, type any real two-variable function into Google Search. You can click the graph to rotate it, use the controls to zoom, or edit the range in the box at the lower-right. This feature works in modern browsers thanks to the magic of WebGL.

Jumping from math to science, this week brings news of a "plasma flashlight" that instantly inactivates bacteria on skin. In tests, the flashlight penetrated all the way to the bottom of a 17-layer stack of bacteria and zapped all of it. You can imagine parents of the world using these on their kids’ hands before dinner.

Finally, technology meets art in the newly expanded Google Art Project, which enables people to view works online from more than 150 museums around the world. Seeing art online might not be as good as being there, but it’s far more accessible. And it’s one of those things that just makes you feel like you’re living in the future.

Fridaygram posts are just for fun. They're designed for your Friday and weekend enjoyment. Each Fridaygram item must pass only one test: it has to be interesting to us nerds. And just because you read this far, here are a couple of bonus links: a test of Google’s self-driving car, and a very special 2D graph.


[Gd] Introducing the Script Service

| More

Google Apps Developer Blog: Introducing the Script Service

Triggers in Apps Script allow you to schedule your script’s execution in response to an event, at a specific time and date, or at given time intervals. Publishing scripts as services allows you to deploy your web apps with a click of a button. The new Script service lets you perform both of these tasks programmatically. With the Script service at your disposal, you can create smooth install flows, chain your scripts’ executions, generate summaries of current triggers, and even programmatically publish the scripts as services.

Create smooth install flows

You can now set up your triggers from a menu. Here is an example of how you would schedule function foo() to run one year from now via a custom menu in Google Spreadsheets:

function onOpen() {
[{name: "Create Trigger",
functionName: "createTrigger"}]);

function createTrigger() {
var now = new Date();

Chain script executions

By programmatically setting triggers, you are able to schedule a future script’s executions from the script that is currently running. Here is an example of a function that schedules another function to execute two hours after it completes:

// this function is run to send the initial reminder and schedule a subsequent one
function sendRequest() {
"Assignment #1 is due in 2 and a half hours!",
"Your first assignment is due in 2 and a half hours!");
var now = new Date();
var later = new Date(now.getTime() + 2 * 60 * 60 * 1000);

// this function will execute two hours later, sending another reminder
function sendReminder() {
"Assignment #1 is due in 30 minutes!",
"Your first assignment is due in half an hour!");

Generate a summary of current triggers

With the ability to schedule triggers programmatically, it is important to keep track of the existing ones. The function below logs all the triggers that are associated with the current script. Alternatively, you could also write this summary to a spreadsheet or email it to yourself.

function logMyTriggers() {
var triggers = ScriptApp.getScriptTriggers();
for(i in triggers) {
Logger.log("Trigger ID: " + triggers[i].getUniqueId()
+ "\nTrigger handler function: "
+ triggers[i].getHandlerFunction()
+ "\nTrigger type: " + triggers[i].getEventType()
+ "\n----------------------");

Publish scripts programmatically

You can now let your users publish your scripts through a Google Spreadsheets custom menu as a part of the script’s set up process. Below is an illustration of this process using an example of a simple note-taking web app. Once a user clicks the menu item, the script becomes published as a service and the URL is presented back to the user via a dialog box.

function doGet(e) {
var app = UiApp.createApplication();
createApp(app, false);
return app;

function doPost(e) {
var now = new Date();
"Notes taken at " + now, e.parameter.notes);
var app = UiApp.getActiveApplication();
createApp(app, true);
return app;

function createApp(app, isSubmitted) {
var vp = app.createVerticalPanel();
var title = app.createHTML("Enter your notes into the text area below." +
"<br>Hit submit to email them to yourself!")
.setStyleAttribute("fontSize", "25px");
var lbl = app.createLabel("Notes submitted!")
.setStyleAttribute("fontSize", "17px");
var form = app.createFormPanel();
var notes = app.createTextArea()
var sb = app.createSubmitButton("Submit");
if (isSubmitted)
return app.add(form);

function onInstall() {

function onOpen() {
[{name: "Publish as a service.",
functionName: "setup"}]);

function setup() {
var url = "";
try {
url = ScriptApp.getService().getUrl();
Browser.msgBox("Your web app is now accessible at the following URL:\n"
+ url);
} catch (e) {
Browser.msgBox("Script authorization expired.\nPlease run it again.");

The Script service provides you with the means of creating even more powerful applications and makes the development and deployment process smooth.

For more information, please visit the Script service Reference Documentation and User Guide.

Anton Soradoi profile

Anton is a Developer Support Specialist at Google. He works closely with Apps Script developers to help them discover its full potential. Prior to Google, he worked as a Web Developer.


Friday, April 6, 2012

[Gd] Dev Channel Update

| More

Chrome Releases: Dev Channel Update

The Dev channel has been updated to 19.0.1084.15 for Windows, Mac, Linux and Chrome Frame.  This build contains following updates:

  • Other Devices menu shows last update time for other sessions, and allows sessions to be hidden using a context menu.
  • Fix sync issue with sessions (open tabs) triggering an unrecoverable error.
  • Fixed Sync/Apps: NTP apps icons missing after sync. [Issue: 117857]
  • Fixed bookmarks drag-n-drop in Bookmark Manager. [Issue: 118715]

Full details about what changes are in this build are available in the SVN revision log. Interested in switching release channels? Find out how. If you find a new issue, please let us know by filing a bug.

Dharani Govindan
Google Chrome

[Gd] Stable, Beta and Dev Channel Update for Chromebooks

| More

Chrome Releases: Stable, Beta and Dev Channel Update for Chromebooks

The Stable and Beta channels have been updated to 18.0.1025.151 (Platform version: 1660.12.0) for Chromebooks (Acer AC700, Samsung Series 5, and Cr-48). Dev channel has been updated to the same version for Cr-48 systems.

This release contains security and stability improvement.

Release highlights:
  • Updates to Chrome - see this post for details
  • Pepper Flash updated to version 11.2
  • 26731 - Fixes issue with CPU usage going to 100% when voice feedback accessibility is enabled
  • 26253 - Fixes issues with VPN delay

If you find new issues, please let us know by visiting our help site or filing a bug. Interested in switching to the Beta channel? Find out how. You can submit feedback using ‘Report an issue’ under the wrench menu.

Danielle Drew
Google Chrome

[Gd] Stable and Beta Channel Updates

| More

Chrome Releases: Stable and Beta Channel Updates

The Chrome Stable and Beta channels have been updated to 18.0.1025.151 on Windows, Mac, Linux and Chrome Frame.  This release fixes issues including:
  • black screen on Hybrid Graphics system with GPU accelerated compositing enabled (Issue: 117371)
  • CSS not applied to <content> element (Issue: 114667)
  • Regression rendering a div with background gradient and borders (Issue: 113726)
  • Canvas 2D line drawing bug with GPU acceleration (Issue: 121285)
  • Multiple crashes (Issues: 72235116825 and 92998)
  • Pop-up dialog is at wrong position (Issue: 116045)
  • HTML Canvas patterns are broken if you change the transformation matrix (Issue: 112165)
  • SSL interstitial error "proceed anyway" / "back to safety" buttons don't work (Issue: 119252)
Known Issues:
  • HTML5 audio doesn't work on some Mac computers (Issue: 109441)
Security fixes and rewards:

A new version of Flash Player is included. More details are available in an addendum to this Flash Player advisory.

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.

  • [$500] [106577] Medium CVE-2011-3066: Out-of-bounds read in Skia clipping. Credit to miaubiz.
  • [117583] Medium CVE-2011-3067: Cross-origin iframe replacement. Credit to Sergey Glazunov.
  • [$1000] [117698] High CVE-2011-3068: Use-after-free in run-in handling. Credit to miaubiz.
  • [$1000] [117728] High CVE-2011-3069: Use-after-free in line box handling. Credit to miaubiz.
  • [118185] High CVE-2011-3070: Use-after-free in v8 bindings. Credit to Google Chrome Security Team (SkyLined).
  • [118273] High CVE-2011-3071: Use-after-free in HTMLMediaElement. Credit to pa_kt, reporting through HP TippingPoint ZDI (ZDI-CAN-1528).
  • [118467] Low CVE-2011-3072: Cross-origin violation parenting pop-up window. Credit to Sergey Glazunov.
  • [$1000] [118593] High CVE-2011-3073: Use-after-free in SVG resource handling. Credit to Arthur Gerkis.
  • [$500] [119281] Medium CVE-2011-3074: Use-after-free in media handling. Credit to Sławomir Błażek.
  • [$1000] [119525] High CVE-2011-3075: Use-after-free applying style command. Credit to miaubiz.
  • [$1000] [120037] High CVE-2011-3076: Use-after-free in focus handling. Credit to miaubiz.
  • [120189] Medium CVE-2011-3077: Read-after-free in script bindings. Credit to Google Chrome Security Team (Inferno).

Many of these bugs were detected using AddressSanitizer.

More detailed updates are available on the Chrome Blog.  Full details about what changes are in this release are available in the SVN revision log.  Interested in hopping on the stable channel?  Find out how.  If you find a new issue, please let us know by filing a bug.

Karen Grunberg
Google Chrome

Thursday, April 5, 2012

[Gd] The Gmail Public Labels API

| More

Android Developers Blog: The Gmail Public Labels API

[This post is by Nadav Aharony, a product manager on the Android team — Tim Bray]

We’re rolling out new developer features for the Gmail Android app: It now includes a public ContentProvider that you can use to retrieve label data. You can use this to access up-to-date unread counts for specific accounts’ inboxes and labels.

To use the API, the Gmail app needs to be at version 2.3.6 or higher on Froyo or Gingerbread; 4.0.5 or higher on Honeycomb and ICS. Before using it, be sure you first check the Gmail app version; we’ve provided a handy GmailContract.canReadLabels(Context) method to help with this. Your app will need the permission.

Finding the Gmail accounts set up on the device

The Labels API needs a valid Gmail account to build a query for per-label information. Assuming the GET_ACCOUNTS permission, the AccountManager can be used to fetch this information:

// Get the account list, and pick the first one
final String ACCOUNT_TYPE_GOOGLE = "";
final String[] FEATURES_MAIL = {
AccountManager.get(this).getAccountsByTypeAndFeatures(ACCOUNT_TYPE_GOOGLE, FEATURES_MAIL,
new AccountManagerCallback() {
public void run(AccountManagerFuture future) {
Account[] accounts = null;
try {
accounts = future.getResult();
if (accounts != null && accounts.length > 0) {
String selectedAccount = accounts[0].name;

} catch (OperationCanceledException oce) {
// TODO: handle exception
} catch (IOException ioe) {
// TODO: handle exception
} catch (AuthenticatorException ae) {
// TODO: handle exception
}, null /* handler */);

Getting and accessing existing labels

Once you’ve got the email account, you can get a ContentProvider URI to query against. We've provided a simple support class called for constructing the URI and defining the columns and relevant constants.

You can access any label, predefined or user-defined. The predefined labels include (you have to use symbolic constants rather than these strings, see below):

  • Priority Inbox

  • Starred

  • Chats

  • Sent

  • Drafts

  • All mail

  • Spam

  • Trash

To obtain a Cursor with information for all labels in an account, your app can either query this URI directly or use a CursorLoader. Here’s an example:

Cursor c = 
null, null, null, null);

You can query and watch for changes on a single label by storing the URI value in the GmailContract.Labels.URI column from the cursor data.

The NAME value for pre-defined labels can vary by locale, so don’t use GmailContract.Labels.NAME. Instead, identify pre-defined labels like Inbox, Sent or Drafts using the String value in the GmailContract.Labels.CANONICAL_NAME column. Here’s an example:

// loop through the cursor and find the Inbox
if (c != null) {
final String inboxCanonicalName = GmailContract.Labels.LabelCanonicalName.CANONICAL_NAME_INBOX;
final int canonicalNameIndex = c.getColumnIndexOrThrow(GmailContract.Labels.CANONICAL_NAME);
while (c.moveToNext()) {
if (inboxCanonicalName.equals(c.getString(canonicalNameIndex))) {
// this row corresponds to the Inbox

If you choose to use a CursorLoader, it will keep the label counts up to date as they change over time.

Sample App

You can find a sample app that makes use of the new API here. The app provides a basic readout of label and message-count information.

People care about their incoming mail; we’re looking forward to seeing what you do with access to this information. We’re also open to suggestions as to how to improve and extend this new API.


[Gd] Master/Slave Datastore, thanks for all your hard work

| More

Google App Engine Blog: Master/Slave Datastore, thanks for all your hard work

Almost 4 years after launch, we’ve seen fantastic growth both in Google App Engine and the apps that run on it. And although the Master/Slave Datastore was a big part of our early success, it's time to announce the deprecation of the Master/Slave Datastore in favor of the High-Replication Datastore (HRD). HRD has provided us with higher availability and better, more predictable performance. Many upcoming features will be HRD-only and we strongly encourage you to migrate all your applications as soon as possible using the migration tools found in the Application Settings tab of the Administration Console. The deprecation period will follow the guidelines set in our terms of service. If you have any questions or concerns, please contact us at

- Posted by Max Ross, on behalf of the App Engine Datastore Team


[Gd] Join us for g|Senegal and g|Cote d’Ivoire

| More

Google Developers Blog: Join us for g|Senegal and g|Cote d’Ivoire

By Tidjane Deme, Lead Francophone, Google Africa and Melina Mattos, Program Manager, Google Africa

This year so far has been about creating connections with local communities and resharing our knowledge and love for Google products either offline in our conferences or online with Google+. With the success we've had with our conferences in East and West Africa, we are excited to announce that in May we are coming to Dakar for g|Senegal and Abidjan for g|Cote d’Ivoire!

This year’s g|Senegal will have more hands-on coding sessions for more experienced developers, more sessions on new Google technology, and more local success stories--perhaps you will be featured. Join us for g|Senegal on 9 and 10 May at Place du Souvenir.

For advanced developers, the Dakar Google Technology User Group (GTUG) is holding a Google+ Hackathon to help developers build applications on the Google+ API. If you are interested in joining, please flag your interest when applying for g|Senegal Developer Day and we will send you more information at a later date.

For our first ever g|Cote d’Ivoire, we are excited to take part of the vibrant energy in this era of rebuilding. The event will focus on building innovative applications and helping the fast-growing business community come online. Sign up for g|Cote d'Ivoire on 14 and 15 May.

Remember to register early for these free events because May is just around the corner. Don’t forget to join the conversation about g|Senegal and g|Cote d’Ivoire on Google+ using the event hashtags #gsenegal and #gcotedivoire.

Posted by Scott Knaster, Editor

[Gd] Google Cloud Storage: high performance that just works

| More

Google Developers Blog: Google Cloud Storage: high performance that just works


By Navneet Joneja, Product Manager,
and Ville Aikas, Technical Lead

When evaluating options for cloud storage, customers often wonder, "How can we optimize our storage to get the highest performance possible?". We believe you shouldn't have to, so we do all the optimization for you – enabling you to focus on your application instead of the minutiae of storage optimization.

The performance of cloud storage services (and indeed most web services) depends on two main factors: the network that moves the data between us and the end user, and the performance of the storage service itself.

1. Network

When you make a request to Google Cloud Storage, one of the key determinants of performance is the network path between you and our servers. This path is critical because if the network is slow or unreliable, it doesn’t really matter how fast the backend is.

There are two main ways to make the network faster:
  • Serve the request from as close to the user as possible
  • Optimize the network routing between the end-user and the service, including avoiding pockets of network congestion and minimizing the number of network hops between the user and the service.
2. Storage

The other component of system performance is how quickly our servers process your request. The data needs to be managed optimally and once an end-user’s request reaches our servers, we need to serve the request as fast as possible. In a sense, Google Cloud Storage is a gigantic filesystem: authorization checks need to happen, the object in question needs to be looked up, and the data requested needs to be read from the physical storage medium and transferred to the end user, all as efficiently as possible.

So, how do we make sure your requests are served as fast as possible?
  • Google Cloud Storage is built on Google’s proprietary network and datacenter technology. We’ve spent more than a decade building out proprietary infrastructure and technology to power Google’s sites (after all, we believe that fast is better than slow). When you use Google Cloud Storage, the same network goes to work for your data.
  • We replicate data to multiple data centers and serve an end-user’s request from the nearest data center that holds a copy of the data. We also offer a choice of regions (currently U.S. and Europe) to allow you to keep your data close to where it’s most needed. We then take this one step further. When you upload an object and mark it as cacheable (by setting the standard HTTP Cache-Control header), we automatically figure out how best to serve it using Google’s broad network footprint, including caching it closer to the end-user if possible.
  • Finally, you don’t need to worry about optimizing your storage layout (like you would on a physical disk), or the lookups (i.e. directory and naming structure) like you would on most file systems and some other storage services. We take care of all the "file system" optimizations behind the scenes.
In other words, when you store your data on Google Cloud Storage, we do all the background work to make it fast so that you can focus on your application.

Navneet Joneja loves being at the forefront of the next generation of simple and reliable software infrastructure, the foundation on which next-generation technology is being built. When not working, he can usually be found dreaming up new ways to entertain his intensely curious almost-two-year-old.

Ville Aikas likes to work on tools and services that make developers lives easier and "just work". When not busy cranking out code, he loves to play soccer with his kids, build robots and watch F1.

Posted by Scott Knaster, Editor

Wednesday, April 4, 2012

[Gd] Dev Channel Update

| More

Chrome Releases: Dev Channel Update

The Dev channel has been updated to 19.0.1084.9 for Windows, Mac, Linux and Chrome Frame.  This build contains following updates:

Full details about what changes are in this build are available in the SVN revision log. Interested in switching release channels? Find out how. If you find a new issue, please let us know by filing a bug.

Dharani Govindan
Google Chrome

Monday, April 2, 2012

[Gd] The Google Cloud API: cloud coverage anywhere, anytime

| More

Google App Engine Blog: The Google Cloud API: cloud coverage anywhere, anytime

We are thrilled to announce a project the App Engine team has been working on for a long time: the Cloud API. The Cloud API allows developers unprecedented control over cloud deployments in their area.

We think the Cloud API is a huge step forward for developers. For the first time, developers can simply and easily gain cloud coverage in locations around the globe within minutes. With the Cloud API developers can drive increased cloud awareness for a wide range of new users and enterprises. This will not only allow totally new applications in the agricultural and metrology sectors to flourish but also provide a welcome addition to mobile, social and gaming. The Cloud API provides the scalability you would expect from App Engine with clouds seeded on demand and dispersed when they are no longer needed. Clouds are created using cloud engines which are specially designed jet engines with three fins. 

A Cloud Deployed Using the Cloud API. Imagery ©2012 GeoEye, DigitalGlobe, Cnes/Spot Image, TerraMetrics

The Cloud API is supported in Python, Java and Go, check out the Getting Started Guide to find out how simple it is to integrate clouds into your applications.

As with other parts of App Engine, the Cloud API is backed by an SLA of 99.95% uptime along with an accuracy of ±5m. Clouds come in configurable sizes ranging up to 5m3 for free customers with paid and premier customers able to extend clouds to 10km3.

Pricing for the Cloud API are based on the likelihood of cloud in the location the cloud is requested. A cloud pricing calculator will be released in the coming days, however example pricing is provided below:

Example LocationLikelihood of CloudPrice/Cloud Hour/10m3
Seattle, WA, US55%Free*
Brisbane, AU20%$0.10
Yuma, AZ, US10%$0.20

*Removal of cloud from high cloud areas such as Seattle has a cost of $0.10 per Cloud Hour per 10m3.

If you have any questions or comments send them to the App Engine group. We'd love to hear from you.

- Posted by the App Engine team