Rating: 
Summary: Dritfet bok!
Review: Boka er immari bra, jeg digga'n rått!!! Litt tung, nesten en halv kilo. Åsså var'n på engelsk, men det er vel greitt nåk.
Rating: 
Summary: Excellent summary on software project management
Review: Fairly well written book. Focuses on the idea that software complexity (and risk) can be controlled by using objects. Contains an overview of software engineering approaches (RAD, waterfall, spiral, controlled iteration), and related information. And it also includes material on people management - issues that may arise when working in a team environment. This is, however, not a book to learn about UML, except that UML is a useful tool for the project manager to plan, describe, and/or keep track of a system that is being built.Recommended reading for those becoming involve in the development of larger, more complex systems.
Rating:
Summary: Excellent summary on software project management
Review: Fairly well written book. Focuses on the idea that software complexity (and risk) can be controlled by using objects. Contains an overview of software engineering approaches (RAD, waterfall, spiral, controlled iteration), and related information. And it also includes material on people management - issues that may arise when working in a team environment. This is, however, not a book to learn about UML, except that UML is a useful tool for the project manager to plan, describe, and/or keep track of a system that is being built. Recommended reading for those becoming involve in the development of larger, more complex systems.
Rating:
Summary: An important step that combines OO with PM
Review: Government agencies provided the motivation for improved software program management (PM) techniques and this effort, lead by Carnegie-Melon University, produced the Software Engineering Institute's Capability Maturity Model (CMM). The premise and underlying structure of the CMM techniques is the waterfall model (though they claim to be agnostic in this regard). Commercial entities led the development of modern object-oriented (OO) methods that are taming some of the complexity of software development, but their methods for software PM weren't as mature as those of government agencies. Until Murray Cantor's and Walker Royce's books there was no structure that effectively combined solid project management techniques with OO's best-of-breed development technology. Dr. Cantor's book is easy reading, but that belies the underlying complexity of the message. The importance of the Unified Modeling Language, an OO product, is to provide communications among the members of the team (engineers, customers, and management) and the importance of the iterative process is to maintain control of the project. Dr. Cantor shows the program manager, particularly those in charge of very large (millions of SLOCS) developments, how to combine project management tools (earned value, WBS, and integrated schedules)with strong risk management (iterative development) to significantly reduce the risk of unmanageable cost or schedule problems with that software development project. This is a breaktrhough book in this regard and Dr. Cantor deserves thanks for his work.
Rating:
Summary: Good Overview for this Beginner
Review: Having been dumped into a first-time management situation, I found this book helpful in understanding the group dynamics, the steps to follow and the problems to expect. The next time I'll probably remember what I learned here, but probably I haven't absorbed it all, so will browse it again. The author uses a flight simulator example that is helpful both in understanding the evolution of a project and in some of the "unexpected" problems that crop up. He also describes how the various UML tools help in organizing and documenting the project. This book is not so much about code as it is about management.
Rating:
Summary: A must for project managers
Review: I found this book very useful because it covered UML nicely, and did so in the context of real-world project management scenarios. The book is full of useful tips on how to improve your next PM experience.
Rating:
Summary: A must for project managers
Review: I found this book very useful because it covered UML nicely, and did so in the context of real-world project management scenarios. The book is full of useful tips on how to improve your next PM experience.
Rating:
Summary: A Timely Book for Managers and Sophisticated Customers Alike
Review: Murray Cantor's Object-Oriented Project Management with UML is of value to both the young manager looking for guidance and the seasoned manager looking to ground one's practices. The book is an engaging read that blends best practices with personal opinions. The author is careful to distinguish his personal opinions from the rest of the text and is conscientious to appropriately cite the work of others. Some 70 plus references are listed in the bibliography. In fact, what comes across is Mr. Cantor would prefer software managers to have a repertoire of books on one's shelf. I myself keep returning to Walker Royce's Software Project Management, a Unified Framework, Grady Booch, James Rumbaugh, and Ivar Jacobson's The Unified Modeling Language User Guide, as well as Mr. Cantor's O-O Project Management. Managing great software teams within projects is tough in today's environment of complex solutions, anxious customers, and shrinking time-to-markets. It takes more than just common sense. It requires a game plan and an awareness of when to be flexible. Mr. Cantor lays out a series of methods that focuses on attacking project complexity, leveraging team dynamics, and what needs to be accomplished when in the controlled, iterative development lifecycle. The underlying theme is risk management. Software projects will likely be adventurous for the foreseeable future as we seek ever larger scale systems, but if more engineers and customers were grounded in the techniques espoused by this book a lot more businesses would achieve their goals.
Rating: 
Summary: Useful in places, but not a HOW TO book
Review: The author applies standard project management techniques to object-oriented projects. In particular, the assumptions and techniques underlying UML and the Unified Process are to be found in the various chapters in the book. For example, the author advocates managing complexity by using packages, use cases, encapsulation, inheritance and aggregation.
The main strengths of the book are: It attempts to integrate OOT with project management techniques using the standard UML and this integration process lasts for the duration of the full software lifecycle.
The book may or may not be useful depending on what you are looking for. For example, it is (very) superficial in places and in general I would say that it lacks 'meat' in the following places: Traceability issues
Useful checklists and tables
Quantitative treatment (measurement) Furthermore, the chapter on lifecycle models is not convincing. The author suggests that we should NEVER use the Waterfall model while he suggests that the Controlled Iteration model. Why? I have not understood this latter model when reading the boook. I think that it is too complex. Concluding, this book serves as a baseline for further research and should be complemented by other sources, for example from Boehm, Air force and IEEE. Finally, the title is an attention-grabber and in my opinion incorrect. Project management is independent of the technology used (in this case OOT). A better name would have been "Project management of software projects that use UML".
Rating: 
Summary: A beginner's book bound to gather dust after the first read
Review: There is no doubt that this book is very good for somebody, who is going to start working in a software engineering environment. However, there are a couple of points which indicate that one should look around before deciding upon a purchase. (Even with the current price of 24 $) Here are my points of concern: - The chapter on object technology is really a half-hearted introduction and not very useful for getting started in this field. - The book relies heavily on just a few references. Those references are recommended repeatedly. One of them is the doubtful 'Journey of a Software Professional' (Hint: Check out the mixed reviews.) - The author can't resist recommending the 80-20 rule throughout the different project phases. This is hardly inventive and adds to a certain degree of repetitiveness. - The case study is more entertaining than informative. - The third part of the book (consisting of only one chapter) simply gives the impression that the book was rushed out for print. I am not quite sure why this book merits a hardcover and on some occasions throughout the book, I could not help thinking that the layouters tried to increase the number of pages by adding a few commentary boxes ('Tips') here and there and enlarging diagrams to 'poster-size'. Despite all those complaints, I have to say that the book helped me to gain an overview of the management process of a software product. But, after my first reading, it now gathers dust on the bookshelf ...
| 
