Understanding WSRF, Part 4: Using the WS Java Core classesUnderstanding WSRF, Part 4: Using the WS Java Core classes Skill Level: Introductory Babu Sundaram ([email protected]) Grid Specialist
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Understanding WSRF, Part 4: Using the WS JavaCore classesSkill Level: Introductory
This tutorial introduces the Globus WS Java Core, an implementation of theWS-Resource Framework (WSRF). It explains how to use these classes to create asimple auction system.
Section 1. Before you start
What is this tutorial about?
This tutorial is Part 4 in a four-part series about the WS-Resource Framework(WSRF). Part 1 and Part 2 detailed the WSRF specification, defining WS-Resourcesand the means for creating, setting, retrieving, and destroying them and theirResource Properties. Part 3 explained WS-Notification, in which a Web servicecould subscribe to receive notification of various events or topics.
In this tutorial, we will explain how to use the Globus WS Java™ Core to build anapplication that creates an auction as a WS-Resource, and gets and sets resourceproperties. We'll also see notifications in action.
We will cover the following:
• Setting up the WS Java core environment
• Building a WSRF application
• Creating a singleton-WS Resource
• Creating and referencing multiple WS-Resource instances
This tutorial should be read by developers who are trying to use Web services withstateful resources. It will be particularly helpful for developers working on gridapplications targeted at Globus Toolkit 4.
This tutorial requires a familiarity with the general principles of WSRF. (All the WSRFinformation needed can be found in the other parts of this series (see Resources).The code uses the Java™ language, so being comfortable with Java programming isa must.
Prerequisites
This tutorial uses a component of the Globus Toolkit V4 (GT4), consisting of thebase WSRF classes. You can download the container classes.
This tutorial uses GT4 Beta, V3.9.5, of the WSRF classes, but the interface isunlikely to change between now and final release.
In order to follow along with the code, you will also need the Java 2 Standard EditionSoftware Development Kit (J2SESDK). You can download V1.5.
You may use any development environment you like to create your classes,including a simple text editor. The files are actually compiled during the buildingprocess. On the other hand, an IDE such as Rational Application Developer V6.0can make your life easier.
To build the examples, you will also need the Ant Java build tool.
Make sure Java and Ant are installed and tested before proceeding. We'll install andtest the Globus container in Getting ready: The server.
Section 2. Overview
What is WSRF?
If you've read the other parts of this tutorial, you're well aware of the principlesbehind the WS-Resource (WSRF), but just in case you haven't, let's take a momentto explain what it's all about.
WSRF is a way to use "stateful" resources in the stateless environment of Webservices. When you make a request to a Web service, the only information availableis the information that is part of the request. That's fine for transient operations, butdoesn't really lend itself to more complicated applications. WSRF is about changingthat environment into one in which you can create a persistent resource and manageit through a Web service. That combination is called a WS-Resource.
For example, we are going to create a simple auction service. Each auction has astatus message and tracks the highest bid placed on it. That means the auctionmust exist even when we're not directly interacting with it, which makes the auction"stateful."
We'll also create a Web service that interacts with the auction, enabling us to readthe status message and place bids.
The combination of the service is the WS-Resource. Each service can interact withmultiple resources, creating multiple WS-Resources. The values of aWS-Resource's Resource Properties define its state. In the course of this tutorial,you'll see how to view and manipulate these properties.
WS-Resources can be created and destroyed, and we'll look at that as well.
What is the WS Java Core?
WSRF is a great idea, but implementing it can be almost ludicrously complicated.What's more, WSRF was developed as a way of simplifying state managementwithin the Globus grid environment, so a standard implementation was a must.
The WS Java Core is a Java implementation of WSRF, intended to be part of V4 ofthe Globus Toolkit. To use it, we need a "container," or Web server, that hosts ourWeb services. The Java classes come packaged with a container, as well as variousscripts that can be used to interact with the WS-Resources.
What is JNDI?
The Java Naming and Directory Interface (JNDI) provides a way to look up variousobjects, much like looking up a phone number in the phone book. Objects can beadded to the directory and associated with a key. When an object is needed, simplyreference it via the key.
The directory itself can be virtually anything, from a database to an LDAP directoryto the file system, as long as the appropriate "provider" class exists.
Consider this simple example, adapted from The JNDI Tutorial:
} catch (NamingException e) {System.err.println("Problem looking up " +
name + ": " + e);}
}}
Concentrating on the try-catch block, where the action is, we're creating acontext in which items are looked up. Once we have that context, we can look up theObject based on its name or the key with which it was added to the context. In thiscase, we're looking for a file, so we can retrieve it and display information about it.Running the application looks something like this:
The file, /home/globus/jnditest/Lookup.java, has a size of 2581.
(The command should be all on one line. It's broken here only for spacerequirements.)
So why is this important to WSRF? Because JNDI is used to let the system knowwhere to look for specific classes that are part of an application.
What we're going to accomplish
We are going to create a simple auction application. We'll start by creating a singleresource so you can see how all the necessary files -- and there are many -- fittogether.
Next, we'll create multiple instances of the WS-Resource auction and look at how toadd bids to an individual auction by manipulating its resource properties.
Finally, we'll look at destroying these resources, directly and indirectly.
Along the way, we'll learn about creating not only the actual WS-Resources but alsothe clients that access them, and the script and configuration files that keep it alltogether.
Section 3. Putting together a WSRF service
Getting ready: The server
We're going to create a simple WSRF-based system, but before we can do that, weneed to take care of several prerequisites. Follow these steps to set up your system.First, get the container running:
1. Download the Globus WS Java Core.
2. Uncompress the .tar file into a directory, such as/home/globus/ws-core-3.9.5. That directory will be yourGLOBUS_LOCATION.
3. In a terminal window, set the value of GLOBUS_LOCATION. For example,the following may be used:
Normally, when building a Java application, the code is written, compiled, thentested. The process we're going to use works a little bit differently.
Instead of compiling the code directly, we're going to write it and place it in theproper directories, then we're going to use the Ant build tool to compile and deploythe application. That means we must do the following to get ready:
1. Choose a location for the development files, such as/home/globus/auction. We'll refer to it as AUCTION_HOME.
2. Create the following directories in AUCTION_HOME:<AUCTION_HOME>/etc<AUCTION_HOME>/schema<AUCTION_HOME>/schema/tutorial<AUCTION_HOME>/src
suggesting CLASSPATH problems, execute the following script:
$GLOBUS_LOCATION/etc/globus-devel-env.sh
In the rest of this section, we'll look at the files needed to add to the directories we'vecreated.
How the structure works
Before we look at the actual files, it helps to understand how the process works. AWSRF application consists of a number of interconnected resources and Webservices, and it helps to understand how they fit together.
We're going to deal with the following files:
• Auction.java -- This is the resource. This class actually manages allthe actions we're going to take with regard to the auction, such as settingproperty values.
• AuctionHome.java -- This is the ResourceHome. This class isresponsible for creating multiple instances of the resource and for helpinglocate a specific instance, as requested.
• AuctionService.java -- This is the service that will interact with theresource. This class contains methods such as Bid(), which then call theresource class to actually do the work.
• auction_port_type.wsdl -- This is the WSDL file that defines whatthe service can do. It also defines the resource properties document forthe resource.
• deploy-jndi-config.xml -- This file links the service, the resource,and the ResourceHome so the server knows where to look when itreceives a request.
• deploy-server.wsdd -- This file explains how to link the service withthe actual class that implements it. It also provides a way to integratestandard capabilities into our application, which we'll see later, in .
• deploy-client.wsdd -- We're not actually using this file, and it'spractically empty, but we need it anyway.
• NStoPkg.properties -- This one is actually empty, but it needs to bepresent. This file specifies how to derive the package names from thenamespaces if they need to be different from what can be derived fromthe service's WSDL file.
• post-deploy.xml -- This file provides instructions for miscellaneousinstructions to be carried out after Ant finishes the deployment, such ascreating shell scripts to represent the client classes.
• build.xml -- This is, in many ways, the grand-daddy of them all,containing the instructions that guide the entire build process.
Many of these files are standard files that come with WSRF. We'll only concentrateon the changes needed to make to these files to customize them for an application.
Create the WSDL file
This is, at its core, a Web services application, so it makes sense that we shouldstart with the WSDL file. Much of this file should look familiar from Part 1 of thisseries. Create the following file and save it asAUCTION_HOME/schema/tutorial/auction_port_type.wsdl:
This creates a basic WS-Resource with a resource properties document calledAuctionResourceProperties and the basic operation required of aWS-Resource: GetResourceProperty. We haven't added any extra operationsyet.
Create the service
The actual service doesn't do anything specific yet, except provide a way to accessthe capabilities built in to a WS-Resource by virtue of the providers we'll add to it in amoment, so create the following empty service class and save it asAUCTION_HOME/src/org/globus/tutorial/auction/AuctionService.java:
At the moment, this is very basic. We're simply initializing the value of theStatusMessage resource property with a message and the value of the class' uniquekey so we can see whether it changes when we call the service multiple times. (We'lllook more closely at this class in the next section. For now, just copy and paste.)
Before we move on to ResourceHome, we need to take care of the constantsreferenced in the class.
Create the constants
One of the goals of this project is to have code that is easily translatable. In otherwords, we should be able to simply replace a class or some other easilyinterchangeable part in order to change the language used by the application. Forsimplicity, we've cheated and hard-coded the initial StatusMessage in the class, butthe rest of the text has been separated out into a separate class. Create the classfile asAUCTION_HOME/src/org/globus/tutorial/auction/AuctionConstants.java:
package org.globus.tutorial.auction;
import javax.xml.namespace.QName;
public interface AuctionConstants{
static final String AUCTION_NS="http://tutorial.globus.org/auction";
static final QName RP_SET = new QName(AUCTION_NS,"AuctionResourceProperties");
static final QName MESSAGE_RP = new QName(AUCTION_NS,"StatusMessage");
static final QName BID_RP = new QName(AUCTION_NS,"CurrentBid");
}
Another advantage of pulling these names into a separate class is the ease ofmaintainability; to change the namespace, we can simply change it here and bedone with it.
Create the ResourceHome
To start with, we're creating a singleton class, which makes the ResourceHome's jobeasy. All it needs to do is create a single instance of the Auction object. Create theclass and save it asAUCTION_HOME/src/org/globus/tutorial/auction/AuctionHome.java:
public class AuctionHome extends SingletonResourceHome{
static final Log logger =LogFactory.getLog(AuctionHome.class);
public Resource findSingleton() {logger.info("Creating a single Auction.");try {
Auction myAuction = new Auction();myAuction.initialize();return myAuction;
} catch(Exception e) {logger.error(
"Exception when creating the Auction: "+e);return null;
}}
}
The logging information gets output to the container window by default.
Create a simple client
At this point, we've created all of the classes for the WS-Resource, but we'll need away to see it in action. Create this simple client class and save it asAUCTION_HOME/src/org/globus/tutorial/auction/client/ShowStatus.java:
** This file or a portion of this file is licensed under* the terms of the* Globus Toolkit Public License, found at* http://www.globus.org/toolkit/download/license.html.* This notice must appear in redistributions of this file,* with or without modification.*/package org.globus.tutorial.auction.client;
We'll look at this code in much more detail later, but for now, understand that itsimply requests the value of the StatusMessage resource property for the currentAuction object, then it displays it in the client window.
Alter the build file
Now we can start putting things together. Let's start with the build file. Create this fileand save it as AUCTION_HOME/build.xml:
The standard server deployment file needs to be customized to match the names ofthe classes we're using. Create the file and save it asAUCTION_HOME/deploy-server.wsdd:
The JNDI file links the service with the appropriate ResourceHome. Create the JNDIconfiguration file and save it as AUCTION_HOME/deploy-jndi-config.xml:
Now we need to tell Ant to create a shell script for the client so we don't have to typethe fully qualified class name every time we want to execute it. Create the followingfile and save it as AUCTION_HOME/etc/post-deploy.xml:
This file tells Ant to create a script called show-status in the GLOBUS_HOME/bindirectory. Calling that script is the same as calling the client class directly.
The stragglers
We have two more files to create. First, createAUCTION_HOME/deploy-client.wsdd:
Then create an empty file and save it as AUCTION_HOME/NStoPkg.properties.
Deploy the service
Now we're ready to test the service. Remember that window where we setANT_HOME and JAVA_HOME? Navigate to the AUCTION_HOME directory and type:
ant deploy
If all goes well, a BUILD SUCCESSFUL message will be displayed. If not, look at theoutput to find the problem and correct it, then run the Ant script again.
Once we've deployed the service, we need to start or restart the container. In thecontainer window, enter <ctrl>-C, if necessary, and once again type:
globus-start-container -nosec
Now we're ready to run the client.
Test the service
To test the service, we need to run the ShowStatus class. We don't have to worryabout package names or any of that, however, because the build process created ashell script that calls the class. At the command line in the deployment window, type:
Now that we have a working application, we can start actually dealing with thefeatures of a WS-Resource.
The first capability to look at is the ability to have multiple instances of the sameresource type. For example, we can create multiple auctions. But when we do that,things get a little more complicated. For one thing, rather than simply referring to theservice by its URL, we need to refer to the WS-Resource by its endpoint reference.An endpoint reference, part of the WS-Addressing specification, includes informationabout the URL for the service, as well as other identifying information. Consider thisendpoint reference, generated by the finished application:
It contains all the necessary information for locating a specific WS-Resourceinstance. Now let's go ahead and create those specific instances.
Let AuctionHome handle multiple instances
In order to change the application to handle multiple instances, we don't actuallyhave to touch the resource at all. Instead, this job is handled by the ResourceHome.Make the following changes to the AuctionHome.java file:
"Exception when creating Auction: "+e);return null;
}}
}
Now, rather than maintaining a single instance, the class creates multiple instancesas necessary and keeps track of them via a ResourceKey.
To make that work, we need to let JNDI know about the ResourceKey.
Add the ResourceKey to JNDI
In order for JNDI to be able to find the new WS-Resource instances, it needs toknow about the ResourceKeys we're using to track them. Make the followingchanges to the deploy-jndi-config.xml file:
These are the same additions we made in Part 1 of this series.
Now we have to add the operation to the service itself.
Add create support to the service
It's not enough to simply add the operation to the WSDL file. If we want the serviceto create a new instance, we have to add that to the actual service:
Let's take a look at what's actually going on here. First we get the JNDI context forthe resource, and from there, a reference to the appropriate ResourceHome:AuctionHome. From there, we can actually create the new resource and return itsendpoint reference.
Creating a new auction
To make all of this happen, we'll again need a client script. Create a new class as inAUCTION_HOME/src/org/globus/tutorial/auction/client/CreateAuction.java:
/** This file or a portion of this file is licensed under the terms of the* Globus Toolkit Public License, found at
* http://www.globus.org/toolkit/download/license.html.* This notice must appear in redistributions of this file,* with or without modification.*/package org.globus.tutorial.auction.client;
System.out.println("EPR written to file: "+filename);
}}
Let's take this one step at a time. First off, when creating this class in an IDE, theremay be trouble compiling it because some of the referenced classes won't exist untilthey're generated by the build process.
Having said that, note that the class extends BaseClient, which has some handyfeatures, such as the ability to parse the command-line arguments and determinethe server or endpoint we're trying to reach.
From there, we're getting a reference to the Web service and using it to create a newinstance of the Auction class. Once we have it, we write the endpoint reference outto a file and output the name of the file so we can reference it.
Before moving on, add this class to the post-deploy.xml file, just as we addedShowStatus. Call it create-auction.
Welcome to the Auction Service (No Bids yet!): 27844531</ns1:StatusMessage>
Notice that we didn't have to change the ShowStatus class to handle endpoints;that's taken care of by the system.
Section 5. A closer look: Resource properties
Define the currentBid property
Working with WS-Resources depends on being able to access and manipulate theresource properties. In this section, we will view and set the CurrentBid resourceproperty.
The first step is to add the Bid operation to the WSDL file:
First, create the Bid and BidResponse elements, then use them to create theBidRequest and BidResponse messages. Finally, use the messages to createthe Bid operation.
Now we need to add this capability to the service.
Add bidding to the service
Again, just adding the operation to the WSDL file doesn't tell the service how to do it,so add the Bid() method to the AuctionService class:
public BidResponse Bid(String bid)throws RemoteException
{// get appropriate resourceAuction resource = (Auction)ResourceContext.getResourceContext().getResource();
// set the text on itresource.setCurrentBid(bid);
return new BidResponse();}
}
This method requests the appropriate Auction WS-Resource based on theendpoint reference submitted with the request. Once JNDI locates the resource, wecan simply set the appropriate value for the resource property.
Now we need to enable that capability for the actual resource.
.
Manage the currentBid property
In order to work with the CurrentBid resource property, we need to initialize it andprovide access to it:
...public class Auction implements Resource, ResourceProperties, ResourceIdentifier
{final static String INITIAL_STATUS =
"Welcome to the Auction Service (No Bids yet!)";final static String INITIAL_BID = "0";
/** the identifier of this auction*/private Object id;
public ResourcePropertySet getResourcePropertySet(){
return propSet;}
public void setStatusMessage(String m){
this.StatusMessage.set(0, m);
}
public void setCurrentBid(String bid){
this.CurrentBid.set(0, bid);}
public Object getID(){
return id;}
}
First, we set the initial value for CurrentBid in the initialize() method bycreating a new SimpleResourceProperty and adding the Object thatrepresents the appropriate value. From there, we simply provide a method that setsthe private CurrentBid variable.
Now we're ready to create a client that places a bid on the auction.
Get the currentBid property
The first step in adding a bid to the auction is to retrieve the existing CurrentBidvalue. Create a new class and save it asAuction_Home/src/org/globus/tutorial/auction/client/OfferBid.Java:
/** This file or a portion of this file is licensed under the terms of the* Globus Toolkit Public License, found at* http://www.globus.org/toolkit/download/license.html.* This notice must appear in redistributions of this file,* with or without modification.*/package org.globus.tutorial.auction.client;
System.err.println("Error with writing bid: " + FaultHelper.getMessage(e));
}}
}}
As in our other clients, we're first parsing the command line, so the system canlocate the appropriate WS-Resource based on the endpoint reference. Once we
have a reference to that service, we can execute the GetResourcePropertyoperation and turn the response into a String.
As we saw in Test the service, the response consists of an element and not just thevalue, so here we're extracting the actual value. (We know this is a simple element,so we can use this somewhat unorthodox method of parsing the string looking forthe > and < characters.) From there, we output it to the command line.
Set the currentBid property
To actually set the value we will need to call the Bid operation for the appropriateresource:
...public class OfferBid extends BaseClient {
final staticWSResourcePropertiesServiceAddressingLocator locator1= new WSResourcePropertiesServiceAddressingLocator();
final static AuctionServiceAddressingLocator locator =new AuctionServiceAddressingLocator();
public static void main(String[] args) {...
try {
GetResourceProperty port =locator1.getGetResourcePropertyPort(
Although it's not obvious at the moment, the service that executes theGetResourceProperty request and the service that executes the Bid request arenot the same service. The former comes from a provider we added to thedeploy-server.wsdd file, as we'll see in Add destruction support to the resource. Fornow, notice that we're using two locators to locate the different ports.
Calling the bid() method actually executes the Bid operation inAuctionService. This method, in turn, calls the appropriate setter within theAuction class.
Now we need to create the script for the new client.
Add the new client
As before, to use this new client, we'll want to add it to the post-deploy.xml file:
Now we've created and manipulated WS-Resources, so we should look atdestroying them, as specified in the WS-ResourceLifetime specification. In thissection, we'll look at immediate and scheduled destruction of resources.
Let's start by destroying a resource. The first step is to add support for the Destroyoperation to the WSDL file:
The next step, however, is not to add this method to the service.
Add destruction support to the resource
Because the destruction of a WS-Resource is a standard operation likeGetResourceProperty, the tool kit includes a way to add support for it withouthaving to implement it directly.
Part of the deploy-server.wsdd file is a parameter called providers, which hasas its value the list of standard providers that should be added to the service:
In this case, we're adding the DestroyProvider, which covers the immediatedestruction we're attempting now, and the SetTerminationTimeProvider, whichwe'll be attempting in a moment.
Destroying the WS-Resource directly
We have two choices for destroying an auction resource. The first is to create aclient application:
/** This file or a portion of this file is licensed under the terms of the* Globus Toolkit Public License, found at* http://www.globus.org/toolkit/download/license.html.* This notice must appear in redistributions of this file,* with or without modification.*/package org.globus.tutorial.auction.client;
new org.oasis.wsrf.lifetime.Destroy());} catch (Exception e) {
if (client.isDebugMode()) {FaultHelper.printStackTrace(e);
} else {System.err.println("Error: " +
FaultHelper.getMessage(e));}
}}
}
In this case, we're using theWSResourceLifetimeServiceAddressingLocator and itsgetImmediateResourceTerminationPort to get the actual service port thatrepresents the DestroyProvider. From there, we can simply call the destroy
Once this class is added to the post-deploy.xml file, we can redeploy theapplication, restart the container, and create and destroy a resource just as we usedthe other scripts.
But that's not our only option.
Using the utilities
When it comes to standard operations, such as destroying resources, andmanipulating or querying resource properties, it's not necessary to add the code to aclient application. The WSRF container actually comes with scripts for all of theseactions. for example, we could have destroyed the resource using thewsrf-destroy script, as in:
$ create-auction -s http://localhost:8080/wsrf/services/AuctionServiceNew Auction Created...EPR written to file: bid-352967109.epr$ show-status -e bid-352967109.epr<ns1:StatusMessage xmlns:ns1="http://tutorial.globus.org/auction">Welcome to
the Auction Service (No Bids yet!): 22445676</ns1:StatusMessage>$ offer-bid -e bid-352967109.epr 1129Current Bid = 0Your Bid = 1129Bid Accepted.$ wsrf-destroy -e bid-352967109.eprDestroy operation was successful$ show-status -e bid-352967109.eprError: org.oasis.wsrf.properties.ResourceUnknownFaultType
After destroying a resource, trying to access it produces aResourceUnknownFaultType.
Expiring an auction: The WSDL file
The process of adding support for the scheduled destruction of a WS-Resource issimilar to that of destroying a resource immediately, but includes an extra step.
First, add the SetTerminationTime operation to the WSDL file:
Now we need to add support to the actual resource.
Expiring an auction
We added support for the SetTerminationTimeProvider provider in Adddestruction support to the resource, but unlike in the case of immediate destruction,we're not finished. To schedule the destruction of a resource, we need to be able toset its TerminationTime:
We don't have to set an initial TerminationTime value in the initialize()method -- although we can -- but the WS-ResourceLifetime specification requires usto provide a way to get and set the TerminationTime, and to get theCurrentTime as seen by the resource.
With these methods in place, we can schedule the destruction of the resource,through a client application or through the wsrf-set-termination-time script,which takes as parameters the endpoint reference and the number of seconds untilthe desired destruction.
Section 7. Summary
This tutorial provided an introduction to working with the WSRF implementationprovided by The Globus Alliance as part of Globus Toolkit V4. It explained thevarious pieces of the puzzle and how they all fit together, and demonstrates thecreation of a complete WSRF application.
It covered the following aspects of working with WSRF classes:
• Setting up the system
• The various configuration files
• Creating single and multiple resources
• Working with resource properties
• Destroying a resource
This is, of course, just a small portion of what we can do with these classes. Be sureto read the first three parts of this series to understand what WSRF can do, thenenvision even further implementations.
• This tutorial is Part 4 in a series on WSRF. Be sure to read UnderstandingWSRF, Part 1: Using WS-ResourceProperties; Part 2: Working withWS-Resources: WS-ResourceLifetime, WS-ServiceGroup and WS-BaseFaults;and Part 3: Publish-subscribe with WS-Notification.
• The main location for WSRF documentation is at The Globus Alliance Web site,but the latest specifications can be found at OASIS.
• Check out The WS-Resource Framework at Globus.org.
• Learn more about Web Services Resource Properties 1.2 at OASIS.org.
• WS-ResourceLifetime (WSRF-RL)
• WS-ServiceGroup (WSRF-SG)
• WS-Base Faults (WSRF-BF)
• The actual recommdendations for SOAP and WSDL are maintained by theWorld Wide Web Consortium, and IBM is one of the companies that proposedWS-Addressing.
• Read "Merging grids and Web services" for more information.
• Be sure to read "Using WSDL in SOAP applications."
• "Deploying Web services with WSDL: Part 1" offers an introduction to Webservices.
• Read "Discover SOAP encoding's impact on Web service performance" toimprove performance by changing your encoding style.
• "The hidden impact of WS-Addressing on SOAP" looks at the current state ofthe "Web services revolution."
• You can find more information on the developerWorks SOA and Web serviceszone.
• The XML and XPath V1.0, XPath V2.0, and XML Schema recommendations aremaintained by the World Wide Web Consortium.
• Read "A survey of XML standards."
• developerWorks offers tutorials titled "Introduction to XML" and "Get started withXPath."
• You can also find more resources in the developerWorks XML zone.
• To listen to interesting interviews and discussions for software developers,check out check out developerWorks podcasts.
• Stay current with developerWorks' Technical events and webcasts.
• Check out upcoming conferences, trade shows, webcasts, and other Eventsaround the world that are of interest to IBM open source developers.
Get products and technologies
• Download IBM product evaluation versions, and get your hands on applicationdevelopment tools and middleware products from DB2®, Lotus®, Rational®,Tivoli®, and WebSphere®.
• Innovate your next development project with IBM trial software, available fordownload or on DVD.
Discuss
• Participate in developerWorks blogs and get involved in the developerWorkscommunity.
About the author
Babu SundaramBabu Sundaram has been actively involved with grid computing research since theearly days of Globus Toolkit. He was part of the Globus implementation team duringhis internship at Argonne National Labs. He holds a bachelor's degree in mechanicalengineering and master's degree in computer science. He is pursuing hisdoctoral-level research in computer science at the University of Houston. He haspublished many papers in various conferences and grid-related workshops, and alsoco-authored sections of a few books about grid computing. He loves teaching and, attimes, works as lecturer teaching courses on Web services and aspects of gridcomputing. He welcomes feedback and can be reached at [email protected].