5 comments about Continuous Integration: Improving Software Quality and Reducing Risk (Addison-Wesley Signature Series).

1. Any software developer who has spent days in 'integration hell' handling a complexity of software components will appreciate the invaluable information in CONTINUOUS INTEGRATION: IMPROVING SOFTWARE QUALITY AND REDUCING RISK. From the initial concept of CI and its practices to over forty CI-related practices from database integration to development, this book covers the entire cycle of CI development and surveys all kinds of events, repetitive processes, and more. An outstanding guide any serious software development library needs.



2. This book is an excellent overview of why Continuous Integration is important and about more than just compiling frequently. The book helps you to understand why to do CI, what you can do beyond building, and how to do it. In addition to general principles, the book points you to some excellent tools and resources. This book is an excellent companion to Software Configuration Management Patterns: Effective Teamwork, Practical Integration; it provides teriffic information that support the build patterns in that book. You might already know some of the information in this book, but it is worth buying if you need to encourge CI in your organization for the clear discussion of why CI matters and the for the detailed advice on how to implement it.



3. As a software developer, you know that one of the critical period in a project is when you try to make integrate your code in the overall application and push it towards the final user. It is sometimes a long process that you would like to accelerate so that you could obtain a quicker feedback on the quality of your code. This book written by Paul Duvall, with Steve Matyas and Andrew Glover, will help you improve the way you build and deliver software.
   
   After a initial presentation of the continuous integration (CI) concepts and objectives, the content of the book goes far beyond the simple "continuous build" aspect to cover all disciplines concerned by CI: risk management, configuration management, database evolution, software testing, inspections, deployment. It is clear that CI is just not installing a suite of tools, but is mainly changing software development practices and process. Each chapter is well structured with practical examples related to real life situations. The book reach also nicely the objective of maintaining a balance between a somewhat tools- and language-neutral position, but still giving enough practical advice so that you could quickly adapt the advice to your own software development environment. Final appendixes give valuable information on CI resources and evaluating available CI tools.
   
   Finally, you can get more and updated information on continuous integration and download book's chapter two from the Web site associated to the book: http://www.integratebutton.com



4. As Martin Fowler says in his foreword to this book, all of this information is available on the internet. However, that should by no means demean the value of this book. This is an extremely readable and well-organized presentation of this important development practice. Often the organization and comprehensive analytical thought are themselves important contributions to a given topic, and that is what Duvall, et al deliver here. Highly recommended.



5. If you have not been exposed to continuous build/integration, this book covers the approach along with the advantages and points you to some references.
   However, if you already have an understanding of CI or have decided that you need to set up a CI environment, this book doesn't add much: few details, little discussion of fine points, etc. That is, don't buy this book if you want concrete help setting up CI.
   There is quite a bit of repetition (how many times does one have to list the advantages of CI, or a dedicated build machine, or whatever?).
   I found Ant in Action (Manning) much more useful: both in providing the motivation for CI, explaining fine points, providing examples, and in breadth (even if "Ant in Action" is nominally about a Java build tool).

2 comments about Troubleshooting Oracle Performance.

1. "Troubleshooting Oracle Performance" is the most thorough, yet physically compact book covering performance tuning with Oracle 9i R2 through 11g R1 on the market. It is quite clear that a great deal of effort was made by the author to carefully verify the tips and test results contained in the book and to organize the material in a logical progression, thus building a bridge between the reader's current understanding to the understanding of complex tuning approaches.
   
   What this book accomplishes, which most other performance tuning books seem to miss, is to indicate which performance tuning features are available in each Oracle release (and which are available at no additional licensing cost) as the various performance tuning approaches are discussed. Not only does the book indicate when a feature would be appropriate, but also potential problems ("Pitfalls and Fallacies") associated with each feature.
   
   The depth of coverage of Oracle 11g R1 features is surprisingly thorough given the short amount of time which that version has been on the market. A little more detail in a couple areas, such as hacking stored outlines, would have been helpful; at the same time, everyone who reads the book might have a different opinion of what needed additional detail, the book could have grown to 2500 or more pages, and likely would have been obsolete by the time it was published.
   
   The Apress Roadmap on the back cover of the book indicates that this book should be read before "Forecasting Oracle Performance", "Expert Oracle Database Architecture", and "Cost-Based Oracle Fundamentals". The "Troubleshooting Oracle Performance" book seems to assume that the Oracle database concepts are well understood. As such, it is probably wise to read "Expert Oracle Database Architecture" first, followed by this book, "Cost-Based Oracle Fundamentals", and finally "Forecasting Oracle Performance".



2. BOTH Developers and DBAs can learn from this book. Along the line of "Optimizing Oracle Performance" by Cary Milsap; this books shows by clear examples how to Identify Performance Problems (Chapter 3) and how to solve those problems (the remainder of the book).
   
   Developers can learn how to Instrument code to help the tuning process.
   DBAs can then trace the code and find the bottleneck/waits.
   
   This book bridges the gap between Developers and DBAs and points out indirectly that Performance is a teams effort and solution.

5 comments about C++ in a Nutshell.

1. I found this book is excellent. It concisely covers many finer
   points of c++ language, which are not fully explained
   in many other similar books. Of course, your understanding of
   this book will be greater if you have already studied c++ for
   a while.



2. I always like O'Reilly books and are usually what I purchase. The "In A Nutshell" may be misleading to some. Just think of it as "C++ A Language & Library Reference." If you are a beginner looking for a how to, this isn't the one for you. "Thinking in C++" by Bruce Eckel (great book), or "Practical C++ Programming" would be the one a beginner would want. However, when you are ready to explore the inter-details about what C++ classes provides, this would be a good one to add to your collection. The first half describes C++ in general, while the last half details the language reference. I like how the reference is structured, grouped by the easy to find header declaration at the bottom of the page. Quickly finding what you need is a great feature here. You can only do so much "std::cout << "hi" << std::endl; without a reference and this one covers the missing details. Not for beginners, but an excellent reference.



3. This is a great reference book. You definitely need to know something about c++ to get the full benefit of it. I would recommend it.



4. Many implementations of C++ extend the language and standard library. Except for brief mentions of language and library extensions in the appendixes, this book covers only the standard. The standard library is large, but it omits much that is common in computing today such as concurrency, network protocols, database access, graphics, and windowing. However, Appendix B contains some information about nonstandard libraries that provide additional functionality.
   
   This book is a reference, not a tutorial, thus those unfamiliar with C++ might find portions of this book difficult to understand. Although each portion of the book contains some advice on idioms and the proper use of certain language constructs, the main focus is on the reference material. This book is divided into two interleaved sections that cover the language and the library, and a couple of appendixes. Roughly speaking, the language is the part of C++ that does not require any additional #include headers or files. The library is the part of C++ that is declared in the standard headers.
   
   Chapter 1 through Chapter 7, Chapter 11, and Chapter 12 cover the language itself. The first seven chapters form the main language reference, organized by topic. It is customary for a programming reference to contain a formal grammar, and this book does so in Chapter 12, which is organized alphabetically by keyword with some additional entries for major syntactic categories, such as expressions. Chapter 11 is a reference for the preprocessor. Chapter 13 is the library reference, organized alphabetically by header. Chapters 8 through 10 present an overview of the library and introduce the topics that span individual headers. A detailed accounting of each chapter follows:
   
   Chapter 1. Language Basics - describes the basic rules for the C++ language.
   1.1. Compilation Steps
   1.2. Tokens
   1.3. Comments
   1.4. Character Sets
   1.5. Alternative Tokens
   1.6. Trigraphs
   
   Chapter 2. Declarations - describes how objects, types, and namespaces are declared and how names are looked up.
   2.1. Declarations and Definitions
   2.2. Scope
   2.3. Name Lookup
   2.4. Linkage
   2.5. Type Declarations
   2.6. Object Declarations
   2.7. Namespaces
   
   Chapter 3. Expressions - describes operators, precedence, and type casts.
   3.1. Lvalues and Rvalues
   3.2. Type Conversions
   3.3. Constant Expressions
   3.4. Expression Evaluation
   3.5. Expression Rules
   
   Chapter 4. Statements - describes all the C++ statements.
   4.1. Expression Statements
   4.2. Declarations
   4.3. Compound Statements
   4.4. Selections
   4.5. Loops
   4.6. Control Statements
   4.7. Handling Exceptions
   
   Chapter 5. Functions - describes function declarations and definitions, overload resolution, argument passing, and related topics.
   5.1. Function Declarations
   5.2. Function Definitions
   5.3. Function Overloading
   5.4. Operator Overloading
   5.5. The main Function
   
   Chapter 6. Classes - describes classes, unions, structures, members, virtual functions, inheritance, accessibility, and multiple inheritance.
   6.1. Class Definitions
   6.2. Data Members
   6.3. Member Functions
   6.4. Inheritance
   6.5. Access Specifiers
   6.6. Friends
   6.7. Nested Types
   
   Chapter 7. Templates - describes class and function template declarations, definitions, instantiations, specializations, and how templates are used.
   7.1. Overview of Templates
   7.2. Template Declarations
   7.3. Function Templates
   7.4. Class Templates
   7.5. Specialization
   7.6. Partial Specialization
   7.7. Instantiation
   7.8. Name Lookup
   7.9. Tricks with Templates
   7.10. Compiling Templates
   
   Chapter 8. Standard Library - introduces the standard library and discusses some overarching topics, such as traits and allocators.
   8.1. Overview of the Standard Library
   8.2. C Library Wrappers
   8.3. Wide and Multibyte Characters
   8.4. Traits and Policies
   8.5. Allocators
   8.6. Numerics
   
   Chapter 9. Input and Output - introduces the I/O portion of the standard library. Topics include formatted and unformatted I/O, stream buffers, and manipulators.
   9.1. Introduction to I/O Streams
   9.2. Text I/O
   9.3. Binary I/O
   9.4. Stream Buffers
   9.5. Manipulators
   9.6. Errors and Exceptions
   
   Chapter 10. Containers, Iterators, and Algorithms - introduces the suite of container class templates, their iterators, and generic algorithms. This is the portion of the library that has traditionally been called the Standard Template Library (STL).
   10.1. Containers
   10.2. Iterators
   10.3. Algorithms
   
   Chapter 11. Preprocessor Reference - an alphabetical reference for the preprocessor, which is part of the language, but with a distinct set of syntactic and semantic rules.
   
   Chapter 12. Language Reference - an alphabetical reference for the language and grammar. Backus-Naur Form (BNF) syntax descriptions are given for each keyword and other language elements, with pointers to the first seven chapters for the main reference material.
   
   Chapter 13. Library Reference - a reference for the entire standard library, organized alphabetically by header, and alphabetically by name within each header section.
   
   Appendix A. Compiler Extension - describes ways that some compilers extend the language: to satisfy customer need, to meet platform-specific requirements, and so on.
   
   Appendix B. Projects - describes a few interesting, open source C++ projects. You can find information about additional projects on the book's web site.
   
   The book illustrates the descriptions and definitions it covers with plenty of examples - some quite short, and then some longer ones as you get further into the book. If you need a good desk reference on C++, this is definitely the one to buy and keep by your side.



5. Hi,
   I'm a recent graduate B.Sc CS and used this book extensively for a month+ as to prepare for a c++ job interviews.
   
   Unfortunately I can't say I loved this book. I found the examples to be overcomplicated by irrelevant information and language to be ambiguous at the times.
   
   As an example, from page 160 (classes/ covariant return types):
   "In a derived class, a covariant return type is a pointer or reference to a class type that derives from the return type used in the base class" ?!
   
   Code examples are contaminated by the irrelevant programming techniques and irrelevant code. Page 158, "declaring and using virtual functions", the code example extends over two pages. In it, author uses concepts of templates, complicated operators overloading, constructor and destructor, pure virtual functions (its different topic in the book, much later) as well as a very complicated programming code. And all of this extra information used to explain a rather simple virtual functions.
   
   If the reader is not very familiar with some concepts of programming language, reader might face a difficulty to understand the topic illustrated, as it would be polluted with much unrelated code technique.
   
   I wouldn't recommend this book for the beginners, and would proceed with caution if you are an intermediate programmer. This is a great start but author need to maintain focus on the particular topic and not to make it more complicated then it's already is. After all it's a reference book and not the collection of the brain teasers.

5 comments about Beginning Database Design: From Novice to Professional.

1. This book delivers what it promises. It give a object oriented approach to designing databases. The basic topics and design methodology are addressed. I have become a better programer having read this book
   
   Using several examples of data modeling (plants, argiculture testing, personal management) it tracks the process from use cases and data collection to modeling the information with UML, and presenting this informaotion in a useable format. She touches on a number of common issues, such as a 'fan trap', key generation and data types that need to be addressed early in a project.
   
   The style is light and fast paced. The impact of different techniques are illustated in a concise manner with sufficent detail to be understandable and not overwhelming. I see it as a good basic introduction, and will use it as a foundation for more in depth study.



2. The more I get into database design, the more I keep coming back to this book, as well as Database Design Demysified. The two books are oriented toward small to medium databases, and that's the best way to learn the fundamentals. In my work for the government, I've only seen one or two decently designed databases. The true examples in the book of databases gone wrong are amazing and oh so common. Some much needed humor enlivens a dry subject in both books, and neither throws a lot of jargon at you. Database Modeling and Design (T Teorey) could never teach me how to design a good database! It just never gets down to the nitty gritty details of what works and what doesn't, and why. The two good books are complementary- I reccommend you get them both. Good Luck!



3. This book is excellent for someone who is trying to get into learning databases. I like using a different form of ERD than mentioned in this book, but I couldn't find any errors with this book. I found this comforting since many database books use the author's interpretations of database design, rather than generally accepted practices. Awesome educational book!



4. I am about 1/2 way through this book and all the things that I thought I would get out of it, I haven't. It is a fast read, but it is lacking in content.



5. Clare Churcher is an excellent teacher! She can explain difficult things in a clear and concise way. This is e.g. the first book who explains table joins to me without getting a hazy feel in the head. Nice to have this book as a first introduction. For digging a little bit deeper in the subject I would reccommend Beginning Database Design (Wrox Beginning Guides) wich I also bought.

5 comments about Practical Django Projects (Pratical Projects).

1. This book is a solid, practically-oriented introduction to Django, but be warned: the code in the book fails with Django 1.0. This is an important caveat because you cannot progress through the exercises unless you know the gotchas and how to modify the code accordingly. Some of the incompatibilities are quite major.
   
   I found that the book pitches a bit low for an experienced developers and it's thin on discussion of the meat of what's going on under the hood. A minor issue with the book is the author's insistence on "admonishing" you literally every second page. You see, calling things "admonitions" one of the secret signs that Python nerds use to show that they're part of that very special little gang of elite hardcore "Pythonistas". For the rest of us, it's just grating (or maybe I'm just not dope enough to be a Pythonista, yo. Y'know what I'm saying, bro? Word.)
   
   Issues aside, I do like its very hands-on approach and I'm betting that the next edition will be a 4.5 star book.



2. This book is a great book. 2 nits. One big, one small.
   
   Nit #1: "Admonitions" seems a bit contrived.
   
   Nit #2: This book should have either been released earlier or released 3 months later. The game is changing with 1.0 and all previous books will require fixes and updates to work. This increases the barrier to entry for newbies and should be rectified as soon as possible.
   
   [Update: Word is there will be a hg repo for updated code samples. Now retracting Nit #2]



3. Where's the chapter on deployment? You, know, that silly thing you have to do in order to put that practical project up somewhere that people can practically use it. Getting a Django application up and running in such a way as to not destroy your server when you get slashdotted (or whatever the kids call it nowadays) is the one thing nobody on Team Perfectionist seems to know how to do well enough to tell anyone else about, so they simply elect to avoid the subject altogether. What do they talk about instead? Regular expressions! Thank you, Mr. Hideous Neckbeard, I had no idea what regular expressions were until you came along. Your pandering rapport has completely distracted me the fact that the only way to get decent caching behavior out of your framework is to outfit it with third-party solutions that patch up the holes in your code.
   
   This title is marginally better than APress' "Definitive Guide to Django" but not so much so as to make it worth the money they charge. Why it's taking them so long to reach 1.0 is a mystery to me as their "roadmap" is a joke rife with non-features, but this book definitely ain't compatible with the current beta, so it's practically useless.



4. This is a well-written book that is fairly easy to read. If you're new to Django (or web development in general), this book will teach you how things fit together. There are lots of code examples, and the author walks you through building an app, and then puts the complete code at the end of the section (which I like).
   
   The code in this book seems to be built using the 0.96 release of Django. I started learning with the svn version (leading up to 1.0), and a large number of things work differently than explained in the book. If you buy this book and want to use version 1.0, you'll often need to read through Django's documentation, too. Also, the author periodically explains some basic python syntax in an effort to make the book more accessible to new python users. In my opinion, this could be removed from the book in order to spend more effort explaining Django.
   
   Overall: A good book. I'm glad I bought it.



5. Another reviewer noted that this was the perfect book for beginners/newbies. It is not. As stated in the book and on the back cover, it is for intermediate folk.
   
   The book makes quite a few assumptions about the reader's level of Django and development experience, as a result it can be a very frustrating experience for a beginner.
   
   Please also note, as other reviewers have noted, that the book's code examples are for Django .9x (update: written for 0.96) and not for 1.0. Apress, the publisher, has not given any updates to the errata nor do they have the book's source code posted. So, if you are not an intermediate python programmer or an intermediate Django developer, you may find yourself throwing this book or your computer in frustration.
   
   Other than that, if I could just figure out which version of Django it is written for, I would love this book.

4 comments about The Essential Guide to Flex 3 (Essential Guide).

1. I have learned a great deal from this book. Along with taking a course with the author and reading this book I have learned how to do things the correct way and have reaped the rewards from it. I would recommend this book to anyone looking to learn Flex quickly and/or catch up on whats new in Flex 3.



2. Good Book. Would have raised rating to 4 1/2 stars if that was an option.
   Enjoyed reading and doing the exercises. Not many errors, few but they where small. Wish Chapter 15 (AIR) would have been a little longer with more detail.
   
   All in all, a good start. Introduced to many topics, ColdFusion was a good one.
   
   Thanks



3. If you don't know Flex 3 and want to learn the basics and then some, well then this book might just be for you. The author takes you through Installing Eclipse and Flex Builder 3 (FB3) which I found very informing. He then takes you through some of the different areas in FB3. The chapter on ActionScript (Chapter 3) is not a very good one. You will need a different book for ActionScript reference. You then go through some of the "essentials" of Flex 3 to understand how to build an application.
   
   I was a bit confused at times but it might have been because of the speed I was going through this book. If I would have slowed down a bit, I think it would have been a lot clearer. Also, I am new to Flex so it was learning from scratch for me.
   
   This book does not come with the files, nor can you download them. I really think if it had the files it would have been a MUCH better read/work along. There are a few errors in the code and you have to guess at times as to what it should be. I could not get one section to work at all (as was shown in the book).
   
   If you want to learn Flex 3 or get a better understanding of Flex 3, then I would tell you to read this book. The information you will learn far outweighs the few errors and lack of files. I've always said the best way to learn code, is to sit down and type it out. You will be doing a lot of this. Good job Charles!



4. This is one of the most well-written books I have ever read. I have been programming JavaScript for several years, so I assume that makes learning ActionScript fairly easy for me. Nevertheless, this is a good introductory book to Flex 3. All of the examples work flawlessly. The only thing wrong with the book are some unbelievably huge typographical errors, but they are easy to spot and easy to decipher. Sometimes you have to look at the example code from the website to get the correct text. The errors have not caused me any problems and I would highly recommend this book to anyone new to Flex 3.

5 comments about UML 2 Certification Guide: Fundamental & Intermediate Exams (The MK/OMG Press).

1. I passed the Fundamental exam with a score of 66/80 using this book exclusively. It is very concise and to the point. It has 34 practice questions in the back that help you prepare for the Fundamental exam. The questions are similar to the real exam questions. There are no practice questions for the Intermediate exam. I am now using this book to prepare for the Intermediate exam.



2. Good book to have for UML Certification...I wish every UML evangalist must have for reference.



3. This is a good book for preparing to the OMG UML exam. Each one of the most important elements of the UML metamodel are treated with a simplified view.
   
   The sample exam of the end is so useful. I recommend the book.



4. Before buying this book, I had no doubt that it would be instrumental in passing my certification exams. I did pass the the Fundamental exam in the first try itself and I don't believe I would've been able to do so if I had not laid hands on this material. Neither do I think there's a book out there that covers UML with the level of detail as this one does. After all, this guide is published by the same Group that sets the UML standards and administers the certification program! I'll be referring back to it again for my Intermediate-level exam. Thanks OMG!



5. Really complete book, clear and concise. It's a very good tool to pass both of the exams, as well it's a great resource for those who want to initiate and work with UML.

5 comments about Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) (Pragmatic Programmers).

1. There are dozens of technical books on my bookshelf, most of them quite good... but none as relevant and valuable an addition as Release It! If you are a professional involved in the development, deployment, and production support of modern information systems it is in your interest to get a copy of this book and (unlike many a technical manual) *actually read it*



2. I just completed reading Release It! by Michael T. Nyggard (Pragmatic Bookshelf 2007). It is part of The Pragmatic Programmers series. I have read the book cover to cover twice. At first, I thought that the book was just another book on how to manage projects. So What! The ideas presented in the book were common sense. I have been doing these same things for many years.
   
   Then one day I was working on a project, and was trying to figure out how to handle a problem. I remembered what I read in Release It! about the topic. I grabbed the book off the bookshelf and looked it up; logging. The ideas presented are common sense, but how often have we missed to boat. The ideas presented in the book I implemented much to my own joy. The result was a customized deployment of the Java Logging system which is simple to maintain and does not require external libraries.
   
   It was at that point I realized the brilliance of the book and the pragmatic side of things. I re-read the book. As an architect, project manager, developer, and maintainer of complex software ecosystems, the ideas in the book provide a "pragmatic" common sense approach to handling situations. The book is a learning tool, one person's personal perspective on software design and deployment, and a reference. It is an all-in-one book.
   
   This book provides a great tutorial on how to manage complex projects for the novice, and a gentle practical reminder to the seasoned architect/project manager.
   
   The book is divided into 4 major sections: Stability, Capacity, General Design Issues, and Operations. The first two sections provide the basis for the remainder of the book. The Stability and Capacity sections have divided the topic into an explanation, followed by general design patterns and anti-patterns. It explains in enough detail how to implement good patterns and recognize bad ones.
   
   The section on General Design covers items like Administration and Security. There is nothing earth shattering in these sections, but they do provide a basis for a "check list" of items to make sure you consider in your designs.
   
   The final section on Operations is the one where you will make friends with your administrators and keep your sanity. The portions on designing for monitoring including logging will be your savior at 2:00 AM in the middle of a blizzard. The discussion on designing for the future does not get enough attention in our modern get it out the door now world. This may be the push you need to think about it.
   
   This is a book to have on your bookshelf. Mine is full of tabs and post-it notes.



3. Unlike many books (such as those with animal kingdom on their cover or photos of several programmers) this book is by/for a real software engineer with real life production ailments and antidotes for them. Even if all the use cases discussed here may not be applicable, if people follow at least 50% of those that apply I think there will less business outages, better user experience and a happier IT department.
   
   On top of all the good technical stuff, this book also happens to be well written - enough to be just enjoyed for the anecdotes and such.
   
   A must read for any software engineer of web applications!



4. Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) (Pragmatic Programmers)
   
   This book offers very sound advice, based upon Author's years of experience. Every serious developer/architect should own it. The only reason why I gave it 4 stars is that the book is devoid of code; it would have been % star plus, book had Author put some code samples there (even pseudo code or more diagrams).



5. This is a book of advices on how to make the system running. Not just to write and release it (no pun intended), but to keep it running after the release.
   
   The book is about prior planning for capacity and stability, designing systems capable of handling the load while being resilient and fault-tolerant, build it in a maintainable and adaptable way, so that it lives through the years. A great deal of information in it too.
   
   Overall, it was a pleasant reading, because in most parts it matches precisely what I'm doing on my job and what I've learned to be the right way of doing through hard experience. As always, such practical convergence with published material is very comforting.
   
   Why did I give it 4 stars then ?
   
   Because the book itself needs more work.
   
   It is poorly structured and is stylistically informal. It doesn't have a plot, but it is also not a collection of independent essays or articles. Near the end it feels like the author just gave up the structure and stuffed the book with random thoughts.
   
   Despite the author's promise for each part of the book to have a case study, only 3 out of the 4 unconnected book parts are opened with one, and the studies are of anecdotal nature. A few pages of horror in everybody's eyes to find out that a janitor had accidentally pulled the plug, something like that.
   
   As the few architectural patterns suggested by the author reside near the middle of the book, the first half is full of forward references, like "but wait till you see the MagicPattern !". The patterns when you encounter them are useful but are explained shortly and in informal manner again.
   
   A lot of assorted hints, ranging from TCP handshaking to stripping whitespace off web pages and wrapping a web service around a database. Interesting, but inconsistent.
   
   It is difficult for me to be unbiased about a book like that, because, like I said, it correctly describes many of the practical considerations that I already knew in the first place.
   
   I'd say it is the kind of book for the architects with development past. It will be useless for you unless you have a lot of practical experience as a developer. On the other hand, if you are a beginning developer, it won't help much either because it doesn't offer any analysis or any kind of formal textbook kind of information.

No comments about Pro SQL Server 2008 Relational Database Design and Implementation (Pro).

5 comments about Software Project Survival Guide (Pro -- Best Practices).

1. The biggest part of managing a large project with deliverables is knowing the timing and details of your deliverables to make sure that all pieces are in place and planned for...time and resource wise. This book is a huge help in providing those pieces. Whether you use all the pieces or not it gives you the details you need to think through before you incorporate a deliverable and help you weigh how much detail and effort needs to be a part of it.



2. will the book be convincing enough for you to adopt it?
   
   I have not found this book very fun to read because of its very structured and academic format. I have not learned much from it as much of its content is general wisdom that anyone with many years of experience in the industry has probably seen around before. Something positive I can say about the book is that I totally adhere to the methodology explained in the book. In my software development career, I have experienced myself the benefits of applying similar software development management methodology and I have also seen the negative consequences of not following it.



3. I'm a one-man database development shop at a nonprofit with a shoestring budget. Without the benefit of senior level programmers, I've had to learn most of my software engineering lessons the hard way- by experience.
   
   I picked up this book seven years into the job, which in retrospect was about seven years too late. In some respects, this book repeats lessons that that have already become obvious through experience (e.g., software testing needs to be performed separately from development). But, this lends credibility to my judgment, and provides new insights substantiated by software engineering research studies. Non-technical management and funders are responsive to the hard figures I often find myself citing from this book. For example:
   
   1) Programmers are 2.5 times more productive in a quiet office vs. a cubicle- so, I need to be allowed to work from home
   
   2) The most efficient programmers are 10 times more productive than the least efficient programmers- really, you would think this would be obvious, but when work needs to be contracted, the low bidder is not necessarily the best choice over the long haul
   
   Currently faced with my most substantial and challenging programming project yet, I'm essentially using this book as a cookbook to process. Upfront I was a bit overwhelmed with the scope of the project. Having finished the book, I have a well-defined process in place, am confident this will get done, and feel I am much more articulate describing the stages of software development to management and contracted vendors. Some presumably industry-standard strategies are proving invaluable- implementing a Top Ten Risk list to ensure that major barriers are addressed upfront rather than deferred, creating specific milestones, etc.
   
   This book (or an equivalent) should absolutely be mandatory for anyone about to take on their first major software project. It is most useful because it reads like a cookbook- guiding you through all the phases of software development, one after the other.



4. The book presents an analysis about the project management in a very practical way.
   
   In it, Steve demystifies that in a project the "well" and "fast" are in opposite sides. By contrast, him tells us that for do it fast and cheap, it is essential to do it well.
   
   A project leader should have it in his desk.



5. I've read this book several years ago, in 1998, I think. It was my first glimpse on software project planning. At the time, I was a bit confusing, the book has a lot of examples of very big projects. But the best practices it provides are useful until today.
   
   Don't know if it's a good book nowadays, but it's definitely a book I won't forget.