The first time you sign into developerWorks, a profile is created for you. Select information in your developerWorks profile is displayed to the public, but you may edit the information at any time. Your first name, last name (unless you choose to hide them), and display name will accompany the content that you post.

All information submitted is secure.

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.

All information submitted is secure.

My developerWorks:

My notifications:

Sign out

Select a language:

Open Standards, Open Source, and Domino 6: Using Domino 6 Open Source projects

Raj Balasubramanian, Consulting IT Architect, IBM

Raj Balasubramanian is a Consulting IT Architect for IBM Software Group. He works on customer engagements delivering application and infrastructure related projects. His interests range from anything technical to history and physics. During his copious spare time, he enjoys dating his wife and talking about robots with his sons. You can read about his technical and personal escapades on his personal blog Gurukulam (http://balasubramanians.com/blog)

Summary: In Part 2 of this article series, we discuss how you can use Domino 6 Open Source features to dynamically convert Domino documents into PDF and JPEG format. We also show how to create a graphic server connection diagram, as well as an RSS generator that lets you use a Personal Journal for blogging.

Tag this!

Date: 12 Apr 2004
Level: Intermediate

Activity: 4993 views
Comments:

In the first article in this series, we introduced several key Open Standards implemented in Domino 6 as well as related Open Source projects. In Part 2, we examine how you can leverage some of these Open Source projects. This includes building applications that use Apache Cocoon to dynamically generate PDF and JPEG files from Notes/Domino content and that dynamically convert a Notes Personal Journal document to RSS, the format used by Web "bloggers." (You can download the complete sample code used in this article from the Sandbox.)

Part 3 of this series will conclude this theme, looking at additional ways you can extend Domino 6 functionality with the available Open Source projects.

As with the previous article, we assume that you're an experienced Notes application developer.

Apache Cocoon and Domino 6

Apache Cocoon is an Open Source project for delivering XML-based publishing without requiring a great deal of sophisticated coding. Cocoon is built upon the concept of "component pipelines," in which each component specializes in a specific operation. This allows developers to quickly and easily produce files in industry-standard formats such as PDF and JPEG. For more information, see the Apache Cocoon Project home page.

In this section, we discuss how you can use the Cocoon implementation in Domino 6 to convert Notes/Domino content to PDF and JPEG format on-the-fly. But first, let's take a closer look at how Cocoon works.

Cocoon overview

Cocoon is a J2EE application that you can host on any J2EE-compliant Web container. A powerful feature of Cocoon is its ability to "wire together" various components using configuration files without requiring you to write any Java code (although Cocoon does allow you to customize functionality by using Java). In the example we discuss in this article, we use the various configuration files to "wire" Domino 6 to Cocoon.

Sitemap
The key components in our example Cocoon applications are the Sitemap (sitemap.xmap) and stylesheet (XSL) files. The Sitemap file provides configuration options to the Cocoon processing engine. These options range from static XML files to be processed to dynamic URLs to the stylesheet used to transform the XML.

The following is a sample Sitemap file for processing the XML document:

<!---------------------------------BEGIN SAMPLE-------------------------

<?xml version="1.0"?>

<map:sitemap xmlns:map="http://apache.org/cocoon/sitemap/1.0">

 <map:components>
        ......
	..........
 </map:components>

 <map:views>
  <map:view name="content" from-label="content">
   <map:serialize type="xml"/>
  </map:view>
   ..........
    ......
 </map:views>

 <map:pipelines>

  <map:pipeline>
   <map:match pattern="hello.html">
    <map:generate src="content/xml/hello-page.xml"/>
    <map:transform src="style/xsl/simple-page2html.xsl"/>
    <map:serialize type="html"/>
   </map:match>

   <map:match pattern="hello.txt">
    .......
   </map:match>
   
   <map:match pattern="hello.xhtml">
    .......
   </map:match>
   .......
    .....         
  </map:pipeline>
 </map:pipelines>

</map:sitemap>
<!---------------------------------END SAMPLE-------------------------

The key elements in the Sitemap.xmap file that we use to generate dynamic content are:

<map:pipeline />
<map:match />

For a detailed description and understanding of the Sitemap.xmap file, refer to the Cocoon user documentation.

Stylesheet
A stylesheet is a well formed XML document used to present the XML source document in various formats of your choosing. In a typical Web scenario, the stylesheet delivers HTML to the browser from source XML. For more information on stylesheets, refer to the Web page XML Stylesheet Language for Transformations.

The Sitemap.xmap and stylesheet files are normally stored in the /mount/ directory. In our example, Cocoon is installed on an existing Tomcat server and the COCOON_ROOT directory is c:/os/jakarta-tomcat-4.1.27/webapps. For PDF generation, the associated Sitemap and stylesheet are stored in c:/os/jakarta-tomcat-4.1.27/webapps/mount/html-pdf. (The directory html-pdf is one that we created specifically for our example.)

As long as we're on the subject of XML, we should quickly mention DXL (Domino XML Language), a powerful feature introduced in R5 and now part of the core Domino 6 services. The concluding article in this series describes how to use DXL to deliver content to Open Source platforms. (For more information on DXL, see Dick Annicchiarico's Lotusphere 2004 presentation. This presentaton includes sample DXL code.)

Example system configuration

In our sample Cocoon application, we provide users with the ability to generate a Notes Person document in PDF format any time they are in the Domino Directory. Our application also provides a graphic image of the business card of the Person document being viewed. In addition, we give administrators the ability to generate a diagram of their server topographies, showing how each server connects to others in the domain for replication, routing, and instant messaging (an extremely handy tool).

The environment on which to run this application was set up as follows: On a Windows 2000 machine, we ran Domino 6.5. This Domino server was configured with the HTTP port set at 8088. On the same computer, we installed the Tomcat server version 4.1.2.7. The Tomcat server included Apache Cocoon 2.0.4 with the HTTP port set to 8080. The following illustration shows this setup:

Figure 1. Cocoon environment

On our Domino server we installed a customized Domino Directory called testnab.nsf. We created this directory from the standard Domino Directory template, and then made several design changes to accommodate our Cocoon application. These design changes consisted of two new agents (GetSVG and GetXML) and a modified Person form.

Our changes to the Person form consist of two new URL links. The first link views the current document in PDF format, and the second link views the document as a business card. The two links reference the Cocoon applications we have defined, while passing the shortname as a query string:

<a href="http://localhost:8080/cocoon/mount/html-pdf/getxml?Open&
qs=">Print</a>

The GetSVG and GetXML agents both output XML to the browser:

Print "Content-Type: text/xml"
strTmp = |<?xml version="1.0" encoding="UTF-8" standalone="yes"?>| 
strTmp=strTmp+Chr(10)+|<entry>|

The GetXML agent accepts a UID parameter in the form of a URL query string:

Set doc=s.documentcontext
qs$=doc.QUERY_STRING(0)
qs$=Right(qs$,Len(qs$)-Instr(qs$,"="))

Then using the value obtained, it looks up the Person document, extracts the appropriate fields, and prints them with valid XML tags:

strTmp=strTmp+Chr(10)+|<rb_street>|+
pdoc.OfficeStreetAddress(0)+|</rb_street>|

You can download our sample testnab.nsf database from the Sandbox.

Generating PDF dynamically

For our first application, we use Cocoon to generate PDF from a given Notes document, in this case a Person document in the Domino Directory. (PDF is a widely used standard for formatting print-ready documents.) We start by creating a subdirectory under the mount directory called html-pdf (.../mount/html-pdf). To do this, we edited a standard Sitemap file with the required configuration changes to process the XML and a stylesheet file to transform the XML to PDF. The modified stylesheet is named xml2pdf.xsl, and the Sitemap is called sitemap.xmap. You can download these and all other files mentioned in this article from the Sandbox.

The sitemap.xmap file for generating PDF

The following code snippet from the sitemap.xmap file generates PDF for the requested file:

<map:match pattern="*">
<map:act type="request">
<map:parameter name="parameters" value="true"/>

These lines define the source (note the reference to the GetXML agent as the source of the Person document in XML format):

<map:generate src=
"http://localhost:8088/testnab.nsf/getxml{requestQuery}"/>

And this line defines the stylesheet to use:

<map:transform src="xml2pdf.xsl"/>

The sitemap.xmap file contains a dynamic URL for XML generation source. Our application uses the {requestQuery} variable within Cocoon to pass the query string back to Domino. The query string contains the document key that we use to generate XML and to pass back to Cocoon for PDF rendering.

The xml2pdf.xsl file

The xml2pdf.xsl stylesheet for this example is relatively simple. However, you can use the example stylesheet to add more robust presentation features in PDF format, using additional presentation tags. (See the Web site XSL-FO Input for more information.)

After setting up the basic PDF specific elements, xml2pdf.xsl defines the primary element (rb_entry in this instance) to be the match from the source XML:

<xsl:template match="entry/rb_entry">
        <fo:block><xsl:apply-templates/></fo:block>
</xsl:template>

When the code finds the rb_title tag, it specifies the font style to use (bold, red, and a larger font):

<xsl:template match="rb_title">
   <fo:block font-size="20pt" color="red" font-weight="bold">
      <xsl:apply-templates/>
   </fo:block>
</xsl:template>

Finally, if there are other tags, xml2pdf.xsl sets the text style to normal:

<xsl:template match="rb_company">
   <fo:block font-size="12pt" color="black" font-weight="bold">
      <xsl:text>Company::</xsl:text>
      </fo:block>
   <xsl:apply-templates/>
</xsl:template>

The PDF process

Figure 2 shows the workflow of the PDF generation process:

Figure 2. PDF generation workflow

In the preceding diagram:

The user opens a Person document, and clicks the Print link.
The URL passes in the person's shortname as part of the query string. This accesses the Cocoon HTML-to-PDF application we have defined.
The application uses the sitemap defined to get the XML source (in this case, the GetXML agent). The link also passes the user's shortname.
The GetXML agent extracts the shortname value from the URL and processes the Person document.
The agent prints the Person document in XML.
The Cocoon application processes this XML using the stylesheet we have defined (xml2pdf.xsl) and outputs PDF to the browser.
The user views the PDF version of the Person document.

When the user views the Person document in PDF format, it appears as follows (notice the formatting of bold-red-larger font for the user name and normal fonts for the other fields):

Figure 3. Person document in PDF format

You can easily change the appearance of the PDF display by editing the existing xml2pdf.xsl file. You can also display more information than our simple example shows by enhancing the GetXML agent and instructing it to pull and format additional Person document fields. For example, if you want to display another field (for instance, EmployeeID), you can modify the GetXML agent to include this field in the output:

strTmp=strTmp+Chr(10)+|<rb_empid>|+pdoc.EmployeeID(0)+
 |</rb_empid>|

Then modify the stylesheet to process this field like any other field by adding this section:

<xsl:template match="rb_empid">
   <fo:block font-size="12pt" color="black" font-weight="bold">
      <xsl:text>Employee ID::</xsl:text>
   </fo:block>
   <xsl:apply-templates/>
</xsl:template>

It's that simple!

On-the-fly JPEG

The process for creating a JPEG image from a Notes document is similar to the one we used to create PDF files. Again, begin by creating a subdirectory under the mount directory called svg (.../mount/svg). Edit a standard Sitemap file with the required configuration changes to process the XML and a stylesheet file to transform the XML to JPEG. In our example, these files are named simple-page2svg.xsl and sitemap.xmap.

The sitemap.xmap file for generating JPEG

The modified sitemap.xmap file includes the following code to perform the JPEG-to-SVG conversion:

<map:match pattern="*">
<map:act type="request">
<map:parameter name="parameters" value="true"/>

This line defines the source (again using the GetXML agent as the source of the Person document in XML format):

<map:generate src=
"http://localhost:8088/testnab.nsf/getxml{requestQuery}"/>

And this line identifies the stylesheet:

<map:transform src="simple-page2svg.xsl"/>

The Sitemap next defines the type of serialization:

<map:serialize type="svg2jpeg"/>

Serialization is required to deliver JPEG (rather than SVG) to the browser. This ensures that virtually all browsers can view the image (not just browsers with the SVG viewer plug-in).

The simple-page2svg.xsl file

As with our PDF example, the stylesheet for this example is relatively unsophisticated. However, you can make the presentation more robust by using SVG defined presentation tags. The simple-page2svg.xsl stylesheet begins by setting up the basic SVG specific elements. It then defines the sample logo to be displayed (in this case, logo.gif):

<image x="310" y="25" width="150" 
height="50" xlink:href="http://localhost:8088/logo.gif" />

The file next processes the XML similar to the previous PDF example. The primary tag (rb_entry) is matched and the rb_title tag is processed separately from the other tags. In this sample, the rb_title tag is identified with a special font size and color:

<xsl:template match="rb_title">
  <text style="fill:#FFFFFF;font-size:20;font-family:TrebuchetMS-Bold;
  filter:url(#blur2);" 
  x="60" y="70">
   <xsl:apply-templates/>
  </text>
 </xsl:template>

Other tags are set to normal font. Notice how the code defines the position of the text on the page (x=60, y=125):

<xsl:template match="rb_company">
  <text style="fill:#FFFFFF;font-size:18;font-family:TrebuchetMS-Bold;
  filter:url(#blur2);" x="60" y="125">
   <xsl:apply-templates/>
  </text>
 </xsl:template>

The JPEG process

The processing required to generate JPEG format is similar to the previous PDF example. The only difference in this instance is the use of a specific stylesheet to generate the image. Figure 4 illustrates these steps:

Figure 4. JPEG generation workflow

In the preceding illustration:

The user opens the modified Person document, and clicks the Biz Card link.
The URL passes the person's shortname as part of the query string. This accesses the Cocoon SVG application.
The application uses the sitemap.xmap file to retrieve the XML source (in this case, the GetXML agent).
The GetXML agent extracts the shortname value from the URL and processes the Person document.
The agent prints the Person document in XML format.
The Cocoon SVG application processes this XML (using the simple-page2svg.xsl stylesheet) and outputs the JPEG image to the browser.
The user views the JPEG image of the Person document as a business card.

Figure 5 shows how the person's business card appears in JPEG format:

Figure 5. Business card in JPEG format

Server connection diagram

Now let's look at something a bit more complicated. The Domino Directory provides a repository of server-related information and inter-server connectivity based on replication, routing, and instant messaging. Wouldn’t it be nice to automatically create a server layout diagram of the servers, showing all these connections graphically? With the help of Cocoon, you can do this with very little Domino programming.

First, create a directory called /mount/svg1. Then edit the Sitemap file with the required configuration changes to process the XML, and create a stylesheet file to transform the XML to JPEG, similar to the business card example. As with our previous examples, these files (called simple-page2svg.xsl and sitemap.xmap) are included in the sample download available in the Sandbox.

The GetSVG agent

The primary difference is that the GetSVG agent generates the XML. This agent collects all the server documents and determines whether or not there are any connection documents for this server. If it finds connection documents, it notes the link and defines an XML relation between the two.

Because SVG is well formed XML, the agent delivers SVG:

Print "Content-Type: text/xml"
o = |<?xml version="1.0" standalone="yes"?>|
o =o+ Chr(10)+|<svg width="800" height="600">|

The agent distributes the server objects (which appear as circles filled with color) around an invisible circle of set radius:

While Not doc Is Nothing
      i = i+1
      svr1$ = Ucase(doc.ServerName(0))
      cirk(svr1$) = ""
      Set doc=v.getnextdocument(doc)
Wend
...
deg = 360 / (dc)

So if two servers are defined in the Domino Directory, they are separated by 180 degrees (opposite each other) in this virtual circle. If there are 30 servers, each is placed every 12 degrees, and so on.

The agent then builds the XML string for the position of the server (based on the preceding placement rule) and fills it with basic color for display:

o = o+Chr(10)+|<circle cx="|+Cstr(x)+|" cy="|+Cstr(y)+|" 
r="12" style="fill:black;stroke:none;stroke-width:2;fill-opacity:.4" />|

After the agent determines the position of the sever, it analyzes its connections to other servers:

Set v1 = db.getview("($Connections)")
Forall q In cirk
   sxx$ = getx(q)
   syy$=gety(q)
   Set coll = v1.getalldocumentsbykey(Listtag(q))
   Set pdoc = coll.getfirstdocument
   While Not pdoc Is Nothing
      If pdoc.Enabled(0) = "1" Then
         con1$ = Ucase(pdoc.Destination(0))
         Set doc = v.getdocumentbykey(con1$)
         If Not doc Is Nothing Then
            o = o+Chr(10)+|<path d="M|+sxx$+| |+syy$+| L|+
             getx(cirk(con1$)) +| |+gety(cirk(con1$))+ |" 
             style="fill:blue;stroke:blue;stroke-width:2;" />|
         End If
      End If
      Set pdoc = coll.getnextdocument(pdoc)
   Wend
End Forall

Finally, the agent places the server name below each server:

o = o+Chr(10)+|<text x="|+Cstr(x-30)+|" y="|+Cstr(y+10)+|" 
font-family="Verdana" font-size="10" fill="black" 
font-weight="bold">|+svr$+|</text>|

Generating the server connection diagram

The following shows the steps involved in creating the server connection diagram:

Figure 6. Creating a server connection diagram

In Figure 6:

The user opens a server document, and clicks the View Topology link. This accesses the Cocoon SVG1 application.
The application uses sitemap.xmap to retrieve the XML source (in this case, the GetSVG agent).
The GetSVG agent queries all server documents in the Server view and obtains the corresponding connections for each server.
The agent prints the connection diagram in XML.
The Cocoon SVG1 application processes this XML file (using simple-page2svg.xsl) and outputs the JPEG image to the browser.
The user views the server topology.

The server connection diagram generated by our application appears as follows:

Figure 7. Server connection diagram

Because this application delivers SVG directly to Cocoon, you can change the color and/or size of the connection lines from within the GetSVG agent. For example, to change the line color from blue to black with this line:

o = o+Chr(10)+|<path d="M|+sxx$+| |+syy$+| L|+
getx(cirk(con1$)) +| |+gety(cirk(con1$))+ |" 
style="fill:blue;stroke:black;stroke-width:2;" />|

You can also change line color based on the connection type (replication, router, instant messaging, and so on). This line displays mail connections with a thicker blue line than other types of connections:

if doc.ConnectionType="2" then
o = o+Chr(10)+|<path d="M|+sxx$+| |+syy$+| L|+
 getx(cirk(con1$)) +| |+gety(cirk(con1$))+ |" 
     style="fill:blue;stroke:blue;stroke-width:3;" />|
else
o = o+Chr(10)+|<path d="M|+sxx$+| |+syy$+| L|+
 getx(cirk(con1$)) +| |+gety(cirk(con1$))+ |" 
    style="fill:blue;stroke:black;stroke-width:2;" />|
end if

Simple RSS generator

Finally, let's discuss an activity that has become increasingly popular as of late: Web logging (commonly called blogging). In Part 1 of this article series, we looked at how the RSS standard has been popularized by the advent of blogs available over the Internet. In this article, we offer a sample application that allows users to publish RSS feeds out of a Notes/Domino Personal Journal database. The Personal Journal template (journal6.ntf in Notes/Domino 6) has been included as part of the standard Notes/Domino product since Release 5. This template is used to create a Personal Journal database to keep notes, to create entries about specific items/issues, and to classify the entries into meaningful categories. With our example RSS generator, you can extend the functionality of a Personal Journal, making it the front-end to a Web blog.

This section explains how to build an application that creates an RSS feed for the existing entries in a Personal Journal. We also explain how to use a Firebird RSS Reader to view the feed and determine whether or not it is working properly. (See the second sidebar in part 1 of this article series for instructions on how to set up a Firebird RSS Reader.)

To implement the RSS generator, you must add two new design elements to the Personal Journal database:

GetRSS is a LotusScript agent
dispForm is a form

The GetRSS agent delivers XML to the browser using the same techniques described earlier in this article. The agent sets the content type as XML and defines the root element:

Print "Content-Type: text/xml"	
strTmp = |<?xml version="1.0" encoding="UTF-8" standalone="yes"?>| 
strTmp=strTmp+Chr(10)+|<rss version="2.0" 
 xmlns:dc="http://purl.org/dc/elements/1.1/" 
 xmlns:sy="http://purl.org/rss/1.0/modules/syndication/" 
 xmlns:admin="http://webns.net/mvcb/" 
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">|
strTmp=strTmp+Chr(10)+|<channel>|

It then specifies the RSS channel properties:

strTmp=strTmp+Chr(10)+|<title>|+db.title+|</title>|
strTmp=strTmp+Chr(10)+|<link>http://localhost:8088/|+db.FileName+|</link>|
strTmp=strTmp+Chr(10)+|<description>Blah blah blah</description> |
strTmp=strTmp+Chr(10)+|<dc:language>en-us</dc:language> |
strTmp=strTmp+Chr(10)+|<dc:creator>|+s.EffectiveUserName+|</dc:creator> |
strTmp=strTmp+Chr(10)+|<dc:date>|+Cstr(db.Created)+|</dc:date>|

Of course, you could also use a profile document to store some of the metadata and make this more flexible to maintain.

The bulk of the remaining agent code prints XML for every Journal entry found in the database.

The modified Personal Journal database (myjournal.nsf) is included with the other sample files discussed in this article and can be downloaded from the Sandbox. This database includes the form dispForm, which displays the Journal entry within the RSS reader when a user selects an entry to view.

The RSS (v 2.0) feed is an XML format. The main element is the Channel tag, which contains the entries as well as metadata about the feed. The metadata tags are title, link, and other information about the RSS feed itself, while the item tag represent each entry in the feed. In our example, the Journal database and related information serve as the Channel metadata and the fields in each Journal entry as items and their related children tags (see Figure 8):

Figure 8. RSS feed tags

Our example hard-codes the required metadata about the blog (actually the Personal Journal database). Alternatively, you can store this metadata in profile documents, which can later be modified. This allows you to control the blog using the standard Domino database management interface to configure this information.

The GetRSS agent outputs text with content type set to text/xml. When viewed through the Firebird RSS Reader, the My Journal entries appear similar to the following:

Figure 9. My Journal blog entry

This application is a simple example of leveraging an existing standard within the Domino 6 environment. You can also devise far more sophisticated, production-quality blogging engines based on Domino. For more information, see the DomBlog template page or the Domino Blog Home page.

One must have standards...

In this article, we expanded the theme of using the Opens Source projects and Open Standards built into Domino 6. We demonstrated how you can use these to dynamically convert various Notes/Domino content to PDF, JPEG, and RSS formats. This allows you to share your existing Notes/Domino content with Web users, greatly expanding your audience for this information. And best of all, you don't have to modify the original content -- or for that matter, even do a great deal of heavy-duty application development, especially if you use and adapt the samples we've included with this article.

In the concluding installment of this series, we'll carry this topic further, looking at leveraging various Open Source projects to access Domino data on a Linux desktop, using OpenLDAP to build an LDAP directory, and Domino futures.

Resources

Download the example code used in this article from the Sandbox.
See Part 1 of this article series to learn about the Open Standards and Open Source projects available in Domino 6.
The Apache Cocoon Project home page offers detailed specifications for the Cocoon Open Source project.
For more information about XML stylesheets, see XML Stylesheet Language for Transformations.
The Open Source home page provides a good general overview of what the Open Source movement is all about.
The World Wide Web consortium (W3C) page is a good resource for Open Standards information.
You can learn more about RSS by reading the developerWorks article, "Content feeds with RSS 2.0."

About the author

Close [x]

Report abuse help

Report abuse

Thank you. This entry has been flagged for moderator attention.

Close [x]

Report abuse help

Report abuse

Report abuse submission failed. Please try again later.

Close [x]

developerWorks: Sign in

The first time you sign into developerWorks, a profile is created for you. Select information in your developerWorks profile is displayed to the public, but you may edit the information at any time. Your first name, last name (unless you choose to hide them), and display name will accompany the content that you post.

All information submitted is secure.

Close [x]

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.

All information submitted is secure.

Rate this article

Comments

Close [x]

Help: Update or add to My dW interests

What's this?

This little timesaver lets you update your My developerWorks profile with just one click! The general subject of this content (AIX and UNIX, Information Management, Lotus, Rational, Tivoli, WebSphere, Java, Linux, Open source, SOA and Web services, Web development, or XML) will be added to the interests section of your profile, if it's not there already. You only need to be logged in to My developerWorks.

And what's the point of adding your interests to your profile? That's how you find other users with the same interests as yours, and see what they're reading and contributing to the community. Your interests also help us recommend relevant developerWorks content to you.

View your My developerWorks profile

Return from help

Close [x]

Help: Remove from My dW interests

What's this?

Removing this interest does not alter your profile, but rather removes this piece of content from a list of all content for which you've indicated interest. In a future enhancement to My developerWorks, you'll be able to see a record of that content.

View your My developerWorks profile

Return from help

static.content.url=http://www.ibm.com/developerworks/js/artrating/

SITE_ID=1

Zone=Lotus

ArticleID=12889

ArticleTitle=Open Standards, Open Source, and Domino 6: Using Domino 6 Open Source projects

publish-date=04122004

author1-email=

author1-email-cc=