Search

This paper presents a conceptual model of an event-processing network for expressing the event-based interactions and event-processing specifications among components. The model is based on event-driven architecture, a pattern promoting the production, detection, consumption, and reaction to events. The motivation is the lack of standardization in the areas of configuring and expressing the event-processing directives in event-driven systems. Some existing approaches are through Structured Query Language, script languages, and rule languages, and are executed by standalone software, messaging systems, or datastream management systems. This paper provides a step toward standardization through a conceptual model, making it possible to express event-processing intentions independent of the implementation models and executions. It is a unified model serving as a metamodel to these existing approaches.

IBM products increasingly implement a service-oriented architecture (SOA), in which programmers build services, use services, and develop solutions that aggregate services. IBM Software Group middleware products and tools support the development and deployment of SOA solutions, and increasingly make functional interfaces between components and products visible through a service model. Software Group components will increasingly use SOA standards for intracomponent communications. Our move to SOA encompasses both the programming model and lower-level infrastructure software, for example, systems-management and storage-management application programming interfaces and functions. This paper concisely defines the IBM SOA programming model and the product architecture that supports it. We provide the motivation for our programming-model and design decisions. This paper also focuses on the architectural concepts that underlie our programming model and product architecture.

This paper presents the design and implementation of intraGrid, an experimental grid based on the Globus ToolkitTM and deployed on the IBM intranet. The architecture and the main components of intraGrid are described. Then, the major technical challenges and their solutions are reviewed, including software packaging and distribution, the interface for administrative tasks, and the design and implementation of the three major services: information services, management services, and job submission services. The paper also describes the extensions and modifications to intraGrid that were required to create the ISD grid, a grid that is used for joint projects with customers and thus requires access by external users. The paper reviews the use of intraGrid by various teams of IBM researchers to date and outlines the plans for future applications. The work in progress to migrate the intraGrid to an OGSA-based (Open Grid Services Architecture-based) grid is also described.

During recent years, we have witnessed a major paradigm shift in distributed computing principles, with a focus towards service orientation, open standards integration, collaboration, and virtualization. One particular area of interest centers on the evolution of grid computing principles into the mainstream of distributed computing and Web services. In this paper, we focus our analysis on this evolution and the significance of achieving some form of standardization of grid-computing architecture principles. This paper presents the technology standards that are driving major grid initiatives and explains in simple terms how these standards and technologies are aligned with the IBM on demand business concepts. In addition, we discuss the recent Web services specifications related to stateful resources (i.e., resources whose behavior is defined with respect to their underlying state) and how these standards relate to grid computing. We conclude with discussions exploring major aspects of grid-computing adoption models and some significant attributes that influence the transformation, collaboration, and virtualization features of these models.

This issue of the IBM Systems Journal explores a broad set of ideas and approaches to autonomic computing--some first steps in what we see as a journey to create more self-managing computing systems. Autonomic computing represents a collection and integration of technologies that enable the creation of an information technology computing infrastructure for IBM's agenda for the next era of computing--e-business on demand. This paper presents an overview of IBM's autonomic computing initiative. It examines the genesis of autonomic computing, the industry and marketplace drivers, the fundamental characteristics of autonomic systems, a framework for how systems will evolve to become more self-managing, and the key role for open industry standards needed to support autonomic behavior in heterogeneous system environments. Technologies explored in each of the papers presented in this issue are introduced for the reader.

This issue of the IBM Systems Journal explores the topic of building ease of use into the IBM user experience with hardware, software, Web sites, and services. This paper provides an overview of the process and organizational transformation that IBM has gone through in improving the user experience with our offerings. IBM's process for building ease of use into the user experience is described and two versions of the process are introduced and contrasted. The IBM User-Centered Design (UCD) approach, which has been used for the last several years, is contrasted with the traditional approach to the development of offerings. A recent major enhanced version of the process, called User Engineering (UE), which is optimized for the IBM e-business on demandTM strategy, is contrasted with the existing UCD process. The key elements of our enablement, leadership, and guidance strategy for these processes are outlined, including mission, process integration, education and training, communication, collaboration, and tools and technology. An overview of the papers in this issue is also provided.

Software systems are increasing in size and complexity and, subsequently, are becoming ever more difficult to validate. Finite state verification (FSV) has been gaining credibility and attention as an alternative to testing and to formal verification approaches based on theorem proving. There has recently been a great deal of excitement about the potential for FSV approaches to prove properties about hardware descriptions but, for the most part, these approaches do not scale adequately to handle the complexity usually found in software. In this paper, we describe an FSV approach that creates a compact and conservative, but imprecise, model of the system being analyzed, and then assists the analyst in adding additional details as guided by previous analysis results. This paper describes this approach and a prototype implementation called FLAVERS, presents a detailed example, and then provides some experimental results demonstrating scalability.

IBM is supporting Enterprise JavaBeansTM (EJB) across its application server products. Together with related JavaTM technologies, EJB provides a standard programming model and set of services across major server platforms. This paper presents an overview of the EJB architecture and describes the technical strategy and design approach for the EJB capability that is being delivered in the latest release of the Customer Information Control System (CICS®). It explores why CICS customers want to use enterprise Java technology, identifies some critical success factors for the CICS support of EJB, and explains its architecture in terms of a portable EJB container executing within the existing CICS run-time infrastructure, focusing on aspects such as transaction management, Java virtual machine reuse, and workload management. Application development tooling is then discussed, together with the strategy for exploiting tools such as VisualAge® for Java. Finally, the paper considers future work and challenges for CICS in this area.

This paper describes the Product Advisor component of the IBM WebSphereTM Commerce Suite. Product Advisor consists of a set of tools to be used by marketing personnel to generate, without programming help, Web shopping applications involving a product catalog. The user interfaces generated by these tools cover an extensible set of shopping paradigms including parametric search, a knowledge-based "virtual salesperson," and side-by-side comparison shopping. The paper also describes the JavaTM infrastructure that supports the Product Advisor tools: servlets, JavaBeansTM and JavaServer PagesTM in the server, and applets in the client. Furthermore, it describes the implementation techniques used for rendering dynamic data: a data container hierarchy, a data type hierarchy, and presentation beans.

My intent in this commentary was not to describe every paper related to software development in the 38-year publication history of the Journal, nor to claim that they were all significant. There are many more papers that fit in the sequences described. There are also other important topics that have not been mentioned—for example, the papers describing the methodologies and economic benefits of software reuse. This journal does represent the ebb and flow of ideas as practiced by dedicated professionals whose careers are devoted to the effective and efficient production of software. Along the way it recorded key turning-point ideas that were expanded and modified and that still play a crucial role in how we build software.

A process for preventing defects has been gaining momentum in the IBM Corporation as a way to improve quality and increase productivity. The Communications Programming Laboratory in Research Triangle Park, North Carolina (near Raleigh), has been implementing the process for the past six years and has realized a 54 percent reduction in errors. This paper documents experiences at the IBM Myers Corners Laboratory MVS Interactive programming area in putting the Defect Prevention Process theories into practice. This paper begins with the proposal to adopt the Defect Prevention Process at the Myers Corners Laboratory in Poughkeepsie, New York, and our experiences thus far. It is our belief that other organizations can benefit from our experiences by understanding how the Defect Prevention Process can be adapted to best meet the needs of any organization.

It is important to have guidelines for the scope and breadth of papers being prepared for submission to a technical journal. This article provides information about the IBM Systems Journal and offers guidelines for prospective authors. The Systems Journal, and its audience are described, and the processing of papers is discussed, along with suggestions for content and structure. To further aid the writer in preparing clear, complete papers of high quality, a bibliography of technical writing references is included.

VM/Pass-Through, an interactive networking facility, has gained widespread acceptance within IBM and with IBM customers. Pass-Through allows a single terminal access to many different computers, including those at distant locations. In building Pass-Through, and in observing its growing use, we have had oapnp ortunity to study the practical implications of this facility and of our approach to its design. This paper is divided into two parts. The first, an introduction to Pass-Through networking, describes features of the system, supported configurations, and use of Pass-Through within the IBM Corporation. A brief history of Pass-Through's development is also provided. In the second part of the paper, Pass-Through is used to motivate a technical discussion of interactive network technology and virtual machine subsystems. Topics covered include appropriate use of the virtual machine environment, choice of routing strategy, and performance considerations. Although the introductory portions of the paper presume no prior knowledge of computer network or operating system technology, the subsequent technical discussions do depend on a basic understanding of these areas.

This paper describes IBM's use of Recommendation X and related recommendations of the International Telegraph and Telephone Consultative Committee. After reviewing the development history of X and some of the motivations for using it, the paper gives an overview of packet-switched data networks. The reader is then given a brief technical description of Recommendation X and some other recommendations used in conjunction with X. The architectural relationships between X and IBM's Systems Network Architecture (SNA) are described for packet-switched X connections between SNA and non-SNA nodes. Specific elements of Recommendation X used in SNA nodes are defined. After several IBM products that support X and some of the related recommendations are described, IBM's equipment for testing the X interface is discussed.

The first of a five-part series of papers on IMS/VS, this paper discusses the architecture, goals, and objectives of that information management system, the purpose of which is to facilitate Data Base/Data Communication applications. Subsequent papers present data base facilities, batch processing, data communication, and transaction processing in greater depth.

EAS-E is an application development system based on an entity-attribute-set view of system description. It consists of a procedural language for manipulating data base and main storage entities, and direct (nonprocedural) facilities for interrogating and updating data base entities. The EAS-E software itself was implemented with the entity-attribute-set view. This paper reviews some of the EAS-E features and considers some of its implementation details. This paper is both an introduction to the EAS-E software architecture and an example of the usefulness of the entity-attribute-set view.

There has long been a need for better definition of the audit and control aspects of data processing applications. This paper attempts to satisbt hat need and thereby provide a framework for improving communication between systems analysts and computer scientists. It introduces the concept of spheres of control, which are logical boundaries that exist in all data processing systems, whether manual or automated. The paper describes their essential properties and portrays them as they relate to each other in the batch, on-line, and in-line processing environments. Included are spheres of control that define process bounding for such purposes as recovery, auditing, process commitment, and algorithm (procedure) replacement.

Service-oriented modeling and architecture (SOMA) has been used to conduct projects of varying scope in multiple industries worldwide for the past five years. We report on the usage and structure of the method used to effectively analyze, design, implement, and deploy service-oriented architecture (SOA) projects as part of a fractal model of software development. We also assert that the construct of a service and service modeling, although introduced by SOA, is a software engineering best practice for which an SOA method aids both SOA usage and adoption. In this paper we present the latest updates to this method and share some of the lessons learned. The SOMA method incorporates the key aspects of overall SOA solution design and delivery and is integrated with existing software development methods through a set of placeholders for key activity areas, forming what we call solution templates. We also present a fractal model of software development that can enable the SOMA method to evolve in an approach that goes beyond the iterative and incremental and instead leverages method components and patterns in a recursive, self-similar manner opportunistically at points of variability in the life cycle.

The current approach to the design, maintenance, and governance of service-oriented architecture (SOA) solutions has focused primarily on flow-driven assembly and orchestration of reusable service components. The practical application of this approach in creating industry solutions has been limited, because flow-driven assembly and orchestration models are too rigid and static to accommodate complex, real-world business processes. Furthermore, the approach assumes a rich, easily configured library of reusable service components when in fact the development, maintenance, and governance of these libraries is difficult. An alternative approach pioneered by the IBM Research Division, model-driven business transformation (MDBT), uses a model-driven software synthesis technology to automatically generate production-quality business service components from high-level business process models. In this paper, we present the business entity life cycle analysis (BELA) technique for MDBT-based SOA solution realization and its integration into service-oriented modeling and architecture (SOMA), the end-to-end method from IBM for SOA application and solution development. BELA shifts the process-modeling paradigm from one that is centered on activities to one that is centered on entities. BELA teams process subject-matter experts with IT and data architects to identify and specify business entities and decompose business processes. Supporting synthesis tools then automatically generate the interacting business entity service components and their associated data stores and service interface definitions. We use a large-scale project as an example demonstrating the benefits of this innovation, which include an estimated 40 percent project cost reduction and an estimated 20 percent reduction in cycle time when compared with conventional SOA approaches.

This paper surveys the current state of information technology (IT) availability on the IBM System p5® server platform, then describes how selected hardware and software features of the next-generation IBM Power™ Systems platform (by which we specifically mean IBM POWER6™ processor-based systems running the IBM AIX® 6 operating system) will enable client IT organizations to more closely approach true continuous availability. Also presented is information on several IT management disciplines that are critical to achieving high levels of availability. The objective is to enable accelerated adoption and success with the new Power Systems platform by explaining how the technologies can be used to improve IT availability. We define the underlying dependencies required to implement the new live partition mobility and the live application mobility features and show how the environment can be best designed for planned maintenance. Until now, the concept of server virtualization in the UNIX® environment has been limited to a single server, but the Power Systems platform extends the virtualization realm. A brief discussion is given comparing software clustering with the new mobility features and illustrating how they are complementary.

In this paper we focus on the integration of domain-specific information technology (IT) processes and tools in the IBM Service Management architecture, a service-oriented software architecture that automates and simplifies the management of IT services. The IT processes are based on a generalized concept of service management that incorporates best practices, such as those defined by the Information Technology Infrastructure Library® (ITIL®). The IT tools are the operational management tools in various domains, such as monitoring, network management, and provisioning. We refer to implementation of IT processes as Process Managers. We first describe three typical scenarios in which integrating the domain-specific IT processes through the use of PMs increases the level of automation. Then, we illustrate the benefits to be gained from integrating IT processes and tools and describe the design of four PMs: the Service Level Process Manager, the IBM Tivoli Availability Process Manager, the IBM Tivoli Capacity Process Manager, and the IT Service Continuity Process Manager.

Information technology service management (ITSM) codifies and supports the current best practices in the management and governance of existing IT infrastructures, including the computing infrastructure that underlies service delivery. Once ITSM tools have identified and structured current best practices, there is a significant opportunity to simplify those practices, and thereby ITSM in general, by introducing self-managing resources (SMRs). SMRs and related technologies allow increased delegation of existing ITSM tasks from humans to autonomic managers and the restructuring of ITSM activities through process modification and task replacement or elimination. In particular, the use of SMRs and virtualization can convert many activities that currently require multiple planning, validation, and approval tasks into routine activities that have a simpler task flow, in much the same way that modern file systems have transformed file-layout tasks that formerly required a skilled administrator into tasks that are handled entirely and transparently by the operating system. This paper briefly describes the general principles of SMRs, explores a number of potential impacts that this technology will have on ITSM processes, and illustrates these ideas with an analysis of how selected ITSM flows may be transformed.

The IT Infrastructure Library® defines a set of best practices to align information technology (IT) services to business needs and constitutes the framework for IT service management (ITSM). This framework helps organizations manage their IT services using standard design patterns and the requisite customization. In this paper, we discuss critical contributions that autonomic computing offers to the definition and implementation of an ITSM architecture and infrastructure. We first introduce key architectural patterns and specifications of autonomic computing as they relate to an ITSM logical architecture. We then show how autonomic computing delivers value through a set of ITSM-based case studies that address problem determination, impact assessment, and solution deployment.

In this paper we propose an approach to software development that focuses on architecture decisions and involves the use of ontology. In this approach the architecture is captured by an instance of an ontology. The ontology has four major components: architecture assets, architecture decisions, stakeholder concerns, and an architecture roadmap. We illustrate our approach through a case study involving a real-time credit-approval system and the use of Protege, an open-source ontology development tool.

Rational Software Architect (RSA), the latest generation Rational® modeling tool, is based on EclipseTM Modeling Framework (EMF) technology. RSA offers all the important features of the previous generation of Rational modeling tools, while supporting a much wider range of model formats. RSA diagrams can be used in editing and displaying models derived from any EMF-based metamodel. The combination of RSA and EMF provides a powerful capability for integrating domain-specific languages (DSLs) with UML® in a single toolset. This paper describes how RSA and EMF provide these capabilities and explores some of the ways that IBM is currently exploiting them.

Despite year-to-year increases in R & D budgets, the number of successful NCEs (new chemical entities) has continued to decline. Drug companies are looking into new ways to make research processes more efficient, to manage information better, and to improve collaboration among research groups. This shift from an artisan approach to an organized, streamlined discovery process is often termed the "industrialization of discovery processes." This paper presents an approach to industrializing drug discovery that involves the formal modeling of research processes at several layers of abstraction, mappings between adjacent layers, and an implementation of this hierarchy using information technology-level execution elements. This approach is applied to the assay development phase of the drug discovery process. First, a business operations model is built by identifying the business artifacts, developing models for the life cycles of these artifacts, and then creating a comprehensive model that combines these life-cycle models and their interactions. Using the concept of adaptive business objects, a solution composition model that expands on the business operations model is developed. This model is then mapped into an executable platform-specific implementation by using the IBM WebSphere® platform. Our prototype system was built and validated as a joint effort between IBM Research and Bayer HealthCare.

Modeling and simulation of business processes is a powerful capability for analysis of business solutions in a service-oriented architecture (SOA). In this paper, we describe analysis techniques that are applicable during the design-time and runtime development of business solutions to estimate business process performance. During the design phase, our analysis framework converts the business process model, which is annotated with additional information, into a more granular model by using an underlying middleware model that describes all the middleware components in an SOA. The resulting model can then be evaluated in terms of performance and cost. We discuss a prototype implementation that uses WebSphere® Business Integration (WBI) Modeler and present the results of a case study. After the design phase, several services required to support the business process execution may exist, but others may need to be newly developed. Our runtime simulation framework supports this by allowing users to simulate implementation models consisting of real and simulated services for function and performance testing. Furthermore, when new services are available, they can be easily included in the analysis by switching from the Simulator to the new service. We discuss a prototype implementation for this capability that uses the Process Choreographer of WBI Server Foundation and present results of a case study.

The Web Services standard is becoming the lingua franca for loosely coupled distributed applications. As the number of nodes and the complexity of these applications grow over the coming years, it will become more challenging for developers to understand, debug, and optimize them. In this paper, we describe Web Services Navigator, a visualization tool that fosters better understanding of service-oriented architecture (SOA) applications. We draw on our experience with real SOA applications to show how this tool has been applied to practical problems ranging from business logic misunderstandings to performance bottlenecks to syntax and semantic errors. Web Services Navigator helps to solve these problems by visualizing how applications really execute, enabling business owners, application designers, project managers, programmers, and operations staff to understand how their applications actually behave. We sketch the architecture of Web Services Navigator, outline how it reconstructs application execution from event logs, and describe how users interactively explore their applications using its five linked views.

Aspect-oriented programming (AOP) is an exciting new development in the field of software engineering. The open-source AspectJ® project has taken a leading role in defining what an aspect-oriented programming language should look like and in building tools that enable aspect-oriented techniques to be employed in the development of large-scale commercial software. IBM both contributes to the development of AspectJ and uses it internally with its accompanying IDE (integrated development environment) support, AspectJ Development Tools (AJDT). This paper provides an introduction to aspect-oriented programming using AspectJ and AJDT. We also discuss the role that open source (and being an open-source project) has played in the ongoing development of AspectJ, and how this has facilitated a level of collaboration and exploitation that would not have been possible otherwise.

As an open-source operating system, LinuxTM made an impressive mark in the history of computing when interest from the corporate IT industry soared toward the end of 1990s. Linux, however, still faces some challenges in the areas of high performance, especially on symmetrical multiprocessor systems. This paper describes an initiative to investigate Linux performance using IBM WebSphere® Application Server software. The primary goal was to study how Linux performance and scalability could be improved by applying some of the new enhancements put into the kernel as well as by fine-tuning the middleware. We describe the results of this investigation and explain in detail how issues were resolved through our collaboration with the open-source community as well as within the IBM product teams.

The tools, methods, and techniques used to create business architecture are often quite different from those used in developing software architecture. This "impedance mismatch" or gap is aggravated by volatile business requirements that need to be satisfied in operational systems. Bridging this gap not only allows a more seamless transition and faster time to market, but also enables and empowers business analysts to contribute their deep subject matter expertise at many phases of the software-development life cycle, a critical aid in fruitful application development. This paper presents a case study of a project with the U.S. Patent and Trademark Office (USPTO), which explored the potential for reducing duplication of effort among patent offices by sharing work products. IBM provided an innovative method to support the analysis, the "business compiler," a tool that implements Grammar-oriented Object Design (GOOD). GOOD is a method for creating and maintaining dynamically reconfigurable software architectures driven by business-process architectures. The business compiler was used to capture business processes within real-time workshops for various lines of business and create an executable simulation of the processes used.

Colombo is a lightweight platform for developing, deploying, and executing service-oriented applications. It provides optimized, native runtime support for the service-oriented-computing model, as opposed to the approach of layering service-oriented applications on a legacy runtime. This approach allows Colombo to provide high runtime performance, a small footprint, and simplified application development and deployment models. The Colombo runtime natively supports the full Web Services (WS) stack, providing transactional, reliable, and secure interactions among services. It defines a multilanguage service programming model that supports, among others, JavaTM and Business Process Execution Language for Web Services (BPEL4WS) service composition, and offers a deployment and discovery model fully based on declarative service descriptions (Web Service Description Language [WSDL] and WS-Policy). In this paper we describe these and other aspects of the architecture, design principles, and capabilities of the Colombo platform.

MMBase is an open-source content management system (CMS) with portal functionality, originally created by the Dutch public broadcaster VPRO. MMBase, which is particularly suited for multimedia environments, is based on the concept of presenting objects on different channels. The system is highly platform-independent and has adopted standards such as JavaTM, XML (Extensible Markup Language), J2EETM (JavaTM 2 Enterprise Edition) and JDBCTM. Initially used only by public broadcasters, MMBase has been adopted by a growing number of organizations. This paper presents the history of MMBase, introduces its community of users, and discusses its architecture, focusing on the innovative technical process underlying MMBase and its organizational structure. We identify and discuss three challenges facing the user community: the need to motivate and organize both users and developers to contribute to the development of MMBase, the need to make the software modular, and the need for more and better documentation of the MMBase core and its component packages.

This paper describes the evolution of the JikesTM Research Virtual Machine project from an IBM internal research project, called Jalapeno, into an open-source project. After summarizing the original goals of the project, we discuss the motivation for releasing it as an open-source project and the activities performed to ensure the success of the project. Throughout, we highlight the unique challenges of developing and maintaining an open-source project designed specifically to support a research community.

The term "policy-based computing" refers to a software paradigm that incorporates a set of decision-making technologies into its management components in order to simplify and automate the administration of computer systems. A significant part of this simplification is achieved by allowing administrators and operators to specify management operations in terms of objectives or goals, rather than detailed instructions that need to be executed. A higher level of abstraction is thus supported, while permitting dynamic adjustment of the behavior of the running system without changing its implementation. This paper focuses on the application of the policy-based software paradigm to the automated provisioning architecture described elsewhere in this issue. We show how the use of policies can enhance utility computing services by making them more customizable and more responsive to business objectives.

In this paper we introduce the concept of service domain, to be used as a major building block for implementing service-oriented architectures in large computing grids in which tens or hundreds of services are offered to customers. A service domain maps a collection of comparable or related services to a single logical service. We describe an architecture for service domains that uses a set of policy rules for managing the collection of services and that automatically dispatches the "best" service available to satisfy user requests. The architecture has built-in autonomic properties in that a service domain implementation monitors the events within its control and triggers adjustment actions in its member services, including recovery from service failure and handling of topology changes. We describe a reference Implementation of the service domain architecture that is publicly available as a development toolkit, and we discuss its application in the implementation of a large grid now in progress.

In this paper we present our vision of an information infrastructure for grid computing, which is based on a service-oriented architecture. The infrastructure supports a virtualized view of the computing and data resources, is autonomic (driven by policies) in order to meet application goals for quality of service, and is compatible with the standards being developed in the technical community. We describe how we are implementing this vision in IBM today and how we expect the implementation to evolve in the future.

In this paper we describe a framework for providing customers of Web services differentiated levels of service through the use of automated management and service level agreements (SLAs). The framework comprises the Web Service Level Agreement (WSLA) language, designed to specify SLAs in a flexible and individualized way, a system to provision resources based on service level objectives, a workload management system that prioritizes requests according to the associated SLAs, and a system to monitor compliance with the SLA. This framework was implemented as the utility computing services part of the IBM Emerging Technologies Tool Kit, which is publicly available on the IBM alphaWorksTM Web site.

Performance and scalability are critical elements for a successful Web site and therefore, are fundamental design criteria for the IBM WebSphere® platform. This paper focuses on the evolution of IBM WebSphere Application Server performance and scalability features, the improvements that were achieved, and directions for future work. There are three design principles underlying the success of WebSphere: (1) optimize the design for the predominant (no-failure) case, (2) make finite resources appear infinite, and (3) minimize the number of interprocess calls. We illustrate the application of these design principles in key areas, including workload management, Hypertext Transfer Protocol (HTTP) session management, back-end connection management, session data and content caching, and Enterprise JavaBean™ (EJB™) design and deployment patterns.

Business integration is a set of capabilities that characterize service-oriented architectures for e-business solutions. These capabilities include the ability to integrate and manage business operation systems, enterprise information assets, business partners, and a collaborative network of decision makers to address specific business problems. WebSphere® Business Integration is an IBM software platform that embodies these capabilities to offer rapid time to value for delivering integrated e-business solutions. In this paper, we provide an overview of the WebSphere Business Integration platform-- the architecture, programming model, tools, and runtime.

IBM's Unstrutured Information Management Architecture (UIMA) is a software architecture for developing and deploying unstructured information management (UIM) applications. In this paper we provide a high-level overview of the architecture, introduce its basic components, and describe the set of tools that constitute a UIMA development framework. Then we take the reader through the setps involved in building a simple UIM application, thus highlighting the major UIMA concepts and techniques.

Modern n-tier applications are developed using components implemented in many different technologies, including HTML, Java™, JavaServer Pages™ (JSP™), Enterprise JavaBeans™, connectors, COBOL or PL/1 programs, and relational database schemas. Creating an effective integrated development environment (IDE) for use in programming these applications presents some special challenges because a large number of different tool technologies have to be tightly integrated in support of development task flows. In order to meet these challenges, the Eclipse Platform was designed to serve as the common basis for diverse IDE-based products, providing open APIs (application programming interfaces) to facilitate this integration. This paper describes the overall architecture of the Eclipse Platform and the www.eclipse.org open source organization and consortium created to facilitate broad industry adoption of this platform.