Material ID: GI11-8359-00
© Copyright International Business Machines Corporation 2007. All rights reserved. US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
The latest version of this document is available at
http://download.boulder.ibm.com/ibmdl/pub/software/rationalsdp/v7/rme/70/docs/readme/readme.html.IBM® Rational® Modeling Extension for Microsoft® .NET is a C# and CTS modeling extension for the Rational UML modeling products. This family of design and development tools is built on the open-source Eclipse framework. The Modeling Extenstion for Microsoft .NET software includes plug-ins that enable software architects and model-driven developers to visualize C# applications and CTS types and to create well-architected C# code using Unified Modeling Language (UML 2).
With Rational Modeling Extension for Microsoft .NET you can:
- Import .NET solutions from Microsoft Visual Studio 2005 to create a mirror image of the solution within the Eclipse project.
- Visualize C# applications.
- for architectural discovery and dependency analysis, using Browse Diagrams.
- for documenting application structure, using Class Diagrams.
- for documenting as-implemented and what-if class interactions, using Sequence Diagrams.
- for depicting .NET types within diagrams in UML models as part of the "mixed modeling" theory of operations.
- Transform UML models into C# code.
- Transform changes in the C# code into the UML model.
For the latest details about installation requirements, see the updated version of this readme file at: http://download.boulder.ibm.com/ibmdl/pub/software/rationalsdp/v7/rme/70/docs/readme/readme.html.
You can also view the installation guide for your product from the installation launchpad and in the documents directory of the product CD.
Rational Modeling Extension for Microsoft .NET requires IBM Installation Manager v1.0.0.2 or later and IBM Rational Software Architect, IBM Rational Software Modeler, or IBM Rational Systems Developer, versions 7.0.0.1. The software installation will not continue if the required versions are not installed.
For information about installing IBM Rational Modeling Extension for Microsoft .NET, Version 7.0, see the installation instructions on the Web at http://download.boulder.ibm.com/ibmdl/pub/software/rationalsdp/v7/rme/70/docs/install_instruction/install.html.
You can also view the installation guide for your product from the installation launchpad and in the documents directory of the first product CD.
The modeling extension software can be installed into the GA build of IBM Rational Software Architect v7.0.0.1, IBM Rational Software Modeler v7.0.0.1, or IBM Rational Systems Developer v7.0.0.1. The following procedure provides an overview of the installation process. For more detailed instructions, see the IBM Rational Modeling Extension for Microsoft .NET Install Guide.
To install:
- Ensure a Rational UML modeling product, as specified above, is installed.
- In the IBM Installation Manager, select which host product the modeling extension will be installed with.
The modeling extension shell-shares with the host product and uses the same instance of Eclipse.- Follow the Installation Manager wizard to complete the modeling extension installation.
These release notes include information that was not available until after the product documentation was finalized. Use the following best practices and guidelines when modeling .NET applications using the C# profile.
1. Visual Studio 2005 Standard or Professional Edition must be open whenever the Rational UML modeling product with the extension is opened.
Note: The Installation Guide lists "Visual Studio 2005" as a software requirement. This is amended to "Visual Studio 2005, Standard Edition or Professional Edition." The Express editions are not supported.
2. Using models previously imported from Rational XDE to Rational Software Architect version 6.x
If you have models that were previously imported from Rational XDE to Rational Software Architect version 6.x and you have migrated (or plan to migrate) those forward to Rational Software Architect version 7.0.0.1 and also use the extension, then you must also have the Rational XDE Model Import feature of Rational Software Architect installed.
3. While naming packages in the model, do not use ‘.’ (dot) in the package names. For example, if you need nested packages ‘xtools’ within ‘ibm’ within ‘com’, instead of naming a single package “com.ibm.xtools” , use hierarchical package structure and create a package, “com,” nesting package “ibm” nesting “xtools”. This notation always has a unique representation and will help reduce false fuse changes while transforming code to model.
4. Apply C# stereotypes only when you need to set some C#-specific values through the stereotype properties. Otherwise, if the identical code would have been generated without applying the stereotype, the C#-to-UML transform assumes that no stereotype was used during the prior UML-to-C# transformation, and the Reconcile window opens showing a delta suggesting that the stereotype should be removed from the UML model.
5. The C# profile currently does not define constraints, so invalid combinations of applied stereotypes are not detected. Avoid invalid use of profile stereotypes. For example, applying both <<CSharpClass>> and <<CSharpInterface>> is invalid, and will result in unpredictable transformation behavior.
6. While modeling partial types, the user should use one empty type as partial type on which each part is shown as a dependent part. Include the modeled empty partial type (the source) and the defined partial types (with dependency relations to the source) in a single package in the model. This way all parts of the partial type are defined in one package in the model. The source’s name will be used as the type name and other part’s name is not used as the type’s name. Using a mapping model, each partial part can be directed to a different file. While transforming from code to model, the names that were used by the user for each of the parts is not known and hence the transformation generates the names as <typename>_<filename> which will appear as a difference in the fuse dialog.
7. In C#, generic types can be used only if we specify the values for type parameters i.e. we should construct a new type for a generic type by binding its type parameters. So a List class with parameter T can be used by using List<String> etc. In UML such constructed types will be represented as template bindings and names of these types is not while transforming code to UML to generate the temporary model. So the constructed types appear as anonymous type names which will be shown as difference in fuse dialog and user will have to map it to the actual template binding in the target model.
Overloaded operators are modeled as operations. For example, assume that you expect to overload the following two operators in the context of the class C1 and you would like to model this task with Modeling Extension for Microsoft .NET.
Equal (==)
Not equal (!=)The following steps describe how the overloading of operators can be modeled using this example.
Prerequisites:
A UML model must have been created or opened.To model the overloaded operators:
- Create a new class in the UML model named C1.
- Add a new operation to class C1 and name it operator !=. This operator will contain the implementation for the overloaded operator !=.
- Define the operator as follows.
a. Set the visibility of the newly created operation to Public.
b. Set the qualifiers of the newly created operation to Static.
c. Set the return type of the newly created operation to <Primitive Type>bool.
d. Add two parameters of the type C1 to the newly created operation and name them c1 and c2.- Add another operation to class C1 and name it operator ==. This operator will contain the implementation for the overloaded operator ==.
- Define the operator as in step 3.
Modeling the overloaded operator != and == in the context of the class C1 is complete.
These release notes include release-specific information, such as problems and limitations that were not available until after the product documentation was finalized.
User does not receive notification from the modeling extension software that the imported code was not compiled properly. If the imported C# project contains code with syntax errors, in the modeling extension software the flag indicating errors will not be displayed in Project Explorer or the visualizer diagrams.
Workaround: Ensure that the C# code successfully compiles in Visual Studio .NET before any transformation and before importing it into the Modeling Extension for Microsoft .NET.
- Modeling Extension for Microsoft .NET only recognizes and communicates with the first instance of Visual Studio 2005 that is opened. Run only one instance of Visual Studio at a time on a machine where Modeling Extension for Microsoft .NET is being used.
- Never close or open a different solution (other than the one imported) within Visual Studio when Modeling Extension for Microsoft .NET is running.
- Always keep one instance of Visual Studio 2005 open; Modeling Extension for Microsoft .NET will only recognize and communicate with the first instance of Visual Studio 2005.
- When a solution is imported into Modeling Extension for Microsoft .NET, it creates Eclipse projects in the Eclipse workspace for every corresponding C# project present in the solution. The project created in Eclipse will have the same name as the C# project in the Visual Studio 2005 solution. The following are the important points to note about the projects:
- The created projects in Eclipse will have links to the C# files and .NET Assemblies used by the corresponding C# projects in the Visual Studio 2005 solution. These links are the only way for Modeling Extension for Microsoft .NET to retrieve, update and show information about the Visual Studio 2005 projects and its contents in Eclipse. In effect, they act as a view for the C# projects in Eclipse.
- With the exception of using the UML-C# transformations, avoid using Eclipse mechanisms to modify the imported projects. Using Eclipse mechanisms to rename these projects or to modify their contents can lead to unpredictable results. In particular, avoid creating or adding UML models (.emx) or diagram files (.dnx) in the projects. Instead, create separate projects (like UML Project) in Eclipse for these purposes. Some care is required to avoid creation of diagram files (.dnx) within the imported projects, because as new diagrams are created, the visualization framework will default their locations to be the projects in which the visualized elements reside.
- You can safely close and re-open the imported projects. You can also safely delete them, but do not “remove underlying contents” (if you really need to delete a Visual Studio project and all its contents, do it from Visual Studio).
- Once the Visual Studio 2005 solution is imported in Eclipse, avoid renaming the C# projects in Visual Studio 2005. If you must rename a project then follow these steps:
- Delete the corresponding (imported) Eclipse project (but do not “remove underlying contents”).
- Rename the project in Visual Studio.
- Re-import the Visual Studio solution (the Modeling Extension for Microsoft .NET solution can incrementally import the solution; this capability is also useful for importing newly added C# projects in the Visual Studio 2005 solution.
- Before performing actions in the Modeling Extension for Microsoft .NET, make sure that the C# projects do not contain syntax errors and that they compile successfully in Visual Studio 2005. Modeling Extension for Microsoft .NET uses Visual Studio Code Model APIs to parse the C# files. These APIs return incorrect results and NULL values if there are errors in the C# files. For example, if you change a C# file in Visual Studio, then Refresh its project in Eclipse and you see that the file cannot be expanded in Project Explorer, it might be because C# syntax errors were introduced by the change.
The recommended solution is to switch to Visual Studio 2005, fix all the syntax errors, rebuild the Solution and refresh the imported project in Eclipse to get the changes. It is particularly important that Visual Studio solutions be in a clean, built state when applying transformations.- Modeling Extension for Microsoft .NET uses a COM mechanism to synchronize with Visual Studio 2005. The COM calls may fail or be rejected when Visual Studio is busy. Do not work on Visual Studio 2005 or make it active when performing the following operations in Modeling Extension for Microsoft .NET:
- Importing .NET solutions
- Project Refresh
- Expanding imported projects or files in Project Explorer (for example, expanding the tree view)
- Starting up Modeling Extension for Microsoft .NET in a workspace where a Visual Studio 2005 solution was previously imported
- Composing a .NET visualization diagram
- Running a UML-to-C# or C#-to-UML transformation
- If you are not planning to explore the contents of types defined in the .NET framework assemblies ( for example, to find what operations or fields contained in the type), then use the option "While parsing .Net assemblies get only types" when importing the Visual Studio 2005 solution to the Eclipse workspace. This option is available on the first page of the .NET Solution Import wizard. This speeds up the import of the solution and also speeds up the visualization of C# and .NET types.
- In Visual Studio 2005, always enable the option to auto load the changes. Checking the box “Auto Load changes," available by at the Environment-> Documents page of the Options window, enables this option. This can be opened through “Tools-Options->Environment->Documents->Detect When a file has changed out side the environment ->Auto Load changes, if saved”.
- You can change the encoding of C# projects through Eclipse by selecting Properties option from the context menu of the imported projects. Note that this encoding will take more time than normal since Visual Studio projects are normally large.
When a nested class/struct/interface is used to define the type of an element in an outer class/struct/interface, the type name includes the name of the outer types, though the type and the element are defined in the same class. No known workaround at this time. Issue to be addressed in future version.
For example the following model:
- OuterClass
+ InnerClass
+ attribute1 : InnerClassWill yield the following as part of the generated code for InnerClass, within OuterClass.cs:
private OuterClass.InnerClass attribute1;
Forward transform of unicode characters present in a UML model, such as class names, documentation etc is not supported in this release. All unicode characters will be generated as '?' in the corresponding C# files.
When Modeling Extension for Microsoft .NET is installed with IBM Rational Software Modeler, the viewlet tour that demonstrates Modeling Extension for Microsoft .NET features is not available in the Welcome by clicking Overview > Different modeling approaches... > More about model transformations. The tour is available in the Tutorial Gallery.
To view the tour in Rational Software Modeler, click Help > Tutorials, expand Tours, and then click Transforming UML models into C# code. Click Start tour to launch the viewlet.
In some cases, when rerunning a UML-to-C# transformation with the mapping and create source to target relationship options, the generated code is corrupted. For example, there might be missing "/" on code comments and other code errors.
This occurs when the manifest relationship is moving between artifacts so that using can either combine code into one .cs file or separate code into two files.
This issue will be fixed in a future release.
The first time a C#-to-UML transform is run on an imported XDE code model, the reconcile dialog box shows many differences relating to stereotypes. This is because the XDE related stereotypes in the imported model are not recognized by the C#-to-UML transform. This issue will be fixed in a future release.
Workaround:
Perform a one-time "cleanup" transformation immediately after importing the XDE code model (before making any changes to model or code). Run the C#-to-UML transformation. When the reconcile dialog appears, accept all suggested changes in favor of the temporary model (the model shown in the left-hand pane). This will result in removal of stereotypes from the persisted model so that subsequent runs of the C#-to-UML transformation will no longer report the differences.
Consider a model which contains stereotyped UML properties like <<CSharpProperty>>, <<CSharpField>>, etc. whose type is not set and the source code specifies types from assemblies as datatypes for these elements. If C#-to-UML transform is run on such a code and target model, then the fuse will correctly show the datatype (which will be a UML vizref) that will be set for the element but after the operation completes, the datatype is missing for those elements (null). This is a known issue and will be fixed in a future release.
If a model file name contains a # symbol in it, and is specified as the target of a transformation for C#-to-UML, the fuse dialog box will fail to show the 2 panes with temporary and target model for merging the differences. This issue will be fixed in a future release.
If an XDE imported model is specified as the target of a C#-to-UML transformation and also Mapping model is specified in the transformation configuration, then C#-to-UML transform fails with Null Pointer Exception. This issue is seen only for XDE imported models with mapping model.
Workaround:
Delete the package <<Aritifacts>> from the imported model and then run the transform. Deleting the artifacts package does not lead to any loss of information since the mapping model will have information about various files, etc. The issue will be fixed in a future release.
If a target model is created using the Create New Target Container button in transformation configuration editor, at times the focus gets shifted to newly created model and the new model is not selected in the target pane (where C#-to-UML is the forward transformation).
Workaround:
Manually switch to the configuration editor and select the target model. This is a known issue and will be fixed in a future release.
If a UML-to-C# transformation is executed with a modified mapping model, in such a way that it leads to the deletion of a file, and if the user selects to delete the file in the File Deletion dialog box, that file is not actually deleted. It is just removed from the project, in order to preserve the contents.
Later, if the UML-to-C# transformation is run again, in such a way that it leads to re-creation of the file that was deleted (removed from project) in the previous step, this (re-created) file has the old (original) contents instead of the new contents.
Workaround:
The current workaround for this issue is to delete such files from the file system after step 1. The list of such files can be obtained from:
- the File Deletion dialog box, if the transformation is not running silently.
- the list of files available on the file system compared to the files that belong to the project, if the transformation is configured to run silently.
- the list of empty artifacts in the mapping model (if any).
Reapplying UML-to-C# transformation with the Create source to target relationships option selected in the Common page of the transformation configuration after removing the @generated tag from the C# code leads to the generation of an extra URI tag in the code. This has been observed only with variables.
The URI tag is of the form:
//@C#_transform [
// _URI=platform:/resource/UML%20project/Blank%20Model%20t1.emx#_cd19cKJhEdurjYIa4vhLGA//]
Running reapply multiple times leads to more URI tags being generated in the C# file.
Workaround:
There is no known workaround for this issue.
If @generated tag for a generated setter is removed, and its type is changed in code before re-running the UML-to-C# transform, an extra setter is generated.
Workaround is to make the type change in the model.
When UML-to-C# transformation is run with Replace UML Elements option chosen enumeration literals present in the UML model are not replaced. If an enumeration E has two literals, L1 and L2, and E is contained by package p, then after running the transformation enumeration E gets correctly replaced by a shortcut to the C# enumeration generated in the code; but the literals L1 and L2 appear to be contained in package p after the transformation.
Workaround:
There is no known workaround for this issue.
XDE C# Code Model Importer (File -> Import -> Other -> XDE .Net Solution) does not migrate the setters of C# indexers correctly in some cases. Importing a C# project contained in an XDE .NET solution by specifying the corresponding UML model (.emx file; imported using XDE Base Model Importer) and then running the UML-to-C# transformation with the migrated model as the source and the migrated project as the target may not result in the same setters that existed in the code before the process. In some cases, the setter is not generated at all and in some cases, the setter is generated with an extra parameter (with name value) which results in a compilation error--because C# does not allow the name value to be used for an explicit parameter of the setter.
Workaround:
There is no known workaround for this issue.
When a UML-to-C# transformation is run with the Replace UML elements option on the Common page of the transformation configuration editor and a mapping model is used, the transformation does not replace the UML elements in the source model for which the source files are generated in folders. Only the UML elements for which the code is generated under the root folder of the target C# project are replaced by shortcuts to the corresponding elements in the code.
Workaround:
After running the UML-to-C# transformation for the first time the UML model and the mapping model will be marked dirty; run the transformation once again without making any change to the transformation configuration or the mapping model. Now all the UML elements in the model will be replaced by shortcuts.
When Rational XDE code models are imported, any so-called "assembly models" (also known as "system models" or "reference models") that are referenced by the code models are also imported and referenced within the Eclipse-based environment. As a result, opening the imported code model may take a long time.
Workaround:
Delete the imported assembly models once code models have been successfully imported. This workaround can be used whether you choose to replace the UML elements of the imported code model with direct code references and use the "mixed modeling" theory of operations, or you choose instead to preserve the UML elements of the code model and use the “true round-trip engineering (RTE)” theory of operations (iterative forward and reverse transformations and reconciliation).Effects of the Workaround:
1. Deleting the assembly models will make the opening and editing of the imported code model(s) much faster.2. The product may display warnings or “errors” about “missing” referenced models when the imported code model is opened. These warnings can be ignored.
3. The product may display warnings or “errors” about "missing" referenced models when validation is run against the imported code model. These can be ignored.
Example:
Suppose we have a Visual Studio 2003 C# project called Project1 with its corresponding XDE base model "Project1.mdx". Assume that this model references the following five system models: System.mdx, mscorlib.mdx, System.Data.mdx, System.Web.mdx, and System.Drawing.mdx.- Begin by migrating the VS 2003 project to VS 2005, using the VS 2005 migration utility
Import the project model Project1.mdx, using XDE model import (File > Import > Other > Rational XDE Model). You will choose to import all its referenced models (the importer requires this to assure model integrity during the import process).- This results in the creation of six .emx files in the Eclipse workspace which are “Project1.emx,” “System.emx mscorlib.emx,” “System.Data.emx,” “System.Web.emx,” and “System.Drawing.emx.”
- Next import the Visual Studio 2005 Solution (File > Import > Other > .NET Solution). The legacy .mdx model will be detected in that solution, and you will be asked to provide the name of the imported code models, in this case “Project1.emx.” At this time, you are also given the option of whether to replace the UML elements of Project1.emx with references to the code in the imported Solution. Use that option if you want to practice “mixed modeling,” but don’t use it if you wish to practice “true RTE.”
- The import process is now complete. When you next open model “Project1.emx” the UML framework will try to load all five of the referenced models, and to resolve the references from elements in "Project1.emx" to the elements in those referenced models. This is the cause of the delay in opening and working with the imported XDE model.
- To relieve the performance penalty, simply select and delete each of the five imported assembly models. As noted above, this will improve performance, and will result in appearance of warnings or “errors” when opening and validating “Project1.emx” but it will not negatively impact any of the modeling and transformation operations that you may want to perform with “Project1.emx”
If a C#-to-UML transformation is run in silent mode and all other options are selected in the transformation configuration editior, the transformation fails. Specifically, this happens when the new changes into the target model contain stereotyped elements (for example, <<CSharpStruct>>) that are to be merged in silent mode. This issue will be fixed in a future release.
If a C#-to-UML transformation is run on a source file containing overloaded operators like != or == to get these operators into the target model, on subsequent execution of the transformation without any changes to the code, the fuse dialog box should not show any changes. However, the fuse dialog box incorrectly shows changes relating to the renaming of parameters.
This issue will be fixed in a future release.
For C# transforms, a mapping model should be used to specify just the filesystem heirarchy of how the code should be organized. Renaming of classes, interfaces, etc., through mapping model is not supported yet. The design of a C# application can be done in 2 perspectives:
1. Logical system design
2 Physical system design (will be specified as mapping model)
Logical design model will normally contain the various namespaces, the various types and the inheritance relationship, attributes, functions, etc.
The physical design perspective using a mapping model includes the deployment information for the C# transformation. This means that you are able to control the way you want the transformation to place the various logical constructs in different files. By default, without a mapping model, the UML-to-C# transformation will generate each type, for example a class or an interface, in a file whose name is the same as the type's name but placed in the Visual Studio project's root folder. For example, class "MyClass" will be generated in a file called "MyClass.cs" in the absence of a mapping model. However, if the user wants the code to be generated in a file called "Test.cs", he should specify this in the mapping model through an artifact which manifests that class "MyClass".
The mapping model is used only to specify the folder or file heirarchy for generating code. No renaming can occur by using a mapping model.
Note that both logical design (transformation source model) and physical design (transformation mapping model) are just UML models. The only difference is that:
- UML packages in the logical source model represent C# namespaces.
- UML packages in the mapping model represent folders on file system.
If the UML-to-C# transformation is undone after running the transformation with a Mapping model option enabled and with the Replace UML elements option checked, the mapping model will be in an incorrect state. If the UML-to-C# transformation is run again with the incorrect mapping model, the C# files are generated in an incorrect location.
Workaround:
The user has to manually undo the changes to the mapping model before running the UML-to-C# transformation again. One way this can be done is to close the mapping model and choose not to save the changes.
IBM Rational Software Support provides you with technical assistance.
For contact information and guidelines or reference materials that you will need when you require support, read the IBM Software Support Handbook.
For FAQs, lists of know problems and fixes, and other support information, visit the IBM Rational Software Support Web site.
For Rational software product news, events, and other information, visit the IBM Rational Software Web site.
Before you contact IBM Rational Software Support, gather the background information that you will need to describe your problem. When describing a problem to an IBM software support specialist, be as specific as possible and include all relevant background information so that the specialist can help you solve the problem efficiently. To save time, know the answers to these questions:
- What software versions were you running when the problem occurred?
- Do you have logs, traces, or messages that are related to the problem?
- Can you reproduce the problem? If so, what steps do you take to reproduce it?
- Is there a workaround for the problem? If so, be prepared to describe the workaround.
© Copyright IBM Corporation 2007. All Rights Reserved.
This information was developed for products and services offered in the U.S.A. IBM may not offer the products, services, or features discussed in this documentation in other countries. Consult your local IBM representative for information on the products and services currently available in your area. Any reference to an IBM product, program, or service is not intended to state or imply that only that IBM product, program, or service may be used. Any functionally equivalent product, program, or service that does not infringe any IBM intellectual property right may be used instead. However, it is the user's responsibility to evaluate and verify the operation of any non-IBM product, program, or service.
IBM may have patents or pending patent applications covering subject matter described in this documentation. The furnishing of this documentation does not give you any license to these patents. You can send license inquiries, in writing, to:
IBM Director of Licensing
IBM Corporation
North Castle Drive
Armonk, NY 10504-1785
U.S.A.
For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property Department in your country or send inquiries, in writing, to:IBM World Trade Asia Corporation
Licensing
2-31 Roppongi 3-chome, Minato-ku
Tokyo 106, JapanThe following paragraph does not apply to the United Kingdom or any other country where such provisions are inconsistent with local law: INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OR CONDITIONS OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of express or implied warranties in certain transactions, therefore, this statement may not apply to you.
This information could include technical inaccuracies or typographical errors. Changes are periodically made to the information herein; these changes will be incorporated in new editions of the publication. IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this publication at any time without notice.
Licensees of this program who wish to have information about it for the purpose of enabling: (i) the exchange of information between independently created programs and other programs (including this one) and (ii) the mutual use of the information which has been exchanged, should contact:
Intellectual Property Dept. for Rational Software
IBM Corporation
20 Maguire Road
Lexington, MA
02421-3112
USASuch information may be available, subject to appropriate terms and conditions, including in some cases, payment of a fee.
The licensed program described in this documentation and all licensed material available for it are provided by IBM under terms of the IBM Customer Agreement, IBM International Program License Agreement or any equivalent agreement between us.
Information concerning non-IBM products was obtained from the suppliers of those products, their published announcements or other publicly available sources. IBM has not tested those products and cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of those products.
All statements regarding IBM's future direction or intent are subject to change or withdrawal without notice, and represent goals and objectives only.
Trademarks and service marks
The following terms are trademarks of International Business Machines Corporation in the United States, other countries, or both:
- developerWorks
- IBM
- Rational
Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.
Microsoft, Windows, and Windows NT are trademarks of Microsoft Corporation in the United States, other countries, or both.
Intel and Pentium are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States, other countries, or both.
UNIX is a registered trademark of The Open Group in the United States and other countries.
Linux is a trademark of Linus Torvalds in the United States, other countries, or both.
Other company, product or service names, may be trademarks or service marks of others.