Create a Firefox add-on to access OSLC servers

Creating your own client application to access Open Services for Lifecycle Collaboration (OSLC) servers provides two benefits: removal of extra widgets and removal of extra steps. The author describes the challenges in creating a client application to access OSLC servers and explains how to resolve them by creating and implementing a Mozilla Firefox add-on. A sample of the add-on is included to download.

Share:

Ken Kumagai (theken@jp.ibm.com), Software Engineer, IBM

author photoKen Kumagai (theken) is a staff software engineer at IBM in Japan. He works as a developer on the IBM Rational ClearCase team. One of his current interests is to improve the usability of software development tools. In his spare time, he enjoys reading books at the nearest Starbucks coffee shop.



04 December 2012

Also available in Japanese Portuguese

Unnecessarily complicated user interfaces confuse users

It is important to keep a user interface simple for good usability. This fact fits into application lifecycle management (ALM) tools. ALM tools need to support many use cases for many roles, such as developer, team lead, project manager, or product owner. So user interfaces of these tools often become complicated by two problems (see Figure 1):

  • First, too many widgets, such as buttons, text fields, tabs, and links are provided to edit all properties of resources at any time. However, not all of the widgets are used because users do not edit properties of resources with the same frequency. If for both frequently and infrequently used widgets are displayed at any time, users will be easily confused. Ideally, only the widgets that users need to edit properties should be displayed.
  • Second, widgets to edit properties of resources or to create resources are always provided on particular web pages and views (that are part of web pages). Users need to reach destinations such as web pages and views by clicking links and tabs at many times, and then edit properties of resources or create resources. However, reaching a destination is not an essential action. Ideally, users should edit properties of resources or create resources without nonessential steps to reach destinations.
Figure 1. Two problems in ALM tools
many complicated widgets in ALM tools client

This article resolves these two problems of ALM tools that support Open Services for Lifecycle Collaboration (OSLC).

OSLC standardizes the way that lifecycle tools can share data (change requests and test cases, for example). OSLC uses Representational State Transfer (REST) to link data in those tools for integration, which is one of the great aspects of OSLC.

The example in this article uses the standard way to improve usability, not for integration. In servers that support OSLC, resources can be created, read, updated, and deleted by RESTful services. This means that you can create user interfaces with good usability by calling these services as you choose, not to keep using UIs bundled with the server.

In the approach that this article proposes, widgets are prepared to edit properties of resources and create resources directly. Then user interfaces are composed by widget combinations that can be customized by users (see Figure 2). This approach resolves the two problems like this:

  • Users can reduce unnecessary widgets by customizing combinations in UIs according to their purposes.
  • Users can edit properties of resources and create resources directly by using the widgets in combination without nonessential steps, such as reaching a destination.
Figure 2. How this approach solves the two problems
minimum necessary widgets in ALM tools client

A sample client application created as a Firefox add-on resolves those two problems. The four sections of this article explain how to create and implement that add-on, which the author named FireOSLC:


Prerequisite technologies and software

The Downloads section of this article provides a sample of the FireOSLC Firefox add-on. Before you read the details, download fireoslc.xpi and run it to understand this article quickly.

FireOSLC runs as a Mozilla Firefox add-on, so the only necessary software is Firefox. FireOSLC calls a preinstalled XPCOM (cross-platform component object model) to use both local files and Firefox about:config, so XPCOM support is necessary for Firefox versions. This example uses Firefox Version 15.

You will use these technologies to implement FireOSLC:

  • XUL (XML User Interface language)
  • JavaScript

You can also use Cygwin and Perl to create an XPI (cross-platform installation) FireOSLC package.

To test that FireOSLC runs correctly, this example uses the Rational solution for Collaborative Lifecycle Management (CLM), which includes ALM tools that support OSLC. This article explains the FireOSLC use case to create, read, and update OSLC resources in these applications: CM (change management) resources in IBM® Rational Team Concert™, QM (quality management) resources in Rational® Quality Manager, and RM (requirements management) resources in Rational Requirements Composer. You will use data from these for testing of FireOSLC:

  • Collaborative Lifecycle Management Version 3.0.1
    • Server: testhost.testdomain
    • Port: 9443
  • Account
    • Username: tester
    • Password: testerx
  • Lifecycle project
    • Rational Team Concert
      • Project name: TestProjectCM
      • Process: Scrum
    • Rational Quality Manager
      • Project name: TestProjectQM
      • Process: Quality Management default V3 process
    • Rational Requirements Composer
      • Project name: TestProjectRM
      • Process: Rational Requirements Server template

Architecture overview

Figure 3 shows an overview of FireOSLC architecture. The largest square, with the FireOSLC label, is the overall FireOSLC. Squares inside that largest one are packages of JavaScript that comprise FireOSLC. Each JavaScript package has a com.fireoslc prefix. For example, oslc_cm is an abbreviation for com.fireoslc.oslc_cm. Squares with right-bottom reverse are data entities that users need to edit. The arrows show how packages and data entities interact. Following sentences in this chapter explains the architecture in details.

Figure 3. Overview of FireOSLC architecture
FireOSLC JavaScript packages and data entities

Designs in details

Follow these steps to implement FireOSLC (explanations follow):

  1. Process OSLC services.
  2. Read, update, and create resources.
  3. Design the user interface.
  4. Access properties that are not defined in OSLC.
  5. Set preferences in Firefox.

Process OSLC services

Before getting any information from OSLC server, users need to be authenticated by the server. The auth package requests form-based authentication by sending user account information.

Next, when you need to read the existing resources or create new resources, you need to get query capabilities or creation factories.

OSLC services can be processed by following these steps:

  1. Request information by using the root service, and extract the URL of the service provider catalog.
  2. Request information by using the service provider catalog, and extract the URL of the service provider.
  3. Request information by using the service provider:
    1. Extract the URL of query capabilities so that the existing resources are read.
    2. Extract the URL of creation factories so that new resources are created.

The sprovider package requests information by using OSLC services, such as the root service, service provider catalog, and service provider (in that sequence), and then gets query capabilities and creation factories. By using XPath, the URL of OSLC service can be extracted from returned information from the prior OSLC service. The oslc_cm package provides XPaths to get OSLC services for OSLC CM. It's the same as the oslc_qm package (OSLC QM) and the oslc_rm package (OSLC RM).

Read, update, and create resources

OSLC services uses HTTP for create, retrieve, update, and delete actions on resources. FireOSLC supports read, update, and create operations on resources but does not support the delete operation. This is because the delete operation is not often supported in OSLC servers as much as the other operations.

To select an existing resource in OSLC servers, you can use OSLC Query. For the read operation, FireOSLC fetches one resource at a time by HTTP get method with the oslc.where query parameter. For the update operation, FireOSLC updates the resource fetched during the read operation by HTTP put method with the user's input. For the create operation, FireOSLC creates a new resource by HTTP post method with the user's input. The consts package holds properties defined in OSLC. These properties of resources can be accessed during read, update, and create operations by FireOSLC.

The oslc_cm package performs the operations for the OSLC CM resource, Change Request. Similarly, the oslc_qm package performs the operations for OSLC QM resources: Test Plan, Test Case, Test Script, Test Execution Record, Test Result. The oslc_rm package performs the operations for OSLC RM resources: Requirement and Requirement Collection.

Design the user interface

The user interface of FireOSLC is created by the ui package with XUL. It includes six panes. This article uses the word pane to express a logical area in user interface of FireOSLC.

  1. Login
  2. OSLC settings
  3. Properties list
  4. Create, Retrieve, Update
  5. Properties,
  6. Results

Figure 4 will help you understand the explanations that follow.

Login
Enter the server name with port, user name, and password to log in to the OSLC server. After succeeding, status shows as logged in.
 
OSLC settings
Select an OSLC application type, a service provider, and a resource type.
 
Properties list
This pane corresponds to properties list in Figure 3. The format is a text of properties concatenated by comma. In the properties list, you need to write properties with namespaces that you want to access during read, update, or create operations on resources.

Note:
Properties that are not written in the properties list cannot be accessed during the operations.
 
Create, Retrieve, Update and Properties
Select one of radio buttons from either R|U (Read or Update) or C (Create).

Note:
In FireOSLC, the Update operation cannot be done without the Read operation.
  • When you choose R|U radio button, select a property for the oslc.where query parameter, and write a value for the oslc.where query parameter. FireOSLC supports these three query parameters: dcterms:identifier, dcterms:title, dcterms:description
  • By clicking R radio button, one resource matched with the oslc.where query is fetched from the OSLC server, and the properties of the resource are shown in the Properties pane. If more than two resources potentially match with the oslc.where query, one of them is returned at random.
  • After clicking the R radio button, you can change values of properties shown in Properties pane by writing new values in text fields or selecting items from the menu lists. By clicking U radio button, changed values are sent to OSLC server to update properties of the resource.
  • When you select C radio button, write values of the properties in the Properties pane. By clicking C button, properties are sent to the OSLC server to create a new resource.
Results
  • A returned code and the time are shown when read, update, create operations are executed.
  • A returned body is shown in the dialog window when you click the body button.

 

Figure 4 shows a screen capture of the FireOSLC user interface. Figure 5 shows a Rational Team Concert screen capture, where the same work item shown in Figure 4 appears .

Figure 4. The FireOSLC user interface with a Change Request resource
six panes of the FireOSLC user interface
Figure 5. The Rational Team Concert web client with a Change Request resource
A Rational Team Concert work item screen

Access properties that are not defined in OSLC

By following the previous three steps, you can access properties defined in OSLC specification during read, update, create operations on resources in OSLC servers. However, two challenges remain:

  • How to access properties that are not defined in OSLC specification
  • How to access properties with reference representation, as well as non-reference properties

ALM tools often define properties that are not defined in the OSLC specification. Some of those properties are essential for operations on resources. For example, without the rtc_cm:filedAgainst property, the Change Request resource cannot be created in Rational Team Concert at the default settings. FireOSLC provides a properties extension that is an external file, where you can add necessary properties of your ALM tools that must be accessed during Read, Create, and Update operations on resources. The oslc_ext package reads in data from the external file of the properties extension to make the additional properties accessible during operations on resources.

When the value type of properties (dcterms:contributor, for example) is referenced, you need to request necessary information from the reference to see what values are set for the properties. Requested information needs to be processed to extract values, and then the values are shown in appropriate widgets. Ways of processing requested information differ according to properties and ALM tools. To process such Rational Team Concert properties, oslc_ext package provides two approaches:

  • The first is to show all selectable values of properties in a drop-down menu by requesting information from the specified URL of each property, for example:
    • rtc_cm:filedAgainst
    • rtc_cm:type
    • oslc_cmx:priority
    • oslc_cmx:severity
    • dcterms:contributor
  • The second approach is to show the latest value of a property in a text box by requesting information from the specified URL of a property, such as oslc:discussion.

FireOSLC reads in data from the properties extension, fireoslc_prop_ext.xml (an external file), in which you could write XML tags to define information of properties that are accessed during operations. You can use these tags in the properties extension file:

  • oslc_ext_all
    • oslc_ext_all tag is the root tag, and it has oslc_ext tags as child tags.
  • oslc_ext
    • oslc_ext tag has xpath_ns and property tags as child tags for each OSLC type.
    • oslc_type attribute: 0 is CM, 1 is QM, 2 is RM.
  • xpath_ns
    • xpath_ns tag registers namespaces. Registered namespaces are used in two cases:
      • To add properties in xml that is sent to OSLC server during creation operation, namespaces are added to a header of xml.
      • To access a node (that corresponds to a property) in XML-based document by using the document.evaluate function during update operation, a namespace of the node is added to the namespace resolver (see the link in Resources to "Introduction to using XPath in JavaScript").
    • key attribute: A namespace prefix.
    • url attribute: The namespace URL.
  • property
    • The property tag includes information of a new property. The id and type attributes are necessary.
      • id attribute: A property name
      • type attribute: Read-only, text, list, rtc_ext
    • A property with type read-only is shown as a label in the user interface.
    • A property with type text is shown as a textbox in user interface.
    • A property with type list is shown as a drop-down menu in the user interface. The attribute needs item tags as children.
    • A property with an rtc_ext type is shown as a drop-down menu or a text box (only oslc:discussion). id with rtc_ext type would be rtc_cm:filedAgainst, rtc_cm:type, oslc_cmx:priority, oslc_cmx:severity, dcterms:contributor, oslc:discussion. The attribute needs four additional attributes: def_url, tgt_xpath, tgt_ns, and tgt_name.
      • def_url attribute: A specified URL that returns information of all selectable values and labels. This attribute could be empty for oslc:discussion.
      • tgt_xpath attribute: An XPath that enumerate selectable values and labels.
      • tgt_ns attribute: The namespace URL of tag that includes label
      • tgt_name attribute: The name of tag that includes label. A prefix of namespace is needed for oslc:discussion, for example dc:description.
  • item tag
    • item tag includes selectable labels and values of a property.
      • label attribute: Label that is shown in menu item.
      • value attribute: Value that is sent to OSLC server if the label is selected.

For example, you'll add the property tag when you want to access a new property, and you'll add the xpath_ns tag when the new property has a prefix that is not defined in OSLC specification. Listing 1 shows an example of the properties extension file.

Listing 1. An example of the fireoslc_prop_ext.xml file
<oslc_ext_all>
<!-- Extensions for OSLC CM -->
<oslc_ext oslc_type="0">
<!-- Here are examples of properties in RTC.-->
<xpath_ns key="foaf" url="http://xmlns.com/foaf/0.1/"/>
<xpath_ns key="rtc_cm" url="http://jazz.net/xmlns/prod/jazz/rtc/cm/1.0/"/>
<xpath_ns key="oslc_cmx" url="http://open-services.net/ns/cm-x#"/>
<xpath_ns key="rdf" url="http://www.w3.org/1999/02/22-rdf-syntax-ns#"/>
<xpath_ns key="dcterms" url="http://purl.org/dc/terms/"/>

<!-- xmlns:foaf="http://xmlns.com/foaf/0.1/" -->
<property id="dcterms:contributor" type="rtc_ext"
  def_url="https://testhost.testdomain:9443/ccm/oslc/users/?oslc.select=foaf:name"
  tgt_xpath="//foaf:Person"
  tgt_ns="http://xmlns.com/foaf/0.1/"
  tgt_name="name"/>

<!-- xmlns:dcterms="http://purl.org/dc/terms/" -->
<property id="rtc_cm:type" type="rtc_ext"
  def_url="https://testhost.testdomain:9443/ccm/oslc/types/_yJNt8vNgEeCl8oCPwVoRZA/"
  tgt_xpath="//rtc_cm:Type"
  tgt_ns="http://purl.org/dc/terms/" 
  tgt_name="title"/>

<property id="rtc_cm:filedAgainst" type="rtc_ext"
    def_url="https://testhost.testdomain:9443/ccm/oslc/categories.xml
?oslc.select=dcterms:title"
  tgt_xpath="//rtc_cm:Category"
  tgt_ns="http://purl.org/dc/terms/"
  tgt_name="title"/>

<property id="oslc_cmx:priority" type="rtc_ext"
    def_url="https://testhost.testdomain:9443/ccm/oslc/enumerations/
_yJNt8vNgEeCl8oCPwVoRZA/priority"
  tgt_xpath="//rtc_cm:Literal"
  tgt_ns="http://purl.org/dc/terms/"
  tgt_name="title"/>

<property id="oslc_cmx:severity" type="rtc_ext"
  def_url="https://testhost.testdomain:9443/ccm/oslc/enumerations/
_yJNt8vNgEeCl8oCPwVoRZA/severity"
  tgt_xpath="//rtc_cm:Literal"
  tgt_ns="http://purl.org/dc/terms/"
  tgt_name="title"/>

<property id="oslc:discussion" type="rtc_ext"
  def_url="this_field_of_oslc_discussion_is_not_used"
  tgt_xpath="//rdf:Description[rdf:type[@rdf:resource='
http://open-services.net/ns/core#Comment']]"
  tgt_ns="http://purl.org/dc/terms/"
  tgt_name="dc:description"/>

<!-- Here are examples of properties specific for user's ALM tools. -->
<xpath_ns key="t1" url="http://testhost.testdomain/"/>
<property id="t1:list1" type="list">
  <item label="label1" value="value1"/>
  <item label="label2" value="value2"/>
  <item label="label3" value="value3"/>
</property>
<property id="t1:readonly1" type="readonly"/>
<property id="t1:text1" type="text"/>
</oslc_ext>
<!-- Extensions for OSLC QM -->
<oslc_ext oslc_type="1"/>
<!-- Extensions for OSLC RM -->
<oslc_ext oslc_type="2">
<xpath_ns key="dc" url="http://purl.org/dc/terms/"/>
<property id="dc:identifier" type="readonly"/>
<property id="dc:modified" type="readonly"/>
<property id="dc:created" type="readonly"/>
<property id="dc:title" type="text"/>
<property id="dc:creator" type="readonly"/>
<property id="dc:contributor" type="text"/>
<property id="dc:description" type="text"/>
</oslc_ext>
</oslc_ext_all>

Set preferences in Firefox

FireOSLC uses Firefox preferences. All preferences have a prefix, for example, extensions.fireoslc.servername for servername. Table 1 shows all preferences. To set these preferences, write about:config in the Firefox address bar.

Table 1. Preferences for FireOSLC
Preference nameTypeExplanation
servernamestringStore server name with port number.
usernamestringStore user name.
pliststringStore properties list.
logBooleanThis specifies whether the log content is output to a local file. The default value is false.
root_serv.cm
root_serv.qm
root_serv.rm
stringA path of the root services that returns service provider catalogs. It is a relative path to the server name. The default values are ccm/rootservices, qm/rootservices, and rm/rootservices, in the order.
workdirstringThis is a path to a directory where both the properties extension file (fireoslc_prop_ext.xml) and the log file are stored. The default value is c:\tmp.

Use cases

This section explains how to use FireOSLC to create, read, and update OSLC CM, QM, and RM resources.

Change management (CM)

Create a Change Request resource in Rational Team Concert.

  1. Select Tools > FireOSLC.
  2. Enter server name, user name, and password, and then click login.
    • Server:testhost.testdomain:9443/jts
    • User:tester
    • Password:testerx
  3. If login fails in the previous step, make sure that cookies are enabled.
    1. Open Tools > Options > Privacy, then go to History section.
    2. At Firefox will, click Use custom settings for history.
    3. Click both Accept cookies from sites and Accept third-party cookies. Alternative: Rather than clicking Accept third-party cookies, click Exceptions, write your server name (for example: testhost.testdomain), click Allow, Close
    4. Click OK
  4. Click an OSLC type, select a service provider, and a resource type in the OSLC settings pane, for example:
    • Click CM.
    • For Service Provider, select TestProjectCM.
    • For Resource type, select ChangeRequest.
  5. Write properties in the Properties list pane. For Rational Team Concert, dcterms:title and rtc_cm:filedAgainst must be included, for example:
    dcterms:title,dcterms:description,dcterms:contributor,rtc_cm:type,rtc_cm:filedAgainst
  6. Select C radio button in the Create, Retrieve, Update pane.
  7. Write values in text boxes or select values in drop-down menus next to property labels in the Properties pane, for example:
    1. dcterms:title: write Function A returns an invalid value.
    2. rtc_cm:filedAgainst: select TestProjectCM
    3. dcterms:description: write Investigate a case of input value B.
    4. dcterms:contributor: select tester
    5. rtc_cm:type: select Defect
  8. Click the C button in the Create, Retrieve, Update pane (Figure 6), and check that the successful code (201) is shown in the Results pane. An error code means that FireOSLC failed to create a Change Request resource.
  9. Click the body button in the Results pane, and you'll see the dcterms:identifier property of the newly created Change Request resource (Figure 7). You can also verify that the Change Request resource is created in Rational Team Concert by using the Rational Team Concert web client.
Figure 6. Create a Change Request resource
values set to properties for a resource creation
Figure 7. The dcterms:identifier property of a Change Request resource
dcterms:identifier property in output

Next, read the newly created resource, and then update it.

  1. Write properties in the Properties list pane, for example:
     dcterms:identifier,oslc_cmx:priority,oslc_cmx:severity,oslc:discussion
  2. Select both an operation type and an oslc.where query parameter, and write a value in the Create, Retrieve, Update pane.
    • Select the R|U radio button.
    • Select dcterms:identifier at oslc.where from the drop-down menu.
    • Write a value that you saw at the resource creation step above.
  3. Click the R button in the Create, Retrieve, Update pane, and check that the successful code (200, for example) is shown in the Results pane. Then you'll see properties of the resource in the Properties pane (Figure 8). An error code means that FireOSLC failed to read the Change Request resource.
  4. Select and write values, for example:
    • oslc_cmx:priority: select High
    • oslc_cmx:severity: select Critical
    • oslc:discussion:We need to fix it ASAP!
  5. Click the U button in the Create, Retrieve, Update pane, and check that the successful code (200, for example) is shown in Results pane (Figure 9). An error code means that FireOSLC failed to update the Change Request resource.

    Note:
    Internally, oslc:discussion extended by Rational Team Concert is executed separately by HTTP post, so two successful codes will be shown if oslc:discussion is accessed with other properties, as above.
  6. Click the body button in the Results pane to see updated properties in the returned resource information. You can also see updated properties of the resource by using the Rational Team Concert web browser client (Figure 10).
Figure 8. Read a Change Request resource
properties of the resource are shown
Figure 9. Update a Change Request resource
updated properties of resource
Figure 10. See an updated Change Request resource by the Rational Team Concert web client
updated properties in the web client

Quality Management (QM)

Create a TestCase resource in Rational Quality Manager.

  1. Click an OSLC type, select a service provider, and a resource type in the OSLC settings pane.
    • Click QM.
    • Select TestProjectQM at Service Provider.
    • Select TestCase at Resource type.
  2. Write properties in properties list, for example: dcterms:title
  3. Select the C radio button in the Create, Retrieve, Update pane.
  4. Write a value in textbox in the Properties pane, for example, for dcterms:title: TC0905
  5. Click the C button to create a TestCase resource, and check that the successful code (201, for example) is shown in the Results pane.

Next, read the newly created TestCase resource and update it.

  1. Write properties in properties list, for example dcterms:title,dcterms:description
  2. Select both an operation type and oslc.where query parameter, and write a value in the Create, Retrieve, Update pane.
    • Select the R|U radio button.
    • Select dcterms:title at oslc.where from the drop-down menu.
    • Write the same value as for step 4, for example, TC0905
  3. Click R button, and check that the successful code (200, for example) is shown in the Results pane, and then you'll see the properties in the Properties pane,
  4. Write a value, for example: dcterms:description: this is test description
  5. Click the U button, and check that the successful code (200, for example) is shown in the Results pane.

Figure 11 shows a screen capture of the newly created TestCase resource in the Rational Quality Manager web client.

Figure 11. See an updated TestCase resource by the Rational Quality Manager web client
updated properties in the web client

Requirements Management (RM)

Create a Requirement resource in Rational Requirements Composer.

  1. Click an OSLC type, and select your service provider and a resource type in the OSLC settings pane:
    1. Click RM.
    2. Select TestProjectRM as the service provider.
    3. Select Requirement as the resource type.
  2. Write the properties in Properties list, for example: dc:title
  3. Select C radio button in the Create, Retrieve, Update pane.
  4. Write values in text box in the properties pane, for example: dc:title: Req0905
  5. Click C button to create a Requirement resource, and check that thesuccessful code (201, for example) is shown in the Results pane.

Note:
Normally, you can confirm the ID of the resource by clicking body button in the Results pane. However, Rational Requirements Composer 3.0.1 might return an empty body with the successful code. In that case, confirm the ID by using the Rational Requirements Composer web client.

Next, read the newly created requirement resource and update it.

  1. Write these properties in the properties list, for example:
     dc:identifier,dc:title,dc:description
  2. Select both an operation type and oslc.where query parameter, and write a value in the Create, Retrieve, Update pane, for example:
    1. Select the R|U radio button.
    2. Select dcterms:identifier at oslc.where from the drop-down menu
    3. Write a value that you checked at the step 5, for example: 71.
  3. Click the R button, and check that the successful code (200, for example) is shown in the Results pane. Then you'll see the properties in the Properties pane,.
  4. Write a value in the Properties pane, for example: dc:description: this is test description
  5. Click the U button, and check that the successful code (200, for example) is shown in the Results pane.

Figure 12 shows a screen capture of the newly created Requirement resource in the Rational Requirements Composer web client.

Figure 12. See an updated Requirement resource by Rational Requirements Composer web client
updated properties in the web client

Acknowledgement

The author thanks Masaki Wakao and Takehiko Amano for technical advice.


Download

DescriptionNameSize
Sample file for this articlefireoslc_all.zip35KB

Resources

Learn

Get products and technologies

  • Download a free trial version of Rational software.
  • Evaluate other IBM software in the way that suits you best: Download it for a trial, try it online, use it in a cloud environment, or spend a few hours in the SOA Sandbox learning how to implement service-oriented architecture efficiently.

Discuss

Comments

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 Rational software on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Rational, DevOps
ArticleID=847924
ArticleTitle=Create a Firefox add-on to access OSLC servers
publish-date=12042012