5 comments about Effective Methods for Software Testing.

1. There are a few things to say in favour of this book:
   1. It does walk through on how to approach testing in your organization (however, it is definitely oriented towards organizations with established testing principles).
   2. It does give you some background information on software testing. Sadly, these are mainly explained in a textbook like manner, making them hard to digest.
   3. It provides a thorough, detailed and tested methodology for software testing throughout the various life cycles. Yet again, due to the book's textbook like manners, I found it hard to actually implement the offered methodologies.

   Whatever positive attributes the book has to offer, they pale in comparison to the book's negative aspects:
   1. Total unreadability: The book written in such a boring manner, you will find yourself reading every page thrice, and still lack the satisfaction of being able to quote the meaning of what you just read.
   2. Lack structure: Paragraphs are thrown in one after the other; it's hard to decipher what leads where.
   3. Repetitiveness: Items like "building the test plan" repeat themselves for no particular reason.
   4. No examples: It's hard for the text to find any foundation in your mind when there are no examples to help the reader relate to. Given its monotonous descriptions, nothing could hinder the reader's efforts to understand and implement the book's ideas more than that.

   The final verdict: Look for another software testing book.




2. The book is full of hypothesis. Till now nobody would have implemented all the checklists/templates/procedures mentioned in this book, in their real environment and I can bet on this.

   Checklists are needed if the task of review/testing is very critical and the organizational processes shall demand that. An attempt to define a checklist/template to make it global is real childishness.

   The definition of Verification and Validation itself is written wrong in this book. I dont know if these terms had such definitions during the past years.

   Summary: We are in 2003 now. If somebody wants to go back to 1970 then this book will be very useful for them. A wise decision for normal readers would be to move away from this page. Thanks.




3. This is a very good book, despite what the other reviewers say. It is aimed at the professional software developer, consistent with good software engineering practices. Unfortunately, those who still work ad hoc in software development do not understand the value of formal processes and the resulting reduction of risk or increase in quality. This book assume that readers, and their organizations, have the required discipline to formalize their testing methods. One of the key principles in the book is that requirements must be validated and traced throughout the software life cycle - garbage in garbage out.

   Consider whether or not you would like to fly in a plane or have your bank account managed by software that has not been as rigorously tested as the author requires it to be.




4. Excellent book that covers testing in a lot of detail. It provides excellent ready to use test processes if you don't have any established already. Very comprehensive but you can still pick out the bits that are going to be of immediate value to your organisation. If you don't have a lot of experience you may need some help doing this though.
   
   Highly recommended



5. For several years, I have recommended Bill Perry's Effective Methods for Software Testing, 2nd Ed to people who are looking for testing processes they can customize and apply quickly. I have also included this book as a reference text in many of my testing courses. Obviously, I feel that the book is very helpful to software testers.
   
   In the third edition, there are two fewer chapters, but the coverage of topics has been revised to include areas such as agile testing, the role of testing in software development methodologies, testing internal controls, and an expanded discussion on security testing.
   
   The eleven-step testing process in the second edition has been streamlined to seven steps in this edition. In this process, you will find everything you need to design and customize your own testing process all the way from test planning, through the various phases of testing (static testing, unit testing, integration testing, system testing and acceptance testing), and even through post-implementation testing. The process also addresses analyzing and reporting test results, which also discusses test metrics.
   
   The reasons I'm such a fan of the book are: 1) You get complete templates and examples, including checklists (although the CD contains PDF versions of the forms which would still need to be re-created in a word processor to be usable in electronic format). 2) The book is process-oriented as opposed to a collection of techniques. Collections are fine, but you still need a way to apply them. That's where the processes come in helpful. Also, the workbench process framework is helpful in defining your own processes. 3) These are practical and proven processes that have been used in a variety of organizations worldwide. There is very little theory and a lot of practical application as shown by the examples. 4) You don't have to be a highly mature organization to start applying these techniques. Whether you are CMMi Level 1 or 5, you can still find this information useful. 5)The book also addresses specific topics such as testing commercial-off-the-shelf software and data warehouse applications.
   
   This is a thick book, but then again, it is not designed to be read from front to back. I use it as a desk reference and a collection of processes to help get the job of testing done. I can save hours of work in designing processes by checking here first. My attitude is to tailor the processes to meet my needs. It's also my first stop when doing research. Personally, I like processes because I can transfer them to others and have something tangible to study and improve. However, I will say that if you are "process averse" you will probably not find this book as helpful as someone who does process-based work. The processes described in the book are not heavy ones, though.
   
   This is a good resource for software testers written by someone who has been writing and working in this profession for many years.
   Readability - 4
   Coverage of topics - 5
   Depth of coverage - 5
   Credibility - 5
   Accuracy - 5
   Relevance to software quality - 5
   Overall - 5
   Reviewed by Randy Rice

3 comments about Executing SOA: A Practical Guide for the Service-Oriented Architect.

1. There has been books in the market on the topic of SOA, in numbers. Many of them quickly get into the quagmire of either keeping it too abstract and talk about just business aspects and their benefits or going to the other extreme and treating just the technology aspects of SOA.
   
   'Executing SOA - A Practical Guide for the Service Oriented Architect' is a revealing, startling and supremely practical treatise on this topic of SOA. The first great point about this book is that it does not go into too much of the basics of SOA as a concept; its definitions; terminologies etc. It provides just an introductory chapter on its history and more significanly why SOA matters more and more in today's world of business and IT.
   
   The topic of SOA Governance has not been treated so well if not, at all, in the books that try to fill up the shelf. An entire chapter is dedicated to this topic! The chapter focusses on how business and IT alignment is enabled and empowered by SOA Governance and demonstrates how SOA Governance can and should be used as an SOA Strategy to realistically align IT initiatives with the business drivers and goals of the enterprise. It provides a splendid treatment on how to structure the organization; with its roles and responsibilities and the management of power so that SOA Governance can be implemented as a mainstream SOA discipline inside an enterprise. What I found most useful was the way the authors provided a prescriptive checklist of the various components of SOA Governance and what to execute to make each component be executed upon.
   
   SOA introduces a new architecture paradigm to IT. Rational Unified Process, as a methodology to perform software lifecycle development saw the hole in its existing process around how a typical SOA project should be executed. They used SOMA as a service oriented modeling and architecture method and came up with their new version of RUP called RUP-SOMA. This book is the first of its kind that dedicates an entire chapter in defining to its reader what RUP-SOMA is and more importantly provides step by step guidance on how each phase of the service oriented methodology should be executed in a real world project. I not only find this chapter as a first of a kind in the industry but also am startled by the way the authors have treated the subject and brought it to the reader. One can easily use some very basic and common sense to create a project plan to execute on an SOA project based on the sheer merit that this chapter brings to the table.
   
   Each other chapter focusses on a specific discipline of how to take SOA into a real world project engagement but the topics are kept so well aligned, integrated and standalone that the reader can either focus on one single chapter and execute on it or put them all together and be the guru in your company! The chapter on 'Realization of Services' is a master art that demonstrates how you can implement the RUP-SOMA methodology using the present day products and technologies that are available in the market.
   
   In short, I consider this book as an eye-opening treatment of the subject of SOA and it keeps itself very true to its title i.e. it provides the reader with enough arms and ammunition to go execute successfully on a real-world and practical SOA project.
   
   Thank you authors - now I know why IBM is the best and has the greatest share in the SOA market!



2. Like many of the acronyms in use today, SOA is quickly becoming so broadly used that it is difficult to understand the real role of SOA, the impact on legacy platforms and the realization of true return on investment.
   
   This book avoids focusing on the generalities and re-definitions found in most SOA books and heads straight at the heart of and challenges addressed by SOA. The book gives superb treatments of service modeling and how to maximize reuse of existing silo based services, decomposition of silos and implementation of new reusable components.
   
   But, even more critical to the reader and SOA implementor, the book provides the best and most useful information on SOA governance that I have seen in any of the SOA books out there. Like all models oriented towards reuse, SOA models without proper governance can quickly devolve back into a silo structure negating the value of SOA. This book provides a clear path towards delivering the benefits of SOA in conjunction with implementing an evolving SOA governance model.
   
   Anyone who wants to understand the value of SOA, the challenges of deployment and a means of delivering it while avoiding the risks of "big bang" deployment should definitely read this book.



3. This book contains much valuable information, but I see little that is not readily available on the web. Just do some searching and you can find this information quickly enough. If you don't mind paying for information that is available for free, then buy this book. Look at sites like zapthink, searchsoa.com, soa-consortium.org. Also look at a book named "An Implementor's Guide to Service Oriented Architecture - Getting It Right" and authors like Thomas Erl.

1 comments about Expert Visual C++/CLI: .NET for Visual C++ Programmers (Expert's Voice in .Net).

1. This book pretty much assumes you have some basic C++/CLI knowledge.
   But, if you are like me, you will pick that basic knowledge on your own from the web and then you will probably buy this book :)
   This book has just the right piece of advice for all the coders who can learn the basics on their own but at the same time need to make sure they are doing things right.
   This book will give you that extra confidence and will take you to the next level.

5 comments about Physically Based Rendering : From Theory to Implementation (The Morgan Kaufmann Series in Interactive 3D Technology) (The Interactive 3d Technology Series).

1. This book covers everything you need to know to write a ray tracer with
   advanced features like photon mapping, volume scattering, path tracing,
   etc. The scope of the material it covers is stunning. It starts from the
   basics of topics like 3D geometry and ray/object intersections and then
   builds up to explain reflection models, advanced texturing techniques, and
   then light transport algorithms.
   
   It has excellent discussions of the theory and underlying math of physical
   rendering blended (rather well) with very very useful practical
   implementations of the theory. The leap from theory to implementation is
   often difficult to do, and to do well or efficiently even more difficult.
   (The ray acceleration code alone is worth it's weight in gold.) This is an
   indispensable book for anyone who wants to write their own ray tracer or
   learn more about the latest techniques used in photorealistic rendering.



2. Although it is not possible here, I am fairly sure this book deserves such rating. This is truly remarkable work and is likely to become a classic text in the field of computer graphics.
   
   It is not a survey-type book, instead of trying to describe every possible method out there, the authors have concentrated on a few selected techniques, that are not only good (modern, fast, easy to implement, etc.), but also have some pedagogical merits and can serve as a gentle introduction to the world of ray tracing and digital image synthesis. Despite focusing on selected areas, the authors managed to squeeze here in an amazing amount of material. Among other topics, this book covers: subdivision surfaces, ray-primitive intersection acceleration techniques (3D DDA and kd-tree), color and radiometry, anti-aliasing, tone mapping, physically based reflection models, texture mapping (including texture anti-aliasing using ray differentials), area lights and HDR Image Based Lighting, volume scattering and much more.
   
   A large part of the book has been devoted to the light transport and Monte Carlo techniques. One can find there an introduction to the theory of Monte Carlo estimation (including selected methods for reducing variance and computation time, like Russian roulette, multiple importance sampling or stratified sampling) and explanation of important light transport equations (rendering and transfer equations).
   
   Finally the authors have described (and implemented) several solutions for the rendering equation: Whitted-style recursive ray tracing, direct illumination estimation, path tracing, irradiance caching and photon mapping.
   
   However, it is not only the vastness of the material covered in this book, that causes this volume should be praised so highly. Perhaps, the style, in which this book has been written, is even more impressive. For each of the topics, the authors start with what is usually known as "dry math and theory", and then show how it is supposed to work as an algorithm (including its dirty details) and finally they explain how to turn this algorithm into C++ code. Each of those transitions concentrates on a small portion of the problem, so it is still easy to understand. Anyone, who had to turn a SIGGRAPH paper into something that works, will immediately recognize what kind of gem this book is - it actually shows how to do it!
   
   This brilliant blend of theory and practice is one of its brightest spots, for learning the theory and math formulas is one thing, but writing a working, robust implementation is completely another.
   
   Those, who prefer studying sources, will get source code of a very good, physically based, extensible ray tracer (called pbrt) with the best documentation one could ever imagine. Documentation that gives the rationale for almost every line of code. It shows not only how they did it, but also why they did it that way.
   
   It is not the only book, that one will ever need - computer graphics is a vast topic - too big to be covered in a single volume, even as huge as this one. However, it is certainly one of the books that everyone interested in photorealistic rendering should buy. The price of this book is really low, if you think about it as of an excellent, first-rate computer graphics course.
   
   Aimed at students, researchers and people interested in computer graphics algorithms, it is an indispensable book for anyone willing to write his own photorealistic (not necessarily physically based!) ray tracer and learn more about computer image synthesis.



3. This book mixes detailed algorithm descriptions with actual code in a book that never loses sight of the "big picture" of physically based ray tracing and image synthesis. Although it is very well written and is not a dry academic book at all, it would help if the reader is already familiar with basic computer graphic techniques, linear algebra, calculus, and optics in order to get the most out of this book. It was never meant to be a replacement for Foley & Van Dam's classic book on computer graphics, even though the first few chapters go over basic computer graphic material. The book includes a website where the source code of the authors' renderer can be downloaded. This code is very well organized and commented so that if you wish to lift individual pieces from the entire software package you can with just a little bit of work. I highly recommend this book to the programmer who wishes to implement physically based rendering in his/her own code or wants to know about the practical implementation of image synthesis techniques. Amazon does not show any details about the book here, so I shall explain the contents in the context of the table of contents:
   CHAPTER 01. INTRODUCTION
   This chapter talks briefly about all kinds of topics related to ray tracing. It also talks about how to understand the code in the book and the book website.
   CHAPTER 02. GEOMETRY AND TRANSFORMATIONS
   This chapter is pretty basic computer graphics stuff. It talks about coordinate systems, vectors, arithmetic, scaling, dot and cross products,etc. Applying transformations via matrices is also discussed as well as the representation of points, vectors, normals, rays, and bounding boxes.
   CHAPTER 03. SHAPES
   More basic computer graphics continues with discussions on spheres, differential geometry, cylinders, and disks, paraboloids, triangles and meshes, and the representation and bounding of all of these shapes.
   CHAPTER 04. PRIMITIVES AND INTERSECTION ACCELERATION
   This chapter is about accelerating the speed of your graphics through grid acceleration, tree construction and representation, and object instantiation.
   CHAPTER 05. COLOR AND RADIOMETRY
   XYZ color system is discussed along with radiometric integrals including integrals over projected solid angles, integrals over spherical coordinates, and integrals over area. Beginning in this chapter the math becomes more advanced.
   CHAPTER 06. CAMERA MODELS
   Projective camera models are discussed along with orthographic, perspective, and environment camera models. This information will already be familiar to students of computer vision.
   CHAPTER 07. SAMPLING AND RECONSTRUCTION
   Frequency domain techniques are discussed starting with the Fourier transform and ideal sampling and reconstruction. Also, antialiasing techniques are explained.
   CHAPTER 08. FILM AND THE IMAGING PIPELINE
   This chapter talks about topics such as luminance, photometry, bloom, and imaging pipeline stages.
   CHAPTER 09. REFLECTION MODELS
   The various reflection models are discussed including specular, Fresnel, Lambertian, Oren-Nayer disfuse reflection, and the Lafortune model.
   CHAPTER 10. MATERIALS
   Matte, plastic, bump mapping, and other material effects are explained very well.
   CHAPTER 11. TEXTURE
   We return to frequency models some in this chapter. The texture sampling rate, filtering functions, and mapping in spherical, cylindrical, and planar form are explained. Procedural textures are also discussed including the famous Perlin noise, marble, and windy waves.
   CHAPTER 12. VOLUME SCATTERING
   This chapter is considered more advanced material, and discusses volume scattering processes, absorption, emission, in and out scattering, phase functions, exponential density, and volume aggregates.
   CHAPTER 13. LIGHT SOURCES
   All kinds of light sources are described including point lights, spotlights, texture projection lights, distant lights, area lights, and infinite area lights.
   CHAPTERS 14 and 15 both discuss Monte Carlo integration techniques including improving efficiency.
   CHAPTERS 16 and 17 are about light transport. The first chapter is about surface reflection and the second is about volume rendering.
   CHAPTER 18. SUMMARY AND CONCLUSION includes a design retrospective, a discussion of abstraction versus reality, and design alternatives including triangles only and streaming computation.
   APPENDIXES- These include sections on utilities, scene description interface, input file formats, an index of code fragments, an index of classes and their members, and finally an index of identifiers.



4. I cannot praise this book more than the others already have. The book is about producing high-quality images using raytracing. It basically walks you through the creation of a fully-functional raytracer, discussing all the different algorithms and techniques that are needed along the way.
   
   It's written in the context of their particular implementation of a working raytracer, using the fweb programming/documentation system, where basically the program source and the documentation are written as one document. I've always thought this was academic nonsense as far as writing real code in a production environment, but it turns out to be an EXCELLENT way to write a book or code intended for a learning environment.
   
   This strikes the perfect balance between explaining the theory thoroughly and showing how the ideas can be implemented in a real, functional raytracer. They avoid the trap of many other book that focus on a particular implemention, by not getting too bogged down into pecularities of their system.
   
   The source code itself also stands out as a strong point. There are so many books out there with poorly written and unorganized code that you'd never want to read, much less try to work in. The code is well organized, and the coding style easy to read. It's one of the few books I own that contain source code where I actually read the source code and it added something to my experience. I wish everybody who wrote about programming was actually a decent programmer and not just a mathemiticion.
   
   This book has academic rigor and but also well-written explanations. I'm still learning a lot from it. I expect to refer to it frequently over the next years as we (in the video game industry) take more concepts from raytracers and apply them to real-time graphics, as the processors get more and more powerful.
   
   You probably should not be an absolute newbie when it comes to basic 3D math and things like vectors and basic graphics concepts before buying this book. The authors use some calculus, too, if that scares you off.



5. I do ray tracing and GI for a living. When I got started on my ray tracer I was struggling with several basic issues. Even though I tried to locate all the published material on those subject there was still significant gaps. Issues like 'how to shot photons', what about all these 'cosines'. How do you actually implement a kd-tree. I read Shirley's, Jansen's, Glassner's and Advanced Global Illumination and a lot of the older Siggraph papers. PBRT came out just in time to rescue me. It contains the only complete implementation of a photonmap.
   
   It's strong point is a complete running GI engine. However the literate programming style used in the book meant a lot of time I cannot read a subject by itself. The use of abstract interfaces sort of force you to use the class browser to follow the logic. You pretty much have to read it from the beginning. The quality of the code contained goes beyond the usual standard of code published as examples. It contains a rather sophiscated random number generator. Its treatment of LDS plus sampling and recontruction in general is excellent. It is the only source that shows how to implement Li's algorithm to generate random rays to sample a sphere. Same goes for Malley's. Shirley and Chui's concentric sampling method is hidden in the appendix of a old Siggraph paper.
   
   The book also has code to sample and model most of the common light sources. Which is surprisingly non-trivial.
   
   I highly recommend this book but it does require a certain level of commitment to get the most out of this book. The chapters on sampling, ray differential, texture filtering, light transport I consider must reads for all graphics programmer even though you might not be working on ray tracing.

5 comments about Object-Oriented Programming in C++ (4th Edition) (Kaleidoscope).

1. One of the very good references for study of Object oriented programming and understanding C++.



2. If you are a professional Software Engineer, this is the manual to have at your desk when you work.



3. I have been a C programmer for many years but had stepped away from it. Recently decided to jump to C++/C# and took a University course on OOP that used this book. The ideas are presented well, examples are great. Even as I take advanced courses I find myself refering back to this book for its examples and clear explaination of OOP theory as well as some of the gotcha's C++ can throw your way. I highly recommend this book, this book is used a lot in into C++ courses and there is a reason. Its Great!!!



4. This is a well written book and explains things in a simple form. Author does not add unnecessary items to examples which keeps things simple when you are trying to learn. For me it was a good refresher for the C programing part and was great at teaching me the C++ object oriented part. It explains how to use C++ and expands on why you would want to do it a particular way in the real world.



5. I have read versions 2 and 4 of this book and still find Robert's writing style to be the most entertaining of all the technical book I have read. His use of illustrations clarifies confusing topics such as classes, pointers, inheritance and polymorphism. I return to read these topics each time I start a job search to refresh myself on these concepts in preparation for interviews.

4 comments about Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer).

1. What a fantastic book!! It has helped my software developers and test engineers to better utilize all the tools available to them! The authors are articulate and knowledgeable of the subject. Highly reccomended late night reading!!



2. Some coders may turn away from this book because it has "testing" in the title. Some test engineers who don't code may also waffle when they see source code examples written in C# included in the book.
   
   This book truly caters to both programmers (developers and technical testers: unit testing, code coverage, dynamic analysis, static analysis / fx cop, profiling, unit testing against a database, data-driven testing, build verification testing) as well as testers without a programming background (recorded web testing, load testing, manual testing, test library management).
   
   Because the line between programmer and tester becomes more difficult to define -- especially with today's software test engineers who are also hard core coders and developers who write their own test suites -- this book provides everything the programmer needs as well as everything the test engineer needs when looking to get started and utilize the incredible set of tools the team at Microsoft added into Visual Studio Team System.
   
   (This book also explores how these tools are integrated into Team Foundation Server (including check-in policies, automated testing of builds, associating bugs and tests, and more) -- so in many cases, this book not only applies to testers and developers, it will also be of interest to technical program / project managers, dev managers and test managers).



3. The previous reviews I read about this book gave great praise. And all that they said is true, the book is well written, clear, concise, and easy to understand - with rich wonderful hands on examples and source code. A wonderful entry into the Microsoft offerings of testing right along with software development.
   
   What makes this an even better buy or value added product is that if there is an issue with why things work (or don't work the way they should) the author(s) will follow up with you in an attempt to clear up any misunderstandings.
   
   Not only is it a very good read, the authors can and do add additional value to the book long after it has been paid for - should there be any questions upon anything contained in the text - something that is very unusual in this realm or domain. I can not say enough about the quality of this book and the quality of the service one gets should they have a need to contact one of the authors - in my case it was Andy Leonard - who kept helping with something that wasn't even his issue - it was one of those undocumented Microsoft "features".



4. Precondition: I also went through chapters 1 to 4, for my interest was in Database testing.
   Pro: This is a nice intro into testing databases using VSTS, the only product that I know does that. If you want to see some bits of what can be done using this instrument - go for it. A piece on enhancing built-in functionality with recordsets counter is definitely a nice one - a must-read for anyone who wants to do more realistic testing than what MS offers out of the box!
   Contra: I expected to see how to construct a solid framework for testing industrial-scale applications but failed short of it. Namely, I could not find the discussion of how to set up the whole facilities, how to run tests as a batch from outside the Studio - our SCM/Build Team does not open Visual Studio to run their operations overnight, you see. I could not find detailed discussion of Pre/Post events, yet this seems to be absolutely essential for any serious testing: you need to have some known state of DB before you run your tests and you should be able to restore that state (efficiently, so backup/restore of multi-Gig DBs is not a viable option) to run other tests (DB and non-DB).
   Overall a nice intro, but I had to refer to online help from MSDN more often than I would love to, on having read the book pretending to be more or less coverage of the material. Still a good buy for the money. Looking forward to see a manual that covers DB testing in greater depth.

5 comments about The Rational Unified Process: An Introduction (3rd Edition) (Addison-Wesley Object Technology Series).

1. 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.




2. 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.



3. 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.



4. "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.



5. 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.

5 comments about Oracle Database 11g: New Features for DBAs and Developers (Expert's Voice in Oracle).

1. I selected this book because it's written by Alapati. I've read excellent books before by this author. Unluckily, this one is not among them.
   I've finished reading the first three chapters and so far I found too many typing errors, errors in the code and unprecise statements. Obviously it was written in hurry.
   All in all, this book does its purpose to me to learn Oracle 11g new features but I expected higher quality from Alapati and Apress.



2. This is the most detailed 11g book on the market. It has a ton of material on the new Oracle database. Sam Alapati and Charles Kim deliver an excellent reference on 11g.
   
   These 11g enhancements are covered in the book.
   
   Installation, Upgrading, and Managing Change
   Database Diagnostics and Failure Repair
   Database Administration
   Performance Tuning and Management
   Database Security
   Backup and Recovery
   Data Pump
   Oracle Streams
   Storage Management (Direct NFS and ASM enhancements)
   Data Guard
   Application Development
   Data Warehousing
   
   I would highly recommend this book for anyone who is serious about getting up to speed on Oracle 11g.
   
   For LoveOracleBooks,
   
   I see some of the errors you mention. You obviously went through the book. I tried the queries and they worked fine for me (after some minor editing). Any Oracle DBA should be able to figure it out. Still, the book was excellent for me. Sorry you are upset about a couple of typos (which isn't unusual with any technical book like this... especially with lots of examples). Still, I feel it's a really great book and the content within more than makes up for a couple of typos. There are literally tons of examples and the authors went out of their way to not just tell you how or why but to demonstrate how it's done. Many books don't go to such lengths. 99% of the examples work. The effort that clearly went into this books earns it 5 stars all the way.



3. I'd recommend this book for a DBA who already has experience administering Oracle 9i and 10g, and want to maintain his/her knowledge up-to-date. It focus on the main new features of Oracle 11g, and it's certaily worth buying it!



4. For the most part it was a decent book and gave me a great overview of the new features in Oracle 11g. However there are quite a few typos and a bit of inaccurate information (result_cache_mode = AUTO is not valid/supported).
   
   I wouldn't say this is a bad book - it's a nice read and contains the majority of the information. I am impressed by it being one of the first 11g books out. The authors put in a lot of hard work and I congratulate them.



5. This is the first book I have read from Sam Alapati and Charles Kim. Coincidently or not, Sam is also the author of the "OCP Oracle Database 11g: New Features for Administrators Exam Guide (Exam 1Z0-050)" book.
   After completing this book I am very happy with what I have learned. The authors are very thorough in their coverage of the new features in 11g and do a good job of providing applicable real world examples.
   
   Chapter 9 on ASM covered the new features well and Oracle has made some nice improvements. ASM is a growth area for Oracle and am looking forward to it becoming friendlier and easier to use. Moving files in and out of ASM has been made easier in Oracle 11g.
   
   Chapter 11 on Application Development will be best utlized by developers or DBA's that are involved with development beyond the intermediate level. This chapter also introduces DBAs to APEX.
   
   Chapter 12 is one of the most important chapters. This chapter focuses on Data Warehousing and includes the new partitioning features. The examples are easy to understand and are applicable to the real world. This chapter also does an excellent job on explaing Oracle's next generation LOBs called "Secure Files". This is a must read chapter.
   
   If I could have added a chapter to this book it would be a chapter dedicated to RAC. Even though 11g does not bring too many new features to RAC it does have a few. For example the new features on parallel execution I do not think are mentioned. Their are also enhanced configuration assistants that can be better explained and can be found in a single place.
   
   Overall this is an excellent book and for someone who is just starting to work with 11g this is the best place to start.

5 comments about Unified Modeling Language User Guide, The (2nd Edition) (Addison-Wesley Object Technology Series).

1. Start reading Chapter 1 of this book for even just the first few pages, and for various topics, it will say to go to future Chapters. If you take a look at those future chapters, there will be notes on the side telling you to go back to Chapter 1 or to other chapters. You can run into infinite loops or dead ends not really picking up anything. It is possible to maybe find what you were looking for, or find that the explanation for it is just not sufficient.
   
   If I'm trying to look for a topic to remember, this book is not an easy read with the index either. If you look up some topics in the index and go to all the pages listed, it may not list all the important pages. Sometimes, when I had to look for information on something, say a "use case" for instance, then I'd look that topic up in the index. I'd go to all the different pages listed in the index and it might not be what I was looking for. Then I'd have to look at the side of the page of usually the lowest or 2nd lowest numbered page listed by the indexed topic, and go to the Chapter(s) listed. When I went to those chapter(s) I'd still have to scour the entire chapter(s) until I might find what I was looking for. An example was when I was trying to understand what one of the diagram types was, a "state diagram" I believe it was, as compared to say an "activity diagram." Sometimes I would find out that things just weren't worded well if in there at all, and I'd have to refer to another UML book.
   
   This book may have some good use, but I haven't found that yet. It's hard to read and hard to look things up, and hard to learn from if you don't already know much or anything that is for sure.



2. I picked up this book as a way to familiarize myself with the changes to UML in UML 2.0, which are extensive, as I found the OMG specification nearly impenetrable. I had liked the first edition, though I too felt Fowler's Distilled was a much better intro to give to students and engineers learning UML for the first time. This edition, though, does not meet expectations. The typos and bad references throughout are bad enough. Join that with a complete lack of real-world design examples, poor organization, and poor design. Why a chapter on State Machines and a separate chapter on State Diagrams that repeats a lot of the earlier chapter? The blue cross references make it clear that the book is spaghetti design at its worst. Check out the table of contents, you won't know where to look for your favorite diagrams; check out the index, and you won't be able to find the definition of the concept you just can't quite remember. The glossary is useful, as the UML 2.0 spec dispensed with a glossary, making it even more impenetrable. On the other hand, the authors make no attempt to call out the new UML 2.0 features, which would have made my day. What I find most unforgivable, though, is the authors' inability to present the new UML as it really is: the book is seriously misleading in many ways for learning UML 2.0. My biggest peeve is the way they treat the new and highly useful composite structure diagrams. In the list of diagrams, they don't even mention it, calling it by the name of a different diagram, the "Component Diagram", which they feel is the same thing. They then separate the discussion of composite classes and components, making it seem as though they're totally unrelated. They fail to mention quite a few of the new UML features (the X navigation adornments that make non-navigability explicit, for example, which is critical to code generation, or the fact that you can have multiple stereotypes associated with model elements. In their defense, the UML standard isn't very clear on these diagram types, but this is a practical tutorial that should take practice into account. There are constant references to the Reference Guide for more advanced features; these are mostly the UML 2.0 features that they didn't feel were important enough to include in the comprehensive tutorial. The appendix on UML notation simply ignores many UML 2.0 notations. I can't help but feel shortchanged.



3. Book is complete waste of money. Find more prevalent information online. Not really a required book. Not used at all.



4. I don't know what people who would review this book well are thinking. These authors may be good at creating the UML, but terrible at explaining it. The sentences are packed with words they haven't explained - or uncommon uses of words that really have no meaning, unless you are already a UML expert. I can't imagine a more poorly written text.



5. When I am using tools supported UML, I often search key concept with this book. Because this book is an user guide.
   I made some sequence charts, so I use some functions of UML.
   I can not understand which architecture is good or not.
   I think there are little idea about that.

3 comments about Mac OS X Leopard: Beyond the Manual (Btm (Beyond the Manual)).

1. There are a growing number of guidance books being published about Apple's latest computer operating system OS 10.5, a.k.a. "Leopard." "Mac OS 10 Leopard: Beyond the Manual" by Scott Meyers and Mike Lee aims for a more sophisticated reader group than most of the others which tend to target casual users and perhaps new "Windows switchers."
   
   This book is for advanced computer users, especially those familiar with UNIX and Linux who want or need to learn about the hundreds of new and improved features of the MacOS, and even for casual Windows users who are comfortable with command line interaction and prefer full keyboard use of the computer.
   
   Scott Meyers is an editor and Mac OS consultant and Mr. Lee is a technical specialist. The writing is clear and straightforward. Unlike some other Leopard guides, there is no attempt to be literary or stylish - this is a software manual after all for advanced users. They cover all the Leopard basics and assume the reader is not, or only barely, familiar with the Mac OS 10 system. The first four parts(of eight) of the book, counting 17 chapters, describe the basics--the Aqua interface, the Menubar, Views, the Sidebar and Dock, system and user preferences, the file system, maintenance, security, networking, and included Apple applications like Safari (the browser), Mail, iChat, and iCal. An item by item description of the Safari menus takes up a full seven pages. The Mail menu descriptions take up 11 pages. The menu descriptions are contained in a chart which provides alternative common keyboard shortcuts for each of the menu commands. Like UNIX and other operating systems, one can ignore the mouse completely once one knows the key combinations. They also provide an introduction to the iLife suite of applications, like iTunes, iPhoto, and the other consumer-level productivity applications included with the Leopard installation.
   
   The coverage is comprehensive but not deep. The reader will be exposed to most of the operating system but nothing is treated extensively or with depth. Some of the chapters are very short. Presumably, higher end users will figure the deeper stuff out for themselves after being directed to what is available in OS 10. There is no shortage of illustrations, screenshots, charts, tables illuminating in an effective way the text comments and descriptions.
   
   Throughout, the authors provide numerous "Notes" and "Tips" which elaborate on the basic text. These are more explanatory of specific items and features and some are in the nature of practical recommendations and suggestions - for configuring preferences, for example, or utilizing third-party applications instead of Apple's for certain functions. There is an extensive five-page section on the components of the system-wide and user Libraries in OS 10 with descriptions of all the items contained in them. Throughout the first half of the book - the part focused on the user interface and middleware layers of the OS - the authors provide information on both the menu -mouse navigation and keyboard operation alternatives, the latter for power users and others more comfortable with keyboard use. Differences in desktop and laptop keyboards are detailed as well. There is an an interesting section on calibrating the display and modifying the default Macintosh 1.8 gamma to a Windows-like 2.2 gamma for those users who are not graphics professionals, at least.
   
   The last half of the book is about UNIX, or more specifically for the MacOS, "Darwin" which is Apple's flavor of UNIX. Starting first with the "shell" the authors walk the reader through starting up the command line functions, describe the elemental UNIX commands, note navigation issues, root access, and the like. Later chapters cover scripting Darwin, using the included scripting languages of Perl, Python, PHP, and Ruby, and how to install additional advanced software like Fink and Macports.
   
   Chapters 20 and 21 cover networking, remote monitoring, and firewalls. Chapter 22 deals with the included Web server software, Apache, as well as SQLite and PHP. There is a chapter devoted to Apple' s own scripting applications, Automator and AppleScript. The final chapter covers the developer tools, also included with OS X. There are references to the various "kits" which developers can use to create their own applications and there are many kits included in OS X - for audio, video, graphics, PDF handling, animation, and more.
   
   The appendices include guidance on installations and a list of what's new in Leopard (versus earlier versions of OS 10.) An extensive index of 43 pages rounds out the book.
   
   This book is solidly produced and written and should bring advanced users up to speed with Leopard and to point the way for them to explore the depths of it themselves.



2. When I did the first cut at this review I found myself saying "there's 3 pages on this, then there's 8 pages on that, then there's....". It looked like I hadn't actually read anything beyond the table of contents, when in fact I had read virtually every page of a LARGE computer reference for the first time in as many years as I can remember - including 30+ spent in IT.) "Mac OS X Leopard Beyond the Manual" is one of those encyclopedic tomes that tries to touch on virtually everything about a given subject area without going into anything too deeply. It's targeted at intermediate/professional computer users though, not beginners.
   
   I was coming back to the Apple desktop platform after a decade plus hiatus - since the days of MAC OS 8. Like many people, I don't buy nearly as many computer books as I used to given all the online resources available; but I'm old fashioned enough to feel the need to have a couple good ones around in each major area of interest. Browsing the table of contents of Leopard BTM made me think it would provide the security blanket I wanted as a 'new' user/administrator and that it would give me an intro to OS X architecture and development. So here are some impressions of what I found most useful; your mileage may vary.
   
   The first two parts of the book cover using and administering Leopard. They do a pretty good job of of introducing the Aqua interface and giving an overview of how the file systems are laid out. You're sure to resolve a few of your quandaries and find some unexpected features. Here, for example, I found out about 'fast user switching' which I knew that Leopard, being UNIX, must have but hadn't figured out yet. Also that voice recognition is built-in. (I'm looking forward to testing it with the included chess program.) The section on networked printers was good background. (But what finally got mine working was just doing the same steps over and over til it `took'.) The chapter on backup was rather perfunctory. In a book of almost 600 pages this would seem to warrant a little more than 8? The chapter that covers Spotlight, Expose, Spaces and Dashboard in a dozen pages is typical of too much of the book. And half of these pages are screen shots - that's also pretty typical of the whole book - so you can figure the coverage of each topic is rather lean.
   
   The next two sections cover all the major Leopard applications which, perhaps surprisingly, was the least important area to me.
   I'm a confirmed Firefox user and I didn't really see anything while dipping into the Safari pages to convert me to Apple's browser. Similarly, I have no intention of using Leopard's Mail, Address book or iCal programs - Google covers all these for me across Mac, Windows and Linux desktops. However, I found the iChat chapter surprisingly interesting. I should have known, but didn't, that it supports the built-in iSight camera in my iMac. (I'm really sick of all these iWords.) And that it is Gtalk/AIM compatible. iTunes on the Mac is pretty much like iTunes on Windows. A few pages on Apple's .Mac online service didn't convince me to plunk down $99 so that I can store my photos in an Apple enclave rather than via Flickr or Picasa Web. The iLife 08 'digital lifestyle' apps are covered quickly. My wife probably got more in the first 3 minutes of actually using iPhoto than in the 3 pages here. Coverage of the more powerful iWork 08 applications - similar to MS Office - is even shorter as Leopard includes them only as trials. (My wife liked the Pages word processor enough to shell out the extra bucks for iWork.)
   
   Up next is an intro to Darwin, Apple's UNIX variant underlying OS X. The first chapter was a little disappointing for this former sysadmin as it was pretty much like any UNIX primer you've ever read. The following one was better but uneven - the authors go into shell scripting in some detail but then have a section covering "Advanced Scripting with Perl, Python and Ruby" in under 4 pages?!?
   
   The networking chapters are decent but contain more .Mac propaganda. The authors are very much true believers whereas I simply want my Mac to play well in an existing Windows/Linux environment. Apache is bundled in Mac OS X and a lot of good pointers to other sources of information of interest to new web designers are included.
   
   The most compelling portion of the book to me was the 100+ pages on application development under Leopard. I haven't earned a paycheck as a full-time developer since about the time Gerald Ford was president and there's the presumption that you already have a clue about how objects work, but I feel like I got the lay of the land and could start poking around in Automator or the Xcode IDE now. The authors seem to be passionate about programming and it's a bit infectious.
   
   Overall, I found "Mac OS X Leopard Beyond the Manual" to be fairly good from a using perspective, a little weak from an administrative orientation, pretty strong as an introduction to current Mac development tools. At the Amazon price, I'd say its a superior value if your Mac interests are anything like mine. (Full disclosure - I got my copy free through a user group with the intent of a review.)



3. Those who like to do more with their Macs and aren't afraid to try things will appreciate this book. This is not aimed at absolute beginners although there may be some who are ready to jump in. The nice thing about this book is that there are topics covered that you don't always see in other books. For example, there is a chapter on connecting peripherals to your Mac and another chapter on Leopard as a web server. One chapter is devoted to "common Leopard maintenance."
   As with most Leopard books, you get information about using the applications that come with Leopard, connecting to the internet, what the system preferences do and customizing your Mac.
   Included are chapters on Darwin, Mac OS X Development and tools and cross-platform solutions. These advanced topics are not just a page or two, but chapters long which are a good portion of the book.
   Some people may be scared off by all the advanced topics, but all the basics are covered too. It doesn't hurt to have both even if you aren't ready for all of it just now.