• Rhino
• Javac
• Eclipse
• Janino

Java Speech API 2.0 : JSR 113

Java Specification Request 113, the Java Speech API
2.0 has been posted by the Conversational Computing
Corporation as a second proposed final draft.
With the Java Speech API (JSAPI 2.0) the speech technology can be incorporated by the developers into user interfaces. This is useful for their Java programming language applets (or MIDlets) and applications. It is based on J2ME platform. The API can be scaled in several ways which may look large at the first glance. This API provides a platform to support command and control recognizers. The engines such as Recognition and Synthesis engines used may be small or large depending on their capabilities. For instance, Recognition engines may provide full support for command and control or provide more limited support through specialized built-in grammars.
Synthesis engines may support full text-to-speech capabilities or audio sequencing only.

It also works well on J2SE. To support this compatibility as
well as to aid the developer with familiar programming methods, few small building blocks have been included in the API.

The uses of JSAPI 2.0 are:

• Application switching
• E-mail interaction including both reading and manipulation
• Calendar management and interaction
• Accessibility including screen reading
• System alerts including low memory or low fuel
• Car navigation system
• Games
• Learning
• Data entry

JSAPI 2.0 is especially well suited for downloadable applications, opening rich new interaction possibilities on devices with limited size yet unlimited potential. Capabilities for applications include the ability to

• easily switch between applications,
• prioritize applications, especially between trusted and
untrusted applications, and
• support multimodal interaction

Google’s Java-Checkout-API : new version

Google aims to organize the world’s information and
make it universally accessible and useful. Google provides
around 32 different Google APIs for free. Few of
the E-commerce centric APIs are Checkout API, Order
Processing API etc.

Google Checkout lets the customers buy items quickly
and securely using a Google username and password. It
can be used by E-commerce sites for customers to
checkout to charge customer’s credit cards, track orders
through a fulfillment process and receive order payments
in its bank account. As such, Google Checkout touches
each step of the customer’s shopping experience, beginning with the customer’s search for an item and continuing through the order checkout and fulfillment processes.

The reference implementation of Java Checkout
sample code uses the org.w3c.* classes to provide a fully
functional implementation of the Java Checkout Api interfaces. It is designed to be used as a library which
can be dropped into your existing development environment.

It depends on the JavaCheckoutApi. It provides an implementation of the outgoing APIs only - Checkout API and Order Processing API. Typically, the logic required for the incoming APIs is heavily merchant-specific and therefore does not belong in a library. The web app and J2EE app examples contain default implementations. In future releases, Google wil extend the API and reference implementations to include reference implementations of the incoming classes, exposing a strongly typed API.

The features of this new version of the Java Checkout sample code are as follow:

• Provide clear customization points to avoid the user to have non-standard requirements.
• Clearly defined API for the developer by avoiding the use of static helper style classes.
• For the 80% of merchants who don’t want to customize or build, ship the library as a single JAR + Javadoc.
• Allow only core JDK types on the public API interfaces
therefore independent of JDK version.
• Make the .NET and Java sample code APIs similar, to
reduce support overhead.
• Shipped as a library which can be dropped into a project.
Compatible with the widest possible range of JDK versions
(1.3.x, 1.4.x, 1.5.x)