UML—that makes the many facets of software engineering approachable to. This book is based Object-Oriented So Applying UML and Patterns: An. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and eBook PDF Files; Language: English; ISBN ; ISBN Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition) [Craig Larman] on caite.info
|Language:||English, Spanish, Arabic|
|ePub File Size:||16.43 MB|
|PDF File Size:||14.20 MB|
|Distribution:||Free* [*Regsitration Required]|
Applying UML and Patterns in OOA/D 3. Assigning .. final print images were generated as PDF files using Adobe Acrobat Distiller, from PostScript generated by. applying uml and patterns by craig larman 3rd edition - AraNaldinho/Applying- uml-and-patterns-3rd-editiom. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and. Iterative The final print images were generated as PDF using.
Certain tried-and-true solutions to design problems can be and have been expressed as best-practice principles, heuristics, or pat- terns—named problem-solution formulas that codify exemplary design princi- ples. Seventh, it shows how to map object design artifacts to code in Java. Predictive processes usually have a "waterfall" or sequential lifecycle—first, defining all the requirements; second, defining a detailed design; and third, implementing. How should responsibilities be allocated to classes of objects? The relative effort in disciplines shifts across the phases.
As a Chegg Study subscriber, you can view available interactive solutions manuals for each of your classes for one low monthly price. Why buy extra books when you can get all the homework help you need in one place? You bet! Just post a question you need help with, and one of our experts will provide a custom solution. You can also find solutions immediately by searching the millions of fully answered study questions in our archive.
You can download our homework help app on iOS or Android to access solutions manuals on your mobile device. Asking a study question in a snap - just take a pic.
IT Research Library. Miscellaneous Books. Computer Languages. Computer Science. Electronic Engineering. Linux and Unix. Microsoft and. Mobile Computing. Networking and Communications. The proverb "owning a hammer doesn't make one an architect" is especially true with respect to object technology.
Knowing an object-oriented language such as Java is a necessary but insufficient first step to create object systems. Knowing how to "think in objects" is also critical. It is not meant as an advanced text; it emphasizes mastery of the fundamentals, such as how to assign respon- sibilities to objects, frequently used UML notation, and common design pat- At the same time, primarily in later chapters, the material progresses to a few intermediate-level topics, such as framework design.
The book is not just about the UML. The UML is a standard diagramming nota- tion. As useful as it is to learn notation, there are more critical object-oriented things to learn; specifically, how to think in objects—how to design object-ori- ented systems. It is not so helpful to learn syntactically correct UML diagramming and perhaps a UML CASE tool, but then not be able to create an excellent design, or evaluate and improve an existing one.
This is the harder and more valuable skill. Conse- quently, this book is an introduction to object design. But the emphasis is on helping people learn the art and science of building object systems, rather than notation.
How should responsibilities be allocated to classes of objects? How should objects interact? What classes should do what? These are critical questions in the design of a system. Certain tried-and-true solutions to design problems can be and have been expressed as best-practice principles, heuristics, or pat- terns—named problem-solution formulas that codify exemplary design princi- ples.
This book, by teaching how to apply patterns, supports quicker learning and skillful use of these fundamental object design idioms. Therefore, the case study begins with an introduction to these topics, even though they are not specifically object-oriented. Given many possible activities from requirements through to implementation, how should a developer or team proceed? In this case, the well-known Unified Process is used as the sample iterative develop- ment process within which these topics are introduced.
However, the analysis and design topics that are covered are common to many approaches, and learn- ing them in the context of the Unified Process does not invalidate their applica- bility to other methods. It illustrates this in the context of a single case study. For example, usability engineer- ing and user interface design are critical to success; so is database design. It is one piece of a larger picture. Suppose we must choose a single practical skill from all the topics discussed here—a "desert island" skill.
What would it be? Because it is one activity that must be performed—either while drawing a UML diagram or programming—and it strongly influences the robustness, maintainability, and reusability of software components.
On a real project, a developer might not have the opportunity to perform any other analysis or design activities—the "rush to code" development process. Yet even in this situation, assigning respon- sibilities is inevitable.
Consequently, the design steps in this book emphasize principles of responsibil- ity assignment. Nine fundamental principles in object design and responsibility assignment are presented and applied.
Analysis emphasizes an investigation of the problem and requirements, rather than a solution. For example, if a new computerized library information system is desired, how will it be used? Design emphasizes a conceptual solution that fulfills the requirements, rather than its implementation. For example, a description of a database schema and software objects. Ultimately, designs can be implemented. As with analysis, the term is best qualified, as in object design or database design.
Analysis and design have been summarized in the phase do the right thing analysis , and do the thing right design. During object-oriented analysis, there is an emphasis on finding and describ- ing the objects—or concepts—in the problem domain.
For example, in the case of the library information system, some of the concepts include Book, Library, and Patron. During object-oriented design, there is an emphasis on defining software objects and how they collaborate to fulfill the requirements. For example, in the library system, a Book software object may have a title attribute and a getChap-ter method see Figure 1.
Finally, during implementation or object-oriented programming, design objects are implemented, such as a Book class in Java.
Figure 1. If the total is seven, they win; otherwise, they lose. Use cases are not an object-oriented artifact—they are simply written stories. However, they are a popular tool in requirements analysis and are an important part of the Unified Process. For example, here is a brief version of the Play a Dice Game use case: Play a Dice Game: A player picks up and rolls the dice.
If the dice face value total seven, they win; otherwise, they lose. Define a Domain Model Object-oriented analysis is concerned with creating a description of the domain from the perspective of classification by objects.
A decomposition of the domain involves an identification of the concepts, attributes, and associations that are considered noteworthy. The result can be expressed in a domain model, which is illustrated in a set of diagrams that show domain concepts or objects. For example, a partial domain model is shown in Figure 1.
Note that a domain model is not a description of software objects; it is a visual- ization of concepts in the real-world domain. Define Interaction Diagrams Object-oriented design is concerned with defining software objects and their col- laborations. A common notation to illustrate these collaborations is the interac- tion diagram. It shows the flow of messages between software objects, and thus the invocation of methods. For example, assume that a software implementation of the dice game is desired.
The interaction diagram in Figure 1. Notice that although in the real world a player rolls the dice, in the software design the DiceGame object "rolls" the dice that is, sends messages to Die objects. Software object designs and programs do take some inspiration from real-world domains, but they are not direct models or simulations of the real world. DiceGame play die1: Die fv1: Die roll roll fv2: This illustrates the attributes and methods of the classes.
For example, in the dice game, an inspection of the interaction diagram leads to the partial design class diagram shown in Figure 1. Since a play message is sent to a DiceGame object, the DiceGame class requires a play method, while class Die requires a roll and getFaceValue method. In contrast to the domain model, this diagram does not illustrate real-world con- cepts; rather, it shows software classes. Summary The dice game is a simple problem, presented to focus on a few steps and arti- facts in analysis and design.
To keep the introduction simple, not all the illus- trated UML notation was explained. Future chapters explore analysis and design and these artifacts in closer detail. The Unified Modeling Language UML is a language for speci- fying, visualizing, constructing, and documenting the artifacts of software systems, as well as for business modeling and other non-software systems [OMG01].
The UML has emerged as the de facto and de jure standard diagramming nota- tion for object-oriented modeling. It started as an effort by Grady Booch and Jim Rumbaugh in to combine the diagramming notations from their two popu- 10 Define domain model Define interaction diagrams Define design class diagrams Define use cases 2 Die faceValue: Die die2: Die play 1 They were later joined by Ivar Jacobson, the creator of the Objectory method, and as a group came to be known as the three amigos.
Many others contributed to the UML, perhaps most notably Cris Kobryn, a leader in its ongoing refinement. This book does not cover every minute aspect of the UML, which is a large body of notation some say, too large1.
It focuses on diagrams which are frequently used, the most commonly used features within those diagrams, and core nota- tion that is unlikely to change in future versions of the UML. This is not just a UML notation book, but one that explores the larger picture of applying the UML, patterns, and an iterative process in the context of software development. For a detailed discussion of UML version 1.
UML revision work and soon-to-be released versions can be found at www. There are many books on software patterns, but the seminal classic is Design Patterns, by Gamma, Helm, Johnson, and Vlissides.
It is truly required reading 1. The UML 2. This book presents high-use UML likely to survive future simplification. However, it is not an introductory text and is best read after developing comfort with the fundamentals of object design and programming. Good people with a good process will outperform good people with no process every time.
Consequently, it is useful to read this chapter so that these core concepts and their influence on the book's structure are clear. This chapter summarizes a few key ideas; please see Chapter 37 for further dis- cussion of the UP and iterative process practices. Informally, a software development process describes an approach to build- ing, deploying, and possibly maintaining software. The Unified Process [JBR99] has emerged as a popular software development process for building object-oriented systems.
The Unified Process UP combines commonly accepted best practices, such as an iterative lifecycle and risk-driven development, into a cohesive and well-doc- umented description. This book starts with an introduction to the UP for two reasons: The UP is an iterative process. This text presents an introduction to the UP, not complete coverage. Also, the UP presents common activities and best practices. Nevertheless, the central ideas of this book—such as use cases and design patterns—are indepen- dent of any particular process, and apply to many.
Iterative Development The UP promotes several best practices, but one stands above the others: In this approach, development is organized into a series of short, fixed-length for example, four week mini-projects called iterations; the outcome of each is a tested, integrated, and executable system.
Each iteration includes its own requirements analysis, design, implementation, and testing activities. The iterative lifecycle is based on the successive enlargement and refinement of a system through multiple iterations, with cyclic feedback and adaptation as core drivers to converge upon a suitable system.
The system grows incremen- tally over time, iteration by iteration, and thus this approach is also known as iterative and incremental development see Figure 2. Figure 2. Example As an example not a recipe , in a two-week iteration half-way through a project, perhaps Monday is spent primarily on distributing and clarifying the tasks and requirements of the iteration, while one person reverse-engineers the last iteration's code into UML diagrams via a CASE tool , and prints and displays noteworthy diagrams.
Tuesday is spent at whiteboards doing pair design work drawing rough UML diagrams captured on digital cameras, and writing some pseudocode and design notes.
The remaining eight days are spent on implementation, testing unit, acceptance, usability, Other activities include demonstrations and evaluations with stakeholders, and planning for the next iteration. Notice in this example that there is neither a rush to code, nor a long drawn-out design step that attempts to perfect all details of the design before program- ming.
A "little" forethought regarding the design with visual modeling using rough and fast UML drawings is done; perhaps a half or full day by developers doing design work in pairs.
The result of each iteration is an executable but incomplete system; it is not ready to deliver into production. The system may not be eligible for production deployment until after many iterations; for example, 10 or 15 iterations. Iterations are fixed in length, or timeboxed. Rather, the output is a production-grade subset of the final system. Although, in general, each iteration tackles new requirements and incremen- tally extends the system, an iteration may occasionally revisit existing software and improve it; for example, one iteration may focus on improving the perfor- mance of a subsystem, rather than extending it with new features.
Embracing Change: This phrase is evocative of a key attitude of iterative develop- ment: Rather than fighting the inevitable change that occurs in software devel- opment by trying usually unsuccessfully to fully and correctly specify, freeze, and "sign off" on a frozen requirement set and design before implementation, iterative development is based on an attitude of embracing change and adapta- tion as unavoidable and indeed essential drivers.
This is not to say that iterative development and the UP encourages an uncon- trolled and reactive "feature creep"-driven process. Subsequent chapters explore how the UP balances the need—on the one hand—to agree upon and stabilize a set of requirements, with—on the other hand—the reality of changing require- ments, as stakeholders clarify their vision or the marketplace changes.
Each iteration involves choosing a small subset of the requirements, and quickly designing, implementing, and testing. In early iterations the choice of require- ments and design may not be exactly what is ultimately desired.
But the act of swiftly taking a small step, before all requirements are finalized, or the entire design is speculatively defined, leads to rapid feedback—feedback from the users, developers, and tests such as load and usability tests. This early feedback is worth its weight in gold; rather than speculating on the correct requirements or design, the feedback from realistic building and testing something provides crucial practical insight and an opportunity to modify or adapt understanding of the requirements or design.
End-users have a chance to quickly see a partial system and say, "Yes, that's what I asked for, but now that I try it, what I really want is something slightly different. Yet, as mentioned, this is not an endorsement of chaotic and reactive development in which developers continually change direction—a mid- dle way is possible.
In addition to requirements clarification, activities such as load testing will prove if the partial design and implementation are on the right path, or if in the 1. Or more likely, "You didn't understand what I wanted!
Better to resolve and prove the risky and critical design decisions early rather than late—and iterative development provides the mechanism for this. Consequently, work proceeds through a series of structured build-feedback-adapt cycles. Not surprisingly, in early iterations the deviation from the "true path" of the system in terms of its final requirements and design will be larger than in later iterations. Over time, the system converges towards this path, as illustrated in Figure 2.
The requirements and design instability lowers over time. Benefits of Iterative Development Benefits of iterative development include: Via feedback and adaptation, the system converges towards the most appropriate requirements and design.
In late iterations, a significant change in requirements is rare, but can occur. Such late changes may give an organization a competitive business advantage. Small steps, rapid feedback, and adaptation are central ideas in iterative development; long iterations subvert the core motiva- tion for iterative development and increase project risk. Much less than two weeks, and it is difficult to complete sufficient work to get meaningful through- put and feedback; much more than six or eight weeks, and the complexity becomes rather overwhelming, and feedback is delayed.
A very long iteration misses the point of iterative development. Short is good. A key idea is that iterations are timeboxed, or fixed in length. For example, if the next iteration is chosen to be four weeks long, then the partial system should be integrated, tested, and stabilized by the scheduled date—date slippage is dis- couraged. If it seems that it will be difficult to meet the deadline, the recom- mended response is to remove tasks or requirements from the iteration, and include them in a future iteration, rather than slip the completion date.
Chapter 37 summarizes reasons for timeboxing. Massive teams for example, several hundred developers may require longer than six-week iterations to compensate for the overhead of coordination and communication; but no more than three to six months is recommended.
For example, the successful replacement in the s of the Canadian air traffic control system was developed with an iterative lifecycle and other UP practices. It involved programmers and was organized into six-month iterations. A six-month iteration is the exception for massive teams, not the rule. To reiter- ate, the UP recommends that normally an iteration should be between two and six weeks in duration.
Philippe Kruchten, who also led the development of the RUP, served as chief architect for the project. Inception— approximate vision, business case, scope, vague estimates. Elaboration—refined vision, iterative implementation of the core architec ture, resolution of high risks, identification of most requirements and scope, more realistic estimates. Construction—iterative implementation of the remaining lower risk and easier elements, and preparation for deployment. Transition—beta tests, deployment.
These phases are more fully defined in subsequent chapters. This is not the old "waterfall" or sequential lifecycle of first defining all the requirements, and then doing all or most of the design.
Inception is not a requirements phase; rather, it is a kind of feasibility phase, where just enough investigation is done to support a decision to continue or stop. Similarly, elaboration is not the requirements or design phase; rather, it is a phase where the core architecture is iteratively implemented, and high risk issues are mitigated. Notice that one development cycle which ends in the release of a system into production is composed of many iterations.
In the UP, an artifact is the general term for any work product: There are several disciplines in the UP; this book focuses on some artifacts in the following three: When engaged in large-scale business analysis or business process reengineering, this includes dynamic modeling of the busi ness processes across the entire enterprise. In , the old UP term "workflow" was replaced by the new term "discipline" in order to harmonize with an international standardization effort called the OMG SPEM; because of its prior meaning in the UP, many continue to use the term work- flow to mean discipline, although this is not strictly correct.
The term "workflow" took on a new but slightly different meaning within the UP: On a particular project, it is a particular sequence of activities perhaps across disciplines —a flow of work. The end of each iteration is a minor release.
The Environment discipline refers to establishing the tools and customizing the process for the project—that is, setting up the tool and process environment.