Home > Store > Software Development & Management > Object Technology

Developing Applications with Java™ and UML

Register your product to gain access to bonus material or receive a coupon.

Developing Applications with Java™ and UML

Book

  • Your Price: $35.99
  • List Price: $44.99
  • Available on demand.

Description

  • Copyright 2002
  • Dimensions: 7-3/8x9-1/4
  • Pages: 504
  • 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

More Information

Unlimited one-month access with your purchase
Free Safari Membership