Architected RAD: Tackling the challenges of on demand business

Transcription

1 Architected RAD: Tackling the challenges of on demand business by Arun Gupta Chief Technologist, Enterprise Applications Rational Software IBM Software Group (186 K) It's an inescapable fact: Companies whose processes depend on software must be able to adapt their software assets as rapidly as possible to meet challenges and opportunities as they come along. The ability to generate reliable, scalable business applications has a direct correlation with the ability to respond to both internal and external customer demands. And for many companies, business applications are the most critical software assets, because they reflect the business's core competency and are essential for maintaining a competitive edge. Today's smart companies are connecting business applications to their customers, vendors, and other partners; they're connecting the many departments, locations, and people within the enterprise; and they're making the growing enterprise responsive to the needs of the business. These applications need to be agile, so they can adapt to changes in the business and advances in technology. They need to extend existing mainframe systems and enterprise applications to the Web and to the outside world. And they need to be high performance, scalable, manageable, and highly secure. Building such applications is a tall order for many in-house development teams, which typically have essential domain knowledge about how the business works but may also have legacy technology skills. This is one of the major challenges of the new business environment that IBM describes as e-business on demand. With the acquisition of Rational Software, IBM adds a powerful way for companies to meet this challenge. IBM Rational's latest application development tool, IBM Rational Rapid Developer, enables teams to add sophisticated J2EE development (1 of 22) [5/19/2003 3:28:38 PM]

2 capabilities to their toolbox without extensive retraining. This article will focus on how this new product can help teams achieve "architected rapid application development" (ARAD) in the new on demand environment. What is architected RAD? Simply described, ARAD is Rapid Application Development (RAD) that has grown up to meet the needs of development teams charged with creating enterprise class applications for on demand business. Picture a team of eleven people working on an enterprise application -- a project leader, one analyst, eight developers, and one technology architect. Whereas RAD focused only on the developers, ARAD provides a unified environment for all these team members that comprises all the elements and capabilities essential to software development success: a unified process; business modeling via the Unified Modeling Language (UML); rapid application development; integration of legacy and enterprise systems; and scalable n-tier development. We'll begin by describing these elements and capabilities and then take a look at how IBM Rational Rapid Developer puts them into practice. Unified ARAD process One problem with the early RAD approaches was that they lacked a formal process. This led to an ad hoc approach to development, applications that did not meet requirements, and missed deadlines -- if the project wasn't canceled altogether. The Unified ARAD process fills these gaps. First, the process unifies the team by providing roadmaps for application development that include defining process flows, stakeholders, and artifacts, and explaining how they interrelate in order to achieve consistent, on-time delivery of software applications. Second, the Unified ARAD process is a version of the Rational Unified Process, or RUP, that has been optimized for ARAD. It is an agile, rapid, iterative, and time-boxed IBM Rational Rapid Developer -- accelerating on demand applications With IBM Rational Rapid Developer, IT shops can deliver on demand applications in less time and at a lower cost. Staff developers with valuable business domain skills but limited J2EE skills (or outdated technology skills) can quickly train to become skilled n-tier developers using the latest technologies. They can deploy applications with high scalability and performance, and with the flexibility to mix and match technologies as well as adapt to new ones. The repeatable ARAD process helps developers deliver applications with predictability and a high rate of success. IBM Rational Rapid Developer, with its ARAD plug-in for Rational Unified Process, enables an IT shop to transform itself into a powerful strategic enabler for the on demand enterprise. For pricing and availability, click (2 of 22) [5/19/2003 3:28:38 PM]

3 development process that brings traditional here! RAD concepts such as prototyping and joint application development to the world of enterprise applications. It also provides a team-unified platform that supports parallel development, distributed teams, version management, release management, and change management. Business modeling with the UML Early RAD (and non-rad) approaches lacked a focus on the business processes that drive software requirements. Without a clear view of how such processes mapped to business needs, development teams could not accurately target competitive opportunities or improve efficiencies. With Architected RAD, however, analysts on the project team can use UML to analyze business requirements, define business use cases, define the information model for the application -- consisting of business objects and their storage in databases -- and define the business processes and business rules that will drive the application. Rapid application development In today's corporations, most project teams consist of application developers with experience in a variety of coding environments, such as Visual Basic and PowerBuilder, Java and C++, and COBOL. Their experience also covers a diverse array of deployment scenarios, from n- tiered architectures, to client/server, to legacy/mainframe environments. Although they have diverse technology skills, these developers all understand the need to write code at an increasingly rapid pace, and to support requirements that change ever more rapidly as well. With ARAD, companies can leverage the valuable technical and domain skills these developers have acquired through the years to maintain vital legacy applications, but also enable them to quickly develop n-tier applications -- without dealing with the complexities of the underlying n-tier platform. Rapid integration of legacy and enterprise systems Enterprise applications for on demand enterprises are never standalone; they connect to other legacy and mainframe systems across the enterprise and serve as the vital link between the enterprise and its customers and partners. On demand organizations need the ability to quickly construct Web applications that integrate with databases, messaging protocols, and information from a variety of application servers. Then, after the Web application is deployed, the organization needs an efficient approach for maintaining the underlying technologies, which are constantly subject to change. The ARAD process addresses these needs. It supports rapid application integration with J2EE and other new techniques that help teams quickly leverage information from disparate sources. Then, users can select target technologies for deployment without extensive knowledge of J2EE. (3 of 22) [5/19/2003 3:28:38 PM]

4 Scalable n-tier development IBM WebSphere and other n-tier systems allow enterprise applications to scale to the needs of on demand computing -- for example, connecting a large business to millions of customers. With this power, however, comes a complexity that is beyond the scope of most application developers. To fully leverage an extensible n-tier architecture, a project team needs a technology architect -- a person who understands the architecture and knows how to scale up from supporting 1,000 users on a single server to serving millions of users via a 100-server farm. The ARAD process allows the architect to design and fine-tune n-tier patterns, using n-tier components such as JSP, servlets, stateless and stateful session beans, and entity beans. Then, developers who keep their focus on the business can apply these patterns as they create applications to support business processes. The IBM ARAD solution: IBM Rational Rapid Developer IBM Rational Rapid Developer is the new Rational software solution for Architected Rapid Application Development. Although it is new under the Rational brand, it has been in the market for the past three years, and it has been continually refined and updated (to Version 5.01). IBM Rational Rapid Developer provides an integrated application development environment and process that unifies team skills and: Supports model driven development, rapid application development and integration, and architected code construction. Helps development teams rapidly deliver well-architected, executable n-tier business applications without encountering the traditional complexities of the underlying technology platforms. Integrates with the IBM Rational lifecycle toolset and supports the full application development lifecycle. Enables organizations currently struggling with Web or business application backlog to leverage their entire IT workforce toward n- tier, legacy integration, business modernization, and J2EE development projects. To see a brief video clip on how all skills can be put to use in Web-enabled projects, click here for T1 access, or here for 56k modem access. To get a better understanding of this new product's advantages, let's take a look at the essential workflow for a development team using IBM Rational Rapid Developer. IBM Rational Rapid Developer workflow (4 of 22) [5/19/2003 3:28:38 PM]

5 Rational Rapid Developer follows a model-driven approach to application development. In most projects, nine out of ten members of the development team are focused on business process. Application development begins with capturing requirements. Then, as shown in Figure 1, teams take in existing assets: UML models from IBM Rational Rose, DBMS schema and other legacy systems, Web services, components, and so on. They can also leverage frameworks for specific vertical industries. Figure 1: Development teams begin by capturing requirements and assessing existing assets -- or acquiring new ones -- to support the process. The next step focuses on visual modeling. Creating the core UML models is twenty percent of the effort. Rational Rapid Developer provides essential UML models: class, database, business rules, and process models. (For more complete UML modeling, development teams can use IBM Rational Rose or IBM Rational XDE. ) As shown in Figure 2, most of the effort here -- eighty percent -- focuses on visually modeling the application: designing Web, wireless, XML messaging, and Web services transactions. (5 of 22) [5/19/2003 3:28:38 PM]

6 Figure 2: Rational Rapid Developer provides essential UML models, so teams spend most of their time visually modeling the application itself. At this point, the team has visually modeled the complete application, and it resides in an application repository, as depicted in Figure 3. But the application is not yet cast into any specific technology. (6 of 22) [5/19/2003 3:28:38 PM]

7 Figure 3: An application, completely modeled by business-focused developers, resides in the application respository before it is cast onto a chosen technology platform. Now, the other ten percent of the team, the technology experts, come in. They decide how the applications will be constructed and deployed -- for example, whether to use J2EE or Microsoft, and which database, messaging platform, and construction patterns to use. (7 of 22) [5/19/2003 3:28:38 PM]

8 Figure 4: Technology experts are now able to push the application onto the chosen platform, determine patterns and partitioning requirements, and manage changes. Based on choices by the team's technical experts, Rational Rapid Developer automatically constructs the final application in a matter of minutes, and even automatically compiles and deploys it, as depicted in Figure 5. (8 of 22) [5/19/2003 3:28:38 PM]

9 Figure 5: As a final step in an iteration, Rational Rapid Developer automatically compiles and deploys the application. Business-focused developers reap the first benefits from this model-driven process: They get a rapid, productive environment that is easy to learn and use; the applications can adapt quickly to business changes with business owner participation; and the cost of ownership is dramatically reduced. Technology-focused architects also realize significant benefits: They get consistent, high-assurance, high-performance, engineered applications on their choice of technology platforms. They can also adapt new technologies quickly and integrate them with legacy technologies. The complete workflow for this process is illustrated in Figure 6. (9 of 22) [5/19/2003 3:28:38 PM]

10 Figure 6: Rational Rapid Developer covers the complete lifecycle, from requirements gathering to deployment. IBM Rational Rapid Developer and IBM Rational Unified Process Rational Rapid Developer comes with an ARAD plug-in for Rational Unified Process. This process has four main parts: 1. Business Requirements and Analysis with UML (Inception and Elaboration) -- performed by analysts. 2. Rapid User Interface Development (Construction) -- performed by RAD developers. 3. Rapid Integration Development (Construction) -- performed by rapid integration developers. 4. N-Tier Architecture and Deployment (Transition) -- performed by an enterprise architect. This ARAD process is an instance of RUP. As such, it integrates all the team roles and IBM Rational lifecycle tools. The ARAD process is a component of RUP that is geared toward application development in enterprise IT and systems integration shops. It integrates roles and practices found in these shops, including rapid application development, application integration, model-driven development using UML, and scalable enterprise architectures. This process facilitates iterative development, prototyping, joint (10 of 22) [5/19/2003 3:28:38 PM]

11 application development with business owners, flexible use of project team skills, and distributed team development. The resulting agile applications respond quickly to changing business needs and to changing technology architecture. Rational lifecycle toolset used in the ARAD process Under the Rational brand, IBM provides a complete toolset for the lifecycle of architected application development. In addition to RUP and IBM Rational Rapid Developer, the ARAD process can leverage the following IBM Rational software tools: IBM Rational RequisitePro IBM Rational XDE IBM Rational Rose IBM Rational ClearCase IBM Rational ClearQuest IBM Rational TeamTest It can also leverage IBM WebSphere Application Developer. Both IBM Rational ClearCase and IBM Rational ClearQuest are part of the team unifying platform for configuration management and defect tracking. Their close integration allows those using IBM Rational Rapid Developer to check artifacts in and out and to version manage them from within the IBM Rational Rapid Developer user interface. A business application scenario Let's use the ARAD process to design the marketplace application depicted in Figure 7: (11 of 22) [5/19/2003 3:28:38 PM]

12 Figure 7: Enterprise application scenario This marketplace application will be deployed in three stages: 1. A pilot phase for 100 users. 2. The production phase for more than a million users. 3. A production phase that upgrades to the latest versions of the runtime technologies. These are the requirements: 1. Provide Web sites for buyers, sellers, and marketplace administrators. The buyer's site will be in four languages: English, Spanish, German, and Japanese. 2. Provide a wireless site for buyers to place orders and check order status. 3. Integrate with an existing product catalog currently resident on an IMS database. 4. Integrate with an existing order processing application provided by JD Edwards, using XML messaging over IBM Websphere MQ. 5. Provide B2B integration with buyers and sellers systems using XML messaging over Websphere MQ. (12 of 22) [5/19/2003 3:28:38 PM]

13 6. Invoke Web services offered by credit card and shipping companies. The rest of this article will walk through the four main parts of the ARAD process we listed above. For each of these parts we will: Discuss the roles and skills needed. Identify the IBM Rational lifecycle tools to perform it. Explore the unique features of IBM Rational Rapid Developer that support it. Part 1 -- Business requirements with UML Defining and analyzing business requirements should be done by an analyst who is comfortable with business-level UML modeling and with mapping these models to database persistence. Database analysts will require some UML training to perform this role. Estimate work effort using IBM Rational RequisitePro and IBM Rational Rapid Developer. The analyst gathers requirements using IBM Rational RequisitePro -- consisting of use cases that describe the Web, wireless, and integration functions of the application. Then, IBM Rational Rapid Developer provides a project estimator that can estimate the work effort required to develop the application, based on these use cases. This enables the project leader to accurately estimate the size of the project team, staff the project with the requisite skills, and plan out the project timeline. Model visually using IBM Rational Rose or IBM Rational XDE The analyst can then use IBM Rational Rose or IBM Rational XDE for UML modeling. Depending on the application's complexity, the analyst may choose to use all or only some of the UML models. The most essential is the UML Class Model. Each class represents an entity (or a business object) in the application: customer, order, product, and so forth. Import class model from XDE into Rational Rapid Developer The class model is imported from IBM Rational XDE into IBM Rational Rapid Developer (Figure 3). This model can be resynchronized at any time. In some projects that do not need full UML modeling, the Class Architect built into IBM Rational Rapid Developer may be used instead of IBM Rational XDE or IBM Rational Rose (see Figure 8). Import legacy database models (13 of 22) [5/19/2003 3:28:38 PM]

14 In our marketplace application, the product catalog data is resident on a legacy IMS database. IBM Rational Rapid Developer provides connectors to almost every legacy database, including IMS, VSAM, ADABAS, IDMS, and so on. To connect to the product catalog IMS database, an IBM Rational Rapid Developer import process runs on the mainframe that converts the IMS database schema (in COBOL copybooks) into an XML schema file. This XML schema file is then imported into IBM Rational Rapid Developer as a class model. We then link the class model imported from IBM Rational XDE with the IMS class model to complete our application class model. Figure 8: A class model in Class Architect (click to enlarge) Establish database persistence The product classes have already been made persistent in the IMS database. The remaining classes will be made persistent in a DB2 database. IBM Rational Rapid Developer can perform object-to-relational mapping and create database schema for all popular relational databases, including many versions of DB2, Sybase, Microsoft SQL Server, and Oracle. For the application in this scenario, we create a database schema in DB2 V7. Define business rules (14 of 22) [5/19/2003 3:28:38 PM]

15 We can now define business rules in IBM Rational Rapid Developer as validation, derivation, and initial value expressions on the attributes of entities. Rule examples are: inventory check, order item pricing, order pricing, customer credit check, and so forth. Rules are defined using a Java business rule editor. Define business processes Optionally, the analyst can also define business processes in the application: for example, an order process for checking out a Web order. A business process is defined as a state chart/activity diagram. These process models are purely analytical and do not lead to any direct code construction. So far, we have created the core infrastructure UML models of this marketplace application: class model, database persistence, business rules, and business processes. We are now ready for rapid user interface and integration development. Of course, even as we develop the application, we can still continue to refine the core UML models. Part 2 -- Develop user interface(s) rapidly In IBM Rational Rapid Developer, user interface development consists of the following activities: Define site flow models for each actor of the application -- performed by an analyst. Define the look and feel of the application with styles and themes -- performed by a graphic artist. Define the functional pages -- performed by a team of RAD developers. Create site models This application has three types of human actors: buyers, sellers, and administrators. For each class of actor, a site model is designed that maps the flow of the users through the application. These site models should directly reflect the user interface use cases defined in Rational RequisitePro. This is the most important model for clearly communicating with business owners of the application, and it is crucial for projects in which joint application development with business users is important. In a typical Rational Rapid Developer project, the project room walls are full of large- size pictures of site models, and much of the design and discussion focuses on these models. Establish page styles and themes In order to maintain a consistent look and feel for the application, and to be able to change it easily, a graphic designer creates: 1) visual style (15 of 22) [5/19/2003 3:28:38 PM]

16 sheets for each type of control; 2) page templates for each type of actor; and 3) color themes, font themes, and image themes for the application -- all within IBM Rational Rapid Developer. Design Web pages Most of the work in an application consists of page design. The application in our scenario consists of about eighty Web and five wireless pages to be implemented by five RAD developers. A developer with application development skills in almost any language or IDE -- Visual Basic, Power Builder, COBOL, RPG, and so on -- will find this a comfortable environment, and can be trained within days to be productive in IBM Rational Rapid Developer. Lay out pages visually With IBM Rational Rapid Developer, page design is visual and rapid, and it is greatly facilitated with the Page Architect feature, as shown in Figure 9. Developers pick and place styled controls, attach them to attributes of entities, and specify their properties. IBM Rational Rapid Developer is a very rich user interface design environment for rapidly creating featurerich Web applications. As a developer designs a page by laying out its controls, IBM Rational Rapid Developer automatically creates a page content model called ObjectSpace. Developers can refine the page content by adding selection, sort, grouping, and pagination specifications to ObjectSpace. (16 of 22) [5/19/2003 3:28:38 PM]

17 Figure 9: Page design using Page Architect (click to enlarge) Design page logic In this application, thirty pages require business logic. For example, the OrderBasket page has a "submit" button that invokes the CheckOutOrder method to process the basket. This business logic is written in Java used as a 4GL language and is written with the assistance of Logic Architect, shown in Figure 10. Business logic typically represents about five percent of the code in a running application. In order to make it easier to learn and write this logic, IBM Rational Rapid Developer provides nearly 100 code templates, which means that developers need only fill in parameters to write code. Development teams can also add their own templates. After designing the page logic, a developer can quickly construct and test it. IBM Rational Rapid Developer automatically constructs, compiles, and deploys the application. This enables an iterative style of application development conducive to prototyping and joint application development with business owners. Figure 10: Rapid business logic using Logic Architect (click to enlarge) (17 of 22) [5/19/2003 3:28:38 PM]

18 Internationalization of pages After all pages are designed and tested, we internationalize the twenty buyer pages. We define the four locales, and for each locale we define the language, country, and code set. A developer then marks all the text and image controls on these pages that need to be localized. A translation file is then created and exported in the developer's choice of translation formats -- TMX, XLIFF, CSV, or Excel. After translation, the returned translated file is imported back, and we can then view and test the translated pages in Page Architect. IBM Rational Rapid Developer automatically handles date, time, and currency formatting functions, but developers can optionally override them with their own logic. Additional application functionality The marketplace application also leverages the following IBM Rational Rapid Developer capabilities: Advanced page design functions -- such as controlling page access through role-based security, defining client-side page logic, and overriding the generated HTML. Debugging via Websphere Application Developer -- code is constructed as a project in WSAD (and other IDEs), and it can be used to inspect and debug the code. Wireless page design -- IBM Rational Rapid Developer functionality helps us ensure adherence to the size of the wireless device screen by marking construction, using WML instead of HTML. Part 3 -- Rapid integration development The next step for the developers is integrating with a legacy IMS database (as defined in our requirements for this application). Describing all the steps involved in doing this would require another article, so for our present purposes, we will assume that this step is now complete. We are now ready to integrate with an internal order processing application, as well as B2B applications using XML messaging and Web services. Enterprise and B2B integration with XML For integration with the JD Edwards order processing application, we first define that we are going to use IBM WebSphere MQ as our messaging facility and define two queues that will be used to communicate with this system. We have defined 10 use cases (user interactions) for this system. Each interaction includes a request and a response; therefore, twenty XML messages will be exchanged over Websphere MQ. For each message, we read the XML DTD that defines the format of the message, and map it into an ObjectSpace (see Figure 11). This is the same ObjectSpace that we encountered earlier in the Web and wireless development activity; the only difference here is that it is being mapped to XML, not HTML or WML. (18 of 22) [5/19/2003 3:28:38 PM]

19 The mapping process is visual and rapid. For each request/response set, we also define the business logic that will handle the request and submit the response. This business logic is also the same logic that we encountered earlier during Web design. So, as you see, Web design and XML messaging are only superficially different. Figure 11: Integration using XML messaging (click to enlarge) Now we repeat this process for integrating with the buyer and seller systems. Integration with Web services In this application, Web services are being used to invoke commonly available services from credit card and shipping vendors. We first use IBM Rational Rapid Developer to discover these Web services that have been published in a public UDDI repository. Once these services have been discovered, it becomes very easy to invoke them from the correct place in our business logic. Most will be invoked from the order processing logic. In the IBM Rational Rapid Developer Logic Architect, all of the services are available from the services tab. The developer can click on a service, and a service call is inserted in the code, appearing as a Java method call. The developer then specifies the method call parameters, and then he is finished. IBM Rational Rapid Developer will (19 of 22) [5/19/2003 3:28:38 PM]

20 automatically handle all the mechanics of invoking the service, using SOAP request/response mechanism for the target application server. Part 4 -- N-tier architected deployment At this point, we have completed our application development. The application is ready to be deployed by the team's technology architect, who deeply understands the target technologies and knows how an application can be optimally deployed with the desired degree of performance, scalability, security, and manageability. In contrast, the analyst and the developers active on the project so far have used their skills in modeling business functionality, but have not been required to delve into the underlying n-tier technologies. In our scenario, the technology architect actually creates a number of staging deployment models. A key benefit of IBM Rational Rapid Developer is that an architect can deploy the same application in all of these varying environments, yet optimize it for each one. For each deployment model, the architect selects appropriate technologies, fine tunes the construction patterns, and partitions the application for optimum load handling on a server farm. Staging requirements The staging deployment models defined by IBM Rational Rapid Developer Enterprise Application Architect feature (see Figure 12) are: One or more deployment models for developers. They use lightweight application servers (e.g. Tomcat or IBM WebSphere Express) and database technologies (IBM Personal DB2 or SQL Server) that can easily be installed on developers' laptops. A number of test deployment models for each stage of testing. A production model for the prototype phase, deployed on a single server using IBM WebSphere 4.0, IBM WebSphere MQ, and IBM DB2 7.0 UDB. A production model for the main production phase, targeted to deploy on a 100-server farm to support more than one million users. This will use WebSphere 4.0, WebSphere MQ, and DB2 on the mainframe. In this model, the architect fine tunes the construction patterns for the transactions that have the most volume. The Rational Rapid Developer Enterprise Application Architect feature also partitions the application on the 100-server farm by creating three main partitions for buyers, sellers, and administrators, and then further creating multiple n-tier partitions for each main partition. A production model for the next generation of technologies migrating to WebSphere 5.0 and DB IBM Rational Rapid Developer will create a different and independently optimized code for each of these deployment models and package it for (20 of 22) [5/19/2003 3:28:38 PM]

21 easy deployment. Figure 12: Deployment models (click to enlarge) IBM Rational TeamTest can now be used for functional and performance testing of the application. To aid in testing, IBM Rational Rapid Developer can automatically create sample data in the database. Finally, the tested application is deployed, and the development team is ready for the next iteration. See the demo! To hear and watch Arun Gupta design, construct, and deploy this marketplace application as described in the steps above, click here. For more information on the products or services discussed in this article, please click here and follow the instructions provided. Thank you! (21 of 22) [5/19/2003 3:28:38 PM]

22 Copyright Rational Software 2003 Privacy/Legal Information (22 of 22) [5/19/2003 3:28:38 PM]