Google

A while back I wrote a post about creating a Product search using the Google Base API. We'll I've made a few examples for another blog that I've been writing on called The Porsche Guy's.

Since the blog focuses on Porsche related news and projects (I happen to have an older Porsche 944, so enjoy talking about the cars) I created two Porsche related searching tools. The first is a Porsche Parts finder that makes it easy to find the best prices on the Web for Porsche parts (you can go to the Porsche Parts Finder here). The second is a Porsche Finder, so it you are looking for a good deal on a Porsche then this tool will find the best on the web (You can see the Porsche Finder here).

My next post will go into detail as to how exactly I created these searching tools including code snippets, so look for part 2 of this post. Until then check out my first post about creating a Google Product Based Search Application here.

You may have seen the Google Product Search and may have thought that it would be useful to include a customized version of the search into a website or application. Unfortunately, you can't just create a custom search engine based on the Product Search using Google's custom search creator.

So, how would you incorporate the Product Search into an application? The answer is to use the Google Base API. The API allows for you to call a feed and if you use the [item type:products] option it will use the Product Search data.

The API allows you to receive the feed in Atom, RSS and JSON formats. Google has also made it very easy by making a feed URL builder (you can access the builder here).

So, if you want to make an application using the Products Search now you can.

Java dependency injection just got better: Google Guice 2.0 has been released.

What's new:

• Provider methods. You can now annotate methods in your Module so you avoid manually constructing dependencies.
• Binding overrides. One Module can now override the bindings in another.
• Private modules. You can now create bindings that are not externally visible, in order to encapsulate your dependency injections.
• The ability to inject members of sets and maps using Multibinder and MapBinder respectively.
• ServletModule now provides programmatic configuration of servlets and filters. GuiceServletContextListener can be used to help bootstrap a Guice application in a servlet container.
• Custom injections. Guice now includes hooks that allow other frameworks to define custom injection annotations. This enables Guice to host other frameworks that have their own injection semantics or annotations.
• A tree-like structure for Injectors, i.e., an Injector can have children that inherit all of its bindings.
• An introspection API: like reflection but for Guice bindings.
• Pluggable type converters that convert constant string bindings to other types, i.e., Dates, URLs, etc.
• OSGi compatible. Guice now works well in OSGi managed environments, because AOP-generated classes use a bridge classloader.
• AOP is now optional, so Guice will work on platforms that don't support bytecode generation (Android).

You can download the new release here. The new manual is here. Now all they have to do is update the public Maven repository.

javax.inject.Inject

On related news (Crazy) Bob Lee, the creator of Guice, and Rod Johnson, the creator of Spring, have gotten together to propose a standard set of annotations and interfaces for using dependency injection in Java under the banner of JSR-330: Dependency Injection for Java (still only a proposal, so JSR-330 is a tentative moniker). There is also a corresponding project over at Google Code. The standardization should greatly help the use of dependency injection in shared 3rd party libraries, allowing the application developer to avoid having to initialize more than one dependency injection framework.

These annotations are modelled closely on those currently in Google Guice:

• @Inject - Identifies injectable constructors, methods, and fields
• @Qualifier - Identifies qualifier annotations
• @Scope - Identifies scope annotations
• @Named - String-based qualifier
• @Singleton - Identifies a type that the injector only instantiates once

The utility interface Provider is also in the proposed specification.

Hot on the heels of the announcement that Java can now be used with the Google App Engine, the Google Plugin for Eclipse has been released, supporting both Google Web Toolkit and Google App Engine development.

GWT Features:

• Recognition of inline JavaScript (JSNI): syntax highlighting, auto-indenting, Java Search and Refactoring integration
• GWT compiler shortcuts and configuration UI
• Wizards to create entry points, modules and HTML pages
• Support for GWT JUnit tests

App Engine Features:

• Easy deployment to App Engine
• As-you-type validation ensures that your code is compatible with App Engine
• Build projects and 'enhance' JDO classes automatically without the need for ANT

The user's manual for the plugin is here. The plugin works with both Eclipse 3.4 (update site) and 3.3 (update site).

Google has released the 2.0 beta version of its Webkit-based browser, Chrome. The new release features:

• 25-35% faster JavaScript performance for Google's V8 engine
• Form autofill
• Bookmark sorting
• Autoscrolling
• Full-screen mode
• A new way to drag tabs in order to get a "side by side" view
• Mouse gestures for resizing windows
• Limited Greasemonkey support

Like its cousin Safari, the new Chrome browser should also be Acid 3 compliant since it is built using a much more recent version of Webkit (Chrome 1.x is not). You can download the new beta here.

UPDATE: Actually, Chrome 2 (build 2.0.169.1) scores 98/100 on Acid 3. Close, but not yet.

Google has created an online resource for testing your JavaScript code, the AJAX APIs Playground. The tool includes support for a number of Google APIs (including Maps, Earth, Blogger Data, and Visualization) as well as jQuery, jQuery UI, Prototype/Scriptaculous, MooTools, and Dojo.

Google Chrome has just turned the big 1.0, as the browser has met Google's requirements for stability and performance.

Changes from the Beta

A short list of improvements includes:

• Numerous bug fixes, including video and audio glitches
• Bookmark management
• Import and export of bookmarks
• Centralized privacy options

Of course, the Chrome team isn't done yet. Future enhancements to the browser include form autofill, RSS support, and extensions.

You can download Chrome here.

Ext GWT, a library for integrating Ext JS with Google Web Toolkit, has released version 1.2. New features include Drag and Drop (with support for Grids, Trees, and Lists), Form Data Binding, and File Upload.

It can be downloaded here.

Hot on the heels of the JavaFX release, Google has released a beta version (of course, what else?) of its own browser plug-in for--get this--running native x86 code inside your browser. It's called, appropriately enough, Native Client. If your security alarm bells are going off, take some comfort: the code is sandboxed in order to prevent untrusted code from freely accessing your computer. How effective the "static analysis" that the sandbox performs is an open question, but Google for its part seems to have thought through the problem: code is disassembled and run through a rigorous analysis to detect unwanted interactions, e.g. file I/O. Nevertheless, it is unlikely to ever be as secure as running code inside a VM.

While Java aficionados may scoff at the idea of running non-portable code inside the browser, one has to admit that x86 clients are nearly universal, at least on the desktop. In the mobile arena that's anything but the case so Native Client has a very specific target audience: desktops that need absolute performance. If this fits the requirements of your browser-based application, Native Client may just be the ticket.

Today Salesforce.com has announced Force.com. This makes it possible to create Web and business applications that go accross both Salesforce.com and Google's cloud computing platforms.

Below is an except from the post.

This morning Salesforce.com announced Force.com for Google App Engine, a Python library for apps running on App Engine that enables simple and robust access to the Force.com Web services API. Using this library, App Engine developers can now build and deploy scalable web apps that manipulate and display data stored on Force.com. App Engine developers interested in building enterprise-class applications can now build anything from browser-based tools for members of your organization to personalized, customer-focused apps that scale to meet demand.

You can read the full post here.

You can learn more about Force.com here.