Using Apache Pivot to build an iTunes search client

Build a rich internet application with WTKX and Java technology

Apache Pivot is an open source platform for building rich internet applications (RIAs) in a Java™ environment. It combines the enhanced productivity and usability features of a modern RIA toolkit with the robustness of the industry-standard Java platform. Apache Pivot applications take advantage of WTKX, an XML-based language for user interface design, which makes the application's output easy to visualize. In this tutorial, you will follow the implementation of a simple but practical Pivot application that allows a user to execute searches against the contents of the iTunes Store.


Greg Brown, Senior Software Engineer, VMWare

Greg Brown is a senior member of the technical staff at VMware. He has been working with and evangelizing rich client-enabling technologies for over 10 years, including Java, Flash, Flex, and Ajax. He is the architect and lead developer of Pivot, a Java-based rich client platform. He holds a bachelor's degree in Computer Systems Engineering from the University of Massachusetts Amherst.

13 October 2009

Also available in Chinese Japanese Portuguese

Before you start

This tutorial assumes some familiarity with common Web development concepts and technologies, including Java technology, XML, JSON, JavaScript, and HTTP. By the end of the tutorial, the reader will understand how these skills can be readily applied to building Pivot applications.

About this tutorial

Frequently used terms

  • Ajax: Asynchronous JavaScript + XML
  • API: Application programming interface
  • CSV: Comma separated value
  • GUI: Graphical User Interface
  • HTML: HyperText Markup Language
  • HTTP: Hypertext Transfer Protocol
  • JSON: JavaScript Object Notation
  • JVM: Java Virtual Machine
  • REST: Representational State Transfer
  • UI: User Interface
  • URL: Uniform Resource Locator
  • W3C: World Wide Web Consortium
  • XHTML: Extensible HyperText Markup Language
  • XML: Extensible Markup Language

Like other RIA development platforms, Apache Pivot includes a number of features that make building modern GUI applications much easier, including a declarative user interface, data binding, visual effects and transitions, and Web services integration. Pivot applications are built using a combination of Java technology and an XML-based markup language called WTKX. Java Virtual Machine scripting languages are also supported. You can run applications either in a Web browser using the Java plugin or as standalone (optionally offline) desktop applications.

In this tutorial, you will implement a simple but practical Pivot application that allows a user to execute searches against the contents of the iTunes Store. I begin with an introduction to the Pivot platform, followed by an overview of the iTunes search API, and then go on to present the demo application. Along the way I cover how to:

  • Create the user interface declaration in WTKX, Pivot's XML-based UI markup language
  • Process JSON data using Pivot's built-in support for JSON serialization
  • Handle user interface events in JavaScript


The example code in this tutorial is based upon Pivot 1.3 release, which requires the Java 6 (or higher) SDK. You can download Pivot 1.3 as binaries or source; the source distribution contains a BUILD file that describes how to build the project.

Source code for the demo application is distributed with the platform. All code samples are released under the Apache Software License, Version 2.0.

See Resources for links to download the example code, Pivot 1.3, the Java 6 SDK, and the demo application.


In this section, you get an introduction to Apache Pivot and application development on the Pivot platform before you look at the sample application you'll be creating in this tutorial.

Introducing Apache Pivot

The Web is now the defacto standard method for application delivery. However, functional requirements for Web applications have begun to scale beyond the capabilities of the browser. Even with the addition of scripting support, dynamic element manipulation, and asynchronous server communication, it is difficult to create a user experience in HTML that is truly on par with that of a desktop application.

RIA development platforms are a means to bridge the gap between the Web and desktop experiences. Using browser plugins, these platforms allow developers to build applications that look and feel more like native desktop applications but are deployable through the Web, like traditional, HTML-based Web applications. RIAs also often incorporate visual effects intended to enhance the overall user experience, such as animations and other dynamic behavior.

Common platforms for building RIAs today include Adobe® Flex®, Microsoft® Silverlight™, and Sun™ JavaFX™. Although, by many accounts, Java is still the most popular programming language, none of these platforms allow developers to write RIAs in Java. Flex applications are written in ActionScript, Silverlight applications are built using .NET, and JavaFX applications are built with JavaFX Script. Pivot allows developers to build RIAs that target the Java platform, using technologies and APIs that they already know.

Pivot also offers a truly open alternative for RIA developers. While they can be open source to varying degrees, Flex, Silverlight, and JavaFX are still proprietary platforms. Pivot began as an R&D effort at VMware in 2007 and was released as an open-source project in June 2008 under the Apache 2.0 license. Pivot joined the Apache Incubator in January 2009, and is currently driven entirely by the software.

Pivot platform overview

Pivot provides a comprehensive set of foundation classes that together comprise a framework. Pivot classes are grouped into the following primary categories, which are packaged and distributed in a corresponding set of libraries:

  • Core - A set of common, non-UI classes
  • WTK - Classes for user interface development, including windows, dialogs, buttons, lists, text input, layout, drag and drop, XML markup, and more
  • Web - Classes to facilitate communicate with remote data services
  • Charts - Classes for adding interactive charting capabilities to Pivot applications
  • Tools - Development tools and utility applications

The application described in this tutorial highlights features provided by the Core, WTK, and Web libraries.

The demo application

The demo application described in this tutorial allows a user to search the iTunes Store for titles matching a given set of query criteria. Queries are specified as a set of string terms, and matching items are presented in a table view. The user selects an item in the table to show a thumbnail preview of the title, and double-clicks the item or presses Preview to play a 30-second preview of the item. This example was chosen because it highlights a number of Pivot's strengths, including ease of UI construction using WTKX and JavaScript as well as Pivot's built-in support for interacting with JSON-based REST services.

Figure 1 is a screen capture of the sample application, taken after executing a search for titles by the band Cheap Trick.

Figure 1. iTunes Search demo application
Screen capture of a completed search in the iTunes Search demo application

For a link to a live example of the demo application, see Resources (Java 6 SDK required). You click on a row in the table to display a thumbnail image of the search result, and click Preview to play a 30-second preview of the item.

WTKX, covered in the next section, is used to establish the initial structure of an application's user interface. Java is used to define the core logic and behavior behind the UI, and JavaScript, a lighter-weight scripting language, serves as the glue that binds the other pieces together.

UI markup in Pivot: WTKX

WTKX is an XML-based markup language used to construct Pivot applications. It is most commonly used to define the user interface structure of an application. The hierarchical structure of an XML document closely parallels the structure of the Pivot component hierarchy, making it easy to visualize the resulting output. However, you can actually use WTKX to declaratively construct any type of Java object tree. This section provides a brief introduction to WTKX and highlights some key aspects of how to apply it in the sample application.

Introducing WTKX

As with all XML-based UI markup languages, WTKX relies on the fundamental XML concepts of elements and attributes. Let's see how Pivot maps these constructs to instances of Java classes and properties.


In WTKX, an XML element represents one of two things: a class instance, or a property of a class instance. Elements whose tag names begin with an uppercase letter represent class instances, and those that begin with a lowercase letter are properties of a class instance. When the WTKX serializer (the class responsible for loading a WTKX file) encounters an element whose tag name begins with an uppercase letter, it considers the tag to be the name of a Java class and creates an instance of that class. The element's namespace is assumed to contain the name of the package that the class belongs to. Any nested elements that begin with a lowercase letter are assumed to contain property values that will be applied to the class. A property element's name translates to the name of a JavaBean property exposed by the class instance.


Attribute values also translate to JavaBean properties. The attribute value is passed as the argument to the setter method. If the type of the property is a string, the value is passed as-is; however, if it is one of the primitive types (boolean, char, byte, short, int, long, float, or double) or one of their wrapper equivalents, it is converted to the appropriate type before invoking the setter.

For example, look at the following simple JavaBean class shown in Listing 1.

Listing 1. Simple JavaBean class
view sourceprint?
public class MyBean {
    private String foo = null;
    private int bar = 0;
    public String getFoo() {
        return foo;
    public void setFoo(String foo) { = foo;
    public int getBar() {
        return bar;
    public void setBar(int bar) { = bar;

This WTKX code instantiates the bean and invokes the foo and bar setters, passing a String value to setFoo() and an int to setBar(): <MyBean xmlns="" foo="hello" bar="123"/>.

Listing 2 produces the same result as Listing 1.

Listing 2. Producing the same result
<MyBean xmlns="" bar="123">

Note that the bar property is still specified as an attribute. This is because the primitive conversion process described above is applied to attributes, but not to element values. However, in addition to string content, element properties can contain complex types (for example, other JavaBean instances), whereas attributes cannot.

In addition to class instantiation, WTKX provides a number of other features that help to facilitate user interface construction, including includes, scripting, and resource injection. Some of these features are discussed in more detail next.

The application example

Listing 3 shows the WTKX source used to construct the user interface of the application. The root element is a <Window>, which, because it uses the default namespace, corresponds to an instance of org.apache.pivot.wtk.Window. This is the most basic window type provided by Pivot; it provides no trim such as a title bar or resize handle, and serves simply as an entry point into the display (the top-level UI construct in a Pivot application).

Listing 3. WTKX source for the user interface of the application
<Window title="Search Demo" maximized="true"

Note that the maximized property of the window is set to true; this causes the window to expand to fill the entire client area of the application context. When running in a browser, this corresponds to the client area of the applet in which the application is executing; on the desktop, it is the client area of the frame of the application.

The only immediate child element of the <Window> is a <content> element. The contents of this element are set as the content property of the window. The content of a window is a component that is sized to fit the available client area of the window itself. In this case, the window content is a TablePane. TablePane is a Pivot container that corresponds roughly to an HTML table. It arranges its child components in a grid of rows and columns, optionally spanning cells. The structure of the table is defined by its <rows> and <columns> collections, as specified in the XML (see Listing 4).

Listing 4. Defining the TablePane container
<TablePane styles="{padding:6, verticalSpacing:6}">
        <TablePane.Column width="1*"/>

Note the styles attribute of the TablePane element. Styles are used to customize the appearance of a component, and are specified in WTKX as a JSON-formatted collection of name/value pairs. All WTK components support the styles attribute, but each component can support a different set of styles depending on its current skin (skins are how Pivot supports pluggable look-and-feels). In this example, the table pane is assigned padding and verticalSpacing values of 6 (pixels). Padding represents the amount of space that the table pane will leave around its components, and vertical spacing is the size of the gap the table pane will leave between rows.

The remainder of the WTKX file serves to establish the structure for the user interface of the application. It also defines some JavaScript event handlers, which are discussed in more detail in Event handling: JavaScript. Of particular interest is the definition of the TableView component that is used to present the search results (see Listing 5).

Listing 5. TableView component definition
<TableView wtkx:id="resultsTableView">
        <TableView.Column name="itemName" width="1*" headerData="Name"/>
        <TableView.Column name="itemParentName" width="1*" headerData="Album"/>
        <TableView.Column name="artistName" width="1*" headerData="Artist"/>

The table view defines a set of columns whose names correspond directly to item properties in the returned JSON data. Pivot's TableView component is capable of presenting JSON data as-is, with no additional data transformation required (CSV data is also supported). This makes Pivot an ideal platform for building REST clients that can consume these common data formats. Let's look at how that works.

Query processing: Java + JSON technologies

While the user interface of a Pivot application is often defined using WTKX, application behavior is generally defined in Java code. Application logic can also be written in script, allowing developers to build some or all of a Pivot application using popular JVM languages such as Groovy or Scala. I used JavaScript to define event handlers in the sample application.

JavaScript Object Notation (JSON) is a platform-independent format for data exchange. Like XML, it is used to represent structured data, but often maps better to the data structures used by many popular programming languages, including Java and JavaScript. It is also slightly less verbose than XML, since it does not require closing tags. While JSON is most commonly used in Ajax development, it can be used by any language or platform that supports it. Pivot supports JSON natively and makes extensive use of it throughout the platform, for resource definition and style declaration as well as for data exchange.

Now you will see how Java code can load the user interface of a Pivot application from WTKX, and how to use Pivot's robust support for JSON data to easily take advantage of existing services originally created for Ajax applications, such as the iTunes Search API. The source code for the entire application is available from Resources.

Loading the user interface: Java code

The SearchDemo class implements the org.apache.pivot.wtk.Application interface, which serves as the main entry point into every Pivot application. It defines the following four methods, similar to the lifecycle methods used in traditional applet development:

  • startup(): called when an application is starting up
  • shutdown(): called when a running application is shutting down
  • suspend(): called when an application is temporarily deactivated
  • resume(): called when a suspended application is resumed

The implementation of startup() and shutdown() in the sample application is discussed below; suspend() and resume() are not used in this example.


The startup() method in the application is defined in Listing 6.

Listing 6. startup() method for the application
public void startup(Display display, Map<String, String> properties) 
throws Exception {
    WTKXSerializer wtkxSerializer = new WTKXSerializer();
    wtkxSerializer.put(APPLICATION_KEY, this);

    window = (Window)wtkxSerializer.readObject(this, "search_demo.wtkx");
    wtkxSerializer.bind(this, SearchDemo.class);



This method creates an instance of org.apache.pivot.wtkx.WTKXSerializer, which is used to load the UI from the WTKX file. It adds a reference to itself to the serializer scope so that script code defined in the file can call back into the application to execute queries through the executeQuery() method discussed in The executeQuery() method. It then invokes the readObject() method of the serializer, which parses the WTKX source and returns the class instance corresponding to the root WTKX element.

startup() then calls the bind() method on the serializer. This method maps named object references in the WTKX file to member variables of the application. The objects are identified in the source file through wtkx:id attributes, and the corresponding member variables are tagged with an @WTKX annotation in the Java source (see Listing 7).

Listing 7. Tagging the member variables with the @WKTX annotation
@WTKX private TextInput termTextInput;
@WTKX private PushButton searchButton;
@WTKX private Label statusLabel;
@WTKX private TableView resultsTableView;

The @WTKX annotation is simply a convenience for the developer. You can obtain the same references through the get() method of the serializer; for example, the startup() method might alternatively contain a number of statements similar to the following:
termTextInput = (TextInput)wtkxSerializer.get("termTextInput");.

startup() then opens the window and requests that the user input focus be set to the search term text input.

The shutdown() method

The shutdown() method is defined in Listing 8.

Listing 8. shutdown() method for the application
public boolean shutdown(boolean optional) {
    if (window != null) {

    return false;

This method simply closes the main application window that was opened in startup() and returns false to indicate that shutdown should proceed (that is, it should not be canceled, which is what happens if the method returned true).

Next you'll see how this works with an existing service: the JSON-based iTunes Search API.

Executing search queries: JSON and the iTunes search API

The iTunes Store is an online media catalog provided by Apple to users of their iTunes media management software. The store allows users to browse and purchase music, movies, and other digital content.

Apple provides a JSON-based HTTP API for executing simple search queries against the iTunes Store. For example, retrieving the content of the following URL returns a collection of search results for the band Cheap Trick:

(Note: The above URL is split across two lines for formatting purposes. It is actually a single, continuous string.)

The results of this query is similar to Listing 9 (multiple results omitted for brevity).

Listing 9. Query results
{ "resultCount": 100,
  "results": [
    { "wrapperType": "track", 
      "mediaType": "song", 
      "artistName": "Cheap Trick", 
      "itemParentName": "Heaven Tonight (Remastered)", 
      "itemParentCensoredName": "Heaven Tonight (Remastered)", 
      "itemCensoredName": "Surrender", 
      "itemName": "Surrender", 
      "artistLinkUrl": "
      "artworkUrl60": "
      "artworkUrl100": "
      "country": "USA", 
      "currency": "USD", 
      "discCount": 1, 
      "discNumber": 1, 
      "itemExplicitness": "notExplicit", 
      "itemLinkUrl": "
      "itemPrice": "0.99000", 
      "itemParentExplicitness": "notExplicit", 
      "itemParentLinkUrl": "
      "itemParentPrice": "9.99000", 
      "previewUrl": "
      "primaryGenreName": "Rock", 
      "trackCount": 13, 
      "trackNumber": 1, 
      "trackTime": 253733},  

All iTunes query URLs begin with this base URL:

You customize them through query string arguments; for example:

  • limit=10: restricts the number of results to 10
  • term=cheap+trick: searches for matches on the character string "cheap trick"
  • output=json: requests the output in JSON format (the default response is an HTML page used primarily to construct links to the store content)
  • media=all: requests matches on all media types (other possible values might be "music", "movie", or "podcast")
  • country=us: requests results from the U.S. version of the iTunes Store

The example application uses this API to obtain information about the contents of the iTunes Store and present it to the user (see Resources for a link to the complete API).

For a handy utility (written in Pivot) for browsing the (somewhat verbose) response content, see the link in Resources. It requires the Java 6 SDK.

Pasting the JSON data returned by a query into this applet will present a tree view of the data that is much easier to navigate.

The executeQuery() method

The main application defines an additional method named executeQuery() that is called by event handlers defined within the WTKX itself to actually perform a search. This method executes the HTTP request and processes the retrieved JSON results. It takes a single string argument containing the search string.

Most of the work is done by an instance of org.apache.pivot.wtk.GetQuery. This class represents one type of what Pivot calls a "Web query". Web queries are Pivot's native means of communicating with remote data services. They are designed primarily to facilitate interaction with JSON-based REST services. However, they are sufficiently generic to support communication with any type of HTTP-based service, using any data format. Pivot also provides query classes for the other HTTP operations including POST, PUT, and DELETE.

executeQuery() sets up the query request as in Listing 10.

Listing 10. executeQuery() method
getQuery.getParameters().put("term", term);
getQuery.getParameters().put("country", country);
getQuery.getParameters().put("media", MEDIA);
getQuery.getParameters().put("limit", Integer.toString(LIMIT));
getQuery.getParameters().put("output", "json");

It then updates the UI state to reflect that a search is in progress and executes the query (see Listing 11).

Listing 11. Updating the UI state
getQuery.execute(new TaskAdapter(new TaskListener() {

Executing the query makes an HTTP GET request to the server specified in the constructor argument and deserializes the resulting JSON data.

A Web query is a kind of task, which is represented in Pivot as an instance of org.apache.pivot.util.concurrent.Task (a superclass of GetQuery). Tasks are used to simplify the execution of background operations. A dispatcher is used to queue and process task requests on a background thread. Tasks operate similarly to the XMLHTTPRequest object used in Ajax programming, but they are not limited to server requests. A Pivot task can be used to implement any type of background operation.

An instance of org.apache.pivot.util.concurrent.TaskListener is passed to the execute() method. This interface defines methods that are called when the task has finished executing (see Listing 12).

Listing 12. The TaskListener interface defines methods that are called when the task has finished executing
public interface TaskListener<V> {
    public void taskExecuted(Task<V> task);
    public void executeFailed(Task<V> task);

The first method is called when the task completes successfully, and the second when the task fails to complete.

Note that the actual listener implementation is wrapped in an instance of org.apache.pivot.wtk.TaskAdapter. Because tasks in Pivot are not limited to use in UI-driven applications, task listener methods are called on the thread on which the task was executed. However, like most user interface toolkits, Pivot allows only a single thread (called the event dispatch thread, or EDT) to interact with the user interface. TaskAdapter ensures that the task callbacks occur on the EDT rather than on the actual background thread.

Upon successful completion, the result data is obtained from the query. The returned JSON data is an object containing two values: resultsCount, which is the number of results returned, and results, an array containing the actual search results. In Pivot, JSON objects are converted to instances of org.apache.pivot.collections.HashMap, and JSON arrays are converted to instances of org.apache.pivot.collections.ArrayList. The list containing the result data is extracted from the root result object as in Listing 13.

Listing 13. List containing the result data
Map result = (Map)task.getResult();
List results = (List)result.get("results");

After preserving any previously applied sort, the results are set into the table view: resultsTableView.setTableData(results);.

The results can immediately be applied as the table data because Pivot's TableView component uses an instance of org.apache.pivot.collections.List as a data model, and the ArrayList containing the JSON result data is an implementation of this interface. All data-driven components in Pivot, including ListView, TreeView, and Spinner, use Pivot collections as a data model. This makes Pivot a very efficient client for consuming data provided by JSON-based Web services, since data returned from a server doesn't need to be transformed or adapted before it is used to populate the UI.

Event handling: JavaScript

To this point, you've seen how the search result data is structured and how it is processed by the demo application, but you have not yet seen how a query is actually initiated. In this section, you'll see how to accomplish this using JavaScript.

Initiating a query

Like most other user interface toolkits, actions within a Pivot application generally take place in response to events. Events are notifications that something has occurred. Often they are fired in response to user input such as a mouse click or a keystroke, but they can also be fired by other asynchronous processes (such as the successful execution of a query task, as described in The executeQuery() method).

Callers signal their interest in an event by registering an event listener. In Pivot, an event listener is defined as an implementation of an interface that defines the event. For example, the following interface defines a "pressed" event for buttons (see Listing 14).

Listing 14. Pressed event for buttons
public interface ButtonPressListener {
    public void buttonPressed(Button button);

In Java code, event listeners are registered by adding the listener to the relevant "listener list" (see Listing 15).

Listing 15. Registering an event listener
myButton.getButtonPressListeners().add(new ButtonPressListener() {
    public void buttonPressed(Button button) {
        // Handle event

This seems simple enough, but can become cumbersome, since many listener interfaces define more than one method. While Pivot includes adapter classes that provide default no-op implementations for most listener interfaces, any non-trivial application will probably need to define many event listeners. Creating all the listeners as anonymous (or even named) inner classes can complicate the Java source in an application and obfuscate the real purpose of a class. Fortunately, Pivot provides a simpler way to define listeners: WTKX script blocks.

For example, consider the WTKX declaration for the Preview button shown in Listing 16.

Listing 16. WTKX declaration for the preview button
<PushButton wtkx:id="previewButton" buttonData="Preview" enabled="false">
        function buttonPressed(button) {
            var selectedResult = resultsTableView.getSelectedRow();

This markup creates an instance of org.apache.pivot.wtk.PushButton and registers the contents of the <wtkx:script> element as a button press listener. The functions defined in the script element correspond to the methods declared by the listener interface. While it is not obvious from this simple example, definition of additional handler methods is optional; if a caller is not interested in a particular event, the handler for that event can simply be omitted. As a result, implementing event listeners in script can be much more concise than doing so in the Java environment.


In this tutorial, you can clearly see the Pivot philosophy of "using the right tool for the job":

  • XML, a hierarchical markup language that makes the resulting output easier to visualize, is used to declare the structure of a user interface.
  • Java code, in a robust and popular programming language, defines the main working behaviors in an application.
  • JavaScript, a well-known and popular scripting language, defines the quick-acting event handling logic that is often more tedious to code in the Java environment

You were introduced to Apache Pivot and learned how you can use to build a simple search client for the iTunes Store. And you were given an introduction to the WTKX markup language, an overview of how Java and JSON programming can be used in Pivot, and some examples of integrating script code for event processing.



  • Apache Pivot: Visit the site for more information about Pivot and WTKX.
  • The WTKX Primer from Learn about WTKX, an XML-based markup language used for constructing Pivot applications.
  • Apache Pivot FAQ: Get all your questions answered.
  • Demos section: Find additional Pivot demos on the Pivot Web site, as well as throughout the Pivot tutorial.
  • Pivot iTunes Search Demo: See the demo application in action.
  • Stock Tracker tutorial example: Try this sample Pivot app that uses Web queries to process CSV data returned by a Yahoo! Finance stock quote Web service.
  • JSON: Learn all about the lightweight data-interchange format.
  • The TIOBE Programming Community index: Get an indication of the popularity of programming languages.
  • New to XML: Visit this great starting point for resources available to XML developers on IBM developerWorks.
  • XML zone: See the developerWorks XML zone for a wide range of technical articles and tips, tutorials, and standards.
  • The no-cost developerWorks On demand demos: Watch and learn about IBM and open source technologies and product functions.
  • Open source events around the world: Check out upcoming conferences, trade shows, webcasts, and more that are of interest to IBM open source developers.
  • Open source: Visit the developerWorks Open source zone for extensive how-to information, tools, and project updates to help you develop with open source technologies, and use them with IBM products.
  • The developerWorks Java technology zone: Find articles about every aspect of Java programming.
  • IBM XML certification: Find out how you can become an IBM-Certified Developer in XML and related technologies.
  • XML technical library: See the developerWorks XML Zone for a wide range of technical articles and tips, tutorials, standards, and IBM Redbooks.
  • developerWorks technical events and webcasts: Stay current with technology in these upcoming sessions.
  • developerWorks podcasts: Listen to interesting interviews and discussions for software developers.

Get products and technologies



developerWorks: Sign in

Required fields are indicated with an asterisk (*).

Need an IBM ID?
Forgot your IBM ID?

Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name

The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.


All information submitted is secure.

Dig deeper into XML on developerWorks

Zone=XML, Open source, Web development
ArticleTitle=Using Apache Pivot to build an iTunes search client