Friday, February 4, 2011

[Gd] Optimizing your site for TV is now easier

| More

The official Google Code blog: Optimizing your site for TV is now easier

Ever since we launched Google TV last October, we’ve seen web developers optimize their sites for TV with amazing results. However, designing a 10 foot UI and implementing controls optimized for the television is still a foreign concept for most web developers. Understanding that challenge, we’re happy to release new templates and a UI library to make it easy for developers to optimize their sites for TV.

Google TV comes with the Chrome browser that supports familiar technologies such as HTML5, JavaScript, CSS and Flash. Keeping this in mind, we have created two template designs in HTML5 and Flash that are focused on delivering video content, but equally suitable for photos or other multimedia:








For those developers who prefer to design their own 10 foot UI, we’ve created the Google TV Web UI Library to enable TV friendly controls such as D-pad (up, down, left, right) navigation. To accommodate different web developers needs, the Google TV Web UI Library is provided in 2 different flavors; jQuery based and Closure based. Get started by downloading the library and reading the documentation and tutorials.

Both the templates and the library are available under the Apache 2 license. As always, we love to hear your feedback. Please post comments and questions on the library and templates to our Google TV Web Developer Forum. Happy coding!


By Steve Hines and Daniels Lee, Google TV Developer Relations Team
URL: http://googlecode.blogspot.com/2011/02/optimizing-your-site-for-tv-is-now.html

[Gd] How Google Tests Software

| More

Google Testing Blog: How Google Tests Software

By James Whittaker

This is the first in a series of posts on this topic.

The one question I get more than any other is "How does Google test?" It's been explained in bits and pieces on this blog but the explanation is due an update. The Google testing strategy has never changed but the tactical ways we execute it has evolved as the company has evolved. We're now a search, apps, ads, mobile, operating system, and so on and so forth company. Each of these Focus Areas (as we call them) have to do things that make sense for their problem domain. As we add new FAs and grow the existing ones, our testing has to expand and improve. What I am documenting in this series of posts is a combination of what we are doing today and the direction we are trending toward in the foreseeable future.

Let's begin with organizational structure and it's one that might surprise you. There isn't an actual testing organization at Google. Test exists within a Focus Area called Engineering Productivity. Eng Prod owns any number of horizontal and vertical engineering disciplines, Test is the biggest. In a nutshell, Eng Prod is made of:

1. A product team that produces internal and open source productivity tools that are consumed by all walks of engineers across the company. We build and maintain code analyzers, IDEs, test case management systems, automated testing tools, build systems, source control systems, code review schedulers, bug databases... The idea is to make the tools that make engineers more productive. Tools are a very large part of the strategic goal of prevention over detection.

2. A services team that provides expertise to Google product teams on a wide array of topics including tools, documentation, testing, release management, training and so forth. Our expertise covers reliability, security, internationalization, etc., as well as product-specific functional issues that Google product teams might face. Every other FA has access to Eng Prod expertise.

3. Embedded engineers that are effectively loaned out to Google product teams on an as-needed basis. Some of these engineers might sit with the same product teams for years, others cycle through teams wherever they are needed most. Google encourages all its engineers to change product teams often to stay fresh, engaged and objective. Testers are no different but the cadence of changing teams is left to the individual. I have testers on Chrome that have been there for several years and others who join for 18 months and cycle off. Keeping a healthy balance between product knowledge and fresh eyes is something a test manager has to pay close attention to.

So this means that testers report to Eng Prod managers but identify themselves with a product team, like Search, Gmail or Chrome. Organizationally they are part of both teams. They sit with the product teams, participate in their planning, go to lunch with them, share in ship bonuses and get treated like full members of the team. The benefit of the separate reporting structure is that it provides a forum for testers to share information. Good testing ideas migrate easily within Eng Prod giving all testers, no matter their product ties, access to the best technology within the company.

This separation of project and reporting structures has its challenges. By far the biggest is that testers are an external resource. Product teams can't place too big a bet on them and must keep their quality house in order. Yes, that's right: at Google it's the product teams that own quality, not testers. Every developer is expected to do their own testing. The job of the tester is to make sure they have the automation infrastructure and enabling processes that support this self reliance. Testers enable developers to test.

What I like about this strategy is that it puts developers and testers on equal footing. It makes us true partners in quality and puts the biggest quality burden where it belongs: on the developers who are responsible for getting the product right. Another side effect is that it allows us a many-to-one dev-to-test ratio. Developers outnumber testers. The better they are at testing the more they outnumber us. Product teams should be proud of a high ratio!

Ok, now we're all friends here right? You see the hole in this strategy I am sure. It's big enough to drive a bug through. Developers can't test! Well, who am I to deny that? No amount of corporate kool-aid could get me to deny it, especially coming off my GTAC talk last year where I pretty much made a game of developer vs. tester (spoiler alert: the tester wins).

Google's answer is to split the role. We solve this problem by having two types of testing roles at Google to solve two very different testing problems. In my next post, I'll talk about these roles and how we split the testing problem into two parts.
URL: http://googletesting.blogspot.com/2011/01/how-google-tests-software.html

[Gd] [Libraries][Update] jQuery 1.5.0 and YUI 3.3.0

| More

Google AJAX API Alerts: [Libraries][Update] jQuery 1.5.0 and YUI 3.3.0

jQuery has been updated to 1.5.0 and YUI has been updated to 3.3.0

Note: YUI version 3 has removed the YUI loader, so the path is different than for older version. See the documentation for details.
URL: http://ajax-api-alerts.blogspot.com/2011/02/librariesupdate-jquery-150-and-yui-330.html

Thursday, February 3, 2011

[Gd] Update to Webmaster Tools Search Queries

| More

Official Google Webmaster Central Blog: Update to Webmaster Tools Search Queries

Webmaster level: All

Last year we relaunched an exciting feature in Webmaster Tools: Search Queries, an analysis tool that visualizes your site’s presence in our search results. It has two main parts: an interactive graph, and a table containing detailed data related to queries for which your site appears in our search results.

Two of the most important pieces of information in the table are ‘impressions’ and ‘clicks.’ ‘Impressions’ shows the number of times your pages were shown in the search results for a certain query, and ‘clicks’ is how many times users actually clicked on a result from your site.

Based on webmaster feedback, today we’re announcing a slight change in how these numbers are represented in Webmaster Tools, to simplify their interpretation. Instead of showing numbers rounded to two or three digits, the numbers will now be shown with one or two significant digits. For example, instead of Webmaster Tools showing you 246,000 impressions, it will now show 250,000 impressions, which is a nicer representation for a better, less confusing experience. We have not altered the way we calculate the numbers internally, but only changed how we round them in Webmaster Tools. Generally, a difference of less than 10% between the numbers you see now and those you saw prior to this change should not be considered significant.



Impressions before and after today’s Search Queries update

We hope that this update makes Search Queries easier to understand. If you want to learn more about this feature you can visit our Help Center. If you have feedback or suggestions for Search Queries, please let us know in the Webmaster Help Forum.

Posted by Pierre Far and Gary Illyes, Webmaster Trends Analyst team
URL: http://googlewebmastercentral.blogspot.com/2011/02/update-to-webmaster-tools-search.html

[Gd] The Android 3.0 Fragments API

| More

Android Developers Blog: The Android 3.0 Fragments API

[This post is by Dianne Hackborn, a Software Engineer who sits very near the exact center of everything Android. — Tim Bray]

An important goal for Android 3.0 is to make it easier for developers to write applications that can scale across a variety of screen sizes, beyond the facilities already available in the platform:

  • Since the beginning, Android’s UI framework has been designed around the use of layout managers, allowing UIs to be described in a way that will adjust to the space available. A common example is a ListView whose height changes depending on the size of the screen, which varies a bit between QVGA, HVGA, and WVGA aspect ratios.

  • Android 1.6 introduced a new concept of screen densities, making it easy for apps to scale between different screen resolutions when the screen is about the same physical size. Developers immediately started using this facility when higher-resolution screens were introduced, first on Droid and then on other phones.

  • Android 1.6 also made screen sizes accessible to developers, classifying them into buckets: “small” for QVGA aspect ratios, “normal” for HVGA and WVGA aspect ratios, and “large” for larger screens. Developers can use the resource system to select between different layouts based on the screen size.

The combination of layout managers and resource selection based on screen size goes a long way towards helping developers build scalable UIs for the variety of Android devices we want to enable. As a result, many existing handset applications Just Work under Honeycomb on full-size tablets, without special compatibility modes, with no changes required. However, as we move up into tablet-oriented UIs with 10-inch screens, many applications also benefit from a more radical UI adjustment than resources can easily provide by themselves.

Introducing the Fragment

Android 3.0 further helps applications adjust their interfaces with a new class called Fragment. A Fragment is a self-contained component with its own UI and lifecycle; it can be-reused in different parts of an application’s user interface depending on the desired UI flow for a particular device or screen.

In some ways you can think of a Fragment as a mini-Activity, though it can’t run independently but must be hosted within an actual Activity. In fact the introduction of the Fragment API gave us the opportunity to address many of the pain points we have seen developers hit with Activities, so in Android 3.0 the utility of Fragment extends far beyond just adjusting for different screens:

  • Embedded Activities via ActivityGroup were a nice idea, but have always been difficult to deal with since Activity is designed to be an independent self-contained component instead of closely interacting with other activities. The Fragment API is a much better solution for this, and should be considered as a replacement for embedded activities.

  • Retaining data across Activity instances could be accomplished through Activity.onRetainNonConfigurationInstance(), but this is fairly klunky and non-obvious. Fragment replaces that mechanism by allowing you to retain an entire Fragment instance just by setting a flag.

  • A specialization of Fragment called DialogFragment makes it easy to show a Dialog that is managed as part of the Activity lifecycle. This replaces Activity’s “managed dialog” APIs.

  • Another specialization of Fragment called ListFragment makes it easy to show a list of data. This is similar to the existing ListActivity (with a few more features), but should reduce the common question about how to show a list with some other data.

  • The information about all fragments currently attached to an activity is saved for you by the framework in the activity’s saved instance state and restored for you when it restarts. This can greatly reduce the amount of state save and restore code you need to write yourself.

  • The framework has built-in support for managing a back-stack of Fragment objects, making it easy to provide intra-activity Back button behavior that integrates the existing activity back stack. This state is also saved and restored for you automatically.

Getting started

To whet your appetite, here is a simple but complete example of implementing multiple UI flows using fragments. We first are going to design a landscape layout, containing a list of items on the left and details of the selected item on the right. This is the layout we want to achieve:

The code for this activity is not interesting; it just calls setContentView() with the given layout:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="match_parent">

<fragment class="com.example.android.apis.app.TitlesFragment"
android:id="@+id/titles" android:layout_weight="1"
android:layout_width="0px"
android:layout_height="match_parent" />

<FrameLayout android:id="@+id/details" android:layout_weight="1"
android:layout_width="0px"
android:layout_height="match_parent" />

</LinearLayout>

You can see here our first new feature: the <fragment> tag allows you to automatically instantiate and install a Fragment subclass into your view hierarchy. The fragment being implemented here derives from ListFragment, displaying and managing a list of items the user can select. The implementation below takes care of displaying the details of an item either in-place or as a separate activity, depending on the UI layout. Note how changes to fragment state (the currently shown details fragment) are retained across configuration changes for you by the framework.

public static class TitlesFragment extends ListFragment {
boolean mDualPane;
int mCurCheckPosition = 0;

@Override
public void onActivityCreated(Bundle savedState) {
super.onActivityCreated(savedState);

// Populate list with our static array of titles.
setListAdapter(new ArrayAdapter<String>(getActivity(),
R.layout.simple_list_item_checkable_1,
Shakespeare.TITLES));

// Check to see if we have a frame in which to embed the details
// fragment directly in the containing UI.
View detailsFrame = getActivity().findViewById(R.id.details);
mDualPane = detailsFrame != null
&& detailsFrame.getVisibility() == View.VISIBLE;

if (savedState != null) {
// Restore last state for checked position.
mCurCheckPosition = savedState.getInt("curChoice", 0);
}

if (mDualPane) {
// In dual-pane mode, list view highlights selected item.
getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
// Make sure our UI is in the correct state.
showDetails(mCurCheckPosition);
}
}

@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putInt("curChoice", mCurCheckPosition);
}

@Override
public void onListItemClick(ListView l, View v, int pos, long id) {
showDetails(pos);
}

/**
* Helper function to show the details of a selected item, either by
* displaying a fragment in-place in the current UI, or starting a
* whole new activity in which it is displayed.
*/
void showDetails(int index) {
mCurCheckPosition = index;

if (mDualPane) {
// We can display everything in-place with fragments.
// Have the list highlight this item and show the data.
getListView().setItemChecked(index, true);

// Check what fragment is shown, replace if needed.
DetailsFragment details = (DetailsFragment)
getFragmentManager().findFragmentById(R.id.details);
if (details == null || details.getShownIndex() != index) {
// Make new fragment to show this selection.
details = DetailsFragment.newInstance(index);

// Execute a transaction, replacing any existing
// fragment with this one inside the frame.
FragmentTransaction ft
= getFragmentManager().beginTransaction();
ft.replace(R.id.details, details);
ft.setTransition(
FragmentTransaction.TRANSIT_FRAGMENT_FADE);
ft.commit();
}

} else {
// Otherwise we need to launch a new activity to display
// the dialog fragment with selected text.
Intent intent = new Intent();
intent.setClass(getActivity(), DetailsActivity.class);
intent.putExtra("index", index);
startActivity(intent);
}
}
}

For this first screen we need an implementation of DetailsFragment, which simply shows a TextView containing the text of the currently selected item.

public static class DetailsFragment extends Fragment {
/**
* Create a new instance of DetailsFragment, initialized to
* show the text at 'index'.
*/
public static DetailsFragment newInstance(int index) {
DetailsFragment f = new DetailsFragment();

// Supply index input as an argument.
Bundle args = new Bundle();
args.putInt("index", index);
f.setArguments(args);

return f;
}

public int getShownIndex() {
return getArguments().getInt("index", 0);
}

@Override
public View onCreateView(LayoutInflater inflater,
ViewGroup container, Bundle savedInstanceState) {
if (container == null) {
// Currently in a layout without a container, so no
// reason to create our view.
return null;
}

ScrollView scroller = new ScrollView(getActivity());
TextView text = new TextView(getActivity());
int padding = (int)TypedValue.applyDimension(
TypedValue.COMPLEX_UNIT_DIP,
4, getActivity().getResources().getDisplayMetrics());
text.setPadding(padding, padding, padding, padding);
scroller.addView(text);
text.setText(Shakespeare.DIALOGUE[getShownIndex()]);
return scroller;
}
}

It is now time to add another UI flow to our application. When in portrait orientation, there is not enough room to display the two fragments side-by-side, so instead we want to show only the list like this:

With the code shown so far, all we need to do here is introduce a new layout variation for portrait screens like so:

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">
<fragment class="com.example.android.apis.app.TitlesFragment"
android:id="@+id/titles"
android:layout_width="match_parent"
android:layout_height="match_parent" />
</FrameLayout>

The TitlesFragment will notice that it doesn’t have a container in which to show its details, so show only its list. When you tap on an item in the list we now need to go to a separate activity in which the details are shown.

With the DetailsFragment already implemented, the implementation of the new activity is very simple because it can reuse the same DetailsFragment from above:

public static class DetailsActivity extends FragmentActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

if (getResources().getConfiguration().orientation
== Configuration.ORIENTATION_LANDSCAPE) {
// If the screen is now in landscape mode, we can show the
// dialog in-line so we don't need this activity.
finish();
return;
}

if (savedInstanceState == null) {
// During initial setup, plug in the details fragment.
DetailsFragment details = new DetailsFragment();
details.setArguments(getIntent().getExtras());
getSupportFragmentManager().beginTransaction().add(
android.R.id.content, details).commit();
}
}
}

Put that all together, and we have a complete working example of an application that fairly radically changes its UI flow based on the screen it is running on, and can even adjust it on demand as the screen configuration changes.

This illustrates just one way fragments can be used to adjust your UI. Depending on your application design, you may prefer other approaches. For example, you could put your entire application in one activity in which you change the fragment structure as its state changes; the fragment back stack can come in handy in this case.

More information on the Fragment and FragmentManager APIs can be found in the Android 3.0 SDK documentation. Also be sure to look at the ApiDemos app under the Resources tab, which has a variety of Fragment demos covering their use for alternative UI flow, dialogs, lists, populating menus, retaining across activity instances, the back stack, and more.

Fragmentation for all!

For developers starting work on tablet-oriented applications designed for Android 3.0, the new Fragment API is useful for many design situations that arise from the larger screen. Reasonable use of fragments should also make it easier to adjust the resulting application’s UI to new devices in the future as needed -- for phones, TVs, or wherever Android appears.

However, the immediate need for many developers today is probably to design applications that they can provide for existing phones while also presenting an improved user interface on tablets. With Fragment only being available in Android 3.0, their shorter-term utility is greatly diminished.

To address this, we plan to have the same fragment APIs (and the new LoaderManager as well) described here available as a static library for use with older versions of Android; we’re trying to go right back to 1.6. In fact, if you compare the code examples here to those in the Android 3.0 SDK, they are slightly different: this code is from an application using an early version of the static library fragment classes which is running, as you can see on the screenshots, on Android 2.3. Our goal is to make these APIs nearly identical, so you can start using them now and, at whatever point in the future you switch to Android 3.0 as your minimum version, move to the platform’s native implementation with few changes in your app.

We don’t have a firm date for when this library will be available, but it should be relatively soon. In the meantime, you can start developing with fragments on Android 3.0 to see how they work, and most of that effort should be transferable.

URL: http://android-developers.blogspot.com/2011/02/android-30-fragments-api.html

Wednesday, February 2, 2011

[Gd] New Merchandising and Billing Features on Android Market

| More

Android Developers Blog: New Merchandising and Billing Features on Android Market

[This post is by Eric Chu, Android Developer Ecosystem. —Dirk Dougherty]


Following on last week’s announcement of the Android 3.0 Preview SDK, I’d like to share some more good news with you about three important new features on Android Market.

Android Market on the Web


Starting today, we have extended Android Market client from mobile devices to every desktop. Anyone can now easily find and share applications from their favorite browser. Once users select an application they want, it will automatically be downloaded to their Android-powered devices over-the-air.

Android Market on the Web dramatically expands the discoverability of applications through a rich browsing experience, suggestion-guided searching, deep linking, social sharing, and other merchandising features.

We are releasing the initial version of Android Market on the Web in English and will be extending it to other languages in the weeks ahead.

If you have applications published on Android Market, we encourage you to visit the site and review how they are presented. If you need additional information about what assets you should provide, please visit Android Market Help Center.

You can access Android Market on the Web at:

http://market.android.com/

Buyer’s Currency

Android Market lets you sell applications to users in 32 buyer countries around the world. Today we’re introducing Buyer’s Currency to give you more control over how you price your products across those countries. This feature lets you price your applications differently in each market and improves the purchase experience for buyers by showing prices in their home currencies.

We’ll be rolling out Buyer’s Currency in stages, starting with developers in the U.S. and reaching developers in other countries shortly after. We anticipate it will take approximately four months for us to complete this process.

We encourage you to watch for the appearance of new Buyer’s Currency options in the Android Market publishing console and set prices as soon as possible.

In-app Billing

After months of hard work by the Android Market team, I am extremely pleased to announce the arrival of In-app Billing on Android Market. This new service gives developers more ways to monetize their applications through new billing models including try-and-buy, virtual goods, upgrades, and more.

The In-app Billing service manages billing transactions between apps and users, providing a consistent purchasing experience with familiar forms of payment across all apps. At the same time, it gives you full control over how your digital goods are purchased and tracked. You can let Android Market manage and track the purchases for you or you can integrate with your own back-end service to verify and track purchases in the way that's best for your app.

We’ll be launching In-app Billing in stages. Beginning today, we are providing detailed documentation and a sample application to help you get familiar with the service. Over the next few weeks we’ll be rolling out updates to the Android Market client that will enable you to test against the In-app Billing service. Before the end of this quarter, the service will be live for users, to enable you to start monetizing your applications with this new capability. For complete information about the rollout, see the release information in the In-app Billing documentation.

Helping developers merchandise and monetize their products is a top priority for the Android Market team. We will continue to work hard to to make it the best marketplace for your to distribute your products. For now, we hope you’ll check out these new features to help you better deliver your products through Android Market.

URL: http://android-developers.blogspot.com/2011/02/new-merchandising-and-billing-features.html

[Gd] [This post is by Eric Chu, Android Developer Ecosystem. —Dirk

| More

Android Developers Blog:

[This post is by Eric Chu, Android Developer Ecosystem. —Dirk

[This post is by Eric Chu, Android Developer Ecosystem. —Dirk Dougherty]


Following on last week’s announcement of the Android 3.0 Preview SDK, I’d like to share some more good news with you about three important new features on Android Market.

Android Market on the Web


Starting today, we have extended Android Market client from mobile devices to every desktop. Anyone can now easily find and share applications from their favorite browser. Once users select an application they want, it will automatically be downloaded to their Android-powered devices over-the-air.

Android Market on the Web dramatically expands the discoverability of applications through a rich browsing experience, suggestion-guided searching, deep linking, social sharing, and other merchandising features.

We are releasing the initial version of Android Market on the Web in English and will be extending it to other languages in the weeks ahead.

If you have applications published on Android Market, we encourage you to visit the site and review how they are presented. If you need additional information about what assets you should provide, please visit Android Market Help Center.

You can access Android Market on the Web at:

http://market.android.com/

Buyer’s Currency

Android Market lets you sell applications to users in 32 buyer countries around the world. Today we’re introducing Buyer’s Currency to give you more control over how you price your products across those countries. This feature lets you price your applications differently in each market and improves the purchase experience for buyers by showing prices in their home currencies.

We’ll be rolling out Buyer’s Currency in stages, starting with developers in the U.S. and reaching developers in other countries shortly after. We anticipate it will take approximately four months for us to complete this process.

We encourage you to watch for the appearance of new Buyer’s Currency options in the Android Market publishing console and set prices as soon as possible.

In-app Billing

After months of hard work by the Android Market team, I am extremely pleased to announce the arrival of In-app Billing on Android Market. This new service gives developers more ways to monetize their applications through new billing models including try-and-buy, virtual goods, upgrades, and more.

The In-app Billing service manages billing transactions between apps and users, providing a consistent purchasing experience with familiar forms of payment across all apps. At the same time, it gives you full control over how your digital goods are purchased and tracked. You can let Android Market manage and track the purchases for you or you can integrate with your own back-end service to verify and track purchases in the way that's best for your app.

We’ll be launching In-app Billing in stages. Beginning today, we are providing detailed documentation and a sample application to help you get familiar with the service. Over the next few weeks we’ll be rolling out updates to the Android Market client that will enable you to test against the In-app Billing service. Before the end of this quarter, the service will be live for users, to enable you to start monetizing your applications with this new capability. For complete information about the rollout, see the release information in the In-app Billing documentation.

Helping developers merchandise and monetize their products is a top priority for the Android Market team. We will continue to work hard to to make it the best marketplace for your to distribute your products. For now, we hope you’ll check out these new features to help you better deliver your products through Android Market.

URL: http://android-developers.blogspot.com/2011/02/this-post-is-by-eric-chu-android.html

[Gd] [Libraries][Update] WebFont 1.0.18

| More

Google AJAX API Alerts: [Libraries][Update] WebFont 1.0.18

WebFont has been updated to 1.0.18
URL: http://ajax-api-alerts.blogspot.com/2011/02/librariesupdate-webfont-1018.html

Tuesday, February 1, 2011

[Gd] Discover v201008: Product ads and criteria

| More

AdWords API Blog: Discover v201008: Product ads and criteria

We’ve recently released additional product advertising options in Google AdWords, and have exposed features in AdWords API v201008 to enable you to leverage these new ad formats. Product extensions enhance your existing text ads with relevant production information, while product listing ads expose your entire product catalog with minimal setup and maintenance. You can read further about the differences between these ad formats here.

In this post we’ll discuss how product ads can be created using the API. Note: both features require that you first link your Google Merchant Center account to your AdWords account. This is done through the Google Merchant Center web interface using these instructions.

Product extensions

Like other extensions, product extensions are represented as CampaignAdExtensions using the type ProductExtension. The CampaignAdExtensionService can be used to retrieve or delete product extensions, but at this time they can only be created through the AdWords web interface. Once they have been created they will be automatically applied to all text ads in the campaign, and utilize existing keyword targeting.

Product listing ads

The API type ProductAd corresponds to a product listing ad, and can be manipulated using the AdGroupAdService. Unlike other ad types, a majority of the information displayed in the ad is not stored in the AdWords system but is pulled from the Google Merchant Center when the ad is served. For this reason the ad is very simple, introducing only an optional promotionLine field. Additionally, the fields url and displayUrl aren’t supported for product listing ads, as these values are populated based on the product that is being shown.

The Product criterion (known as a “product target” in the web interface) is what allows you to control which products are eligible to be shown with a product listing ad and what the bid should be for those products. This criterion contains conditional rules used to filter your product catalog, limited to the following product attributes: product_type, brand, adwords_grouping, condition, and adwords_labels. It’s worth noting that a single Product criterion usually corresponds to multiple different products in the catalog.

Let’s take the example of a merchant that wants to advertise their line of store-made premium chocolates for Valentine’s day. Using the PHP client library they would first add the product listing ad to the ad group, with a promotional message for the holiday.

// Create product listing ad.
$productAd = new ProductAd();
$productAd->promotionLine = 'Order some sweets for your sweet!';

// Create ad group ad.
$adGroupAd = new AdGroupAd();
$adGroupAd->adGroupId = $adGroupId;
$adGroupAd->ad = $productAd;

// Create operation.
$operation = new AdGroupAdOperation();
$operation->operand = $adGroupAd;
$operation->operator = 'ADD';
$operations = array($operation);

// Add ad.
$result = $adGroupAdService->mutate($operations);


They would then add a product criterion to the ad group, filtering for products that are chocolates in their premium brand.

// Create product conditions.
$productTypeCondition = new ProductCondition('Chocolate',
new ProductConditionOperand('product_type'));
$brandCondition = new ProductCondition('Acme Premium',
new ProductConditionOperand('brand'));

// Create product criterion.
$product = new Product();
$product->conditions = array($productTypeCondition, $brandCondition);

// Create biddable ad group criterion.
$adGroupCriterion = new BiddableAdGroupCriterion();
$adGroupCriterion->adGroupId = $adGroupId;
$adGroupCriterion->criterion = $product;

// Create operation.
$operation = new AdGroupCriterionOperation();
$operation->operand = $adGroupCriterion;
$operation->operator = 'ADD';
$operations = array($operation);

// Add ad group criteria.
$result = $adGroupCriterionService->mutate($operations);


Using only this single ad and criterion all of their premium chocolates are ready to be advertised.

Additional information on how you can set up your campaigns to use product listing ads is available here. If you have any question about how to use product ad features in the API you can reach us on the forum.

Best,
- Eric Koleda, AdWords API Team
URL: http://adwordsapi.blogspot.com/2011/02/discover-v201008-product-ads-and.html

[Gd] Interview with Astigmatic

| More

Google Web Fonts: Interview with Astigmatic

We recently got a hold of Brian Bonislawsky, founder of Astigmatic type foundry, to describe his design process and motivations.

Q: When did you design your first font? What font was it?
My very first font was called ChickenScratch. I designed it in the summer of 1996 as the first freeware font for my website to test the waters to see if I was able to make a usable font for the public. I still see it out there a lot today, and seeing all the different design intentions for it has only helped inspire me in my design process since then.

Q: How do you go about creating a new font? Where do the concepts come from?
Making a new font starts with the idea, and luckily...font inspiration is everywhere. It can come from seeing advertisements and signs, to vintage advertising, to movies and music, to the surprise of seeing how fonts are used in projects outside of how you ever intended them to be used.

I'm still a bit old school when it comes to making new fonts, by starting out with sketches on paper. I like to work on creating consistency across all of my characters while also imaging possible variation to the lettering before taking it into a digital form. This stage of creation is the most appealing to me, before it gets into the technical side of point placements, spacing, kerning, and other features. It is the artistic period of the font.

Q: What is your favorite font you've designed?
That's difficult to answer, only because I have so many fonts I've designed, and at one time or another, they've each been my favorite font. I am usually driven to create what appeals to me, and by that, I find the latest fonts of mine to be my favorites. I really love offbeat and comic styles of fonts though, because they remind me of watching Saturday morning cartoons when I was a kid. With that said, right now, my favorite font of mine is Luckiest Guy.

Q: What is your favorite font from another designer? Why?
Besides offbeat comic fonts, I've always been drawn to historical lettering and typestyles, and while it isn't a single font from another designer, my favorite fonts from another designer are the Bluemlien Collection from Sudtipos. They encompass such a variety of handwritten styles, in a variety of refinements. I could just look at specimens of these for hours at a time.

Q: What is your favorite part of the type design process, and why?
All my early schooling was driven predominantly by fine arts training, so I definitely find the sketch development process is my favorite part of the type design process. I've done a lot of freelance for other designers on the technical side of font development, and while there is a degree of enjoyment I get out of it, it definitely feels more mechanical in nature. The sketch and idea phase of a typeface is the chance to free or restrain yourself depending on the type of font you are creating, and reminds me the most of how I used to express myself through other mixed medias. It's the time most open to experimentation.

Q: What do you think could be improved about the type design process?
Perhaps the main thing that could be improved is schooling. When I started, there weren't any schools for this, it was all picked up as I went along, and not many people wanted to share how they did things. I got lucky enough to get paired up with Bitstream and some other designers through TypeCon, a yearly type conference, and through those connections I expanded my skill set.

There are plenty of schools and courses for Graphic Design out there, but I haven't seen a lot of courses for type design itself. I've seen a number of designers with creative ideas come and go because they've been intimidated by the type design process, and that's a shame. It can seem like an overwhelming task when you start making fonts, but once you learn the ropes, it can become second nature like anything else. I'd like to encourage more font designers to come forth, as I think, like any other art field, the infusion of new blood and fresh ideas not only helps type design evolve as an art form, but it also spawns developers to create even more fluid production tools to enable us in new and better ways.
URL: http://googlewebfonts.blogspot.com/2011/01/interview-with-astigmatic.html

Monday, January 31, 2011

[Gd] Dev Channel Update

| More

Google Chrome Releases: Dev Channel Update


The Chrome Dev channel has been updated to 10.0.648.11 for all platforms.  This build contains stability fixes and refinements to the new settings pages. Full details about the Chrome changes are available in the SVN revision log. If you find new issues, please let us know by filing a bug. Want to change to another Chrome release channel? Find out how.

Jason Kersey
Google Chrome
URL: http://googlechromereleases.blogspot.com/2011/01/dev-channel-update_31.html

[Gd] Go Daddy Makes The Web Faster by enabling mod_pagespeed

| More

The official Google Code blog: Go Daddy Makes The Web Faster by enabling mod_pagespeed

As part of our Make The Web Faster initiative, Google announced the availability of mod_pagespeed, an open-source module for Apache webservers to automatically accelerate the sites they serve. Go Daddy, the top web hosting provider and world's largest domain name registrar, announced that they would roll out the mod_pagespeed feature for their Linux Web hosting customers. The feature is now available and is in use by Go Daddy customers who have already started to report faster webpage load times.

“Who on the Internet wouldn't want a faster website?” asked Go Daddy CEO and Founder Bob Parsons. “The benefits of mod_pagespeed are really a slam dunk. It’s built to boost users’ web performance, and ultimately, the bottom line for their business.”

By using several filters that implement web performance best practices, mod_pagespeed rewrites web page resources to automatically optimize their content. The filters improve performance for JavaScript, HTML and CSS, as well as JPEG and PNG images.

Mike Bender, co-creator of photo-blog AwkwardFamilyPhotos.com and Go Daddy customer, detected a 48% decrease, slicing the load time for his image-rich website from 12.8 to 6.6 seconds. mod_pagespeed speeds up the first visit of the site by reducing the payload size and improving compression. Repeat visits are accelerated by making caching more efficient and decreasing the size of resources such as CSS and HTML on the page as demonstrated in this chart (where smaller is faster):



“From the moment we enabled mod_pagespeed, the difference was noticeable,” said Bender. “It was a simple ‘flick of the switch,’ and the site started loading faster.”


For Go Daddy customers currently using the Linux 4GH web hosting platform, find out how to enable mod_pagespeed for your own website here. Other webmasters can install mod_pagespeed binaries or build directly from source.


By Joshua Marantz, Google 'Make The Web Faster' Initiative and Flavio Andrade, Go Daddy Product Line Manager
URL: http://googlecode.blogspot.com/2011/01/go-daddy-makes-web-faster-by-enabling.html

Sunday, January 30, 2011

[Gd] Help your customers stay in touch with Google Contacts

| More

Google Apps Developer Blog: Help your customers stay in touch with Google Contacts

A while back we began a series of articles about integrating with Google Apps and the Google Apps Marketplace, starting with how to make a great first impression on your users. Today we're continuing that series with an eye on collaboration and the various "people" APIs in Google Apps -- Contacts, Shared Contacts, Profiles, and Provisioning.

Why contacts? Contacts data is used pervasively and makes it easier to share documents, arrange meetings, or communicate in general. It's synced with mobile phones & email clients. Many apps in the Google Apps Marketplace use contacts to help users share projects and assign tasks to coworkers. In short, the contacts APIs act as a hub for applications and devices to share important information about the people users communicate and collaborate with the most!

Untangling the APIs

Before jumping in to how to use these APIs to make work easier for users, let's take a step back and look at the role of each API.

Contacts API - This API provides access to an individual user's personal contacts & is available to all users on all editions of Google Apps. Each user manages their own contacts separately.

Shared Contacts API - The shared contacts API is available only to Google Apps for Business and Education editions, and provides a way for domain administrators to manage a global address list of external (non-employee) contacts viewable by all users in the domain.

Profiles API - Like the Shared Contacts API, the profiles API is only available for Google Apps for Business and Education education, and is managed by domain administrators. But while shared contacts can be used to manage contact information for people outside the domain, the Profiles API is exclusively for managing contact information for users in the domain.

Provisioning API - A distant cousin of the others, the Provisioning API allows domain administrators to manage users, groups, and organizational units in their domain. While the full version of the API is restricted to Google Apps for Business & Education editions, all editions support a read-only view of the data and it can be a quick and easy way to discover organizational information for a domain.

Speeding Setup

As mentioned in our earlier post on creating a good initial experience, these APIs, can be a great way to help administrators set up and configure applications quickly. The provisioning API in particular is well suited to this and provides user, group, and organizational data for a domain.


Expensify uses the provisioning API to quickly configure roles and reporting relationships for submitting expense reports.

Making Users More Productive

There are a variety of ways to use the various contacts APIs to help users save time and be more productive. Project & task management apps often benefit from importing contact information to speed user entry.

Manymoon's project management app helps users assign tasks quicker by auto-completing names as the user types.

Likewise, CRM and marketing automation apps can also speed user adoption and reduce the need for time consuming data entry by importing existing customer data stored in contacts.

Importing contacts to Bantam Live

Share and Share Alike

For applications that aim to be the system of record for contact or employee information, pushing data to Google Apps can be a big win both for users and developers. Syncing contact data with Google Apps means syncing with every other application and device that syncs as well. It allows developers to magnify the reach of their integrations and lets users access important partner data no matter what the context.

Sharing contacts with BatchBook

Full bi-directional contacts synchronization is more challenging. It can be equally rewarding. Not only does it allow users to edit contacts in context, it can enable innovative new services that seamless enhance data without disrupting how users work.

Rainmaker's bi-directional sync automatically enhances contacts with data from social networks and other sources.

While the example so far have focused on the Contacts API and individual users, synchronization with the Shared Contacts API can provide added value for larger organizations on Google Apps for Business.

As our friends over at Manymoon wrote not too long ago, they learned three key lessons about what it takes to be successful in the Google Apps Marketplace: Appeal to a broad audience, integrate deeply, and demonstrate immediate value. Integration with contacts & provisioning APIs is a great way to do accomplish those goals that just about any app can benefit from!

Posted by Steven Bazyl, Google Apps Marketplace Team

Want to weigh in on this topic? Discuss on Buzz

URL: http://googleappsdeveloper.blogspot.com/2011/01/help-your-customers-stay-in-touch-with.html

[Gd] YouTube Captions Uploader Web App

| More

YouTube API Blog: YouTube Captions Uploader Web App

Captions can greatly enhance the experience of viewing a YouTube video, and the YouTube API has offered developers ways to upload and retrieve caption data in authorized requests for a while now. However, the various YouTube API client libraries don’t natively support interacting with captions at this time, and writing your own code for uploading or retrieving captions can be challenging.

With that in mind, we're happy to announce the YouTube Captions Uploader open source project on Google Code, which provides real-world code for uploading captions to YouTube. The code is written for the Java App Engine environment, and it uses some nifty new App Engine features like the Channel API, the Blobstore Service, and Task Queues. And even if you're not an App Engine developer, we hope that the code that interacts with the YouTube API's captions service will provide a good starting point for writing your own code.

In addition to open sourcing the code for this project, we’re also running the code itself on a public App Engine instance, http://yt-captions-uploader.appspot.com/. So, even if you're not a developer, you can still use the application to upload captions for videos in your YouTube account.

Please share your comments or feedback via the project’s issue tracker. We hope that you find it useful both as a standalone web application and as a starting point for writing your own code!

Cheers,
—Jeff Posnick, YouTube API Team
URL: http://apiblog.youtube.com/2011/01/youtube-captions-uploader-web-app.html