5 comments about Microsoft® Office FrontPage® 2003 Step by Step (Step By Step (Microsoft)).

1. The book did not follow what appeared on the screen. So difficult to follow that we just gave it up and tried another book.
   Some of it was useful for reference, but step by step no way!



2. I never got it. The FrontPage 2003 that I ordered in September 2006 never arrived.
   I sent you a message about it, and apparently you have on your records that I re-ordered it.
   In fact, you supposedly sent a replacement copy. In fact, you sent a 2nd FrontPage Step by Step
   instruction book, which I had also ordered in September and received at that time. So, I have
   2 instruction books, no software, I've stopped payment on my Visa for this purchase, and I've given up.
   I will likely NEVER order from Amazon.com again.
   
   Charla



3. I purchased this book and the software a year ago. I found out a few months ago that Microsoft is no longer supporting this software and has come out with a new program. Of course microsoft did not notify any registered users of this. I am now out the money for the software and the book. Microsoft instead of changing this program so that extensions are no longer used, came out with a brand new program which cost $299-.



4. An excellent book to start learning Frontpage. The layout and style are very clear and the practice examples lead you through the steps in a logical manner.



5. Arrived on time and in perfect shape. I like the way this book is written. It not only gives valuable info on Front Page, but touches on a number of basics that apply to any website and that are simply assumed by most other books. I appreciate that. I would recommend this book if you aren't even using Front Page, if you want to learn more about websites in general.

5 comments about Data Structures with C++ Using STL (2nd Edition).

1. Excellent book! It was assigned for my Data Structures course. Basic knowledge of C++ and the way classes work is required, but it is an excelent reference. I would NOT sell this book back to the campus bookstore for anything after completing the class.



2. This text is for sophomore-level students, but as the authors claimed it's a good read for professionals as well, a reason being that a professional of many years may not have learned data structures together with designs and implementations in C++ with STL. Going back five to ten years, the book in its current form could not have existed, which is why it's beneficial for the professional to read it.

   As a professional, I envy the current college students who are lucky to have this book as the text of one of their courses. A student is also given a semester to digest its content, to do the exercises and projects at the end of each chapter, which is not usually possible for a professional. On the other hand, because of years of experience and perhaps plus college background, things students usually and sometimes must do aren't necessary for the professional, who should be able to read through the book in considerably shorter period of time.

   In summary, it's a great read on the subjects, though one star is taken off for its imperfection such as mistakes in the code and less than superior presentation of some materials.




3. Because of physical problems with this book, the authors' programming style, and lack of a proper audience, I just can't recommend it. There are just too many problems and too few positives for the book to be worthwhile.
   
   First, the physical problems with the book: in my case, the binding appears to be bad. As I took it out of its plastic wrapping, I noticed a gap between the cover spine and the glued/sewn binding of the actual pages. It looks like the glue that was supposed to hold the two parts of the book together failed. Turning the pages causes a lot of snapping, crackling, and popping and I worry that the binding will break. Second, it seems like the book uses too small a font (these old eyes don't focus like they used to). Oddly, if I compare the font size to that in other textbooks, it looks comparable. I'm not sure, but I think the publisher used a slightly smaller line spacing and either a lighter ink or darker paper. Whatever it is, it makes reading the book a bit hard. That's pretty subjective and minor, but more aggravating is that the publisher used an even lighter (gray) font for the code segments. This makes the code even harder to read than the text. Again, I'm not certain, but it also looks like the font in the code sections is even smaller than the font in the text. And finally, the authors don't use any color in their code. It's hard to distinguish the actual code from the comments. This makes reading the code difficult.
   
   Next, I highly disagree with the authors' coding style. Essentially, I consider it sloppy. In general, they don't write their class methods to ensure data integrity (and that's one of the big advantages of classes (which are at the core of this book)). Also, the authors tend to directly access private class members within the class methods instead of using the class' already defined public methods that do the same thing (get/set). I know this is allowed, but it's still bad software engineering: you should re-use code wherever possible. Similarly, and worse, the authors violate the principles of data hiding by writing classes with public data members instead of with private data members and public get/set methods. I also have a problem with the authors using "using namespace std;" in their code. Since this exposes all of the C++ standard library methods to the program, it can lead to conflicts. I understand that in a teaching environment this might be good for keeping the focus on the topic at hand instead of "cluttering up the code" with nuances, but the authors make no reference to this rationale. They just blindly use that line in all their code. I'd much prefer they explicitly did a "using std::whatever;" when they needed it. What's especially bad is that they do this in all the HEADERS they provide for their examples (not just in the "main" programs). Anyone who uses any of those headers automatically ends up with all the namespace names included in their code. And, finally, not only are the authors lax in their object oriented programming, they're also lax in their structured programming: they routinely, and without comment, use break statements to jump out of the infinite for-loops (which are feats in themselves) they set up to handle their file input.
   
   Finally, and most importantly, the authors don't seem to have a grasp on who their audience is. In the Preface and the start of the first chapter, they specifically state that the readers should already be familiar with objects and classes from a first course in C++. They note that they aren't about to review old topics, but, instead, will pick up where that left off. However, most of the book is a re-hashing of basic C++ programming. For instance:
   
   - Chapter 1 is a review of programming classes (and, thus, objects) in C++.
   
   - Chapter 2 discusses 1) software design, 2) handling runtime errors, 3) object composition, and 4) operator overloading.
   
   - Chapter 3 covers templates and recursion. The algorithms discussed are those usually presented in C++ programming courses: selection sort, sequential search, binary search, tower of hanoi, and greatest common divisor.
   
   - Chapter 5 goes over pointers, pointer arithmetic, dynamic memory allocation, constructors and destructors.
   
   - Chapter 7, stacks. Chapter 8, queues. Chapter 9, linked lists. Chapter 10, binary trees. Chapter 13, inheritance and abstract classes.
   
   All of this is what I consider to be basic C++ (see Deitel's "C++ How to Program" book to find references to all those things). I just can't see how anyone could learn even the rudiments of C++ without having covered those topics. I could be wrong (in which case, since I've provided my rationale for my rating, you'll at least know what to ignore in this review). But, for all intents and purposes, the authors don't really start teaching anything new until after page 500 (Chapter 10) in a 1000 page (16 chapter) book. And even there, I was so irritated with the various problems I noted above, that I kept wondering how much credence to put in the authors' presentation.
   
   So, in a nutshell, because of the physical problems with the book itself, the sloppiness of the authors' programming style, and their mis-identification of the audience, I can't recommend this book. I rate it at only 2 stars out of 5.
   
   As a side note, at the time I bought this book, Florida State University (FSU) used it in their COP 4530: "Data Structures, Algorithms & Generic Programming" course. They've now switched to a book called "Data Structures & Algorithms in C++," 3e, by Drozdek. I don't know anything about that book, but based solely on this book, FSU did the right thing.



4. having read 1st four chapters, i find Ford and Topp are stingy in examples and theory.
   You'd better do all the programming exercises at the end of chapter since that's where the value of this book lies.
   Thinking in C++ Vol.1 and 2 have better reference material. Please buy Bruce Eckels' "Thinking in C++"!



5. The book itself is great and illustrates the core concepts well.
   The code examples are grossly out of date (were talking 1990's) and completely ruins the beautiful text by adding confusing, poorly written code examples to reinforce good literature.
   
   If you are buying this to learn data structures as a reference, great.
   If you expect usable code examples this is not the book for you.
   Highly Microsoft Visual Studio Centric. Not ANSI C++.
   
   My note to the author's / publisher: You need to keep up with the times. This is technology and it moves quickly. Otherwise future-proof your code as much as possible.

5 comments about Eclipse IDE Pocket Guide.

1. I found the book to contain several tips and tricks that were new to me and I have been using Eclipse for over two years now. I would highly recommend this book to new Eclipse IDE users to help you get a leg up on learning the Eclipse IDE. I found this book well worth the price and will be looking for more pocket guide books by O'Reilly to add to my bookshelf.



2. I expected a little more from this book than creating a simple java file and compiling it. This book is for someone who is new to IDEs. This is *NOT* for someone trying for a quick reference to migrate from another IDE to Eclipse - which was my purpose.



3. The most common comment from the people I showed this book to was "I wish I had it when I started using Eclipse".
   
   While this is a very small book, the contents have been selected to give you a best start with the main features of the Eclipse IDE. The topics are short but concise and include scattered tips for the points of interest.
   
   If you're just starting with this IDE, the Eclipse IDE Pocket Guide will give you a great head start and will continue helping you as a lovely reference to refer back to as the features become familiar. Having all of these critical features pointed out earlier will save you a lot of bother in the future, since you'll be annoyed if you only find out about them much later by accident or experimentation!
   
   Experienced users are less likely to get much from it though. The authors made a decision between content and size, and I feel they chose to stick with a smaller, simpler book than I would have expected. There is a final section on places to go for more information, but it just refers to various community sites.
   
   I wish I had this book when I started using Eclipse.



4. I've come to expect a lot from O'Reilly guides, and this one didn't let me down. It really helped me past some areas of confusion I had with Eclipse, although I think I may want a larger book eventually that gets into more detail on some of the add-ins.



5. I thought this would be a handy little "tips and tricks" reference. It basically just tells you all the obvious stuff you already figured out on your own. Save your money and just use the doc from the internet.

5 comments about A Practitioner's Guide to Software Test Design.

1. Lee Copeland's book, "A Practitioner's Guide to Software Test Design" provides an easily read introduction into a critical but often ignored subject. As those familiar with the IEEE Standard for Software Test Documentation (IEEE-Std-829) know, Test Design is the first step in turning the "What" of the Test Plan into the "How" of test execution. The IEEE Test Documentation lifecycle is Test Plan - Test Design - Test Case Development - Test Procedure Development - (Test Execution) - Test Summary Report creation. Many test engineers proceed directly from Test Planning into Test Procedure creation, and do Test Design implicitly as opposed to explicitly. This can have a negative impact on an effective test program. This book clearly shows how to implement the test design process described in Drabick's book "Best Practices for the Formal Software Testing Process".
   
   Lee's book provides a concise description based on excellent Case Studies of Black-Box (Requirements Focused) test techniques, moving from the simple (Equivalence Class and Boundary Value testing) to the more complex (Domain Analysis and Use Case testing). He provides the best description I've seen of test case development using orthogonal arrays. Lee then addresses White-Box (Structural Focused) testing, showing how to approach Control Flow and Data Flow testing. Again, he has the best description with illustrative examples of Data Flow testing that I've ever seen.
   
   Lee then describes two Test Paradigms: Scripted Testing and Exploratory Testing that appear to be significantly different, and shows how the two can be used together for even more effective testing. That's the way I've always done testing, by the way.
   
   His Defect Taxonomies chapter provides valuable insight on how to use such information in test design (I never thought of that), and he concludes with a short chapter that addresses the critical question When to Stop Testing.
   
   The Case Studies on "Brown & Donaldson" and "Stateless University Registration" are effectively used to provide valuable insight into the techniques.
   
   This book would be a good read in combination with the book from Rick Craig and Stefan Jaskiel, "Systematic Software Testing".
   
   In summary, this book is well done, is an easy read, and should be read by every test engineer.



2. Most texts on software testing have a chapter or two which describe test design techniques. This is the first text that is devoted exclusively to this subject. There is little in the way of theory. The text is practical and provides the software test professional with clear explanations and examples of test techniques that have been proven to be effective.
   
   Although Copeland covers both black box (behavioral) and white box (developer oriented) test techniques, the majority of the test design techniques described are black box. Each technique is explained along with its applicability, advantages/disadvantages, along with references for more information.
   
   For what can be a dry subject, Copeland effectively used humor to make this book very readable.
   
   I also appreciated the chapter summaries, key points in the margins, and a thorough works cited -- including several web articles. Highly recommended.



3. This information in this book is simply presented and very easy to apply.
   
   I think the price is a bit high compared to a related book (Systematic Software Testing by Rick D Craig and Stefan P Jaskeil). I managed to get the other book (536 pages) for about $40.00. While the other book represents much better value, I still bought this one and would do it again. If you can only buy one, I'd suggest getting Systematic Software Testing.



4. This is a great reference, giving a good overview of most common test methods. Good bases for in-depth study or to structure a class around.



5. I purchased this book to help me with a university unit primarily on system testing methods and techniques. Although this book covers many of the primary testing concepts needed for software testing, some of the concepts covered were sometimes completed short (or too verbose in some sections). All of the example questions after each chapter that were stipulated for the student to complete - answers were not provided either in the book, or online. So as a fellow software testing student, when completing some of the exercises, I was unaware of whether I was completing them correctly or not.
   
   However, on the contrary the book has some valuable information that I couldn't even find on the internet (when investigating some further explanations on particular topics covered).
   
   The book could have been written in a more professional manner, covering topics in more detail and exploring some of the minor (and major) difficulties that one can encounter when developing test cases for any software being created.
   
   It helped me with basic understanding of concepts. Further investigation on the internet was needed to get what I deem as "sufficient understanding" of the material covered.

No comments about Beginning Microsoft Visual Basic 2008 (Wrox Beginning Guides).

4 comments about Sams Teach Yourself WPF in 24 Hours (Sams Teach Yourself -- Hours).

1. I believe I have every book on WPF. My first impression was 24 hours books have very little information, but it has changed my perception. The book has 24 small chapters and every chapter's information is to the point. The whole book has 4 applications and every example worth looking. I am impressed with authors. Everyone is talking about Adam Nathan's book, but this book has its own place.



2. The first 6 chapters in this book are the best introduction to WPF I've come across in any book on the topic. Its starts at square one and moves very logically and clearly along. If you're looking for basics that will help you understand the layout panels, binding data, WPF architecture from a real world work need perspective, this is a great book to have. The authors do a great job of showing you the ropes and explaining the background of the WPF architecture in a way that clarifies why you would use this control over that one, or this panel instead of this one. Very good conceptual model for both designers and developers!



3. This book is perfect for anyone who is trying to get started with WPF. If you are an experienced .net programmer who is just trying to learn WPF, this is definitely the quickest way to get started. For someone like myself who is totally new to the .net world, the book also offers examples on how to develop very organized applications using a Model-View-Presenter approach. Just by following along with this book I was able write my own WPF application by switching in my own pertinent data elements into the examples. More than anything, this book was very clearly written and all examples are color coded to match Visual Studio. Gotta like that!



4. I liked this book. It was better than Cats. I am going to read it again and again.

No comments about Programming with Alice and Java.

5 comments about Building Microsoft® Access Applications (Bpg Other).

1. Easy to read first few chapters with basic design info, remainder of the book focuses on complete applications that can serve as a template/best practice for almost any other MS Access application.
   
   Viescas clearly understands/communicates an in depth knowledge of Access Applications that I have not seen anywhere else.



2. Definitely not for the newbie. This is for the seasoned access programmers. I you are new to programming (at least in access) and are looking for a book on how to program with access, this is not for you. This is a great book for those seasoned programmers who are looking to make their applications better.



3. This book is a good start toward understanding how to build Access applications. Some of the details are missing. An example would include the proper syntax for referencing fields in a form.



4. Very hard to follow, poorly organized and written. Unless you're well versed in Access already, skip this book. Definitely NOT for beginners.



5. This book is written with the intermediate to advanced programmer in mind. There is much to learn from this book on options and techniques to use when building business applications in Access. There is explanations of every sample application and it's function. I would give it five stars if it were not for the title. The title maybe a bit misleading since it talks about building applications since it kind of sways you into thinking that it is a book on the step by step process of "Building Microsoft Access Applications." If you are seasoned in Access programming it is a gem to have in your bookshelf.

5 comments about Professional SQL Server 2005 Programming (Programmer to Programmer).

1. I found this book extremely helpful in wrapping my brain around some very difficult to grasp concepts. The author writes in a way that's very easy to understand (especially with such a difficult topic such as SQL programming).



2. I've never been a fan of the Wrox product line, but purchased this book on the recommendation of a friend.
   I couldn't be happier. The author is one of the most knowledgeable, and he writes in an accessible style.
   I've heard some gripes about how he discusses the organization of his book a little too much, but the reasons for these passages are to reinforce the importance of the concepts being covered in relation to other concepts.
   I'd recommend this book to beginners who are fast learners, or to old hands that want to pick up a new trick or two.



3. The second topic I looked up I ran across this problem...
   
   Page 353:
   
   He says there are four different isolation levels you can set - that was in SQL Server 2000 - this book is about SQL Server 2005. Where is SET TRANSACTION ISOLATION LEVEL SNAPSHOT?
   
   Chapter 12, 'Transactions and Locks' is almost a cut and paste from his 'Transactions and Locks' chapter in SQL Server 2000 Programming!
   
   Encryption - Let's see - 2 pages, and 3/4 of a page is a copy of an image from BOL.
   
   His 2000 book is better.



4. When working with databases, there's querying, and everything else. A DBA might set up a database; an advanced user might progam stored procedures and triggers, ponder indexing, effectively use cursors, etc. - but if you just want to know how to write a query to accompish a task, this is *not* the right book to help you learn. Check out 'SQL Server 2005 T-SQL Recipes: A Problem-Solution Approach' by Sack.



5. This is an excellent follow to his book on Professional SQL Server 2000 Programming. If you're going to be doing a lot of true SQL server programming, there is no better guide out there.

5 comments about Accelerated C# 2008 (Accelerated).

1. I bought this book last Wednesday and figured it would be a decent enough overview of the new language features. I don't want to downplay the job he does covering new langauge features becuase that coverage is superb, but the job he does covering C# fundamentals is so well done that it eclipses everything else.
   
   So it's a great book for beginners? Well, probably not. I think beginners would benefit by it but it's not a beginners book by any mean. What I do mean is that he does a really in depth job of covering just about every aspect of C# so that he can show the benefits of the new features as well. I've read over 100 books on .NET in the 7 years I've been working with it and frequently the Go to guy when it comes to exception handling for instance. So I really wasn't expecting to learn anything new here. But stylistically, the points he raises in showing how one could elegantly handle a Transaction rollback scenario is just really brilliant. And that same brilliance is exemplified throughout the book.
   
   To that end, the examples in this book are it's real strength. As someone who's written a few books myself, I know how tempting it can be to come up with really simple and overused examples b/c basics aren't much fun to write about. Trey however totally resisted that temptation and I for the life of me can't see a single area that looks like he just 'wanted to get it done'. Everything is seemingly well thought out and written in a way that can clearly make his point clear. He also harkens back to C++ and the fact he has a ton of C++ experience shows through everywhere. It has a feel to it reminiscent of my senior computer science textbooks but without the stuffiness and without coming off as academic. On the contrary, it's the whole aire of advance business scenarios that makes it so cool
   
   Now on to the new language features. I've read several books on LINQ and Lambda expressions. And while they are all great, his explanation of Lambda exprssions and the walk down Functional Programming memory lane is priceless. Had I read this book early on, the nuances of Lambda expressions would have been a lot easier to understand. His coverage of LINQ is in depth as well but he manages to really keep on track and show the business aspects of LINQ without every going down the path of sounding like a 'cool new feature cheerleader'.
   
   I'll admit I have a pretty strong like of Apress books and have a pretty high expectation with their stuff. When I read Faison's Event-Based Programming : Taking Events to the Limit - I found it to be one of the most compelling and well done books I had read in ages. Internally, I thought it would be a longgg time before I came across a book anywhere near that good. Well, all I can really say is that Trey Nash proved me quite wrong. He exceeded any expectation I had by tenfold and got a lot out of this book - not just in C# terms but across the board.



2. This is a pretty good book. This author is obviously a strong C++ programmer or was for many years, so his approach to the writing about
   C# is very C++ bias which I think is very refreshing and pretty neat, to compare the OLD way and the NEW way. Dont get me wrong I am not implying
   C++ is dead, I think is still by far the strongest most powerfull language ever, i am just saying C# is more practical, more FOR NOW, for the 21th Century..............
   I like many 1990s programmers started in C, C++ so C# is like back to the good old days. C was one of my favorite language for many years..I did some java but I feel C# has gone beyond it by far.



3. Overall, this is a decent book. But, simply because the author didn't properly define his audience, I have to mark it down a notch. From the 1st sentence of the "About This Book" section in the Introduction (on page xxvi), the author states:
   
   "I assume that you already have a working knowledge of some object-oriented programming language, such as C++, Java, or Visual Basic .NET."
   
   So, I assumed that since I'd already learned C, C++, and Java, but just dabble in programming, I could use this book instead of plowing through another 1200 page book that starts out with a chapter on sequential statements, a chapter on conditional statements, a chapter on iterative statements, etc.. But, that was a faulty assumption. Instead, this book is REALLY designed for programmers who've done some fairly advanced work in other object-oriented languages UNDER THE WINDOWS .NET FRAMEWORK. For instance, at the start of Chapter 1 (page 1, paragraph 1, line 1), it says:
   
   "Since this is a book for experienced object-oriented developers, I assume that you already have some familiarity with the .NET runtime."
   
   And, on page 231:
   
   "I'm assuming that you're already familiar with the nongeneric collection types and collection interfaces available in .NET 1.1--specifically, those defined in the System.Collections and System.Collections.Specialized namespaces."
   
   So, if you're not very familiar with .NET, you'll have problems with the book. Also, the author tends to slip out of even that "advanced .NET programmer" audience in another way: he sometimes writes to programmers who've used previous versions of C#. For instance, when he introduces Delegates in chapter 10, he never really ties them to the C/C++ model of function pointers or Java's inner classes. The closest he comes is saying they implement a callback function.
   
   The author also assumes knowledge of various design patterns from the "Gang of Four's" Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) book (and a few other sources, too). Here are the patterns he references and the pages where he makes those references:
   
   - Abstract Factory: p 451
   - Bridge: p 262
   - Collection: p 36
   - Disposable: pp 3, 19, 106, 187, 189, 374, 376, 377
   - Expert: pp 172, 193
   - IOU: pp 320, 354, 355, 362
   - Monitor: p 337
   - Non-Virtual interface (NVI): pp 117, 143, 144, 236, 238, 365, 366
   - Observer: p 265
   - Singleton: pp 74, 143 285, 377, 381
   - Strategy: pp 122, 266, 276, 291
   - Template Method: p 366
   - Visitor: pp 424, 437
   
   There are also some smaller things that are a bit irritating. First of all, his code formatting is inconsistent. His use of braces ({}) changes constantly. Sometimes he'll start a block with the first "{" immediately following a keyword on the same line. At other times, he'll put it at the start of the next line. Sometimes, he uses both in the same hunk of code. Ditto for his positioning of instance variables (fields in C# terminology). Sometimes he'll have them at the top of the class. Other times, he'll have them at the bottom. Sometimes, both. And, least importantly, he uses too many forward references (especially referring to Chapter 13).
   
   Overall, if you happen to be an advanced programmer who programs in an object-oriented .NET environment for a living and you want to pick up the latest version of C#, this is a very good book. It certainly won't bore you with trivial stuff, and the way the author presents things will be very helpful. But, if you're just a dabbler with limited experience, the book will probably be confusing. As such, I can only rate it an OK 3 stars out of 5. In future printings, if the author merely revises the stated audience to reflect the actuality, and standardizes the formatting of the code, this book would easily be a 4 star book.



4. This book briefly covers the basics and then shows more advanced ways of applying the basics to the problem at hand. I felt like reading this book was worth my time as I began to understand how a seasoned C# programmer thinks when solving a problem. Trey Nash is trying to impart tidbits of experience he has gained in the trenches of writing complex multi-threaded apps. He brings in a lot of object and pattern theory by showing both the "wrong" and "right" way to do something. This clearly shows the benefits of using patterns and good object theory when constructing applications.



5. After reading the reviews praising this book, I had high expectations. While the author's prose is clearer than most, it suffers from the usual technical-author-verbosity. I found the overall content of the book lacking, while several sections were very well presented.
   
   The author switches between beginning and intermediate C# topics throughout the text, which can be a bit jarring. For example, he spends about 3 pages introducing delegates before getting into meatier issues. I would have loved a book 1/3rd of this length that skipped intro to intermediate topics.
   
   The author provides constant comparisons and references to how things are done in C++. However, the usefulness of each section rarely exceeds what you can find in MSDN or Effective C#: 50 Specific Ways to Improve Your C# (Effective Software Development Series).
   
   There are moments where the author delves into less frequently used features or advanced topics, such as using yield, SafeHandles, or exception neutrality. These are usually presented in an overly complex manner that left me re-reading MSDN or the C# Language Reference more often than not.
   
   There is excellent use of IL to illustrate what's going on behind various language constructs. The chapter on threading is well presented and worth a read.
   
   The best practices embedded in the "Note" subsections can be useful but, again, these ideas are better presented in Effective C# or the various "patterns" pages on MSDN.
   
   Beginners should avoid this book -- this is not an intro text. Intermediate C# developers may want to skim it to ensure they're aware of the latest language features and catch any tips they may not be aware of. Advanced C# developers can probably pass on this book -- you'll likely know all of the content already and the ideas are presented more thoroughly elsewhere.