Developing Applications with Java and UML

Description

• Copyright 2002
• Dimensions: 7-3/8" x 9-1/4"
• Edition: 1st

• Book
• ISBN-10: 0-201-70252-5
• ISBN-13: 978-0-201-70252-1

Developing Applications with Java™ and UML focuses on the craft of creating quality Java software. The book introduces the fundamentals of the Unified Modeling Language (UML) and demonstrates how to use this standard object-oriented notation to build more robust Java applications that fulfill users' requirements and stand the test of time.

The book features the Rational Unified Process, using a large-scale application to illustrate the development process: how to establish a sound project plan, gather application requirements using use cases, create a successful Java design with UML, and implement Java code from the UML class and sequence diagrams. This sample application showcases the latest Java technology frameworks, including Java Server Pages™ (JSP), servlets, and the Enterprise Java Beans™ (EJB) 2.0 server-side technology.

You will learn how to:

• Estimate with accuracy and confidence projects built using the use case approach
• Map UML to Java-based deliverables
• Understand and describe application requirements using UML use cases
• Create a design based on UML class and sequence diagrams
• Use Rational Rose to create and track UML artifacts and generate skeletons for component code
• Build server-side Java functionality using JSP, servlets, and EJB 2.0 beans
• Produce code using several options, including JavaBeans, EJB Session Beans, and EJB Entity Beans (using both Bean-Managed Persistence and Container-Managed Persistence)
• Explore the benefits of deploying Java applications on both open-source and commercial application server products

Based on the author's extensive professional experience and the most advanced software development methods, Developing Applications with Java™ and UML teaches you how to use UML and the latest developments in technology to create truly successful, professional-quality Java applications.

0201702525B09042001



Extras

Related Article

Inheritance and Interfaces in Java and UML

Web Resources

Click below for Web Resources related to this title:
Author Web Site



Sample Content

Online Sample Chapters

Constructing a Solution: Servlets, JSP, and Enterprise JavaBeans

Constructing a Solution: Servlets, JSP, and JavaBeans

Java, Object-Oriented Analysis and Design, and UML

The Java Project Dilemma

The Java Technology Landscape

Downloadable Sample Chapter

Click below for Sample Chapter related to this title:
reedch02.pdf

Table of Contents

Preface.


Acknowledgements.


1. The Project Dilemma.

In This Chapter.

Goals.

The Sad Truth.

The Project Dilemma.

Iterative and Incremental Software Development.

Risk-Based Development.

The Iterative Software Process Model.

Combining Iterative with Incremental: Multidimensional View.

The Synergy Process Model.

The Unified Process.

Other Processes (XP).

Selling the Idea of a Software Process to the Business.

The Unified Modeling Language.

The Place of UML in a Software Process.

The Essence of Modeling.

The UML Diagrams.

Checkpoint.

Where We've Been.

Where We're Going Next.

2. Java, Object-Oriented Analysis and Design, and UML.

In This Chapter.

Goals.

Java as an Industrial-Strength Development Language.

Java and Object-Oriented Programming.

Java and Classes.

More on Java and Classes.

Java and Complex Types (Java Reference Types).

Java and Message Passing.

Java and Encapsulation.

Java and Inheritance.

Java and Polymorphism.

Why UML and Java.

Class Diagram.

Sequence Diagram.

Component Diagram.

Deployment Diagram.

Visual Modeling Tool Support.

Checkpoint.

Where We've.

Where We're Going Next.

3. Starting the Project.

In This Chapter.

Goals.

Establishing the Project Vision.

The Process Model.

Working Template of the Project Vision.

Actors.

Event List and Event Table.

Identifying and Categorizing Business Rules.

Event Capture Format.

The Project Vision.

Checkpoint.

Where We've Been.

Where We're Going Next.

4. Use-Cases.

In This Chapter.

Goals.

The Sample Project.

The Process Model.

Use-Cases.

Finding the Pathways through Use-Cases.

Use-Case Template: Section 1e.

Use-Case Template: Section 2.

Use-Case Template: Section 3.

Use-Case Template: Section 4.

Finding the Happy Path.

Finding the Alternate Pathways.

Finding the Exception Pathways.

Common Use-Case Pitfalls.

Shadow Use Cases.

Describing Details of the Happy Path.

The Completed Process Orders Use-Case Template.

Preparing the Preliminary Architecture.

Project Charter: Increments and Estimates.

Increments.

Estimates: The Issues.

Estimates: The Process.

Checkpoint.

Where We've Been.

Where We're Going Next.

5. Classes.

In This Chapter.

Goals.

The Elaboration Phase.

Detailing Details of Pathways.

Identifying Classes.

Role of the UML Class Diagram.

What Makes a Good Class?

Applying Filter Rules.

Types of Classes.

Relationships.

Establishing Associations.

Establishing Roles.

Establishing Multiplicity.

Advanced Associations.

Generalization.

Creating the Class Diagram.

Identifying Attributes and Operations.

Attributes.

Operations.

Interfaces.

Object Diagram.

Finishing Up: The Analysis Model.

Checkpoint.

Where We've Been.

Where We're Going Next.

6. Building a User Interface Prototype.

In This Chapter.

Goals.

Building an Early Prototype.

The Prototype.

Gathering Requirements.

User Interface Prototype.

Actor and Use-Case Boundaries.

User Interface Artifacts.

Use-Case Coupling.

The First Pass.

Screen Structure Charts.

Creating the Prototype.

Windowing Components.

Collecting User Feedback by Using Screen Dialogs.

Learning from the Prototype.

Checkpoint.

Where We've Been.

Where We're Going Next.

7. Dynamic Elements of the Application.

In This Chapter.

Goals.

Next Steps of the Elaboration Phase.

Dynamic Modeling.

Types of Dynamic Models.

The Sequence Diagram.

Sequence Diagram of the Happy Path.

Use-Case Template.

Class Coupling and Cohesion.

Sequence Diagram for an Alternate Pathway.

Transferring Knowledge to the Class Diagram.

Walking Through the Sequence Diagram.

The Collaboration Diagram.

The State Diagram.

Modeling the State Diagram of the Remulak Order Class.

Alternative View of State Diagrams.

The Activity Diagram.

Selecting the Right Diagram.

Non-UML Extensions in the Design: Usage Matrices.

Event/Frequency Matrix.

Object/Location Matrix.

Object/Volume Matrix.

Checkpoint.

Where We've Been.

Where We're Going Next.

8. The Technology Landscape.

In This Chapter.

Goals.

Next Steps of the Elaboration Phase.

Separating Services.

Logical versus Physical Tiers.

Tier Strategy.

Communication among the Six Layers.

Interprocess Communication Architecture.

Layer Communication Architecture.

Managing Transaction Scope.

Enterprise JavaBeans.

Incorporating the Internet into the Solution.

More About the Web Interface.

Remulak Productions' Execution Architecture.

Checkpoint.

Where We've Been.

Where We're Going Next.

9. Data Persistence: Storing the Objects.

In This Chapter.

Goals.

Next Steps of the Elaboration Phase.

Object-Oriented Concepts and Translating to the Physical Design.

Mapping Classes to Tables.

Mapping Simple Associations.

Mapping Inheritance to the Relational Database.

Mapping Aggregation and Composition to the Relational Database.

Mapping Reflexive Associations to the Relational Database.

Key Structures and Normalization.

Using a Visual Modeling Tool to Generate the DDL.

Stored Procedures and Triggers and the Object-Oriented Project.

The Data Translation Services and Data Access Services Layers.

JavaBeans with Native JDBC Support.

JavaBeans and Native JDBC Data Management.

Enterprise JavaBeans and Data Management.

Commercial Persistence Layers.

Checkpoint.

Where We've Been.

Where We're Going Next.

10. Infrastructure and Architecture Review.

In This Chapter.

Goals.

Next Steps of the Elaboration Phase.

Infrastructure Issues and Communicating with All Layers.

The Presentation Services Layer.

The Business Context Services Layer.

The Business Rule Services Layer.

Cooperating Classes: Boundary, Control, and Entity.

Deployment Architecture View.

Checkpoint.

Where We've Been.

Where We're Going Next.

11. Constructing a Solution: Servlets, JSP and JavaBeans.

In This Chapter.

Goals.

Next Steps of the Elaboration Phase.

Building the Architectural Prototype: Part 1.

Baselining the Environment.

Setting up Your Environment.

Invoking Servlets.

The Servlet for Remulak: Broker Services.

The Servlet for Remulak: Responding to an Action Request.

Java Server Pages for Remulak.

Building the Architectural Prototype: Part 2.

Remulak Controllers and Initial Operations.

Remulak Transaction Management: Roll Your Own.

Remulak Controllers and Subsequent Operations.

Building the Architectural Prototype: Part 3.

Entity Beans.

Data Access Objects.

Front to Back in one Package.

Checkpoint.

Where We've Been.

Where We're Going Next.

12. Constructing a Solution: Servlets, JSP, and Enterprise JavaBeans.

In This Chapter.

Goals.

Next Steps of the Elaboration Phase.

Building the Architectural Prototype: Part 1.

Baselining the Environment.

Visual Modeling: Its Mission for the Project.

Visual Modeling: Its Mission for Program Code Generation.

Reviewing the Setup Issues.

Modifying the Code Generation Parameters.

A Final Pass at Attributes and Operations.

Converting Classes to Enterprise JavaBeans.

Generating Code.

Building the Architectural Prototype: Part 2.

A Primer on Enterprise JavaBeans.

EJB Callback Mechanism.

Working with an EJB.

EJB Sequence Diagrams.

EJB Transaction Management.

Building the Architectural Prototype: Part 3.

Adding Logic to the Generated Code.

A Bit of Magic in Those Tags.

Compiling the EJB Code.

Building a Simple Client to Test the Beans.

Enhancing the CMP Implementation.

Adding More Use-Case Pathways.

Changes to the JSPs.

Adding an Address JSP.

Changes to the Servlet.

Changes to the Use-Case Controller.

Creating a BMP Implementation.

A Road Most Traveled.

The Technology Decision.

The Process of Getting There.

Checkpoint.

Where We've Been.

Appendix A: The Unified Process Project Plans.

In This Appendix.

The Plans.

Appendix B: The Synergy Process Project Plan.

In This Appendix.

The Plan.

Appendix C: Estimating Projects on the Basis of Use-Cases.

In This Appendix.

Weighting Actors.

Weighting Use-Cases.

Weighting Technical Factors.

Weighting Project Participants.

Use-Case Points.

The Project Estimate.

Appendix D: Sample Project Output.

In This Appendix.

Use-Case Definitions.

The Process Orders Use-Case.

The Maintain Orders Use-Case.

The Maintain Inventory Use-Case.

The Shipping Use-Case.

The Invoicing Use-Case.

The Maintain Relationships Use-Case.

The Decision Support Use-Case.

Happy Path Task Steps.

The Process Orders Happy Path.

The Maintain Orders Happy Path.

The Maintain Inventory Happy Path.

The Shipping Happy Path.

The Invoicing Happy Path.

The Maintain Relationships Happy Path.

The Decision Support Happy Path.

Database Support.

Microsoft SQL Server 7.0.

DDL for Oracle (Version 8.1.0).

Appendix E: BEA WebLogic Application Server.

In This Appendix.

Bibliography.


Index. 0201702525T10302001

Preface

This book focuses on the most powerful approach available today to modeling and building industrial-strength Java applications: the Unified Modeling Language (UML) adopted in 1997 by the Object Management Group (OMG). A project lifecycle and software process model are demonstrated (Rational's Unified Process) through a sample application from requirements gathering, using use-cases, through implementation via the creation Java code from class and sequence diagrams. This sample application uses the latest Java technology frameworks, such as JavaServer Pages (JSP), servlets, and most importantly, the Enterprise JavaBeans 2.0 (EJB) server-side enabling technology for implementation of the business rules. Products to implement these server-side solutions range from the Apache Tomcat server to commercial application servers such as BEA's WebLogic.

Reason for the Book

It took me many years to understand that writing a program is nothing more than a learned tactical skill. To program in a language like Java is to be a journeyman. But to capture someone's requirements in an intelligent fashion and organize the necessary resources and resulting software into a cohesive deliverable are the signs of a strategic craftsman.

To me, the majority of Java books never consider Java "in the large." They focus on the small view, covering single Java-enabled extensions such as JavaBeans, servlets, and JavaServer Pages. Although these views, too, are necessary, unfortunately no one seems to touch on project planning, software process, and the methodology for building enterprise-status Java applications. This is a difficult topic to explore and present because the whole subject of process spurs on many heartfelt debates and opinions. At the urging of many of my colleagues and supportive readers of my first book, Developing Applications with Visual Basic and UML, I have undertaken a similar project for Java.

Who Should Read This Book

This book is intended for anyone who wants to successfully build Java applications that can stand up over time. It provides an accurate road map for anyone to achieve the following goals:

• Review two processes: one commercially available through Rational Software called the Unified Process and one from my own experiences called Synergy. The greatest emphasis will be placed on the Unified Process.
• Establish a sound project plan (presented in depth in Appendix A).
• Estimate projects with confidence, rather than by using a rule-of-thumb approach.
• Understand and describe the requirements of the application using UML use-cases.
• Create a sound design based on UML class and sequence diagrams.
• Use a visual modeling tool such as Rose by Rational Software not only to create and track UML artifacts, but also to generate skeleton component code. Although I firmly believe that an automated code generation process is a big factor contributing to successful projects, it is certainly not mandatory.
• Use Java to build server-side Java functionality employing frameworks such as JavaServer Pages (JSP), servlets, and Enterprise JavaBeans 2.0 (EJB).
• Produce the code for the project using an evolutionary approach showing various technology options: (1) servlets, JSP, and JavaBeans; (2) servlets, JSP, and bean-managed persistence (BMP); and (3) servlets, JSP, and container-managed persistence (CMP).
• Investigate the benefit of deploying Java applications on both open-source products like the Apache Tomcat server and commercial application server products such as BEA's WebLogic application server.

Anyone building Java applications today needs this book.

What You Need to Know to Use This Book

Maybe it's best to start out with what you don't need to know to benefit from this book. First, you don't need to know anything about UML. I present the essential aspects of UML and, more importantly, how they relate to Java deliverables. Although UML is expressed through nine separate diagrams, you will benefit the most from a core set.

Second, you don't need a formal background in object-oriented concepts (but it certainly doesn't hurt). I discuss standard object constructs in Chapter 2.

Third, you should have some conversational understanding of what Enterprise JavaBeans is. For a really thorough treatment of Enterprise JavaBeans (EJB), you should focus on one of the many texts that cover them in more detail. A favorite of mine is a book by Richard Monson-Haefel entitled Enterprise JavaBeans, published by O'Reilly. You will also benefit from some exposure to JavaServer Pages (JSP). One of my favorite sources on this topic is a book by Hans Bergsten entitled Java Server Pages, also published by O'Reilly.

This book assumes that you have a working knowledge of Java. Both the new Java programmer and the experienced Java programmer will benefit. I don't cover the basics of simple Java constructs, assuming that you already know these. I do briefly review the tenets of Java's support for object-oriented principles in Chapter 2, but only as a baseline for other topics related to UML. If you have had no exposure to Java, buy this book anyway and open it after you have had some initial training in that programming language.

This book emphasizes the most mainstream Java techniques and products that are used to build production applications. When I began this book, I planned to cover all kinds of Java technologies (i.e., applets, Java applications talking to servlets or JSPs). However, it quickly became apparent to me that the majority of my clients and my associates' clients were all pretty much cut from the same mold in terms of architecture. They consist of a light client browser on the front end (with minimal JavaScript for syntax editing), and a Web server intercepting those browser requests with either servlets and/or JavaServer Pages acting as a broker within a container product that houses the business rules. These business rules are implemented as either JavaBeans or Enterprise JavaBeans. The container products range from open-source solutions like Apache Tomcat to commercial products.

The two biggest of the commercial application server players I run across are BEA (with its WebLogic product) and IBM (with its WebSphere product). This doesn't mean there aren't other good commercial container products, but these two vendors have the lion's share of the market. This book will utilize a light client-side technology (no applets or Java applications), and a Web server running servlets and JavaServer Pages, which in turn send messages to either JavaBeans (Tomcat) or Enterprise JavaBeans (session and entity beans) residing in a commercial application server.

In the case of the latter, I have chosen to use BEA's WebLogic as my application server. Don't be discouraged if you are using another vendor's application server product because this book's coverage of EJB is based on the 2.0 specification. This release of EJB resolved many of the ambiguities that kept beans from being truly transportable across vendor implementations. So regardless of your EJB vendor, you will be able to use the code built in this book.

It would be unfair to say that you will know everything about EJBs after reading this book. If you already know about EJBs, this book will help you put them into a sound design architecture. The emphasis is on the notation (UML) and the process (Unified Process and Synergy) in beginning, developing, and implementing a software project using the Java language. The benefit of seeing an application from requirements gathering to implementation is the key goal of this book. This is where I shall place my emphasis.

Structure of the Book

The following sections summarize the contents of each chapter.

Chapter 1: The Project Dilemma

Chapter 1 reviews the current state of software development and my reasoning regarding why it's in the shape that it is today. It also reviews the concept of iterative and incremental software development and provides an overview of both Rational Software's Unified Process and my Synergy Process methodology. In addition, it touches on the primary components of UML that will be covered in more depth later in the book.

Chapter 2: Java, Object-Oriented Analysis and Design, and UML

Chapter 2 covers some of the benefits of adopting Java as a development environment, presented in the context of Java's implementation of encapsulation, inheritance, and polymorphism. It then maps UML to various Java deliverables. Highlights include mapping the UML diagrams to Java classes and Java interfaces; mapping use-case pathways to Java classes; and mapping component diagrams to Java classes and Java packages.

Chapter 3: Starting the Project

Chapter 3 explores the case study used in the book: Remulak Productions. This fictional company sells musical equipment and needs a new order entry system. The chapter introduces a project charter, along with a tool, called the event table, to help quickly solidify the application's features. Further, the chapter maps events to the first UML model, the use-case.

Chapter 4: Use-Cases

Chapter 4 reviews the use-case, one of the central UML diagrams. Included is a template to document the use-case. Actors and their roles in the use-cases are defined. The concept of use-case pathways, as well as the project's preliminary implementation architecture, is reviewed. Also reviewed is an approach to estimating projects that are built with the use-case approach.

Chapter 5: Classes

Chapter 5 explores the class diagram, the king of UML diagrams. It offers tips on identifying good class selections and defines the various types of associations. It also covers business rule categorization and how these rules can be translated into both operations and attributes of the class. Finally, it discusses the utilization of a visual modeling tool as a means to better manage all UML artifacts.

Chapter 6: Building a User Interface Prototype

Chapter 6 reviews unique user interface requirements of each use-case. It develops an early user interface prototype flow and an eventual graphical prototype. Finally, it maps what was learned during the prototype to the UML artifacts.

Chapter 7: Dynamic Elements of the Application

Chapter 7 discusses the dynamic models supported by UML, exploring in depth the two key diagrams, often referred to as the interaction diagrams: sequence and collaboration. These are then directly tied back to the pathways found in the use-cases. Other dynamic diagrams discussed include the state and activity diagrams.

Chapter 8: The Technology Landscape

Chapter 8 covers the importance of separating logical services that are compliant with a model that separates services. It explores technology solutions specific to the Remulak Productions case study, including distributed solutions and the Internet using HTML forms, JSP, and servlets. Both JavaBeans and Enterprise JavaBeans as solutions for housing the business rules are also explored.

Chapter 9: Data Persistence: Storing the Objects

Chapter 9 explores the steps necessary to translate the class diagram into a relational design to be supported by both Microsoft SQL Server and Oracle databases. It offers rules of thumb regarding how to handle class inheritance and the resulting possible design alternatives for translation to an RDBMS. This book will deliver solutions that range from roll-your-own persistence using JavaBeans and JDBC, all the way to container-managed persistence (CMP) features of the EJB 2.0 specification. The latter removes all the requirements of the application to write SQL or control transactions. This chapter introduces the concept of value objects to reduce network traffic, as well as data access objects that encapsulate SQL calls.

Chapter 10: Infrastructure and Architecture Review

Chapter 10 finalizes the design necessary to implement the various layers of the application. It also presents the communication mechanism utilized between the layers and possible alternatives. Each class is delegated to one of three types: entity, boundary, or control. These types are used as the basis for the design implementation and as the solution to providing alternative deployment strategies.

Chapter 11: Constructing a Solution: Servlets, JSP, and JavaBeans

Chapter 11 builds the first architectural prototype for Remulak and does not rely on Enterprise JavaBeans. With the Maintain Relationships use-case as the base, the various components are constructed. The primary goal of the architectural prototype is to reduce risk early by eliminating any unknowns with the architecture. This chapter uses the Apache Tomcat server and introduces the concepts of user interface and use-case control classes.

Chapter 12: Constructing a Solution: Servlets, JSP, and Enterprise JavaBeans

Chapter 12 initially uses Rational Rose to generate EJB components. A primer on EJB is offered, along with a thorough discussion of the transaction management options in the EJB environment. Session beans are utilized as the use-case controller. Solutions that incorporate both container-managed persistence (CMP) and bean-managed persistence (BMP) are presented. Leveraging the data access objects created in Chapter 11 is crucial to the success of a BMP implementation.

Updates and Information

I have the good fortune to work with top companies and organizations not only in the United States, but also in Europe, Asia, and South America. In my many travels, I am always coming across inventive ideas for how to use and apply UML to build more-resilient applications that use not only Java, but also C++, C#, and Visual Basic. Please visit my Web site, at www.jacksonreed.com, for the latest on the training and consulting services that I offer, as well as all of the source code presented in this book. I welcome your input and encourage you to contact me at prreed@jacksonreed.com.

0201702525P10302001

Index

A

Abstract persistence schema, 249

Accessor methods, 341-344

Accessors, 35

Action elements, 289

Action request response, servlet for, 280-286

Action restricting business rule, 57

Action triggering business rule, 57

Activity diagrams, 20, 21

defined, 161

focus of, 184

Java counterpart to, 45

sample, 183

uses of, 184

Activity plan, 383

Activity state, 183

Actors, 53

defined, 52

event table grouped by, 67-68

functions of 134-135

relationships among, 68-70

types of, 54-56

in use-case template, 72

weighting of, 410-411

Address JSP, adding, 362-365

Aggregation associations, 116

to reduce class coupling, 171

Agile Alliance, 16

Alternate Course of Events (ACOE), 77

Alternate pathways, 77

sample, 78

sequence diagram for, 174

in use-case template, 73

Ambler, Scott, 16

Amodal window, 139

Analysis and Design workflow, 13

Analysis model, 128

Application segmentation architecture, 195

Applying Use Cases: A Practical Guide (Schneider/Winters), 71, 416

Architectural diagram, defined, 21

Architectural prototype, 272

environment for, 273-275

Architecture

areas of, 195, 202

preliminary, 87-89

Architecture Infrastructure, shadow use-case, 81-82

Archiving, shadow use-case, 81

ArrayList, 115

Arrays, 115

Arrival pattern, 58

Artifacts

in dynamic modeling, 159, 161

essential, 381-382

traceability of, 19

in Unified Process, 381

user interface, 136-137

<assembly-descriptor> tag, 338-339, 340

Association class, 118

Associations, 68

advanced types of, 115-119

bidirectionality of, 219-220

described, 110-111

establishing, 112-113

inappropriate handling of, 218

in Java, 46

mapping of, 218-222

and sequence diagrams, 171-172

simple, 223

Attributes

of class, 33, 103

definition of, 122-123, 324-325

distinguished from classes, 104

in Java, 45

Audit, shadow use-case, 80, 81

Average actors, 410

B

Basic Course of Events (BCOE), 76-77

Bean-managed persistence (BMP), 247-248

creating implementation using, 372-376

entity EJBs implemented with, 332

Beck, Kent, 16

beginTran(), 294, 296-297, 300

Bergsten, Hans, 280, 287

Beust, Cedric, 345

Big-bang approach to development, 27

Booch, Grady, 18, 20

Boundary classes, 106, 107

functions of, 108-109

Broker services, servlet for, 278-280

Business Context Services, 200

function of, 264-265

as service layer, 260, 261

Business Modeling workflow, 13

Business objectives, 53

Business purpose, 53

Business Rule Services, 200

functions of, 265-266

as service layer, 260, 261

Business rules, 265

identifying and categorizing, 57

in use-case template, 75

Business Services

components of, 200

dynamism of, 197

location of, 206

scope and objective of, 197

C

Callback operations

for entity EJBs, 334

for session beans, 333

Camelback notation, 122

Charter, project, 89-96

Class coupling, 171-172

Class diagrams, 20, 21, 23

creating, 120-121

importance of, 44-46, 102

Java counterpart to, 45

sample, 127

transferring knowledge to, 175

Class-level operations, 33

Classes

adding operations to, 175

converting to EJBs, 325-328

defining, 31-32

function of, 103

identifying, 102-110

in Java, 29, 33, 45

mapping to tables, 216-228

modeling with state diagram, 181-182

public interfaces of, 30

relationships between, 110-120

selecting, 102-103

in sequence diagram, 168-173

transient, 219

types of, 105-110

Classpaths, 328

setting, 329

Client-centric implementation, 198

drawbacks of, 198-199

closeResultSet() operation, 298, 314-315

closeStatement() operation, 298

cmp fields, 341-342

cmr fields, 342-343, 344-345

Coad, Peter, in development of UML, 18

Code generation

multiplicity and, 114-115

parameters for, 322-324

roles and, 113

Cohesion, defined, 172

Collaboration diagrams, 20, 21

creation of, 178

defined, 160

described, 176

Java counterpart to, 45

sample, 177

sequence numbers in, 177-178

uses of, 184

COM+ (Microsoft), 336

commitTran(), 294

Complex actors, 410

Complex types, 33-34

Component diagrams, 20, 21

Java counterpart to, 45, 47

Component Services framework, 336

Composition associations, 116-117

to reduce class coupling, 171

to relational database, 226-227

Computer-Aided Software Engineering (CASE), 320

Configuration and Change Management workflow, 13

Constraints, 53

in use-case template, 72, 75

Construction phase, 8-9, 12, 13

detailed plan for, 393-395

overview plan for, 392

Synergy Process model for, 407

Container-managed persistence (CMP), 205-206, 239, 322

advantages of, 249, 377

EJB and, 248-249, 332

enhancing, 352-372

Container-managed transactions, 340

<container-transaction> tag, 339, 340

Context edits, 265

Control classes, 107

functions of, 109-110

Controllers, 107

changing, 368-372

interface, 260-262, 263

use-case, 263, 264, 293

Course of Events

Alternate (ACOE), 77

Basic (BCOE), 76-77

CRC sessions, 103

The CRC Card Book (Bellin/Simone), 103

Critical success factors, 53

Customer class, 341-344

CustomerBean class, 303

CustomerDAO object, 374

customerDelete(), 307

CustomerHome interface, 349-350

customerInsert(), 306, 374

customerUpdate(), 306

D

Data access architecture, 195

Data access objects (DAOs), 249, 295

examples of use of, 308-315

JavaBean strategy for, 247

operations on, 241

purpose of, 241

Data Access Services, 200

as service layer, 260

Data Access Services layers

bean-managed persistence, 247-248

container-managed persistence, 248-249

data access objects, 240-247

Data definition language (DDL), 221, 427

generation of, 219, 231-237

Data management, JDBC, 239-247

Data Modeler (Rational), 231

Data segmentation, 188

Data Services

components of, 200

implementation of, 206-207

scope and objective of, 197

static nature of, 197-198

Data Translation Services, 200, 239

as service layer, 260

DataAccess interface, implementation of, 245-246

Database(s)

communication among, 203

connection pooling for, 204

selection of, 188, 189

Database Services, 200, 201

as service layer, 260

Database support, 427

Decision Support use-case, 424-425

happy path for, 427

Declarative transaction management, 336

deleteObject(), 241, 311-312

DeMarco, Tom, 18

Denormalization, 218

Dependencies, 111

Dependency association, 70

Deployment architecture, 268-269

Deployment descriptors, 249-250

Deployment diagrams, 20, 21

Java counterpart to, 45, 47

Deployment workflow, 13

Derivation business rule, 57

Description information, in use-case template, 72

Design, mapping inheritance to, 225

Designing Enterprise Applications with the Java 2 Platform (Kassem), 240

Desired features, 53

Detail, use-case, in use-case template, 74

Detailed plan

for construction phase, 393-395

for elaboration phase, 389-392

for inception phase, 385-387

for transition phase, 397-399

Diagrams. See names of individual types of diagrams

Direction of traversal of window, 139-140

Directives, 289

doGet() operation, 278, 280

Domain classes, 106

doPost() operation, 278, 280

doQuery(), 310

doRltnCustomerAdd() method, 282

doRltnCustomerDelete() operation, 285-286

doRltnCustomerEdit() operation, 285

doRltnCustomerInquiry() method, 281, 365-366

doRltnCustomerNew() operation, 284

Dynamic diagram, defined, 21

Dynamic modeling

activity diagram, 183-184

artifacts in, 159, 161

choice of diagram type, 184-185

collaboration diagram, 176-178

purposes of, 159

sequence diagram, 162-176

state diagram, 178-183

types of, 160-162

usage matrices in, 185-190

E

Editing, syntax vs. context, 264-265

Education tasks, 401

ejb-jar.xml, 346

EJB-QL, 249, 349

ejbActivate(), 333, 334

ejbCreate(), 333, 334, 374

EJBGen, 345-346, 349

ejbLoad(), 334

ejbPassivate(), 333, 334

ejbPostCreate(), 334

ejbRemove(), 333, 334

ejbStore(), 334

Elaboration phase, 8, 12, 13, 100

detailed plan for, 389-392

overview plan for, 388

Synergy Process model for, 402-405

Enterprise Archive (EAR) files, 320

Enterprise JavaBeans (EJB), 28, 144

acceptance of, 377-378

callback mechanism of, 333-335

characteristics of, 327

classes converted to, 325-328

compiling code for, 346

data management by, 247-249

described, 332

differences in v. 2.0, 343

flexible security model of, 205

sequence diagrams for, 335, 336, 337

testing, 347-352

transaction management and, 335-336

transaction types supported by, 338-340

types of, 204, 332-333

uses of, 204-206

and Web interface, 207-210

working with, 335

Enterprise JavaBeans (Monson-Haefel), 249, 332

Entities, distinguished from classes, 105

Entity beans, 204

examples of use of, 303-308

function of, 302

Entity classes, 106, 107

in MVC framework, 260

sample, 108

Entity EJBs, 332

transportability of, 377

Environment

baselining, 273-274, 319-320

setting up, 274-275

Environment workflow, 13

Environmental complexity factor (ECF), 414, 416

Episodic events, 59

Estimates

background issues, 90-92

determining use-case points, 416

process of, 92-96

resources allocated to producing, 416

weighting of actors, 410-411

weighting of project participants, 414-415

weighting of technical factors, 413-414

weighting of use-cases, 411-413

Event capture format, 57-60

Event/frequency matrix

construction of, 185

sample, 186

use of, 186-187

Event list, 53, 56

Event table, 53, 56

arrangement of, 67-68

functions of, 58

sample, 59

Events, distinguished from classes, 105

Evolution, defined, 9

Exception, defined, 77

Exception pathways, 77, 263

sample, 79

in use-case template, 73

executeQuery(), 310

Execution architecture, 195

sample, 210-211

Execution tasks, 401

Explicit navigation, 220

Extends keyword, 39, 42

Extensions, in use-case template, 75

External events, 56

Extreme Programming (XP), 16

eXtreme programming eXplained (Beck), 16

F

Fat-client implementation, 198

drawbacks of, 198-199

Features, desired, 53

Filtering rules, 104-105

Finalized classes, in Java, 46

findAllCustomers(), 348, 349, 350-351

findByCustomer(), 305-306

findByCustomerNumber(), 349

findByName(), 241, 306, 307-310

findByPrimaryKey(), 241, 310-311

Fire-and-forget paradigm, 163

Flexible security model, 205

Focus blocks, 140, 141

Focus-of-control rectangle, 163

forward() operation, 281, 282

4+1 view of architecture, 22-23

Fragile base class problem, 39

FrameMaker (Adobe), 141

Frequency, in use-case template, 76

Functional entitlement, 79

evaluating, 80

Fusion (Ernst and Young), 19

G

Generalization, 69-70

creating associations, 222

described, 111

examples of, 119-120

function of, 119

inappropriate handling of, 218

in relational design, 224

Generation, defined, 9

get operation, 32

getAddressValue(), 354-355

getConnection(), 297

getCustomerValue(), 353-354

getInitialContext(), 347, 348, 367-368

getParameter() message, 281

getRoleValue(), 354

Getters, 35

Goal, in use-case template, 72

Gosling, James, 16, 28, 143

Guard condition

in sequence diagram, 163

in state diagram, 181

Guiney, Eamonn, 71

H

Happy path

defined, 76

details of, 82-83

finding, 76-77

sample, 77

sequence diagram of, 174-175

in use-case template, 73

Hewlett-Packard, in development of UML, 18

Home interface, 335

I

IBM, in development of UML, 18

IDEFIX format, 230

Implementation constructs, distinguished from classes, 105

Implementation inheritance, 37-38

indications for use of, 39

in Java, 39-40

Implementation workflow, 13

Implements keyword, 40, 42, 124

Implied navigation, 220

Inception phase, 8, 12, 13

detailed plan for, 385-387

goals of, 51-52, 63

overview plan for, 384

Synergy Process model for, 402-403

Incremental, defined, 5

Increments, 89-90

Inference business rule, 57

Information

description, 72

retrieval of, 266-268

tactical, 75

Infrastructure, project, 54

Inheritance

implementation, 37-38, 39-40

inappropriate handling of, 218

interface, 36-37, 38-39, 40-41

mapping to database, 222-226

mapping to relational design, 225

Inheritance association, class-to-table, 226

Initial Operational Capability, 9

Initial operations, 292

controllers and, 293-294

Inprise Application Server, 144, 205

Input/output (I/O), as bottleneck, 218

insertObject(), 241, 313-314, 375-376

Instantiation, defined, 29

Integrated development environments (IDEs), 141, 143-144

using, 330

Interaction diagrams, 160

Interface classes, 106

Interface inheritance, 36-37

indications for use of, 38-39

in Java, 40-41

notation for, 124-126

Interface stereotype, 68

Interfaces

controllers of, 260-262

in Java, 46

in MVC framework, 260

in use-case template, 76

Internal events, 56

Internet, incorporating into solution, 206-207

Interprocess communication (IPC) architecture, 202

Invoicing use-case, 422-423

happy path for, 427

Irrelevance, 104

Issues, in use-case template, 72, 75

itemExistsByName(), 309

Iterations

model using, 6-8

in sequence diagram, 163, 173

within phases, 9-10

Iterative, defined, 5

Iterative and incremental software development

described, 4-5

model of, 6-8

multidimensional view of, 10, 11

time line of, 6

J

Jacobson, Ivar, 8, 18, 52, 66, 106, 409

Java, 27

classes in, 29, 33

as development language, 28

encapsulation in, 35-36

IDEs for, 141, 143-144

inheritance in, 36-41

message passing in, 34-35

and object-oriented programming, 28-29

and polymorphism, 41-43

reference types in, 33-34

and UML, 43-48

variable definition in, 33-34

Java Archive (JAR) files, 320

Java Development Kit 1.3, 28, 274

Java Naming and Directory Interface (JNDI), 210, 296, 347

Java Server Pages (Bergsten), 280, 287

Java 2 Platform, Enterprise Edition (J2EE), 143-144

Java 2 Software Development Kit, 274

JavaBeans, 204

functions of, 271

and native JDBC data management, 239-247

with native JDBC support, 239

JavaServer pages (JSPs), 286-287

address, 362-365

changes to, 353-362

elements of, 289-290

sample, 287-289

JBuilder (Inprise), 143, 144

JDBC (Java Database Connectivity), 239

Joins

excess, 217

key structure and, 229

K

Karner, Gustav, 92, 409, 411, 416

Kassem, Nicholas, 240

Key structures, 228-230

Kroll, Per, 381

Krutchen, Philippe, 22

Kulak, Daryl, 71

L

Latency, in sequence diagram, 163

Layer communication architecture, 202

Business Context Services and, 274-265

Business Rule Services and, 265-266

class cooperation in, 266-268

Presentation Services and, 259-263

Lazy loading, 355

Legacy applications, 196

Lifecycle Architecture, 8

Lifecycle driven, defined, 327

Lifecycle Objective, 8, 94

Link associations, 117-118

Links, 117

Locations

of interest, 53

of source, 76

Logical paging, 140, 141

lookupCustomerHome(), 348

lookupHome(), 366-367

M

Main sequence, in use-case template, 74

Maintain Inventory use-case, 420-421

happy path for, 426

Maintain Orders use-case, 419-420

happy path for, 425-426

Maintain Relationships use-case, 423-424

happy path for, 427

Management tasks, 401

Mandatory transaction level, 338

Mapping

aggregation and composition to database, 226

associations, 218-222

classes to tables, 216-228

order of, 263-264

of pathways to operations, 263

pitfalls in, 216-218

Marinescu, Floyd, 355

Marketing plan, 16-17

Martin, James, in development of UML, 18

Matrix

event/frequency, 185-187

object/location, 187-189

object/volume, 189-190

use-case coupling, 138

Mellor, Stephen, in development of UML, 18

Message passing, 34-35

Microsoft, in development of UML, 18

Middleware Company, 355

Modal window, 139

Model-view-controller (MVC) framework, 259

described, 262

Modeless window, 139

Modeling

benefits of, 19

goals of, 20

Monson-Haefel, Richard, 249, 332

MooreÕs law, 218

Multiplicity

defined, 114

establishing, 114-115

mapping to database actions, 223

specifying, 253

Multitier implementation, 200

N

N-tier implementation, 200

Name, in use-case template, 72

Natural keys, 228

Navigation, explicit vs. implied, 220-221

Never transaction level, 338

Normalization, key structures and, 228-230

NotSupported transaction level, 338

O

Object access, determining, 187

Object diagrams, 20, 21

sample, 126-127

Object horizon, 218

Object/location matrix

focus of, 187

sample, 188

use of, 188-189

Object Management Group (OMG), 17

Object Modeling Technique (OMT), 18, 162

Object/volume matrix, 189

sample, 190

Object-oriented database management systems (OODBMS), 216

Object-oriented programming, Java and, 28-29

Object-Oriented Software Engineering (OOSE), 18

Objectives, business, 53

Objectory Process, 18, 66

inputs for, 409

Odell, James, in development of UML, 18

Operation signature, 124

Operations

adding, 175

class-level, 33, 103

distinguished from classes, 104

identifying, 123-124

in Java, 46

specification of, 123

Oracle DDL, 427

project output in, 433-437

Overview plan, 383

for construction phase, 392

for elaboration phase, 388

for inception phase, 384

for transition phase, 396

P

Package diagrams, Java counterpart to, 45

Parameter Maintenance, shadow use-case, 81

Participants, weighting of, 414-415

Pathway name, in use-case template, 73, 74

Pathways, 46

adding, 352

alternate, 77, 78

defined, 63

describing, 101Ñ102

exception, 77, 79

finding, 71-80

mapping to operations, 263

primary (happy path), 76-77, 82-83

Performance targets, in use-case template, 76

Periodic events, 59

Phase plan, 382

sample, 383

Phases, of project, 13

Polymorphism, 124

defined, 41-42

uses of, 42-43

Postcondition, in use-case template, 72

Precondition, in use-case template, 72

Preliminary architecture, 87-88

diagram of, 89

sample, 88

Preliminary execution architecture, 54

Presentation Services, 196, 201

and communication, 259-263

front end of, 206

scope and objective of, 197

as service layer, 260, 261

Primary actor, in use-case template, 72

Primary key, 229

Primary pathway, in use-case template, 73

Priority, in use-case template, 76

Procedures, distinguished from messages, 34

Process. See Software process

Process Order, sample use-case template, 83-87

Process Orders use-case, 418-419

happy path for, 425

Product Release, 9

Programming keys, 228

Project charter

estimates, 90-96

increments, 89-90

Project Management workflow, 13, 49

Project planning, using Synergy Process

education tasks, 401

execution tasks, 401

management tasks, 401

model of, 402-407

Project planning, using Unified Process

activity plan, 383

for construction phase, 392-395

for elaboration phase, 388-392

for inception phase, 384-387

overview plan, 383

phase plan, 382, 383

for transition phase, 396-399

Project vision

building, 50-51, 60

inputs into, 49

and Project Management workflow, 49-50

working template of, 52, 53-54

Projects

estimating of, 409-416

infrastructure of

release strategy of, 54

output of, 417-437

planning of, 95-96

typical time line of, 4

unpredictability of, 3-4

.properties files, 296

Protocycling, 150

Prototypes

architectural. 272-275

cautions about, 134

user interface, 131-159

Public interface, defined, 30

Purpose, business, 53

Q

Qualification associations, 119

Qualifiers, 119

R

Rational Software, 1, 8

market leadership of, 18

The Rational Unified Process: An Introduction (Krutchen), 22

Recursive relationships, 227

Redundancy, 104

Reference types, 33-34

Reflexive associations, 118

mapping to relational database, 227-228

Relational database

mapping aggregation and composition to, 226

mapping inheritance to, 222-226

mapping reflexive associations to, 227-228

Relationships

types of, 110-111

Release strategy, 54

Remote interface, 335

RemoteException, 340

Remulak Productions case study, 42

activity diagram for, 183

actors in, 136

alternative pathways for, 78, 174

architecture for, 263-264

associations for, 112-113

attributes for, 122

class diagram for, 120, 121, 169, 218, 321-322

code generation for, 328-331

composition associations in, 116, 117

controllers for, 292-294, 299-302

data access for, 242-247, 249-253

database support for, 427

DDL project output, 433-437

deployment strategy of, 268-269

EJB code for, 346-372

EJB-based solution architecture for, 317-378

estimates of, 92-94

estimating project, 410-411, 413, 415-416

exception pathways for, 79

execution architecture of, 210-211

generalization/specialization in, 224-225

generalizations for, 119, 120

happy paths for, 77

increments for, 93

information retrieval for, 266-268

initial operations for, 294

Internet strategy of, 207-210

JavaBeans-based solution architecture for, 271-315

JSPs for, 287-292

object diagram for, 126

object/location matrix for, 188

object/volume matrix for, 190

phase plan for, 383

preliminary architecture sample, 88

Process Order use-case template, 83-87

project vision of, 50-51

qualification associations for, 119

reflexive associations for, 118

relational design of, 230

roles for, 113

screen dialogs for, 148-150

screen structure charts for, 142, 143

sequence diagram for, 170, 173

servlets for, 278-286

SQL Server project output, 428-432

state diagram for, 180-182

transaction management for, 294-299

use-case diagram for, 69, 164

use-case issues, 64-65

Web pages of, 144-148

Request for Proposal (RFP), 382

Required transaction level, 338

Requirements model, 94

Requirements workflow, 13

activity sets in, 14

RequiresNew transaction level, 338

Responsibilities, 53

Risk-based software development, 6

Risks, 53

in use-case template, 72, 75

rltnAddAddress(), 371

rltnAddCustomer(), 299-300, 370

rltnAddress.jsp, 362

rltnCustomer() JSP, 290-292

rltnCustomerInquiry(), 294, 369-370

rltnDeleteCustomer(), 301-302

rltnInquiry() JSP, 287-289

rltnInquiry.jsp, 352-362

rltnUpdateCustomer(), 301

Role class, 344-345

Roles, 53

and code generation, 113

distinguished from classes, 104-105

establishing, 113-114

rollBackTran(), 300

Rose (Rational Software), 44

class diagrams in, 120, 121

visual modeling in, 176, 219, 231-237, 320, 321

Ross, Ronald, 57

Round-trip engineering, 231

Rumbaugh, James, 18, 44, 162, 218

RuntimeException, 340

S

Schemas, 249

Schneider, Geri, 71, 416

Scope creep, 70

Screen dialogs, 148-150

Screen structure charts, 139-141

symbols for, 140

Script comments, in sequence diagram, 163

Scripts, 289-290

pitfalls of using, 290

Secondary actors, in use-case template, 72

Security, shadow use-case, 80, 81

Sequence diagrams, 20, 21, 23

of alternate pathway, 174

classes for, 168-173

defined, 160

for EJB, 335, 336, 337

enterprise-level use of, 162-163

of happy path, 164-165

Java counterpart to, 45, 46-47

purpose of, 163

sample, 170

uses of, 184

walk-through of, 175-176

Sequence of steps, in use-case template, 74

Server sizing, 189

Services

tiers of, 198-200

types of, 196

<servlet-mapping> tag, 277

<servlet-name> tag, 277

Servlets

changes to, 365-368

functions of, 261

invoking, 276-278

sample, 278-286

Session beans, 204

stateful vs. stateless, 332

Session EJBs, 332

set operation, 32

setAutoCommit() method, 297

setCustomerValueFromForm() operation, 283-284

Setters, 35

Shadow use-cases, 80-82

Shipping use-case, 421-422

happy path for, 426

Shlaer, Sally, in development of UML, 18

Signature, 321

defined, 30

Simple actors, 410

Six-tier logical model, 200-201

communication in, 201-202

connectivity in, 239-240

Software Architecture Document (SAD), 87-89, 195, 215

Software development

iterative and incremental, 4-10

need for process, 1

risk-based, 6

spiral process model of, 8

Software process

benefits of, 17

marketing of need for, 16-17

need for, 1

UML in, 18-19

Software Requirements Specification (SRS), 87

Source location, in use-case template, 76

Specialization

creating associations, 222

inappropriate handling of, 218

in relational design, 224

Spiral process model, 8

SQL Server, 427

project output in, 428-432

Stakeholders, 53

State diagrams, 20, 21

defined, 160-161

described, 179

history of, 178

indications for use of, 179-180

Java counterpart to, 45

to model classes, 181-182

notation elements in, 181

sample, 180-182

steps for, 179

uses of, 178-179, 184

viewed as table, 182-183

Stateful session beans, 332

Stateless session beans, 332

Static diagram, defined, 21

Static keyword, 33

Stereotypes, 106

interface, 68

Storage, key structure and, 229

Stored procedures, 237-239

Structural fact business rule, 57

Structured Analysis and Structured Design (SA/SD), 18

Struts framework (Apache), 280, 290

advantages of, 356, 362

Subclass, 111

Subsequent operations, controllers and, 299-302

Success factors, 53

Superclass, 111

Supplementary Specification, 87

Supports transaction level, 338

Surrogate keys, 228, 229

Swing graphics library, 28

Synchronization semantics, in sequence diagram, 163

Synergy Process, 1

described, 10

illustrated, 12

omissions of, 11

project planning using, 401-407

Syntax edits, 265

T

T factor, 413

Tabbed controls, 140

Table format, for state diagram, 182-183

Tables

excess, 216

mapping classes to, 216-228

missed, 217

primary key of, 229

Tactical information, in use-case template, 75

Tag libraries, 362

Tags, 345-346

TCF (technical complexity factor), 414

Team leader/members, in use-case template, 72

Technical factors, weighting of, 413-414

Test workflow, 13

Threads, pooling of, 204-205

Three-tier implementation, 199, 200

Tiers of service

logical vs. physical, 198-200

strategy related to, 200-202

Timing, in sequence diagram, 163

Together Control Center (TogetherSoft), 320

Tomcat (Apache), 207, 268

evolution of, 273

installation of, 273

TopLink (BEA/WebGain), 239, 254

Transaction management, 294-295

declarative, 336

EJB and, 205

transaction levels, 338-340

use-case control class and, 295

Transaction monitors, 203

Transaction scope, 202-204

illustrated, 203

TransactionContext class, 294, 295-299

Transient classes, 219

Transition phase, 9, 12, 13

detailed plan for, 397-399

overview plan for, 396

Synergy Process model for, 407

Trigger events, in use-case template, 72, 74

Triggers, 237-239

Try block, 32

try/catch blocks, 300

Tuxedo (BEA), 203

U

UCMaintainRltnshp(), 293, 299-302

changing, 368-372

UML (Unified Modeling Language), 1

diagrams in, 20-24

history of, 17-18

and Java, 43-48

navigation in, 220-221

object orientation of, 27

and project architecture, 22-23

and software process, 18

traceability of artifacts, 19

UML diagrams

architectural, 21

context of, 23-24

static vs. dynamic, 21

types of, 20

Unadjusted use-case points, 412-413

Unified Process (Rational Software), 1, 8, 18

acceptance of, 381

advantages of, 152

birth of, 66

described, 12-15

project planning using, 381-399

Unit of work, defined, 294

updateObject(), 241, 312-313

<url-pattern> tag, 277

Use Cases: Requirements in Context (Kulak/Guiney), 71

Use-case control class, 293, 326-327

and transaction management, 295

Use-case controllers, 263, 264, 293

changing, 368-372

Use-case diagrams, 20, 21, 23

Java counterpart to, 45

Use-case points, 416

unadjusted, 412-413

Use-cases, 53, 99

boundaries of, 134-135

coupling of, 138

defined, 66

definitions of use-cases used in text, 417-425

described, 66-70

goal-oriented nature of, 67

granularity of, 80

pathways through, 71-79

pitfalls of, 79-80

sample, 83-87

shadow, 80-81

templates for, 71-76, 165-168

weighting of, 411-413

User feedback, collection of, 148-150

User interface, in use-case template, 76

User interface prototype, 131

artifacts in, 136-137

creating of, 141-144

early, 132

first pass for, 139-159

functions of, 133

as learning tool, 150-154

requirements gathering for, 133-134

revision of, 150-151

screen dialogs in, 148-150

windows in, 139-148

V

Variables, definition of, 33-34

Variations, in use-case template, 74

Visibility, 33, 35

Visio (Microsoft), 141

Visual Age for Java (IBM), 143

Visual Basic, 141

Visual modeling

importance of, 320-321

in program code generation, 321

Visual modeling tools

importance of, 47-48, 320

in Rational Rose, 176, 219, 231-237, 320

using, 231-237

VisualCafZ (WebGain), 143, 144

W

Waterfall model of development, 27

Web Archive (WAR) files, 320

Web interfaces

front end of, 207

web.xml, 276

WebLogic (BEA), 144, 204, 205, 206, 268, 274, 319

container services of, 208

screens in, 440-441

userbase of, 439

WebSphere Application Server (IBM), 144, 204, 205, 274, 439

<welcome-first> tag, 277

Windowing

components in, 144-148

types of activities, 139-140

Winters, Jason, 416

Wireless Markup Language (WML), 263

Workflow plan, 383

Workflows, 13

X

XP (Extreme Programming), 16

Y

Yourdon, Ed, in development of UML, 18



Updates

Submit Errata

