BN.com Gift Guide

Building Web Applications with UML / Edition 2

Paperback (Print)
Buy Used
Buy Used from BN.com
$29.41
(Save 41%)
Item is in good condition but packaging may have signs of shelf wear/aging or torn packaging.
Condition: Used – Good details
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 96%)
Other sellers (Paperback)
  • All (18) from $1.99   
  • New (5) from $36.61   
  • Used (13) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$36.61
Seller since 2009

Feedback rating:

(10652)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
New Book. Shipped from US within 4 to 14 business days. Established seller since 2000

Ships from: Secaucus, NJ

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$39.14
Seller since 2008

Feedback rating:

(17860)

Condition: New
Brand New, Perfect Condition, Please allow 4-14 business days for delivery. 100% Money Back Guarantee, Over 1,000,000 customers served.

Ships from: Westminster, MD

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$39.15
Seller since 2007

Feedback rating:

(23578)

Condition: New
BRAND NEW

Ships from: Avenel, NJ

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$55.24
Seller since 2010

Feedback rating:

(10)

Condition: New
8-9-01 other 2 BRAND NEW! ONLY Expedited orders are shipped with tracking number! *WE DO NOT SHIP TO PO BOX* Please allow up to 14 days delivery for order with standard ... shipping. SHIPPED FROM MULTIPLE LOCATIONS. Read more Show Less

Ships from: San Jose, CA

Usually ships in 1-2 business days

  • Canadian
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$66.96
Seller since 2014

Feedback rating:

(6)

Condition: New
New

Ships from: Idyllwild, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Page 1 of 1
Showing All
Close
Sort by

Overview

This is a new edition of the widely acclaimed Building Web Applications with UML. Based on the author's extensive experience as a Web developer, it incorporates helpful reader feedback, identifies and addresses modeling problems unique to page-based Web applications, and offers practical advice and straightforward solutions.

This thoroughly revised Second Edition reflects the latest techniques and issues surrounding the development of software and systems for the Web. You will find:

  • Updated, expanded examples and diagrams
  • Enhanced coverage of the latest Web application security concerns
  • Detailed coverage of proven object technology concepts as applied to the development of Web applications

Robust, scalable, and feature-rich Web applications are attainable. Using the industry-standard Unified Modeling Language (UML) to create designs allows Web application developers to easily integrate them with other systems modeled in UML.

Written for project managers, architects, analysts, designers, and implementers, Building Web Applications with UML, Second Edition , demystifies the challenging aspects of modeling with the Web Application Extension (WAE) for the Unified Modeling Language. Because UML has been widely accepted as the standard language for modeling software systems, it is without question the best option for modeling Web application designs. The WAE extends the UML notation with semantics and constructs that empower you to model Web-specific architectural elements using the Rational Unified Process or an alternative methodology. Furthermore, using UML allows the modeling of Web applications as a part of the complete system and the integration of the business logic that must be reflected in each application.

With this book as your guide, you will be able to gain a clear understanding of how to address the unique problems of modeling the design of page-based Web applications, and more important, how to take your model directly into working code.

0201730383B08282002

Read More Show Less

Editorial Reviews

Booknews
Examines the unique aspects of modeling web applications with the web application extension (WAE) for the unified modeling language (UML). The process uses proven object-oriented techniques from traditional client/server applications to build robust web applications. Annotation c. Book News, Inc., Portland, OR (booknews.com)
Read More Show Less

Product Details

  • ISBN-13: 9780201730388
  • Publisher: Addison-Wesley
  • Publication date: 10/28/2002
  • Series: Addison-Wesley Object-Technology Series
  • Edition description: New Edition
  • Edition number: 2
  • Pages: 468
  • Product dimensions: 7.30 (w) x 8.90 (h) x 1.20 (d)

Meet the Author

Jim Conallen is the Web Modeling Evangelist at Rational Software Corporation, where he has continued his work on the development of the Web Application Extension for the Unified Modeling Language. Prior to joining Rational, he was a consultant specializing in full life cycle object-oriented development. He has built client/server and web-based systems in the transportation, telecommunications, and health care domains; has architected large, high-volume transaction processing systems; and has designed and developed applications in C++, Smalltalk, Java, Delphi and Visual Basic. Jim is a frequent speaker on topics ranging from web application modeling to software best practices. He has written for many industry publications, including ASPToday.com, Rose Architect, and Communications of the ACM.

0201730383AB06262002

Read More Show Less

Read an Excerpt

The first edition of this book hit the streets late in 1999. For the most part, it was based on my experiences in developing Active Server Page-based applications for the retail and healthcare industries. I was an independent consultant then, but shortly before finishing the book I joined Rational Software Corporation. Working for Rational has given me the opportunity to visit and to work with many organizations that are in the process of building Web-centric applications. And I've seen everything, from well-managed teams producing top-quality software to chaotic teams desperately seeking the right guidance to a few others that still seem to be in denial.

In the two years since the publication of the first edition, I've also seen the rise of the J2EE platform, and have to say that since then most of my Web application development experience has been with J2EE architectures. As a result, most of the material in this second edition is oriented toward the Java environment. This doesn't mean that .NET developers, or even Cold Fusion and PHP developers, can't build applications with the guidance in this book. You can. It's just that the majority of the examples in the design and implementation chapters, and in the reference applications, are written for JavaServer Page-based applications.

The ideas in this book and in the previous edition are all the result of a desire to combine my object-oriented skills and the area of Web application development. I had little problem applying use case analysis, and it wasn't until I started creating analysis and design models that I realized things were going to get difficult. When creating a Web application, my conceptual focus was always on the Web page; and my idea of a model kept revolving around the concept of a site map. I knew that the navigation paths throughout the system were incredibly important to understanding the application and that any system model would have to include them.

My earliest attempts at modeling Web applications started with Rumbaugh's OMT (Object Modeling Technique), and later when UML (Unified Modeling Language) version 0.8 was publicly released, I began to apply it. I knew that for any modeling technique to be useful it needed to capture both the relevant semantics of Web-specific elements (e.g., Web pages and hyperlinks) and their relation to the back-end elements of the system (e.g., middle-tier objects and databases). At the time, I found both OMT and UML inadequate to express the things I thought were important in a Web application.

Being a somewhat successful object practitioner and engineer, I jumped to the conclusion that a whole new development methodology and notation was needed. After all, if the existing methods and notation didn't have what I needed, then the obvious solution was to invent one. This, of course, is a trap into which many of us in the software industry fall. In my free time, I started to draft new graphical and semantic ways to represent Web application architectures. Proud of my work, I began showing it to two of my colleagues—Joe Befumo and Gerald Ruldolph, both experienced object practitioners. Their immediate reaction was, Why? I tried to explain the issues involved with Web application development and the need for visually expressing their designs. Still, everyone I spoke with continued to think that developing a new method and notation was overkill.

I started to rethink what I was doing. I wasn't stuck up enough to think that I was right and everyone else was wrong; I had more homework to do. I reexamined my original needs: to express Web application designs at the appropriate level of abstraction and detail, and most important, as a part of the rest of the system's design. Because UML was taking the industry by storm, I realized that anything I did would have to work with UML.

So I went back to UML; this time it was in version 0.91, and a new concept was included—stereotypes. At first I was clueless as to what a stereotype was. The UML specification is not the easiest reading, after all. It was long and difficult, but I knew that any success in the area of modeling Web applications had to come from this direction. Eventually, I started to understand what was meant by stereotyping and the other extension mechanisms: tagged values and constraints. I was finally starting to see a light at the end of the tunnel.

I now had a mechanism with which I could introduce new semantics into the UML grammar, without disturbing the existing semantics. I always knew the key was to provide a consistent and coherent way to model Web-specific elements at the right level of abstraction with the models of the rest of the system. The UML extension mechanism provided me with the framework to do so.

The next step was to start defining the extension by creating stereotypes, tagged values, and constraints. The ability to use custom icons in diagrams with stereotyped elements went a long way to ease my concern for intuitive diagrams. Also Rational Rose, my visual modeling tool of choice, had just introduced a way to use your own stereotypes in Rose models. I quickly created a set of icons for Web-page abstractions. I tried to make them consistent, mostly rectangular with the stereotype indication in the upper left corner. I used filled-in dog ears to represent pages and unfilled dog ears to denote components. Icons without dog ears typically represented contained classes, which cannot be requested directly by a Web browser. The icon for Web-page components is pretty much a copy of the icon used by the three amigos in their Unified Modeling Language User Guide.

Looking back, I remember spending less than a day drawing the icons; I didn't spend much time on it then, since I always believed that eventually someone with a little more experience would design some meaningful icons. In the four years since then, the icons have essentially remained the same; however, a more compact version is now available as a "decoration." This edition of the book also includes examples of how I hand draw many of the icons, just to show that it is possible to model Web systems on cocktail napkins. (Really, I do a fair amount of modeling and thinking about these things at conferences.)

As the extension evolved, and as a lot of the details and inconsistencies were getting corrected, I always kept an eye out for code-generation possibilities. In my mind, the modeling technique could be validated if it was possible (in theory only) to unambiguously generate and reverse engineer code. I even prototyped some Rose scripts that did limited forward engineering. From that point, things proceeded at a tremendous rate. I published a white paper on the Internet and presented the topic at the 1998 Rational Users' Conference in Orlando. Grady Booch took an interest in the work and encouraged me. Addison-Wesley asked if I was interested in expanding the topic into a book. If I had only known how difficult it was going to be to write, I'm not sure that I would have agreed. I followed the original white paper with a stream of other articles for both online and print publications and started to get a regular stream of e-mail comments on the extension.

Since the publication of the first edition of this book, Rational Rose has included automation for the Web modeling that was introduced in that book. I have had the opportunity to work with some top-notch engineers throughout that process—namely, Tommy Fannon and Simon Johnston—and have a greater appreciation for what goes on under the scenes of UML round-trip engineering functionality. With their insights and the input of many others, both in and out of Rational, I believe this new edition of the book and the Web-modeling profile are even more robust and applicable to the Web-centric architectures in use today.

Who Should Read This Book?

This book is meant to introduce architects and designers of client/server systems to the issues and techniques of developing for the Web. It will give the project manager an understanding of the technologies and issues related to developing Web applications. Because this book builds on existing object-oriented (OO) methodologies and techniques, it does not attempt to introduce them. It is expected that the reader has some familiarity with OO principles and concepts and with UML in particular. It is also expected that the reader is familiar with at least one Web application architecture or environment.

For the client/server architect, this book serves as a guide to the technologies and issues of Web applications. The systems architect needs to make decisions about which technologies are appropriate to serve business needs, as expressed by the requirements and use cases. Chapter 7 defines three major client-tier architectural patterns that can help categorize a Web application's architecture. By examining these patterns and their advantages and disadvantages, the architect can make decisions that will define the technological bounds of the application. As with any engineering discipline, the architect must consider the tradeoffs for each technology to be employed in the application architecture. With a solid understanding of the technologies available, and their consequences, an appropriate combination can be put together to best meet the needs of the business problem.

For the analyst and designer, this book introduces an extension to UML that is suitable for expressing Web application design. This extension's key goals are to

  • model the appropriate artifacts (e.g., Web pages, page relationships, navigation routes, client-side scripts, server-side page generation).
  • model at the appropriate level of abstraction and detail.
  • enable the Web-specific elements of the model to interact with the rest of the system's elements.

The analyst/designer should be able to express the execution of the system's business logic in terms of UML models. The idea is to have one unified model of a system's business logic. In the model some of the business logic is executed by traditional server-side objects and components (e.g., middle-tier components, transaction processing monitors, databases) and some of it by Web elements (e.g., browsers, client-side scripts).

For the project manager, this book discusses the potential problems and issues of developing Web applications. It also serves as a guide to the development team members' responsibilities, activities, and roles. In addition to the analyst/designer and the architect, other roles in the development process are discussed. The project manager, being responsible for the overall health of a project, needs a clear understanding of all the roles and responsibilities of the people involved with the process.

This edition of Building Web Applications with UML contains significantly more examples and diagrams. Responding to input from readers, I realized that they too can learn more and faster from well-constructed examples than from lengthy prose. To complement the book, I've provided two reference applications—a J2EE version of the Glossary application, which was described in the first edition, and a sample e-retail application. The e-retail application, however, contains only the client and presentation tiers because this is the focus of this book's modeling efforts.

It was my original intention to update the original ASP-based Glossary application for .NET. Because of the delayed release of the .NET tools and environment, however, I was unable to develop the application such that it properly leveraged all that the .NET environment has to offer.

Organization of This Book

This book is divided into thirteen chapters and five appendices. Conceptually it is also divided into two major parts. Chapters 1 through 5 are essentially an introduction to modeling Web application technologies and concepts. They provide the foundation on which the second part of the book is based. These chapters can be skipped by those intimately familiar with Web application architectures; however, at least a cursory reading is still suggested.

Chapter 2, Web Application Basics, is an introduction to the very basic Web application architecture. This chapter defines the term Web application and thereby its scope and focus. The chapter also defines the principal communication mechanisms and languages. Web application-enabling technologies are discussed. These are the infrastructures that transform simple Web sites (Web systems) into business logic execution systems.

Most of the complexities of designing Web applications are encountered when the client performs some of the business logic in the system. The technologies for allowing this are described in Chapter 3, Dynamic Clients. In this chapter, common Web technologies, such as JavaScript, applets, and ActiveX controls, are discussed. The Document Object Model (DOM) is introduced as the main object interface to client-side resources.

The basic Web application architecture, as described by the technologies in Chapters 2 and 3, are capable of delivering very useful Web applications and are especially useful for public Internet applications such as retail storefronts. For some applications, these basic ingredients are insufficient to deliver the sophisticated level of functionality required. The limiting factors are often the fundamental technologies of HTTP and HTML themselves. Web applications can be extended to encompass and use other communication and formatting technologies in addition to HTTP and HTML. In Chapter 4, Beyond HTTP and HTML, the most common of these technologies are reviewed and discussed.

The final chapter of the first part is Chapter 5, Security. No matter how nonthreatening or uninteresting an application may be, if it is on the Internet, then security is a concern. Even for intranet applications, security should be a concern. Securing a Web application is in many ways much harder than a traditional client/server application. By their very nature, Web servers are open to requests to any node on the network. The trick to making an application secure is in understanding the nature of security risks. Unfortunately, no one product or service that you can buy can guarantee a secure application. Security needs to be designed in an application, and it needs to be continually maintained in that application. New security holes in off-the-shelf software are being discovered all the time. Eventually, one of them will represent a risk to your application. By designing your system with this in mind, managing the next security risk that pops up will be easier.

The second part of this book is devoted to the process of building Web applications. It begins with Chapter 6, The Process, which reviews the entire process of developing OO systems. A sample Web application-development process is introduced. This process is not a complete process but does provide enough detail to establish the context in which the models and artifacts of the process can be understood.

Chapter 7, Defining the Architecture, discusses the activities of defining the architecture of a Web application. Even though this activity usually follows a nearly complete examination of the requirements and use cases of the system, it is discussed earlier to help create the mind-set of developing Web applications. Because the process used here is iterative and incremental, when defining and elaborating the system's use cases, use case specifiers will have in the back of their minds a Web system architecture. In theory, this shouldn't be the case; in practice, however, and in an incremental and iterative process, it is not necessarily wrong to place use cases in the context of a specific architecture.

Chapter 8, Requirements and Use Cases, reviews the process of gathering a system's requirements and defining the system's use cases. All sorts of requirements can be gathered to help specify a particular system. One of the most useful techniques for gathering functional requirements is with use cases. Use cases provide a structured way to gather and express the functional requirements of a system; and they describe the interaction between a user of the system (called an actor) and the system. Use cases are textual documents that describe, in the language of the domain, what the system should do without specifying how it should do it. The hows are expressed in Chapters 9 and 10.

Chapter 9, The User Experience, introduces a new model to the development process—the User Experience (UX) model. The UX model describes the architecturally significant elements of the user interface. The creation of the UX model allows you to separate look-and-feel issues and engineering issues. In this chapter, the UX model is described as a contract between the user experience team that is responsible for designing and building the look and feel and the engineering team that is responsible for implementing the required business logic and functionality. The UX model is introduced at this point because, in many of the organizations I've visited, the activities of fleshing out user-experience artifacts happen shortly after the first set of requirements has been created, which is about the time analysts start modeling the solution.

About the same time user experience is being investigated, the analysis team is analyzing the use cases and requirements specifications of the system and starting to express them in terms of objects. This is the topic of Chapter 10, Analysis. Analysis is the activity of transforming the requirements of a system into a design that can be realized in software. An analysis model, which contains classes and class collaborations that exhibit the behavior of the system, is created, as defined by the use cases.

Chapter 11, Design, and Chapter 12, Advanced Design, discuss how to transform the analysis model into something that maps directly into system components (actual delivered modules). Chapter 11 is where the bulk of the Web Application Extension (WAE) for UML is introduced. Once the design model is completed, it can be mapped directly into executable code.

This book's final chapter, Chapter 13, Implementation, discusses the creation of code from the UML model. Because this edition of the book comes with several reference applications, and a detailed description of the WAE's code mappings (Appendix A), this chapter just introduces a few examples of implementing WAE designs.

The appendices are a big part of this edition. Appendix A, a summary of the WAE profile for UML, is a quick and detailed reference of the UML profile introduced in this book. The remaining appendices are realistic examples of applications in this book that have been modeled with the WAE profile. Appendix B contains the key UML diagrams of a typical online retail store. This application was developed in part from two architectural patterns, Controlled Controllers and Master Template, which are described in Appendices C and D, respectively. Appendix E contains the second reference application—a simple online glossary. The glossary application, which manages a set of definitions for a software development team, demonstrates the use and modeling of complex JavaScript objects. The source code can be downloaded from www.wae-uml.org, the Web site I've set up to support this book.

0201730383P09112002

Read More Show Less

Table of Contents

Foreword.
Preface.

I. OVERVIEW OF MODELING AND WEB-RELATED TECHNOLOGIES.

1. Introduction.

What This Book Is About.
Role of Modeling.
Role of Process.
Influences of Architecture.

2. Web Application Basics.

HTTP.

Document Identification.
Domain Names.
Resource Identifiers.
Fault Tolerance.

HTML.

Anchors.
Forms.
Frames.

Web Applications.

Client State Management.
Enabling Technologies.

3. Dynamic Clients.

Document Object Model.
Scripting.
JavaScript Objects.
Custom JavaScript Objects.
Events.
Java Applets.
ActiveX/COM.

4. Beyond HTTP and HTML.

Distributed Objects.
RMI / IIOP.
DCOM.
XML.
Web Services.

SOAP.
UDDI.
WSDL.

5. Security.

Types of Security Risks.
Technical Risk.
Server-Side Risks.
Client-Side Risks.

Cookies.
JavaScript.
Java.
ActiveX.
Plug-ins and MIME Types.

Security Strategies.

Encryption.
Best Practices.

Modeling Secure Systems.

II. BUILDING WEB APPLICATIONS.

6. Process.

Overview of Software Development.
Software Development for Web Applications.

Develop Software.
Iterate.
Software Iteration.

The Artifacts.

Project Management Set.
Domain Set.
Requirements Set.
Analysis Set.
Design Set.
Implementation Set.
Test Set.
Deployment Set.

7. Defining the Architecture.

Architectural Viewpoints.

Requirements Viewpoint.
Design Viewpoint.
Realization Viewpoint.
Test Viewpoint.
Viewpoint Mappings.

Architecture Activities.

Examining and Prioritizing Use Cases.
Developing Candidate Architectures.
Prototyping: Knowing when to stop.

Web Application Presentation Tier: Architectural Patterns.

Thin Web Client.
Thick Web Client.
Web Delivery.

8. Requirements and Use Cases.

The Vision.
Requirements.
Glossary.
Gathering and Prioritizing Requirements.
Use Cases.
The Use Case Model.

Avoiding Functional Decomposition.
Use Case Model Structure.

The User Experience.

9. The User Experience.

Artifacts of the UX Model.

Screens.
Storyboards.
Navigational Paths.

UX Modeling with UML.

Screen Flow.
User Input.
Screen Compartments.
Storyboard Realizations.

Navigational Map.
UX Model Stereotype Summary.

10. Analysis.

Iteration.
Analysis Model Structure.

Defining the Top Level Model.
Analysis Elements.

Structural Elements.

Behavioral Elements.

UX Model Mapping.
Architecture Elaboration.

11. Design.

Introduction to the Web Application Extension for UML.

Logical View.
Component View.

Designing Web Applications.

Thick Web Client Applications.
Web Delivery Web Applications.
Identifying Web Pages.
Client Side Scripting.

Mapping to the UX Model.
Integrating with Content Management Systems.
Guidelines for Web Application Design.

12. Advanced Design.

HTML Frames.
Advanced Client-Side Scripting.

Script Libraries.
Script Objects.

Virtual and Physical HTTP Resource.
JavaServer Page Custom Tags.

13. Implementation.

Number Store Main Control Mechanism.
Glossary Application Tag Libraries.

Appendix A: Web Application Extension Profile, Version 2.

Overview.
HTML to UML.

URL Resolution.
Elements.

UML to HTML.

Component Packages.
Components.
Classes.
Association Class: +URL Parameters;.
Associations.

Mapping Web Elements to UML, and Vice Versa

JavaServer Page to UML.

UML to JavaServer Page.

Appendix B: The Number Store Reference Application.

Vision.
Background.
Requirements and Features.
Software Architecture Document.
Requirements View.

Use Case View.
User Experience View.
Design.
Component View.

Sample Screen Shots.

Appendix C: Controlled Controllers Pattern.

Use Case View.
Analysis Model Classes.
Analysis Model Collaborations.

Appendix D: Master Template Pattern.

Overview.
Use Case View.
Logical View.

Appendix E: Glossary Application.

Introduction.
Requirements and Use Case Model.
User Experience Model.
Design Model.

Client Tier.
Presentation Tier.
Entity Tier.
Data Tier.

Component View.
Sample Screen Shots.

Index. 0201730383T09112002

Read More Show Less

Preface

The first edition of this book hit the streets late in 1999. For the most part, it was based on my experiences in developing Active Server Page-based applications for the retail and healthcare industries. I was an independent consultant then, but shortly before finishing the book I joined Rational Software Corporation. Working for Rational has given me the opportunity to visit and to work with many organizations that are in the process of building Web-centric applications. And I've seen everything, from well-managed teams producing top-quality software to chaotic teams desperately seeking the right guidance to a few others that still seem to be in denial.

In the two years since the publication of the first edition, I've also seen the rise of the J2EE platform, and have to say that since then most of my Web application development experience has been with J2EE architectures. As a result, most of the material in this second edition is oriented toward the Java environment. This doesn't mean that .NET developers, or even Cold Fusion and PHP developers, can't build applications with the guidance in this book. You can. It's just that the majority of the examples in the design and implementation chapters, and in the reference applications, are written for JavaServer Page-based applications.

The ideas in this book and in the previous edition are all the result of a desire to combine my object-oriented skills and the area of Web application development. I had little problem applying use case analysis, and it wasn't until I started creating analysis and design models that I realized things were going to get difficult. When creating a Web application, my conceptual focus was always on the Web page; and my idea of a model kept revolving around the concept of a site map. I knew that the navigation paths throughout the system were incredibly important to understanding the application and that any system model would have to include them.

My earliest attempts at modeling Web applications started with Rumbaugh's OMT (Object Modeling Technique), and later when UML (Unified Modeling Language) version 0.8 was publicly released, I began to apply it. I knew that for any modeling technique to be useful it needed to capture both the relevant semantics of Web-specific elements (e.g., Web pages and hyperlinks) and their relation to the back-end elements of the system (e.g., middle-tier objects and databases). At the time, I found both OMT and UML inadequate to express the things I thought were important in a Web application.

Being a somewhat successful object practitioner and engineer, I jumped to the conclusion that a whole new development methodology and notation was needed. After all, if the existing methods and notation didn't have what I needed, then the obvious solution was to invent one. This, of course, is a trap into which many of us in the software industry fall. In my free time, I started to draft new graphical and semantic ways to represent Web application architectures. Proud of my work, I began showing it to two of my colleagues--Joe Befumo and Gerald Ruldolph, both experienced object practitioners. Their immediate reaction was, Why? I tried to explain the issues involved with Web application development and the need for visually expressing their designs. Still, everyone I spoke with continued to think that developing a new method and notation was overkill.

I started to rethink what I was doing. I wasn't stuck up enough to think that I was right and everyone else was wrong; I had more homework to do. I reexamined my original needs: to express Web application designs at the appropriate level of abstraction and detail, and most important, as a part of the rest of the system's design. Because UML was taking the industry by storm, I realized that anything I did would have to work with UML.

So I went back to UML; this time it was in version 0.91, and a new concept was included--stereotypes. At first I was clueless as to what a stereotype was. The UML specification is not the easiest reading, after all. It was long and difficult, but I knew that any success in the area of modeling Web applications had to come from this direction. Eventually, I started to understand what was meant by stereotyping and the other extension mechanisms: tagged values and constraints. I was finally starting to see a light at the end of the tunnel.

I now had a mechanism with which I could introduce new semantics into the UML grammar, without disturbing the existing semantics. I always knew the key was to provide a consistent and coherent way to model Web-specific elements at the right level of abstraction with the models of the rest of the system. The UML extension mechanism provided me with the framework to do so.

The next step was to start defining the extension by creating stereotypes, tagged values, and constraints. The ability to use custom icons in diagrams with stereotyped elements went a long way to ease my concern for intuitive diagrams. Also Rational Rose, my visual modeling tool of choice, had just introduced a way to use your own stereotypes in Rose models. I quickly created a set of icons for Web-page abstractions. I tried to make them consistent, mostly rectangular with the stereotype indication in the upper left corner. I used filled-in dog ears to represent pages and unfilled dog ears to denote components. Icons without dog ears typically represented contained classes, which cannot be requested directly by a Web browser. The icon for Web-page components is pretty much a copy of the icon used by the three amigos in their Unified Modeling Language User Guide.

Looking back, I remember spending less than a day drawing the icons; I didn't spend much time on it then, since I always believed that eventually someone with a little more experience would design some meaningful icons. In the four years since then, the icons have essentially remained the same; however, a more compact version is now available as a "decoration." This edition of the book also includes examples of how I hand draw many of the icons, just to show that it is possible to model Web systems on cocktail napkins. (Really, I do a fair amount of modeling and thinking about these things at conferences.)

As the extension evolved, and as a lot of the details and inconsistencies were getting corrected, I always kept an eye out for code-generation possibilities. In my mind, the modeling technique could be validated if it was possible (in theory only) to unambiguously generate and reverse engineer code. I even prototyped some Rose scripts that did limited forward engineering. From that point, things proceeded at a tremendous rate. I published a white paper on the Internet and presented the topic at the 1998 Rational Users' Conference in Orlando. Grady Booch took an interest in the work and encouraged me. Addison-Wesley asked if I was interested in expanding the topic into a book. If I had only known how difficult it was going to be to write, I'm not sure that I would have agreed. I followed the original white paper with a stream of other articles for both online and print publications and started to get a regular stream of e-mail comments on the extension.

Since the publication of the first edition of this book, Rational Rose has included automation for the Web modeling that was introduced in that book. I have had the opportunity to work with some top-notch engineers throughout that process--namely, Tommy Fannon and Simon Johnston--and have a greater appreciation for what goes on under the scenes of UML round-trip engineering functionality. With their insights and the input of many others, both in and out of Rational, I believe this new edition of the book and the Web-modeling profile are even more robust and applicable to the Web-centric architectures in use today.

Who Should Read This Book?

This book is meant to introduce architects and designers of client/server systems to the issues and techniques of developing for the Web. It will give the project manager an understanding of the technologies and issues related to developing Web applications. Because this book builds on existing object-oriented (OO) methodologies and techniques, it does not attempt to introduce them. It is expected that the reader has some familiarity with OO principles and concepts and with UML in particular. It is also expected that the reader is familiar with at least one Web application architecture or environment.

For the client/server architect, this book serves as a guide to the technologies and issues of Web applications. The systems architect needs to make decisions about which technologies are appropriate to serve business needs, as expressed by the requirements and use cases. Chapter 7 defines three major client-tier architectural patterns that can help categorize a Web application's architecture. By examining these patterns and their advantages and disadvantages, the architect can make decisions that will define the technological bounds of the application. As with any engineering discipline, the architect must consider the tradeoffs for each technology to be employed in the application architecture. With a solid understanding of the technologies available, and their consequences, an appropriate combination can be put together to best meet the needs of the business problem.

For the analyst and designer, this book introduces an extension to UML that is suitable for expressing Web application design. This extension's key goals are to

  • model the appropriate artifacts (e.g., Web pages, page relationships, navigation routes, client-side scripts, server-side page generation).
  • model at the appropriate level of abstraction and detail.
  • enable the Web-specific elements of the model to interact with the rest of the system's elements.

The analyst/designer should be able to express the execution of the system's business logic in terms of UML models. The idea is to have one unified model of a system's business logic. In the model some of the business logic is executed by traditional server-side objects and components (e.g., middle-tier components, transaction processing monitors, databases) and some of it by Web elements (e.g., browsers, client-side scripts).

For the project manager, this book discusses the potential problems and issues of developing Web applications. It also serves as a guide to the development team members' responsibilities, activities, and roles. In addition to the analyst/designer and the architect, other roles in the development process are discussed. The project manager, being responsible for the overall health of a project, needs a clear understanding of all the roles and responsibilities of the people involved with the process.

This edition of Building Web Applications with UML contains significantly more examples and diagrams. Responding to input from readers, I realized that they too can learn more and faster from well-constructed examples than from lengthy prose. To complement the book, I've provided two reference applications--a J2EE version of the Glossary application, which was described in the first edition, and a sample e-retail application. The e-retail application, however, contains only the client and presentation tiers because this is the focus of this book's modeling efforts.

It was my original intention to update the original ASP-based Glossary application for .NET. Because of the delayed release of the .NET tools and environment, however, I was unable to develop the application such that it properly leveraged all that the .NET environment has to offer.

Organization of This Book

This book is divided into thirteen chapters and five appendices. Conceptually it is also divided into two major parts. Chapters 1 through 5 are essentially an introduction to modeling Web application technologies and concepts. They provide the foundation on which the second part of the book is based. These chapters can be skipped by those intimately familiar with Web application architectures; however, at least a cursory reading is still suggested.

Chapter 2, Web Application Basics, is an introduction to the very basic Web application architecture. This chapter defines the term Web application and thereby its scope and focus. The chapter also defines the principal communication mechanisms and languages. Web application-enabling technologies are discussed. These are the infrastructures that transform simple Web sites (Web systems) into business logic execution systems.

Most of the complexities of designing Web applications are encountered when the client performs some of the business logic in the system. The technologies for allowing this are described in Chapter 3, Dynamic Clients. In this chapter, common Web technologies, such as JavaScript, applets, and ActiveX controls, are discussed. The Document Object Model (DOM) is introduced as the main object interface to client-side resources.

The basic Web application architecture, as described by the technologies in Chapters 2 and 3, are capable of delivering very useful Web applications and are especially useful for public Internet applications such as retail storefronts. For some applications, these basic ingredients are insufficient to deliver the sophisticated level of functionality required. The limiting factors are often the fundamental technologies of HTTP and HTML themselves. Web applications can be extended to encompass and use other communication and formatting technologies in addition to HTTP and HTML. In Chapter 4, Beyond HTTP and HTML, the most common of these technologies are reviewed and discussed.

The final chapter of the first part is Chapter 5, Security. No matter how nonthreatening or uninteresting an application may be, if it is on the Internet, then security is a concern. Even for intranet applications, security should be a concern. Securing a Web application is in many ways much harder than a traditional client/server application. By their very nature, Web servers are open to requests to any node on the network. The trick to making an application secure is in understanding the nature of security risks. Unfortunately, no one product or service that you can buy can guarantee a secure application. Security needs to be designed in an application, and it needs to be continually maintained in that application. New security holes in off-the-shelf software are being discovered all the time. Eventually, one of them will represent a risk to your application. By designing your system with this in mind, managing the next security risk that pops up will be easier.

The second part of this book is devoted to the process of building Web applications. It begins with Chapter 6, The Process, which reviews the entire process of developing OO systems. A sample Web application-development process is introduced. This process is not a complete process but does provide enough detail to establish the context in which the models and artifacts of the process can be understood.

Chapter 7, Defining the Architecture, discusses the activities of defining the architecture of a Web application. Even though this activity usually follows a nearly complete examination of the requirements and use cases of the system, it is discussed earlier to help create the mind-set of developing Web applications. Because the process used here is iterative and incremental, when defining and elaborating the system's use cases, use case specifiers will have in the back of their minds a Web system architecture. In theory, this shouldn't be the case; in practice, however, and in an incremental and iterative process, it is not necessarily wrong to place use cases in the context of a specific architecture.

Chapter 8, Requirements and Use Cases, reviews the process of gathering a system's requirements and defining the system's use cases. All sorts of requirements can be gathered to help specify a particular system. One of the most useful techniques for gathering functional requirements is with use cases. Use cases provide a structured way to gather and express the functional requirements of a system; and they describe the interaction between a user of the system (called an actor) and the system. Use cases are textual documents that describe, in the language of the domain, what the system should do without specifying how it should do it. The hows are expressed in Chapters 9 and 10.

Chapter 9, The User Experience, introduces a new model to the development process--the User Experience (UX) model. The UX model describes the architecturally significant elements of the user interface. The creation of the UX model allows you to separate look-and-feel issues and engineering issues. In this chapter, the UX model is described as a contract between the user experience team that is responsible for designing and building the look and feel and the engineering team that is responsible for implementing the required business logic and functionality. The UX model is introduced at this point because, in many of the organizations I've visited, the activities of fleshing out user-experience artifacts happen shortly after the first set of requirements has been created, which is about the time analysts start modeling the solution.

About the same time user experience is being investigated, the analysis team is analyzing the use cases and requirements specifications of the system and starting to express them in terms of objects. This is the topic of Chapter 10, Analysis. Analysis is the activity of transforming the requirements of a system into a design that can be realized in software. An analysis model, which contains classes and class collaborations that exhibit the behavior of the system, is created, as defined by the use cases.

Chapter 11, Design, and Chapter 12, Advanced Design, discuss how to transform the analysis model into something that maps directly into system components (actual delivered modules). Chapter 11 is where the bulk of the Web Application Extension (WAE) for UML is introduced. Once the design model is completed, it can be mapped directly into executable code.

This book's final chapter, Chapter 13, Implementation, discusses the creation of code from the UML model. Because this edition of the book comes with several reference applications, and a detailed description of the WAE's code mappings (Appendix A), this chapter just introduces a few examples of implementing WAE designs.

The appendices are a big part of this edition. Appendix A, a summary of the WAE profile for UML, is a quick and detailed reference of the UML profile introduced in this book. The remaining appendices are realistic examples of applications in this book that have been modeled with the WAE profile. Appendix B contains the key UML diagrams of a typical online retail store. This application was developed in part from two architectural patterns, Controlled Controllers and Master Template, which are described in Appendices C and D, respectively. Appendix E contains the second reference application--a simple online glossary. The glossary application, which manages a set of definitions for a software development team, demonstrates the use and modeling of complex JavaScript objects. The source code can be downloaded from www.wae-uml.org, the Web site I've set up to support this book.

0201730383P09112002

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)