Friday, July 31, 2009

[Gd] More transliteration languages for Custom Search

| More

Google Custom Search: More transliteration languages for Custom Search

Posted by: Christine Moschella, Online Operations

A few weeks ago, we announced support for transliteration in Custom Search in a bunch of languages, including Arabic and a set of Indic languages. The auto-transliteration feature allows your users to conveniently type in English, for example, and search in one of these languages.

Now, that list of transliteration languages in Custom Search has grown. We now support a dozen languages, including Urdu and Nepali.

The feature is very simple to use: you can turn transliteration on in the Language settings section of the Basics page on the Custom Search control panel.

Once you've enabled automatic transliteration, a language button next to the search box alerts your users. As a user types, the query is transliterated into the selected language in real-time, allowing the user to search in that language.

For more details, read our original transliteration blog post, or search on the Custom Search website!

Here's the current list of supported transliteration languages:
  • Arabic
  • Bengali
  • Gujarati
  • Hindi
  • Kannada
  • Malayalam
  • Marathi
  • Nepali
  • Punjabi
  • Tamil
  • Telugu
  • Urdu
Feel free to share your feedback on transliteration in our forum.
URL: http://googlecustomsearch.blogspot.com/2009/07/more-transliteration-languages-for.html

[Gd] How to think about OO

| More

Google Testing Blog: How to think about OO

by Miško Hevery

Everyone seems to think that they are writing OO after all they are using OO languages such as Java, Python or Ruby. But if you exam the code it is often procedural in nature.

Static Methods

Static methods are procedural in nature and they have no place in OO world. I can already hear the screams, so let me explain why, but first we need to agree that global variables and state is evil. If you agree with previous statement than for a static method to do something interesting it needs to have some arguments, otherwise it will always return a constant. Call to a staticMethod() must always return the same thing, if there is no global state. (Time and random, has global state, so that does not count and object instantiation may have different instance but the object graph will be wired the same way.)

This means that for a static method to do something interesting it needs to have arguments. But in that case I will argue that the method simply belongs on one of its arguments. Example: Math.abs(-3) should really be -3.abs(). Now that does not imply that -3 needs to be object, only that the compiler needs to do the magic on my behalf, which BTW, Ruby got right. If you have multiple arguments you should choose the argument with which method interacts the most.

But most justifications for static methods argue that they are "utility methods". Let's say that you want to have toCamelCase() method to convert string "my_workspace" to "myWorkspace". Most developers will solve this as StringUtil.toCamelCase("my_workspace"). But, again, I am going to argue that the method simply belongs to the String class and should be "my_workspace".toCamelCase(). But we can't extend the String class in Java, so we are stuck, but in many other OO languages you can add methods to existing classes.

In the end I am sometimes (handful of times per year) forced to write static methods due to limitation of the language. But that is a rare event since static methods are death to testability. What I do find, is that in most projects static methods are rampant.

Instance Methods

So you got rid of all of your static methods but your codes still is procedural. OO says that code and data live together. So when one looks at code one can judge how OO it is without understanding what the code does, simply by looking at the relationship of data and code.
class Database {
// some fields declared here
boolean isDirty(Cache cache, Object obj) {
for (Object cachedObj : cache.getObjects) {
if (cachedObj.equals(obj))
return false;
}
return true;
}
}

The problem here is the method may as well be static! It is in the wrong place, and you can tell this because it does not interact with any of the data in the Database, instead it interacts with the data in cache which it fetches by calling the getObjects() method. My guess is that this method belongs to one of its arguments most likely Cache. If you move it to Cache you well notice that the Cache will no longer need the getObjects() method since the for loop can access the internal state of the Cache directly. Hey, we simplified the code (moved one method, deleted one method) and we have made Demeter happy.

The funny thing about the getter methods is that it usually means that the code where the data is processed is outside of the class which has the data. In other words the code and data are not together.
class Authenticator {
Ldap ldap;
Cookie login(User user) {
if (user.isSuperUser()) {
if ( ldap.auth(user.getUser(),
user.getPassword()) )
return new Cookie(user.getActingAsUser());
} else (user.isAgent) {
return new Cookie(user.getActingAsUser());
} else {
if ( ldap.auth(user.getUser(),
user.getPassword()) )
return new Cookie(user.getUser());
}
return null;
}
}

Now I don't know if this code is well written or not, but I do know that the login() method has a very high affinity to user. It interacts with the user a lot more than it interacts with its own state. Except it does not interact with user, it uses it as a dumb storage for data. Again, code lives with data is being violated. I believe that the method should be on the object with which it interacts the most, in this case on User. So lets have a look:
class User {
String user;
String password;
boolean isAgent;
boolean isSuperUser;
String actingAsUser;

Cookie login(Ldap ldap) {
if (isSuperUser) {
if ( ldap.auth(user, password) )
return new Cookie(actingAsUser);
} else (user.isAgent) {
return new Cookie(actingAsUser);
} else {
if ( ldap.auth(user, password) )
return new Cookie(user);
}
return null;
}
}

Ok we are making progress, notice how the need for all of the getters has disappeared, (and in this simplified example the need for the Authenticator class disappears) but there is still something wrong. The ifs branch on internal state of the object. My guess is that this code-base is riddled with if (user.isSuperUser()). The issue is that if you add a new flag you have to remember to change all of the ifs which are dispersed all over the code-base. Whenever I see If or switch on a flag I can almost always know that polymorphism is in order.
class User {
String user;
String password;

Cookie login(Ldap ldap) {
if ( ldap.auth(user, password) )
return new Cookie(user);
return null;
}
}

class SuperUser extends User {
String actingAsUser;

Cookie login(Ldap ldap) {
if ( ldap.auth(user, password) )
return new Cookie(actingAsUser);
return null;
}
}

class AgentUser extends User {
String actingAsUser;

Cookie login(Ldap ldap) {
return new Cookie(actingAsUser);
}
}

Now that we took advantage of polymorphism, each different kind of user knows how to log in and we can easily add new kind of user type to the system. Also notice how the user no longer has all of the flag fields which were controlling the ifs to give the user different behavior. The ifs and flags have disappeared.

Now this begs the question: should the User know about the Ldap? There are actually two questions in there. 1) should User have a field reference to Ldap? and 2) should User have compile time dependency on Ldap?

Should User have a field reference to Ldap? The answer is no, because you may want to serialize the user to database but you don't want to serialize the Ldap. See here.

Should User have compile time dependency on Ldap? This is more complicated, but in general the answer depends on weather or not you are planning on reusing the User on a different project, since compile time dependencies are transitive in strongly typed languages. My experience is that everyone always writes code that one day they will reuse it, but that day never comes, and when it does, usually the code is entangled in other ways anyway, so code reuse after the fact just does not happen. (developing a library is different since code reuse is an explicit goal.) My point is that a lot of people pay the price of "what if" but never get any benefit out of it. Therefore don't worry abut it and make the User depend on Ldap.
URL: http://googletesting.blogspot.com/2009/07/how-to-think-about-oo.html

Thursday, July 30, 2009

[Gd] Sonico has launched its OpenSocial Container!

| More

OpenSocial API Blog: Sonico has launched its OpenSocial Container!

I am pleased to announce that Sonico, one of Latin America's leading social networks, has successfully rolled out its OpenSocial container to over +39 million users! A fantastic group of launch partners, including Buddypoke and GameDesire, worked with us for this initial release! Sonico is one of the leading social networks in Latin America, and is positioned as the second largest social network in Brazil. It is available in English, Spanish and Portuguese.



Sonico's OpenSocial (v 0.8) platform includes the following:

  • Full support for the core Opensocial APIs:
    • AppData
    • People/Person
    • Activities

  • Gadget rendering of home, profile, preview and canvas views
    • Dimensions for views are the same as used by Orkut

  • Viral features:
    • requestCreateActivity
    • requestShareApp
    • requestSendMessage

  • RESTful APIs
    • RESTful and RPC protocols
    • 2-legged Oauth

Test & Publish your apps!

Our goal is to extend our application offering with useful and entertaining applications which bring value to our community and improve their experience!

We’re happy to invite the OpenSocial developer community to our sandbox and encourage the submission of engaging apps! It is a great opportunity to tap into a market that is eager for social applications.

Request sandbox access and read about our OpenSocial implementation:

http://sandbox.sonico.com

To learn about Sonico's RESTful API visit:

http://api.sonico.com

To learn more about Sonico's demographics and growth:

http://www.slideshare.net/sonico/sonico-corporate-en

Background

Sonico is a social communication platform launched in July 2007 that merges social utility and entertainment to organize people’s life online. Developed with a strong emphasis in user legitimacy, privacy and personalization, it has been widely adopted across Latin America. Sonico is positioned as the second largest social network in Brazil, and is available in English, Spanish and Portuguese.

Located in Buenos Aires and with a team over 80 people, Sonico was elected by BusinessWeek as the 5th tech startup with the highest global growth potential. Sonico closed its first round of capitalization of USD 4.3 million in May 2008.

For more information: http://corporate.sonico.com/

Posted by Alvaro Teijeiro
Partner & CIO, Sonico.com
URL: http://blog.opensocial.org/2009/07/sonico-has-launched-its-opensocial.html

[Gd] Dev Channel Update: More progress on Mac and Linux

| More

Google Chrome Releases: Dev Channel Update: More progress on Mac and Linux

3.0.196.0 has been released to the dev channel with the following changes:

All:
  • Crash fixes

Windows:
  • Cursor no longer flickers over the omnibox and other editable controls.
  • Disconnecting a monitor and restarting Google Chrome no longer leaves windows off in space and impossible to access.

Linux:
  • Google Chrome now respects the system font hinting/antialiasing setting.
  • Added a password manager dialog (Options -> Personal -> Show Saved Passwords).
  • Fixed an issue where scrolling a long page by dragging the scrollbar would lag significantly.
  • Dragging a tab off and dropping it puts the dropped window where you dropped it.

Mac:
  • Trackpad scrolling on maps works again.
  • First stab at history menu.
  • Download shelf now has real download items.
  • Lots of polish bugs.

Extensions:

  • Introduce moles! These are a new extra area that can pop up above toolstrips.
  • Themes now work with --load-extension.
  • You can now reload extensions from a button on chrome://extensions.
  • Fix bug where bookmarks.getTree() doesn't return any bookmarks.
  • Minimum auto-update frequency from command line is now 30 seconds.
  • (Re-)enable content scripts executing in isolated worlds.

More details about additional changes are available in the svn log of all revisions.

You can find out about getting on the Dev channel here: http://dev.chromium.org/getting-involved/dev-channel.

If you find new issues, please let us know by filing a bug at http://code.google.com/p/chromium/issues/entry.

The Google Chrome Team
URL: http://googlechromereleases.blogspot.com/2009/07/dev-channel-update-more-progress-on-mac_30.html

[Gd] Stable Update: Back Button Fix

| More

Google Chrome Releases: Stable Update: Back Button Fix


This is a small release to fix an issue with the back button on some popular web sites (reverting r15950).  

If you find new issues, please let us know by filing a bug at http://code.google.com/p/chromium/issues/entry.

Jonathan Conradt
Engineering Program Manager
URL: http://googlechromereleases.blogspot.com/2009/07/stable-update-back-button-fix.html

Wednesday, July 29, 2009

[Gd] Dev Channel Update: 3.0.195.4

| More

Google Chrome Releases: Dev Channel Update: 3.0.195.4

Windows dev channel has been updated to 3.0.195.4.

This update contains some additional themes and crash fixes.

More details about additional changes are available in the svn log of all revisions.

You can find out about getting on the Dev channel here: http://dev.chromium.org/getting-involved/dev-channel.

If you find new issues, please let us know by filing a bug at http://code.google.com/p/chromium/issues/entry.

Anthony Laforge
Google Chrome Program Manager
URL: http://googlechromereleases.blogspot.com/2009/07/dev-channel-update-301954.html

[Gd] Call for Attendance: Google Test Automation Conference (GTAC) 2009

| More

Google Testing Blog: Call for Attendance: Google Test Automation Conference (GTAC) 2009

by Juergen Allgayer, Conference Chair

Testing for the Web is the theme of the 4th Google Test Automation Conference (GTAC), to be held in Zurich, October 21-22.

We are happy to announce that we are now accepting applications for attendance. The success of the conference depends on active participation of the attendees. Because the available spaces for the conference are limited, we ask each person to apply for attendance. Since we aim for a balanced audience of seasoned practitioners, students and academics, we ask the applicants to provide a brief background statement.


How to apply
Please visit
http://www.gtac.biz/call-for-attendance to apply for a attendance.


Deadline

Please submit your application until August 28, 2009 at the latest.


Registration Fees

There are no registration fees. We will send out detailed registration instructions to each invited applicant. We will provide breakfast and lunch. There will be a reception on the evening of October 21.


Cancellation

If you applied but can no longer attend the conference please notify us
immediately by sending an email to
gtac-2009-cfa@google.com so
someone from the waiting list can get the opportunity instead.


Further information
General website:
http://www.gtac.biz/
Call for proposals:
http://www.gtac.biz/call-for-proposals
Call for attendance:
http://www.gtac.biz/call-for-attendance
Accommodations:
http://www.gtac.biz/accomodations

URL: http://googletesting.blogspot.com/2009/07/call-for-attendance-google-test.html

[Gd] The Plague of Blindness

| More

Google Testing Blog: The Plague of Blindness

By James A. Whittaker


And now for the last plague in this series. I hope you enjoyed them (the posts ...not the plagues!)


Imagine playing a video game blindfolded or even with the heads up display turned off. You cannot monitor your character's health, your targeting system is gone. There is no look ahead radar and no advance warning of any kind. In gaming, the inability to access information about the campaign world is debilitating and a good way to get your character killed.


There are many aspects of testing software that fall into this invisible spectrum. Software itself is invisible. We see it only through the UI with much of what is happening doing so under the covers and out of our line of sight. It’s not like building a car in which you can clearly see missing pieces and many engineers can look at a car and get the exact same view of it. There is no arguing whether the car has a bumper installed, it is in plain sight for everyone involved to see. Not so with software which exists as magnetic fluctuations on storage media. It’s not a helpful visual.


Software testing is much like game playing while blindfolded. We can't see bugs; we can't see coverage; we can't see code changes. This information, so valuable to us as testers, is hidden in useless static reports. If someone outfitted us with an actual blindfold, we might not even notice.


This blindness concerning our product and its behavior creates some very real problems for the software tester. Which parts of the software have enjoyed the most unit testing? Which parts have changed from one build to the next? Which parts have existing bugs posted against them? What part of the software does a specific test case cover? Which parts have been tested thoroughly and which parts have received no attention whatsoever?


Our folk remedy for the blindness plague has always been to measure code coverage, API/method coverage or UI coverage. We pick the things we can see the best and measure them, but do they really tell us anything? We’ve been doing it this way for years not because it is insightful, but simply because it is all our blindness will allow us to do. We’re interacting with our application under test a great deal, but we must rely on other, less concrete senses for any feedback about our effort.


Software testers could learn a lot from the world of gaming. Turn on your heads up display and see the information you've been blind to. There's power in information.

URL: http://googletesting.blogspot.com/2009/07/plague-of-blindness.html

[Gd] Social apps for your virtual self

| More

OpenSocial API Blog: Social apps for your virtual self

Avatars United is pleased to announce the launch of the Avatars United Developer Platform and its OpenSocial container! The Developer Platform was initially made available to selected developers two months ago, but is now open to everyone.

Background
Avatars United is a social network for virtual world avatars launched in early 2008. The site was built in recognition of the fact that strong bonds and close friendships exist within virtual spaces. Users can register multiple avatars and connect with their virtual friends or gather in groups to discuss and plan in-game events. Avatars United also offers a virtual currency, which can be used to customize avatar and group profiles, and purchase virtual items. Currently, 80 of the most popular online games and virtual worlds are supported, including World of Warcraft, EVE Online and Second Life.

The Avatars United Developer Platform is part of Avatars United’s vision to allow each user to select and install applications that suit his or her particular character development targets in his or her particular virtual world setting. The platform supports applications for both avatars and groups. This in combination with game-specific APIs allows for some truly innovative social applications that could help enhance the gaming experience in the same way as game add-ons already have proven to do. Check out WoW Armory or the newly launched EVE Achievements for some examples.

Features
Avatars United's OpenSocial container includes the following:
  • Full support for core OpenSocial 0.8.1 JavaScript APIs
  • OpenSocial 0.8.1 JSON-RPC Protocol
  • Gadget views: profile, canvas, home, preview, group profile and group canvas
  • Preview support for OpenSocial 0.9 Albums API
  • OpenSocial extensions for Groups and Worlds, allowing access to information about groups, group members and the worlds (i.e. games) and realms (i.e. game servers) supported on Avatars United

The following features are currently not supported:
  • opensocial.requestShareApp
  • OpenSocial RESTful protocol
  • Proxied requests using 3-legged OAuth (i.e. gadgets.io.AuthorizationType.OAUTH)
  • 3-legged OAuth for the OpenSocial RPC protocol

To learn more about the Avatars United Developer Platform please visit the developer website.

Development Contest
As part of our launch, we are organizing an EVE Online application development contest in cooperation with CCP Games. Develop an application for EVE Online and have the chance to win cool prizes, including cash, cloud services credits, computer gear and special EVE Online prizes! Check out the contest page for more information.

Posted by Jacob Gyllenstierna, Product Manager, Avatars United Developer Platform
URL: http://blog.opensocial.org/2009/07/social-apps-for-your-virtual-self.html

Tuesday, July 28, 2009

[Gd] Dev Channel Update: 3.0.195.3

| More

Google Chrome Releases: Dev Channel Update: 3.0.195.3

This release contains crash and stability fixes as well as patches for:
  • Our brand new tab page
  • Themes
  • The video tag
More details about additional changes are available in the svn log of all revisions.

You can find out about getting on the Dev channel here: http://dev.chromium.org/getting-involved/dev-channel.

If you find new issues, please let us know by filing a bug at http://code.google.com/p/chromium/issues/entry.

Anthony Laforge
Google Chrome Program Manager
URL: http://googlechromereleases.blogspot.com/2009/07/dev-channel-update-301953.html

[Gd] GWT Community Updates

| More

Google Web Toolkit Blog: GWT Community Updates

Community announcements

GWT-in-the-Air (and in Yahoo! BrowserPlusTM): Thomas Broyer, one of our GWT contributors and a regular on the forum, has been working on the GWT-in-the-Air project over the last year. The project provides an Adobe AIR version of your GWT application, making it ready to run in the browser or on the desktop. Thomas has most recently added support for Yahoo! BrowserPlusTM as well, which allows you to add desktop capabilities to your GWT app.

GChart 2.6 released: John Gunther recently announced the GChart 2.5 release, which adds a GWT canvas rendering option for better looking charts and graphs.GChart 2.6 was also published recently which fixes deprecated event listener calls and other bug fixes. Check out the live demo and examples if you're interested in using it for your own GWT application.

An early look at Spring4Gwt: Dustin Mallory has recently created a new project called spring4gwt, which, as you may have guessed, offers a way to integrate GWT with the Spring framework. The project is still in its early stages, but aims to offer both exported Spring services to the GWT client and DI that works specifically for Spring components.

GWT-cs - Springifying your GWT application code: We've seen integrating with Spring, but what if you wanted to develop your GWT client-side code in a Spring-like fashion? In comes the newly started GWT-cs project for just such a use case. With this library, you can develop your GWT client-side application structure using Spring-like bean configuration in an XML format.

Uploading with GWTUpload: While the FileUpload widget in GWT core provides one part of the key to uploading files in your GWT applications, the server-side component and it's interaction with the client-side form submission is often the part developers get stuck on. Using GWTUpload, you can get file uploads ready in just a few steps. You also get other nifty features like progress bars showing file upload progress (file size, bytes transferred).

New Articles on the GWT homepage

We've recently published new articles on the GWT homepage, including:

These articles were created to address the many inquiries we've seen on integration and testing topics, so hopefully they will be helpful to you if you're at the point of making integration or design decisions in your GWT project. Also, many of these articles were written in collaboration with the GWT developer community, so if you have any articles or topics that you would like us to consider for publishing on the GWT homepage, feel free to get in touch with us.

URL: http://googlewebtoolkit.blogspot.com/2009/07/gwt-community-updates.html

[Gd] Google Apps + OpenID = identity hub for SaaS

| More

Google Code Blog: Google Apps + OpenID = identity hub for SaaS

We're happy to announce that the Google OpenID Federated Login API has been extended to Google Apps accounts used by businesses, schools, and other organizations. Individuals in these organizations can now sign in to third party websites using their Google Apps account, without sharing their credentials with third parties.

In addition, Google Apps can now become an identity hub for multiple SaaS providers, simplifying identity management for organizations. For example, when integrated with partner solutions such as PingConnect from Ping Identity, the Google Open ID Federated Login API enables a single Google Apps login to help provide secure access to services like Salesforce.com, SuccessFactors, and WebEX — as well as B2B partners, internal applications, and of course consumer web sites. See Ping Identity's post to learn more about their implementation and view the demo.


Another early adopter is Manymoon.com, a SaaS project management vendor that implemented the Google Open ID Federated Login API directly to make it easier for any organization using Google Apps to sign up for and deploy Manymoon to their users:

In the Manymoon Login page, the user chooses to log in using a Google Apps account

The user types in his Google Apps email address. The user never gives away his Google Apps Account password to Manymoon.

Once approved, the user is redirected to Manymoon and is signed in and ready to work with selected accounts

Once approved, the user is redirected to Manymoon and is signed in and ready to work with selected account.

If you prefer an out-of-the-box solution, we have been working with JanRain, a provider of OpenID solutions that already supports the new API as part of their RPX product.


Supporting the API for Google Apps accounts is exciting news for the OpenID community, as it adds numerous new Identity Provider (IDP) domains and increases the OpenID end user base by millions. In order to allow websites to easily become Relying Parties for these many new IDPs and users, we defined a new discovery protocol. The protocol is designed to allow Relying Parties to identify that a given domain is hosted on Google Apps and to help provide secure access its OpenID Provider End Point. The current proposal is an interim solution, and we are participating in several standardization organizations, such as OASIS and the OpenID Foundation, to generate a next-generation standard. Since the current protocol proposal is not supported by the standard OpenID libraries, we provided an implementation of the Relying Party pieces at the Open Source project, step2.googlecode.com. Google is also offering a set of resources addressing the issues of designing a scalable Federated Login User Interface. You are welcome to visit the User Experience summary for Federated Login Google Sites page, where you can find links to demos, mocks, and usability research data.

You can find more details in our API and Discovery documentation, or join the discussions in the Google Federated Login API Group, where you can ask any question and get answers from other Identity Providers, Relying Parties and Google engineers.

The OpenID Federated Login Service is available for all Google Apps editions. However, it is disabled by default for the Premier and Education editions, and it requires the domain administrator to manually enable it from the Control Panel. We've enabled the service for our employees here at Google, and domain administrators — you can also enable it for your domain.

By Yariv Adan, Google Security Team
URL: http://googlecode.blogspot.com/2009/07/google-apps-openid-identity-hub-for.html