After starting a few books in this series, this is the one I ended up finishing because of its readability. As an introduction to RUP, this book did its job. My only reservation is that it might be a bit too formal for those unfamiliar with the RUP jargon.

"The Rational Unified Process, An Introduction" offers readers a concise and strong introduction to the topic of the Rational Unified Process (RUP). Stressing the role of RUP in unifying the entire software development process, this book underscores the importance of efficient and effective software development.

The book is structured in a logical and easy-to-follow manner and makes good use of descriptive graphics. For those with an interest in optimizing their software development processes, this is a good addition to your library.

It's an introduction, all right. The trouble is, it's such a high level introduction that there's almost no useful information whatsoever. The entire time I was reading, I was waiting for the author to get to the meat, only to discover at the end that there was none. It was like ordering a double cheeseburger, and getting two buns with ketchup and a pickle, and no beef patties.



I can only assume that Rational paid the author for his time in the hopes that people, after reading this book, would purchase their entire software suite just to find out what the RUP actually involves.



Despite my severe disappointment (and relief that I didn't have to pay for it myself), I can't rate it any lower than two stars. It's well written, and it could quite possibly be useful to managers and other business types who have no idea how software development works. The second star is for Rational's sheer chutzpah in getting a respected publisher to put out a $30 marketing pamphlet for them.

It's an introduction, all right. The trouble is, it's such a high level introduction that there's almost no useful information whatsoever. The entire time I was reading, I was waiting for the author to get to the meat, only to discover at the end that there was none. It was like ordering a double cheeseburger, and getting two buns with ketchup and a pickle, and no beef patties.

I can only assume that Rational paid the author for his time in the hopes that people, after reading this book, would purchase their entire software suite just to find out what the RUP actually involves.

Despite my severe disappointment (and relief that I didn't have to pay for it myself), I can't rate it any lower than two stars. It's well written, and it could quite possibly be useful to managers and other business types who have no idea how software development works. The second star is for Rational's sheer chutzpah in getting a respected publisher to put out a $30 marketing pamphlet for them.

It's an introduction, all right. The trouble is, it's such a high level introduction that there's almost no useful information whatsoever. The entire time I was reading, I was waiting for the author to get to the meat, only to discover at the end that there was none. It was like ordering a double cheeseburger, and getting two buns with ketchup and a pickle, and no beef patties.

I can only assume that Rational paid the author for his time in the hopes that people, after reading this book, would purchase their entire software suite just to find out what the RUP actually involves.

Despite my severe disappointment (and relief that I didn't have to pay for it myself), I can't rate it any lower than two stars. It's well written, and it could quite possibly be useful to managers and other business types who have no idea how software development works. The second star is for Rational's sheer chutzpah in getting a respected publisher to put out a $30 marketing pamphlet for them.

This book introduces the logic behind Rational Unified Process (RUP). RUP is a novel idea. It puts several good practices in a consolidated package. What makes RUP useful is the fact that Rational provides all the necessary software tools to support this. This book does an average job in explaining the RUP. It over stresses obvious and well accepted concepts like "iterative development"; which makes the first half (6 chapters) of this book a bit boring. For a professional with software development and management experience, I found the first sixe chapters are best read at a cursory glance. The second half of the book introduces the workflows - and it is this half that I found more interesting. I finished this book as bed time readoing over the weekend - so this book is an easy reading. However this book is not about teaching how to use Rational Products. This book only gives an overview of the basis of origination of RUP. You would need another book to become an expert in using RUP.

Target Audience
IT professionals who need to learn about the Rational Unified Process (RUP)

Contents
This book is a relatively high-level overview of the entire RUP process.

The book is divided into the following chapters: Software Development Best Practices; The Rational Unified Process; Static Structure: Process Description; Dynamic Structure: Iterative Development; An Architecture-Centric Process; A Use-Case-Driven Process; The Project Management Discipline; The Business Modeling Discipline; The Requirements Discipline; The Analysis and Design Discipline; The Implementation Discipline; The Test Discipline; The Configuration and Change Management Discipline; The Environment Discipline; The Deployment Discipline; Typical Iteration Plans; Implementing the Rational Unified Process; Summary of Roles; Summary of Artifacts; Acronyms; Glossary; Bibliography; Index

Review
The Rational Unified Process, or RUP, is a software engineering methodology that attempts to map out and document all parts of a software development project. It's extremely comprehensive, but it's also adaptable to whatever level of effort is appropriate for your situation. This book, The Rational Unified Process - An Introduction, is a good start to begin your understanding of RUP.

First off, let me say this is not an easy read. It's a good book with all the information you need to know to start using RUP, but the information is dense and highly detail oriented. Like most developers, I'm more oriented towards coding and testing. But realistically, you need to know what the system should do before you get to the coding piece. RUP helps to put all that into a formal framework so that the necessary things will get done in the proper order.

While the entire RUP framework might feel overwhelming, the author makes sure to let you know that you can adapt the RUP to meet your situation. If you are adding a function to an existing system, you will be more focused on use cases, development, and deployment processes. The author does a good job in segmenting the information so that you can more easily focus on your needs.

You should also not consider this the end-all volume on RUP that you will ever need. Kruchten doesn't try to detail specific techniques like use cases or UML. You will learn where they fit in to RUP, but you will need additional information on how to implement use cases or UML diagrams. Consider this the volume that allows you to place everything in a mental framework so that you can figure out what you will need to know going forward.

Conclusion
If you are considering or in the process of implementing RUP, this is a book you should be studying. It's not an easy read, but it will give you the overview you need to understand the process and concepts.

The Rational Unified Process (RUP) was originally developed by Rational Software, which was recently purchased by IBM. Therefore, you now see the RUP sometimes referred to as IBM's Web-enabled software engineering process. As this name implies, it is a set of guidelines, some soft and others fairly rigid to the point of being a rule, for the creation of software. Like all useful principles of computer science, the RUP is a dynamic entity, being constantly modified to reflect the changes taking place in software creation. Therefore, if you are already familiar with the RUP and are wondering if you should read this book, the answer is an emphatic yes. If you are unfamiliar with the RUP, the answer is an even more emphatic yes.
The purpose of this book is to provide an introduction to RUP 2003, the latest iteration of the process. Like the previous books on RUP, it is written at a level suitable for managers. There is some necessary technical jargon, but nothing beyond what a software project development manager would be expected to be able to comprehend.
The book opens with a history of the RUP, what it is used for and the overall structure of the RUP. This is followed by a very brief introduction to fundamental concepts such as iterative development, architecture-centric processes and use cases. Necessary for beginners, most of this material can be skipped by those having experience in those areas.
Part II covers the various areas, referred to as disciplines. They are:

* The project management discipline.
* The business-modeling discipline.
* The requirements discipline.
* The analysis and design discipline.
* The implementation discipline.
* The test discipline.
* The configuration and change management discipline.
* The environment discipline.
* The deployment discipline.

While the steps used in the analysis differs from discipline to discipline, the following are common to all:

* Purpose.
* Roles and artifacts.
* Workflow.
* Tool support.
* Summary.

The tool support section is particularly helpful if you are evaluating the RUP for possible use in your organization. IBM/Rational has many tools that can aid you in your efficient use of the RUP. In fact, without software tools to aid you, much of the material in this book would be of theoretical interest only.
Large software projects require an overall organizing process to be imposed on them if there is to be a chance for successful completion. The RUP is currently one of the best such processes and this book will show the fundamentals of the process and how it can work for you.

The Rational Unified Process (RUP) was originally developed by Rational Software, which was recently purchased by IBM. Therefore, you now see the RUP sometimes referred to as IBM's Web-enabled software engineering process. As this name implies, it is a set of guidelines, some soft and others fairly rigid to the point of being a rule, for the creation of software. Like all useful principles of computer science, the RUP is a dynamic entity, being constantly modified to reflect the changes taking place in software creation. Therefore, if you are already familiar with the RUP and are wondering if you should read this book, the answer is an emphatic yes. If you are unfamiliar with the RUP, the answer is an even more emphatic yes.
The purpose of this book is to provide an introduction to RUP 2003, the latest iteration of the process. Like the previous books on RUP, it is written at a level suitable for managers. There is some necessary technical jargon, but nothing beyond what a software project development manager would be expected to be able to comprehend.
The book opens with a history of the RUP, what it is used for and the overall structure of the RUP. This is followed by a very brief introduction to fundamental concepts such as iterative development, architecture-centric processes and use cases. Necessary for beginners, most of this material can be skipped by those having experience in those areas.
Part II covers the various areas, referred to as disciplines. They are:

* The project management discipline.
* The business-modeling discipline.
* The requirements discipline.
* The analysis and design discipline.
* The implementation discipline.
* The test discipline.
* The configuration and change management discipline.
* The environment discipline.
* The deployment discipline.

While the steps used in the analysis differs from discipline to discipline, the following are common to all:

* Purpose.
* Roles and artifacts.
* Workflow.
* Tool support.
* Summary.

The tool support section is particularly helpful if you are evaluating the RUP for possible use in your organization. IBM/Rational has many tools that can aid you in your efficient use of the RUP. In fact, without software tools to aid you, much of the material in this book would be of theoretical interest only.
Large software projects require an overall organizing process to be imposed on them if there is to be a chance for successful completion. The RUP is currently one of the best such processes and this book will show the fundamentals of the process and how it can work for you.

First of all, please let me clarify something. In another review of mine (for the book "The Rational Unified Process Made Easy" of Kroll & Kruchten) I mentioned that there are 3 books on the RUP. Well, this might have been true in August of 2003, but it is not anymore: There are 3 more books on the RUP out there, namely:
- "Adopting the Rational Unified Process"
- "Software Development for Small Teams"
- "Practical Software Engineering" (.NET-oriented)

To be frank, I found the "Made Easy" book to a be a bit more fun than this one. Probably, because this book is more descriptive, whereas the "Made Easy" one is more normative. Having said that, I feel this book is the definitive book to have if you
are working with the RUP, and a heck of a useful book to read even if you're not. Especially now that everything Rational has gained more leverage (because of the acquisition of Rational Software by IBM that gives RUP an arguably more powerful marketing mechanism and exposure, let alone its plausible gradual integration into the methodologies used by the 150,000-people-strong IBM Global Services organization), this book becomes even more relevant.

There is a foreword by Grady Booch (one of the 3 amigos) that goes though a can-never-remember-how-many thousand mile view of the whole landscape, followed by a chapter by the author, who briefly goes through all the nice concepts (iterative development, architecture, etc.) that permeate the RUP. There is also a brief history of the RUP in this chapter that I found quite illuminating. I always like to know the historal context; it usually helps explain the rationale behind ideas and constructs.

The next chapter, entitled "Static Structure", discusses the constituent concepts of the RUP, namely role, activity, artifact, workflow, discipline, deliberately ignoring for the moment the temporal dimension (for the most part). It is chapter 4, "Dynamic Structure", where the core concept of iterative development is expounded, and the expected contrast with the traditional waterfall is made (hence explaining the rationale for coming up with the perhaps-not-intuitive-at-first-glance idea of iterative development). Phases and milestones are explained.

If there are three pillars of the RUP, these are (i) iterative development, (ii) executable architecture, and (iii) use-case driven development. Hence, it comes to no surprise that the next two chapters deal with architecture and use cases. In chapter 5 a mention is made, among other things, to the author's important work on the 4+1 Views of Architecture that underlies the RUP. Chapter 6 is a condensed discussion of the role and merit of use cases in a software development process in general, and RUP in particular.

This concludes Part I of the book. Part II consists of 9 chapters, one for each RUP so-called discipline (Project Management, Business Modeling, Requirements, Analysis and Design, Implementation, Test, Configuration, Environment, Deployment). The "Made Easy" book follows a similar pattern, with the difference, congruent with I've already mentioned above, that this book tends to treat the Disciplines in a descriptive rather than normative manner.

There is a pretty good "Summary of Roles" appendix at the end, and I liked the Glossary too, as the definitions contained therein are very precise but at the same time very comprehensible too. Finally, there is a rich annotated bibliography section, which, if you're at all like me, you'll find rather useful (There's also a poster of the RUP at the back if you're into that sort of thing).

All in all, I haven't at all regretted the ?38.50 and the time I've spent reading the book; and imagine that I was familiar with this stuff already. If this happens to be the first book you read on RUP (as it should normally be) then the benefit for you will be even greater.

First of all, please let me clarify something. In another review of mine (for the book "The Rational Unified Process Made Easy" of Kroll & Kruchten) I mentioned that there are 3 books on the RUP. Well, this might have been true in August of 2003, but it is not anymore: There are 3 more books on the RUP out there, namely:
- "Adopting the Rational Unified Process"
- "Software Development for Small Teams"
- "Practical Software Engineering" (.NET-oriented)

To be frank, I found the "Made Easy" book to a be a bit more fun than this one. Probably, because this book is more descriptive, whereas the "Made Easy" one is more normative. Having said that, I feel this book is the definitive book to have if you
are working with the RUP, and a heck of a useful book to read even if you're not. Especially now that everything Rational has gained more leverage (because of the acquisition of Rational Software by IBM that gives RUP an arguably more powerful marketing mechanism and exposure, let alone its plausible gradual integration into the methodologies used by the 150,000-people-strong IBM Global Services organization), this book becomes even more relevant.

There is a foreword by Grady Booch (one of the 3 amigos) that goes though a can-never-remember-how-many thousand mile view of the whole landscape, followed by a chapter by the author, who briefly goes through all the nice concepts (iterative development, architecture, etc.) that permeate the RUP. There is also a brief history of the RUP in this chapter that I found quite illuminating. I always like to know the historal context; it usually helps explain the rationale behind ideas and constructs.

The next chapter, entitled "Static Structure", discusses the constituent concepts of the RUP, namely role, activity, artifact, workflow, discipline, deliberately ignoring for the moment the temporal dimension (for the most part). It is chapter 4, "Dynamic Structure", where the core concept of iterative development is expounded, and the expected contrast with the traditional waterfall is made (hence explaining the rationale for coming up with the perhaps-not-intuitive-at-first-glance idea of iterative development). Phases and milestones are explained.

If there are three pillars of the RUP, these are (i) iterative development, (ii) executable architecture, and (iii) use-case driven development. Hence, it comes to no surprise that the next two chapters deal with architecture and use cases. In chapter 5 a mention is made, among other things, to the author's important work on the 4+1 Views of Architecture that underlies the RUP. Chapter 6 is a condensed discussion of the role and merit of use cases in a software development process in general, and RUP in particular.

This concludes Part I of the book. Part II consists of 9 chapters, one for each RUP so-called discipline (Project Management, Business Modeling, Requirements, Analysis and Design, Implementation, Test, Configuration, Environment, Deployment). The "Made Easy" book follows a similar pattern, with the difference, congruent with I've already mentioned above, that this book tends to treat the Disciplines in a descriptive rather than normative manner.

There is a pretty good "Summary of Roles" appendix at the end, and I liked the Glossary too, as the definitions contained therein are very precise but at the same time very comprehensible too. Finally, there is a rich annotated bibliography section, which, if you're at all like me, you'll find rather useful (There's also a poster of the RUP at the back if you're into that sort of thing).

All in all, I haven't at all regretted the ?38.50 and the time I've spent reading the book; and imagine that I was familiar with this stuff already. If this happens to be the first book you read on RUP (as it should normally be) then the benefit for you will be even greater.

One thing's for sure: it's impossible for any one person to "know" the Rational Unified Process in and out. So, stop right there if you're looking to get the printed documentation of RUP, because it's logistically impossible to bundle it all into a paperback book. These titles give a bird's eye view of what RUP is and how it can be leveraged for optimal productivity in the vein of software development.

This book gives you great high-level insight on how your organization can benefit by adopting and implementing RUP in your developmental projects.

"The Rational Unified Process: An Introduction" is an overview into the theory behind RUP. Great chart and graphics describe the processes RUP is rooted in, and the title is written in such a way as to indirectly hammer home the concepts into your subconscious, without being too blatantly redundant. Essentially, you'll get the jist of RUP - iterations, that the waterfall process isn't efficient, the importance of establishing diversity in team-based development, and the importance of architecture.

Basically, the book also enforces the concept that self-organization and communication within an organization (within the team, throughout the company, and with clients) is key. It reads more like a business journal than a technical guide, so hands-on examples are left out.

Also, the poster summarizing the key RUP activities that's included with the book is really great. I would have liked a case study at the end of the book to tie together the concepts with a practical example, but the book is great otherwise. I also found the fact that samples of RUP templates to be a bit disappointing. A helpful appendix listing some (not all) of the key artifacts used in RUP planning is also appreciated.

This is a very dense introduction for RUP. You need to read twice to get the complete idea. But the book can be read by workflows (disciplines) individually to emphasize your interest areas. I'm sorry for the folks that think this book is publicity for the Rational software. Did they read the book? This book is already part of the RUP AS A PRODUCT. I read because i want to complete my knolwedge on the process and software engineer process iteself. The book emphasizes in the goods of the process as a process model and a framework not as a product. Buy it, if you are interested in one of the most popular software engineer process outer or want to get some good advices to your own processes. If you're an opposite of RUP, if you aren't interested in software enginnering process at all, don't get it and don't waste your time submitting bad reviews. Judge the book as is: an introduction to RUP.

This book is an introduction to the Rational Unified Process (RUP). It is suitable for readers who have never heard of RUP before and for readers who have little experience with thoughtful analysis of software lifecycles. (I think it's also very useful as a quick, easy-to-read overview of RUP for more advanced readers, but you can read about that use of the book in other reviews.)

I teach Computer Science at Florida Tech, including undergraduate and graduate courses in software testing. Krutchen provides a thoughtful but very readable, persuasive discussion of risks associated with different software lifecycles. In my experience as a teacher, my students' ability to appreciate differences among lifecycles and analyze them critically is significantly boosted by study and discussion of Krutchen. Accordingly, I require my students to read the relevant section of his book, they have detailed small-group discussions of it, and it often appears on their exam.

This book is an introduction. It doesn't address all of the problems with RUP. It doesn't cover all of the areas of RUP equally well. It won't make any reader an expert in the process or its favored practices. It won't persuade someone who doesn't like RUP that they should like. What it does do is expose the reader to the thinking and practices that make up this particular approach to software engineering.

This book is much deeper than marketing fluff, but not so deep as to lose a junior reader. As a teacher, I am delighted to have materials like this available.

(Disclosure: a little bit of my work has been included in RUP, and I have developed a course for Rational on software testing within the Rational process. However, I identify more with the agile development / XP community than with the RUP community. In any case, the question that I'm interested in answering in this review is not whether RUP is any good -- it has its good points and its weaknesses -- but rather whether Krutchen's introduction to RUP is a fair and useful introduction to that subject matter. My conclusion is that it is.)

While this book has received great reviews I must offer disagreement. As an experienced OO professional (I've been working in OO practically since the beginning) the RUP leaves a lot to be desired.

For one thing there is not nearly enough emphasis on requirements gathering and process engineering. For the most part the analysis aspect of RUP focuses on Use Case Scenarios. I feel that this is a major weakness. Use Case Scenarios focus on how user's use the system, but doesn't answer the question: What system? To dive into Use Case Scenarios without first applying process engineering at a detailed level leaves you with a system that no one really asked for.

Furthermore I feel there is not enough emphasis on using Use Case Scenarios as a vehicle for test designs. One of the greatest advantages of Use Case Scenarios, when there done at a very detailed level, is to use them as a System Test design. This would include "expected results" for each step.

Also, I don't feel there is sufficient evidence for support of logical object modeling as apposed to physical object modeling. It's common knowledge with database design that logical modeling comes first, then the physical. This same tactic should be employed with OO modeling. This includes both class models and use case scenarios. This is especially valuable in the Java and EJB environment where Session beans differ from Entity beans and both differ from regular Java classes, singletons etc.

Another reviewer mentioned that this book might be a vehicle for selling Rational products. I agree. That's exactly what this is.
If you're an experienced analyst there are still some takeaways from the book, but you will have to augment it with your own knowledge and experience. The danger lies with inexperienced analysts thinking that they can define and design complex systems using RUP, and that it's sufficient. It's not.

An excellent book well organized and generally well written. Recommended either to learn about Rational Corporation's Rational Unified Process (RUP) or even just to get a general acquaintance with current ideas about software development methodology.

Mr. Kruchten advocates describing a software product with various summary, abstract views. In this book, he practices what he preaches by giving just the "architectural" view of RUP, whose in-depth treatment would not fit in just 300 pages. There are seventeen chapters divided into two sections. A reader interested only in RUP's distinctive features may skip chapters 1 and 14-17.

Section I comprising chapters 1-6 provides the motivation (software development best practices) and the dominant themes (architecture and use cases) of RUP, describing it also along two main dimensions: the dynamic dimension of phase and iteration and the static dimension of workflow.

Section II dedicates a chapter to each of RUP's nine workflows. There are two final chapters, one with sample plans for iterations in different project phases and one discussing how to implement RUP in a development organization. There are two useful appendices, a dictionary of acronyms, a glossary, and a quite helpful annotated bibliography.

In RUP a workflow is an interrelated set of activities producing a cohesive subset of the artifacts of a software development project. The chapters describing workflows vary somewhat in length and quality, but they all follow the same pattern: (1) start with guiding principles; (2) describe the activities, workers, and artifacts of the workflow; (3) conclude with some comments on tool support (a little marketing for Rational Corporation's tool suite). The best workflow chapters: Project Management, Business Modeling, Test, Configuration and Change Management.

The high recommendation comes not without some reservations.

Architectures are important in RUP, but Chapter 5, "An Architecture-centric Process," garbles this message by describing architectures as mere derivatives of "complete" system descriptions (called "models"): "Architecture is what remains when you cannot take away any more things and still understand the system and explain how it works (p. 82)." Again, " . . . models are complete representations of the system, whereas an architectural view focuses only on what is architecturally significant (p. 89)." Finally, "Architectural views are like slices cut through the various models, illuminating only the important, significant elements . . . (p. 90)."

These explanations fail to recognize that architectures come first. Architectures are constraints that determine subsequent design and construction of the system. They are primary, not derivative, not mere views of models. Fortunately, RUP recognizes the primacy of architecture even if these explanations do not.

These explanations also fail to recognize that an architecture is a complete and distinct model in its own right. They are out of harmony with the book's own (wordy) definition of architecture, which includes "The selection of structural elements and their interfaces by which the system is composed . . . (p. 84)." So when the elements and interfaces have been defined, the architecture is complete, right? It escapes this reader how architectures can be inherently less complete than models (whatever they are), when there is not even any one model that completely describes a system (see p. 81).

The relationship that Chapter 5 describes between architectures and models is very similar to that described in Chapter 10 between the analysis model and the design model. Mr. Kruchten limits the value of retaining the analysis model as a distinct artifact: "Generally, there is one design model . . .. The upper layers of this model describe the application-specific, or more analysis-oriented, aspects . . . In some companies-those in which systems live for decades or there are many variants of the system-a separate analysis model has proved useful (p. 175)."

Generally, companies that plan to stay in business DO expect their systems to live for decades-as do companies that spend millions of dollars using RUP to build them. As for "the extra work required to ensure that the analysis and design models remain consistent (p. 175)," the right tool can make all the difference. Anyone familiar with tools for database design (Erwin, for example) knows that they provide extensive facilities for maintaining separate, consistent analysis (logical) and design (physical) models. The tools offered by Rational Corporation, however, do NOT provide such a facility. Could Mr. Kruchten be tailoring the methodology to fit the limitations of the tool that his sponsor sells?

Compare his attitude toward the analysis model with that of another author in the Addison-Wesley Object Technology Series. Martin Fowler in his UML Distilled says, " . . . it is very important to separate the specification perspective and the implementation perspective (p. 52)." Mr. Fowler uses different terminology, but he is saying essentially that the analysis model ("specification perspective") is valuable as an artifact distinct from the design model ("implementation perspective").

Despite these issues-which might profitably have been discussed at greater length-this fine book admirably fulfills its purpose.

This is a great book. It was the first book that actually described RUP, besides the documentation. It's a good and an easy read, and you'll know hat RUP is all about after you have read the book. You will need to practice just like anything else, but this book is a very good starting point. The newer versions of this book is much better, so buy that instead.

Okay. I haven't read this book cover to cover. I never intended to - I got my job to purchased it as a reference for me. Lightweight processes are more appropriate in my professional circumstances (we don't use RUP), and I have been particularly interested in Rosenberg (and Scott)'s Iconix process. (See my reviews)

However, I find Krutchen's book a good fat-free reference on how the heavy-weights do it. Sometimes one needs a bit of extra depth. The book is well illustrated, and it helps me to put processes such as Iconix (and maybe even XP) in context.

The book covers the overall dimensions of the Rational Unified Process well. Issues such as best practice, iteration, team make-up, etc are also discussed. There is a big section on process workflow (more than 50%).

It also adds the architectural viewpoint of the process, a section that I found quite useful. Philippe Kruchten is behind the 4+1 view model of architecture, so it is good to get it from the source.

Should you buy this book? Like anything else, first decide how much you need it.

Kruchten has written what amounts to an excellent summary of the main points of what is in many ways an alarmingly large list of costly books that present an over-worked, extremely detailed methodology that is said to be a reliable guide for software engineering and technical business management. The great virtue of Kruchten 's summary view is that it allows engineers and technical managers to see that much of what is offered as a guide for technology and business management is, in reality, little more than a sophistical reworking of the AI theory of the mid-1970's. Such a summary has long been needed, and this book, for this reason, is a welcome sight.

Kruchten has been an employee of Rational Software, so the implications of the summary view he offers are in some ways unexpected. The explanation may be that it is evident from the first that author maintains reservations about the methodology he describes. While skepticism reveals a level of realism (or perhaps cynicism) that is interesting, the general impression may be a bit discouraging. If one of the primary evangelists of a management method reveals skepticism toward the method, then what is to become of all those managers who have advocated paying all that money to educate their employees in the use of the method?

The answer is, of course, to be expected. Pay equal or greater amounts of money to seek education in alternative methods (possibly marketed by the same vendor). If this is, indeed, the action proposed, then any hint of skepticism ends up being a brave (if not offensive) gesture, to say the least, and it is understandable that it is not explicitly asserted.

This book may represent what may be a significant crack in insular mysticism maintained by one of the major vendors of methodology in today's technical sector. The fact revealed is simply this: no technical method of management can replace the culture that a business creates by having bright people, successful products and good services. Certainly, a failing company seeking an image of success may benefit by purchasing classes on "rational business and technology management methods," but a genuinely successful company has its own culture, its own business vision, and ultimately its own managerial and production practices. These are the simple imperatives of the free market, which thrives, not on ideological conformity or fixed, enforced methodologies, but on innovation, creativity, and a common sense of professional purpose.

Kruchten 's book may bring light to a dark area of the world at a moment when many companies must seek innovation in order to survive the economic downturn that is sweeping the technology industries. Probably the only qualification is that such a book ultimately brings about the conditions of its own demise. If we see the myth for what it is, then why do we continue to invest in it? Obviously, we don't, and the over-priced books summarizing outmoded AI theories go out of print.

There are those who might criticize this book as being a mere commercial for the development tools offered by Rational Software. My reaction to that position is, `so what." If I am a manager considering the adoption of the Rational Unified Process, then my best hope for making the correct adoption decision is to learn what it is designed to do in as short a time as possible. Any material that I can read at a managerial level that explains the capability and what I can get out of it is something of great value, and this book satisfies that requirement.
The main purpose of the book is to explain the unified process at the level of the tops of the trees. This broad overview is an explanation of how a process is constructed by splitting it up into nine overlapping, but still somewhat distinct workflows. They are the project management workflow, the business modeling workflow, the requirements workflow, the analysis and design workflow, the implementation workflow, the test workflow, the configuration and change workflow, the environment workflow and the deployment workflow. The separation of the process into the different sections allows each of them to be described from their somewhat unique perspectives, which makes it easier to see how the synergy of them all makes for a complete, effective process.
It took some time for it to appear, but it is now essential to examine an item of software from the architectural perspective. Such an encompassing examination of software could not exist until the projects grew to such size and complexity that no other paradigm could adequately describe it. Like the plans for a large, complicated building, it is the overlap of several different models that merge together to build something that is more than the collection of pieces. An entire chapter is devoted to the importance of the architecture in the development and unending refinement of a software project. These are wise words to heed, as anyone who tries to build the complex without a sound plan is almost certainly doomed to failure.
The most significant test that any book describing a product can face is whether it is still worth reading if you have no interest in the product. This book easily passes that test and is one of the best manuals for managers of large software projects that is available today.

This is a thin book. I am not sure it is worth $30. If you need a crash course Intro in RUP this book is great. However it does not go into great detail about any of the artifacts. You will need to buy the Ratioinal software, find a website with RUP templates, or buy another book that is more comprehensive if you are trying to implement RUP.

It gives an overview of the different job functions and the artifacts those workers have to produce. Get this if you want an overview or RUP. If you want a step by step guide to follow, look on the web or get a more comprehensive book.

I am very impressed by the Rational Unified Process. This book does a great job of teaching you how to take the complex process of developing software and making it manageable. While I have been a part of complex projects before and have worked in an ISO 9001 environment for more than a year, I joined my first software development project that is making use of RUP recently. I am very impressed that this is "best practices." The book is well organized, easy to read, and very educational. Only a very few times is anything not extremely clear and accessible to even a newcomer to development such as myself. I would recommend this book be read by all members of a development team to assist in getting everyone speaking the same language and making full use of resources.

This book is a much better read than the generic process described by the book named The Unified Software Development Process (UP). The Rational Unified Process (RUP) is a specific instance of the more generic UP. The RUP can be tailored to an organization or project and is considered a product offering by Rational Corp. Many big technology firms are using RUP to include major companies from Telecommunications, Transportation, Aerospace, Defense, Manufacturing, Financial Institutions, and System Integratrors. Some of the major well known companies include: Xerox, Intel, Oracle, Lockheed-Martin, Merrill Lynch, MCI and Charles Schwab.

This book is easy to follow and very informative about a modern user-case driven, architecture centric, iterative/incremental development process. After an introduction to the whole process structure consisting of a Conception Phase, Elaboration Phase, Construction Phase and Transition Phase, each succeeding chapter covers a single workflow such as Business Modeling, Requirements Management, Analysis & Design, Implementation, Testing, Deployment, Configuration & Change Management, Project Management and Environment.

This book is actually an enjoyable read and makes the reader aware of what it takes to develop software using an object-oriented software development process using a proven methodology.

I've been using the RUP since it's inception ( no pun intended ) and this is by far the most valuable reference I have on my desk at all times, ok the RUP web based product from Rational is better but that cost me $800 so if you can't get your hands on that just yet, get this book, you will be satisfied even if your are a seasoned RUPer like myself. For beginers, this is a MUST read, no other book will jump start you into the RUP like this one will. I will be putting up tons of articles and references as well as my own writings on the RUP on my website ( just type in my last name into your browser ;o) ) so check it out on Sep 1, 2000 when I release the new version.

One more quick point, don't get Jacobson's "Unified Software Development Process" until you have read this book, even then I'd wait til the next edition comes out because the current one is somewhat out of date, but still useful if you're really into this stuff.

Also, a great companion to this book is "eXtreme Programming explained, embrace change" by Kent Beck, for people who work at the forefront of technology such as myself, combining these two ways of developing applications will yield great results, I'll be writing several articles on this topic so check out my site for them...

Excellent. A flexible framework for organizing all the things that make for a successful project. Very clearly written; proper level of detail.

This is excellent book for software designers who need to learn the UNIFIED PROCESS in reasonable amount of time with getting lost into nitty gritty details like in book "UNIFIED PROCESS" by the three amigos

I give 4 stars to this book, because it can be red in a very little time (a week-end, if you are motivated), otherwise I probably gave it only 3 stars. It is really an introduction, with swallow description of activities, but with an enought sufficient visibility on overall picture. The unpleasant part is the continuous recall of Rational Softwares, Showing all rational Software as pieces that perfectly fits together, which is not true. I think that a far from free book like that should be written without these continuous references.

Having heard about the Rational Unified Process (RUP) and having seen diagrams that depict the process with all the funny terminology, I wanted to find out more without wasting too much time. This book delivered my wish. After reading just this book on the RUP you will have no better or worst understanding of UML (as it does not touch the subject) and you will not be able to apply a process to a real project (more reading elsewhere is required for that). Having said that, an understanding of the process and its terminology along with whether it would be applicable to your projects will be formed. If you are looking for a `helicopter' view on the RUP and nothing more, read this book. END

There are some good ideas in the book. Overall its sales literature. I should be able to download it from Rational's web site. I don't recommend it unless you have full intentions of buying Rational's developer products.

The good stuff is elsewhere ($ -> Rational) is the basic premise of this book. I would have to say that if you want an introduction to RUP then this is definitely that but no more. Don't expect it to do more than familiarize you with the general concepts of RUP. Almost every chapter ends with which tools you should buy from Rational.

Pros:

* It is a good introduction and starter-kit.

* The methodology is reasonable and functional.

* The organization is easily-followed.

* The writing is clear and not overly technical.

Cons:

* It is not detailed enough in some places.

* It is a little over-priced (for the length).

* It should have artifact-templates.

* It tends towards product-specificity in places.

Overall, this book is well-worth the time. After reading it and some of the supporting materials from Rational, I was able to implement a scaled version right away. I mapped the "outline" of the process into a MS Project file, hooked the artifacts into a web page, and "bang" I now have a process in place that...

* defines common terminology;

* organizes our current system quickly;

* provides a process-model "shell";

* serves as a common-reference for the team;

* removes many management details; and,

* focuses the team on development.

Thank you.

I think you guys need to get lives and but out some better books then this one.

I agree completely with the last reviewer. The book is just a teaser for the product (another 700 USD). Very disappointing after waiting for it for so long.

It documents the Object-oriented design process used by the Rational Corporation. In case you are not aware, the authors of UML work for Rational and they are the company that makes Rational Rose, the market leader in OO design tools.

The book outlines the process, which has many good features. One example is that the process uses the spiral methodology instead of waterfall. The book covers all phases of processes you might want to put in place in an OO project.

Unlike many OO process books for the past, this book keeps it feet on the ground and stays readable. Others in the past have usually drafted into obscure technical details.

The book has two problems. The first is that the prose is pretty stilted. Way too many sentences start with "The Rational Unified Process is". The other problem is that the book is geared around using the tools from Rational. However, it is possible to use most of the process without using the tools from Rational.

In summary, this book documents a pretty good OO design process in a very easy to understand way. If you are looking for an OO process to follow or are looking for ways to improve your existing one, this book is an excellent starting book.

Good and profoun

good boo

This is a very good book for people who wish to bring process and methodology to the software development process. However, it is pretty light on substance, and advances the same mantra that the Amigos have been pushing since they got together. It certainly leaves one salivating for Ivar's book on process. If you are not considering buying the accompanying software product from Rational (about $695), this book may not be for you (in fact this book is the first of 9 manuals that accompany the product).