Modeling

Not so much unimpressed at Joe's knowledge, which is impressive indeed: the book reads a lot more like a teaching text than most technical books.

But there are things in here which may lead astray some who have already done things that Joe advises strongly against. I will concentrate on one example: In chapter 3 "Numeric Data in SQL", under the heading "Generator Functions" (e.g., IDENTITY, AUTO_INCREMENT) we get this doozy: "This is a horrible, nonstandard, nonrelational proprietary extension that should be avoided whenever possible". Just a statement, no reason whatsoever provided for it, because I guess he assumes we know some "math rule" or something behind why it is such a bad idea. Now, we must think for a minute why one uses such a data column. In my own case, I have a table called Parts that contains parts from several different companies. So, I guess Joe would have me make a composite primary key from PN and CompanyID. But, wait a minute, that complicates matters when I need to have a foreign key reference to the Parts table, and, oh by the way, just what is CompanyID anyway, maybe some other composite key, or some goofy "rule-based" (can you say TRIBAL KNOWLEDGE) thing? You can't seriously believe that "ALFKI" is a better key than,say, 33. What happens when I get a new customer named "Alfred Kiplinger", and have to change the "rule" that I came up with for defining the primary key? See the problem? You're not going to remember the ID anyway, because the rule will be broken at some point. I also happen to think that a part number (to give one example) should be changeable. So, I don't make PN the primary key (because you should NEVER change a PK), I simply have the database generate one for me. What am I missing here? It was not explained to me in this book, it was just a blanket statement of preference, put across like a hard and fast rule.

But then come the contradictions. In the very next chapter on temporal data types, we get a very long paragraph on "key generators" and how they need to be designed to eliminate or minimize identical keys (I kid ye not!). He talks about elaborate hashing algorithms, the server system clock, random number generators, and how pseudorandom numbers are not usually a problem since the cycle size can be "hundreds of thousands or even millions of numbers". Huh? Amazon has 50,000,000 customers! I'm sure they wouldn't be too happy if "only" every millionth one had the same id! No mention in this entire section on GUID or UNIQUEIDENTIFIER, which won't repeat forever in the known universe!

Then there is seeming randomness to the topics introduced. I think I work with a guy that's a lot like Joe, but man, can it be hard to follow the "why" of what he is talking about! I usually figure it out about two days later when I'm sitting at my desk working on something completely different. Here's one example: We go from an incredibly long section on Domain Key Normal Form, with all of its calculus functional dependency stuff ("A determines B, therefore if CA = B, &c, &c, &c....."), to a paragraph right after this about normalization, and how a Students table should not have "Student data and also bowling scores". But come on, that's DB101, not Math335!

Bottom Line: The reason I gave three stars to this book is that I think I misread its intention. I believed it to be a book for someone who knew SQL, and wanted to become more advanced in SQL. Now that I ponder the title, however, I believe that it means "OK, here's a book for you scientific math types out there who want to apply your math degree to learn SQL", i.e., SQL for smarties, not for non-degreed dummies like myself. That, to me, is exactly how the book is written, and it probably succeeds against that yardstick.

If you need to sling some really nasty SQL which you probably shouldn't be writing in the first place, then this book is for you. Celko is the man. As a cover-to-cover read, you will pick up on a lot of new SQL techniques, but in general, this is a "I know where to look when I need to know that book." If you know the basics of SQL and want to start your SQL Master training, then start here. Just keep it close by when you need to remember how Celko was able to get "that" to work.

I have been programming database applications since 1984. I started using SQL in 1989. Since that time, I thought I had mastered SQL. Well ... I was wrong. Joe's book helps pin point the finer things concerning SQL ... how it really works. Anyone who is an ADVANCED user of SQL will find this book full of the little things that all most all developers will overlook. For example, how does a SQL statement really execute (pg 174 to 181) explains this in great detail. Many advanced developers are not just satisfied with knowing how to do something; but, want to know every little detail about how something really works. I found the chapters on normalization and Armstrong's Axioms to be the most useful concept in the entire book. Database design concepts are critical in performing a good, solid, and efficient query and this chapter brings it out very well. I have found this book to be my only source for advanced SQL concepts (besides Joe's puzzle book...). Good job ... and thanks.

This book offers a good overall understanding of the UML. However the examples are shallow, and not necessarily on point or real world enough for me. I've read other books I would recommend before this one.

If you'r new to UML this would be a good start, although it may be a bit confusing to the beginner. If you have UML experience and are looking for greater depth of knowledge, look elsewhere.

Having read both Instant UML, and UML toolkit, found toolkit to add the most value in teaching fundamentals of UML design. The description of the processes, components and application to real business cases did not tax my brain too much. Instant UML much more suited as a reference book. Learning the art of designing object oriented business applications requires a robust methodology to relate business events to the OO architecture. UML provides a process flow from the use-case stage right through to the deployment stage to facilitate this process. Also a great productivity tool with DDL, C++, Java code generation functions.

Excellant book on practical UML. Most books don't show show you how the models look like in code, this does so using java.

Also a worthwhile chapter on modeling patterns in UML. There is also a chapter on a process for using UML.

In all a very good detailed book with plenty of good examples.

I was new to SBS 2000 and I though this book was going to be great. If you are looking for anything technical on SBS 2000, forget this book. It talks more about how great SBS 2000 is, and very little on how to set it up. If you are looking for help on SBS 2000 or 2003, a better choice would be to go to Microsoft's page for SBS 2003/2003 and under community review the news groups.

I think the value of this book depends on the amount of experience you've had installing and using prior versions of SBS or even with installing and using Windows 2000 Server or NT4 server. If you've had virtually none then you may find this book of some use. Otherwise I think you'll find it of little value.

The author uses his "SSL Methodology" to guide the reader through setting up SBS 2000. What the author is really doing is setting up a sample company called Springer Spaniels Limited (SSL). The text tells you to do this, do that, click here, etc. and gives screen shots of various things along the way. This may give those with little SBS experience the "warm fuzzies" that they are doing things correctly. However, the SBS 2000 set up is pretty intuitive and there is a good amount of help information built into SBS 2000 that is available as you go from step to step through the set up. My complaint is that, since this is true, the book does little more than give you the same information without any more insight. Worse, there is nothing to really help you if you need or want to deviate from the "SSL Methodology" or run into problems.

I encountered some problems trying to connect workstations to a new SBS 2000 server that had previously been connected to an SBS 4.5 server. The book was of no help for this. In another case I had a new XP Pro machine that when setup did not load the firewall client (the successor to WSP Client). Again, the book was of no help in dealing with this. (The solution was easily found on the MS Knowledge Base).

With no real help for doing things differently from the "SSL Methodology" this book is of limited value. Ditto for no real trouble shooting info.

I purchased the book based on nearly unanimous 5 star ratings. Based on those I was hoping for a book that would be more informative and useful (something akin to Manasi's Windows 2000 server book). I was disappointed.

I rate this as pretty much a novice's book. At virtually $... a copy it certainly isn't worth what you get.

As an aside I note the photo the author provides of an SBS 2000 installation. Apparently this is his work and he points to it with apparent pride. I certainly wouldn't hold up this sloppy job as an example of a quality installation and I hope no one follows it as an example.

Whether you are a computer network consultant specializing in Microsoft technology such as myself or own your business, this best practices book is terrific. Harry's combination of technical instruction with his real-world experience lead to a best practices manual. Use this to avoid novice mistakes and develop a protoype of a small network using Microsoft SBS 2000 which is an excellent server/network product I highly recommend it. I only wish harrybbbbb was more opinionated and let his acerbic wit come out more because I want more wit & comedy in all these IT books I read.

This is the first Apache book i have read, based on the strength of reviews and reccomendations on Amazon.

In short, this book currently has me irritated and disappointed.

In terms of structure, the sections and subsections are not clearly introduced or delimited and even the section headings are often 100% meaningless. Also it is sometimes unclear whether you are being given a sequence of instructions to use or just a list of commands for reference.

Generally the English used in this book contains some apallingly bad, complex and ambigous syntax which is quite unneccesary. The problem with ambiguous syntax is that you often have to already know what the writer is talking about in order to be able to figure the correct interpretation for what he writes.

Also, the "for dummies" style of writing is applied as annoyingly as ever. That is to say that the stuff you read is interrupted without warning (mid-sentence) by a string of gibberish that is supposed to be friendly and humorous. It is not humorous, it is very annoying and yet another unnceccesary source of confusion.

I really hope there are better books out there by now.

Congratulations, Ken Coar! We're ready for the next edition. If every Dummies-series book were written like this, we wouldn't need O'Reilly titles...Seriously, this book is a really first-rate introduction that will get most of us who operate in the Unix/Linux space where we need to be. It's not Windows oriented at all which is just fine since Apache belongs to Unix, right? Friendly advice: Use the Apache Server Bible by Kabir if you must deploy on Windows. But better yet, dump NT and go with a stable OS for a stable, scalable web server.

This is the only apache book I have been reading, so I can't compare it to others. Its organized realy well. All though this is a dummys book, I would strongly suggest learning the basic commands for unix or linux, the basics of the emacs editor, and how the linux operating system is organized before getting involved with apache. Learning the above really shouldn't take that long or much money. If you buy packaged linux distro, it will come with a manual to help you learn how the os works and the commands that you will need.

Mandrake 7.1 and Caldera OpenLinux are available here in the software store, both a very good choice, it will get you up and running quickly and easily. This book is easy to understand and it gets you excited about becoming a web master. Highly recommended. END

I am a very experienced C/C++ software engineer currently taking a community college class on WinSock networking programming. I'm used to dealing with difficult text books. However this is one of the worst I have ever wrestled with.

There are no exercises in the book. All their examples are long; no short examples of code to clarify any topic. Their way of explaining most subjects seems to me to be unclear, their wording such that I have to read a paragraph several times to figure out what they are trying to say. Finally and especially, their explanation of the key topic of socket states is flat-out awful. I have had a little experience dealing tangentially with socket states on my last project, and I still came away from this chapter confused and with my head spinning.

I hope that there are better WinSock books than this out there!

This is an excellent book discussing not only Winsock but low level networking communication in general. Be advised though that this book was last published in 1996 so working in VisualC++ 6 will require a bit of tweaking. Also, this book is 95% Winsock 1.1. The last chapter covers Winsock 2 and is only 25 pages long.

I would have given this book a perfect rating had it been just a little more up to date. Don't get me wrong though, if you want to learn Winsock, this is the book to get. After reading through the whole book, I've used it for reference countless times.

Best Winsock book available IMHO.

If you want to learn about WinSock API and the WinSock programming tactics this book is very good. However, I found few errors which are not very critical, in the examples. I never compiled the programs that comes with it but used the examples and theory learn about WinSock interface. When I started to read this book I have already had some experiance in BSD sockets and my intention as a Unix programmer was to learn the Windows implementation of Socket. For that purpose, this book was extreamly helpfull for me.

I bought the book hoping to get a good start on learning Analysis Services. Chapter one gives a decent overview of terms and definitions for a beginner - but I know there are probably alternate places on the web to find this same information.

Then I reached chapter two and couldn't believe what I saw. It was the same exact tutorial I had just done in SQL Server Analysis Services. Yes, when you install Analysis Services there is a tutorial section in the application. I had only completed the first tutorial section and then went to buy this book.

I can only imagine the rest of the chapters in the book are the remaining tutorials in the application. Even the description on the back of the book almost matches the titles in the application tutorial.

Of course, I won't waste my time checking, but I feel pretty confident the tutorial and the book are pretty identical. Just from flipping through that 2nd chapter I could see they used the same exact screen shots, the same instructions, etc.

I plan to return the book and just go through the remaining tutorials.

This is a good book that will help you get started on Microsoft's SQL Server Analysis Services.
You'll get to learn how to build a Cube, build a Dimension and the different types of Measures.
You'll learn how to determine the type of dimensions you have.
You'll learn how to do some basic tricks.

But you won't learn any of the advanced topics that I was hoping for.
This book doesn't go into any details about how historical data is handled.
How to do some basic MDX programming.
How to make custom incremental cube processing.
etc.

This is a beginner's book, as the title suggests, that will take you from clueless to comfortable in Analysis Services in a short period of time.

That's why I gave it 4 stars.

This book in no way substitutes a good book on OLAP and/or data warehousing (such as Kimbal's books).

Not only is this book useful, it has the added advantage of being well written. I picked it up after spending a few days wandering around in Books On Line and reading Erik Thomsen's book for some theoretical background. This book was a great help to bringing all the various aspect of OLAP objects together in the specific context of MS Analysis Services.

After I purchased the book I noticed the one-star reviews given by two readers. They did not do anyone any favors with those reviews. One reviewer admits he did not read beyond the first chapter, and the other complains that custom rollups and unary operators are never mentioned in the book. Apparently he never got to page 105, where both are discussed. I think you are safe to ignore those jokers.

Enjoy 'Step by Step' for what it is. If you want more on MDX, be prepared to buy another book - I recommend Spofford.

1)The Oracle WebDB is no longer available for download or
purchase.
2)The preface of the book gives some non-working URL's to
download a trial version of the software or updates to the
included CD-ROM.
3)The preface of the book is stating:
"The CD-ROM attached to the back cover of this book provides a
trial copy of WebDB ..." - false
4) I contacted the authors about this, NO answer at all.
5) ...

I worked with WebDB prior to buying the book and found that it provided me with exactly what I wanted - all that extra info Oracle doesn't provide. I reccomend it to people starting out with WebDB but hope the authors update when version 3 comes out.

Not sure I like all the whining about the software not being on the CD, it's easy to get. Download from technet or pester your local Oracle office for a trial CD. On the WebDB site they say that it wasn't on the CD because lawyers got involved, I can believe this!

Good book, good content, for beginers and non-beginers alike..

Great book. Helped me get started quickly. Filled with insightful technical detail, while still easy to use. Well written - would recommend.

Good for Theoretical concepts but when it comes to practical implementation it's not much of a help and you would have to use the web as a guide for implementation and troubleshooting, which in my case was somewhat frustrating
However, it helps you in understanding the design aspects of your LDAP.
So the final verdict i would give is that if you would like to implement your Directory service in the most professional way then it is advisable that you read this book (you have to have lots of free time to yourself too ) but it will not be the only place that you will be looking for information regarding LDAP.

Background:
LDAP (Lightweight Directory Access Protocol) is a software protocol that enables locating organizations, individuals, and other resources such as files and devices in a network, whether it is a public Internet or a corporate Intranet.

As LDAP adoption and deployment is increasing, the expanded second edition of "Understanding and Deploying LDAP Directory Services" is published with more materials from the authors on the protocol and how to apply it effectively in different network environments.

Book Organization:
The book consists of twenty-six chapters divided into six major parts:
- Directory services overview and history
- Designing your directory service
- Deploying your directory service
- Maintaining your directory service
- Leveraging your directory service
- Case studies
The book begins by defining directory services and what they can offer for an organization then gets into the specifics of how LDAP organizes directories and handles queries with coverage of LDAPv3 extensions and the Netscape Directory Server.

The books then moves on to explore a wide range of topics such as designing directory services, naming, topology, replication, privacy, security deploying, directory services, implementation pitfalls, cost analysis, maintaining directory services, troubleshooting, and creating and enabling directory-service
applications.

The book offers help and advice for comparing "LDAP-compliant" products on features, management tools, reliability, performance, scalability, security, standards conformance, interoperability, cost, and other criteria. Then, having chosen a vendor, you'll walk through piloting your application
and testing it for performance, scalability, and reliability. Finally, the authors show how to put the system into production, keep it running smoothly and securely, provide for backups and disaster recovery, and make improvements over time.

The final section of the book presents four thorough deployment case studies, showing how diverse organizations can use LDAP as a simple, versatile solution for a wide variety of problems.

Is the book for you?
The book gives a good architect's or project manager's understanding of LDAP and of the difficulties inherent in deploying any complex mission critical software system.

For architects, this is a concept book rather than a reference book: After reading this book you will still need to refer to product manuals or reference books to help you figure out how to implement your design.

For a project manager, this book is valuable especially with the checklists, something that can be used to guide the deployment of many new systems.

Software developers would read the book to understand more on issues such as redundancy, security and privacy.

For IT professionals who are relatively new to the area, it is the book to read on LDAP.

General Comments:

- There are many specialized terms that are used without being defined or before being defined.

- There is a lot of superfluous material bringing the book to over 900+ pages requiring constant filtering on the part of the reader.

- The book offer more concepts that practical help. You will find a lot of managerial discussions, including talking to your users, piloting your directory and getting feedback. If you are looking to learn how to technically implement LDAP, these discussions will not interest you much.

- The book assumes that you have a good understanding of LDAP and Directory Services. The introduction chapters do not cover many basic concepts, many terms are not explained until used several dozen times, and there is no glossary.

- Managers will appreciate the sections on product selection, piloting an LDAP service, costing, disaster recovery, long-term maintenance, monitoring, and application development in a directory-centric world complete the picture.

- Several case studies are presented, including useful sidebars entitled "20/20 Hindsight".

The Good Stuff:
- Provides a lot of theoretical concepts
- Covers all aspects of LDAP deployment
- Discusses the design aspects of LDAP
- Designed to meet multiple needs
- Minimal knowledge of networking is assumed

The Not So Good Stuff:
- Not much on practical implementations
- Sometimes the explanations are too long
- With over 900 pages, the book is too long
- Sometimes hard to follow the line of thought
- A glossary of technical terms is not provided

Conclusion:

If you are planning to work with LDAP whether you are a network manager, a software developer, or an IT administrator, the book provides a lot of information which will help you define your directory requirements in detail and design a directory service that meets them. You will also ind the book valuable during the evaluation, planning and deployment process. However, if you are a programmer who is looking for a programming book or some kind of a product manual to help you setup LDAP services, this
is not the book for you. It is mostly targeted for architects as it is more of a concept book rather than a reference book.

In general, the text is full of advices and real-world deployment examples to help the readers choose the path that makes the most sense for their specific organization. I personally would recommend the book as a general
overview of LDAP and deployment scenarios.

This long-awaited book definitively answers the question "Why is LDAP so important to Internet-based computing?" Furthermore, it answers the equally important questions concerning how to go about actually building LDAP-based solutions.

It very effectively describes LDAP as a strategic service, traces through complete details regarding design and implementation, and includes information on how small or large organizations can "survive" migration to directory-based computing.

Real-world practitioners will appreciate the sections on product selection, piloting an LDAP service, and costing. Finally, disaster recovery, long-term maintenance, monitoring, and application development in a directory-centric world complete the picture. As a bonus, several fairly deep case studies are presented, including very useful sidebars entitled "20/20 Hindsight".

For those of us who have lived through several large-scale LDAP designs/deployments, this book will be a great reference. For IT professionals and/or architects who are relatively new to the area, it will be invaluable.

The authors jokingly refer to the book as the "LDAP bible" - but that's not an altogether outlandish description.

For those few places left that steep themselves in documentation and don't have a legally-required reason to do so (do they exist?), this book should help motivate why producing too much documentation and doing too much modeling up front can hurt rather than help. Even for a company that sees itself as lightweight, he's got some rough assessments you can do to see if you're overdoing things, which were relevant even where I work.

The only bad thing is that it was a very theory and ideal oriented book. It didn't contain concrete examples of what Agile Modeling would look like on a real project, how it would feel, and how what models were produced would evolve. This made it a bit difficult to verify my interpretation of the book.

My first impression on receiving "Agile Modeling" was that there is lots of information which could be condensed into tighter passages or sometimes omitted.

I have read Scott Ambler's work before and am an admirer of his contribution to software development. I found the book helpful, as with most of Scott's work, despite the sometimes redundant information.

Despite my cautionary introduction above, I recommend this book to developers and project managers.

In this book the reader can expect to find information on how to implement development processes with Agile Modeling (AM).
This book discusses the processes for development - it does not go into the details on how to use the tools.

There is a comparison chapter on AM and XP which is helpful. AM, like all development processes, is a mixture of art and science. It is not carved in stone - although many may disagree with this statement. This book will help the reader decide what is appropriate to utilize for the project, given the real-world scenarios.

Hope this helps - please let me know if you have any questions or suggestions.

The hype that grew around eXtreme Programming (XP) in the year 2001, and the publication of now almost 2 dozen books devoted to XP has not cleared up the original vagueness of what practices are allowed and what aren't. To a casual observer the XP culture seems replete with "Thou shalt not's"¯ don't do Big Requirements Up Front, don't do Big Design Up Front, don't build models because it's only the code that matters, etc. For those of us who think it's important to have a map of where you are going before you start a long trip, some of the radicalness of XP was¯well, too radical and too unplanned.

Scott Ambler's new book, Agile Modeling, addresses a sane middle ground between the apparent unstructured XP and the overly structured approach in the Rational Unified Process (RUP). Agile Modeling is arguably Ambler's best book to date. It conveys an approach that is truly a confluence of best practices and does so in a very readable, accessible presentation.

Ambler presents Agile Modeling (AM) as a set of values, principles and practices. AM's values are borrowed directly from those in XP: Communication, Simplicity, Feedback and Courage, with Ambler's addition of "humility". In my experience this additional value is a defining characteristic of an effective modeler and mentor. From these 5 values Ambler defines the principles for AM, including: Software is your Primary Goal, Travel Light, Embrace Change, use Multiple Models, etc.

It is interesting to me that no one would refute these principles: they are too close to Motherhood and Apple pie. But it is disturbing how seldom I see any of these principles actually embraced by the dozen or more organizations I provide mentoring services to each year.

The bare-metal practicality of AM is in the chapters on "Agile Modeling in Practice". Here Ambler goes into detail on the practices that support the AM principles. Are you curious how your culture might adopt AM? See his chapter on "Nurturing an Agile Culture". In a quandary over what expensive OO CASE tool to buy? See "Using the Simplest Tools Possible?" In his broad reach in this book Ambler covers issues surrounding how you can effectively set up your work areas, how to conduct modeling sessions, how to staff your AM teams, and more. And each chapter ends with a pragmatic commentary on "How to Make This Work in the Real World".

I predict that if one chapter is read more than any other it will be the one on "Agile Documentation". This is also the longest chapter in the book, and Ambler skillfully addresses the two big questions of "Why Do People Document?" and "When Does a Model Become Permanent?" And if for some perverse reason you didn't read any chapter but this one, it alone would justify the cost of the book.

The last two sections of the book show how to apply these principles and practices to an XP environment (Part 3), and then how they can be applied to a Unified Process environment (Part 4). Again the approach is on the practical application of AM so that you can have a better chance of succeeding on your next (or current) software project.

If you are a software developer, a technical manager or project manager, you cannot afford to dismiss this book. Forty years ago no one did the "waterfall" process (Winston Royce hadn't defined it yet) and forty years from now we will certainly be building software in ways we have not yet even conceived. But this year and for the foreseeable future we will be using every idea from Agile Modeling to build better software faster. As Ambler says about building an agile culture, "You can be agile or you can be fragile." That says it all, so get this book and learn how AM can make you a winner.

I had to read this book for a class I took. Here is my interpretation of the purpose of this book:

"I think the world should have used my ICONIX process! This UML stuff is inferior. I hate UML, but I will use it to sell my book."

Fortunately, the class also used Martin Fowler's great UML Distilled book. If you want to know about UML, get that one instead!

As I was learning OOAD concept and techniques, and the UML, the one thing I found lacking in most materials was application. There are a lot of great books on what OO is, with guidelines on good design, and great examples of diagrams you can create. None of them that I've read, with the exception of this work, has provided any look at how to put the pieces together in a sane fashion. Rosenberg succeeds admirably at this goal.

Contrary to what some reviewers seem to think, this isn't a book about the UML, and I don't believe it tries to be a definitive reference on methodology, either. Rather, Rosenberg presents (with a clear disclaimer) his perspective and method for performing OOAD; I find it a valuable one, at that.

If you're just getting started with OO and/or the UML, and want a good overview of how the pieces fit together, read this. I'd recommend it to all other comers, as well, unless you think reviewing an additional perspective (from a successful, well-regarded individual) isn't valuable.

"Use Case Driven Object Modeling with UML, A Practical Approach" is perhaps the best book on the market for a down-to-earth, hands-on introduction to the Unified Process. As the title suggests, it leans heavily on the methodology of Ivar Jacobson, one of the three amigos. If you are trying to figure out what to do or where to start, this will point you in the right direction.

Three things in particular I liked about the book:

1. "The Approach in a Nutshell" as well as constant reference back to it.

2. The lists of ten.

3. The chapter on "robustness analysis" showing the transition from analysis to design (always a difficult transition in any methodology). This is the best part of the book in my opinion. It was real "hands-on".

"The Approach in a Nutshell" gives a great overview of the process including milestones, and provides a framework for everything to fit into. As the reader progresses through the book, each chapter summarizes that part of "the approach in a nutshell" that the chapter fits into. If this was the only feature in the book, it would be worth the price.

If you have ever read another series with "lists of ten", these are better. The lists of ten (there are over half-a-dozen) are worth taping up on the walls. They reflect the experience of someone who has been there and done that. The lists of ten alone are worth the price of the book.

The transition from analysis to design has rather heavy focus in this book, and deservedly so. Going from analysis to design is tricky in any methodology, and "Use Case Driven Object Modeling with UML, A Practical Approach" shines in this area. The authors refer to this as "robustness analysis," and this section alone is worth the price of the book.

This won't be the only book concerning the Unified Process that you will ever buy. But it is more than likely going to be one of the most useful to you.

This is not a tutorial on the UML; purchase "UML Distilled, Second Edition" by Martin Fowler and Kendall Scott if that is what you are looking for. The title may be slightly misleading in this respect. The real focus is on the "Practical Approach" part. If you are trying to sort out HOW TO DO IT, then this is a necessary addition to your library. It won't replace your books on the UML or the Unified Process, but it will help you pull it all together into a cohesive whole so you can get a grasp on how to start and how to proceed.

In addition to being very informative and clear in direction, the book is also surprisingly interesting to read. Its clarity and brevity keep it simple. You won't get bogged down reading this one. It is very well written.