5 comments about MCTS 70-431 Exam Cram: Implementing and Maintaining Microsoft SQL Server 2005 Exam (Exam Cram 2).

1. This book was a good starting point, but I wouldn't suggest taking the exam after only studying it. I don't know what exam the author took, but there was a lot of stuff on mine that wasn't even alluded to in this book.
   
   I've been a SQL Server programmer/admin for 10 years, so I went into this thinking my knowledge would just need a little brushing up. Breezed through the book and the sample tests and thought "This is going to be easy!" Wrong!
   
   Given the MS 70-413 test is like all the other MS cert tests in that it is as much about getting past the trick questions as knowing anything practical, this book's example questions are waaaay too easy. The subject matter is extremely light weight, too.
   
   Didn't try Transcender, but had coupons for MeasureUp and SelfTest preps. If I had it to do over, I'd devote most of my time to the SelfTest product. Its level of trick questions and general difficulty made it the best for this test. Unfortunately, I discovered this later than I should have.
   
   I passed the test, but it wasn't pretty.



2. As mentioned in previous reviews, this book is purely an exam preparation guide. If you are planning on sitting the 70-431 exam, this book is a worthwhile resource. It ignores irrelevant (non-exam) material and contains a few sample test questions extremely similar to ones found in the actual exam (which is what you're after).
   
   If you are planning on becoming a proficient SQL Server DBA, you will need to look elsewhere. However, for what it is intended to achieve, I give it 4 stars!



3. I've been using ExamCram since Windows NT 4. :) Not all of them are impressive. This one is the same.
   
   This is a good last book for quickly reviewing the key concepts to pass the exam. If the topics, such as Service Broker, XML, etc, are new to you and you have read the topic else where, you will appreciate how much the author has condense everything to the basic. It reminds me of the "cheat sheet" at work someone showed me.
   
   Don't get me wrong this is NOT the only book to use to prepare the exam. When I say quickly reviewing, it took me under 30 minutes to finish chapter one because it is easy for me. But, it was snail pace for me on couple new features from sql 2005. To average readers, I think 1 solid day will be the bare minimum to review using this book. I wish author can share more mnemonic to help sponge up all these new stuffs. :)
   
   ON the plus side, ch7, subtitle: "Activity Monitor For Here and Now". really speak out what Activity Monitor does!
   
   On the neg side, I don't like the style of writing. To me, tech book written in present tense with action words is preferred. Also, it was "wordy". May be it is just me.
   
   now for the technical correctness, the following are things that aren't entirely correct.
   ch4, question 2, nodes() and value() can both be the answer.
   ch5, Creating a Queue, ALTER QUEUE example used CREATE.
   ch6, While describing FORMAT option and how it works, it ends with "The default behavior is NOFORMAT, and the media header is not written." So, a FORMAT option has default behavior of NOFORMAT? This is not clear.
   ch 10, q 2, IN is a possible answer when used with NESTED query.
   q3, the choice (a) should have said CLR User-Defined Type, which is different than the plain-o UDT.
   ch 10, q20, can two jobs with different schedules need be scheduled with one schedule?
   Mirror is on the exam and detailed steps was asked.
   The prospects.xls mentioned in the book is missing. where to download it? where is the errata?
   
   The exam has simulation which requires much hands on experience. One will easily fail if this is the only study material.
   
   Overall is a good book, it is destined to be a 5 stars. It is hammered down by a few , yet, important errors. 4 stars.



4. I would recommend using this book in conjunction with Microsoft 70-431 preparation guide and Measure UP's or Self Test Software's preperation and practice tests. Its hard to pass SQL 2005 depending only on this book (unless you have some experience working with SQL 2005). Good for quick final review before exam too.



5. After reading this book, I felt it was lacking in details and possibly had more than a few errors. Although it is a study guide, with some good challenging practice questions, I can not help but emphasize for a few dollars more you could get a better study guide that would be far more useful and prepare you better.

5 comments about Expert Spring MVC and Web Flow (Expert).

1. As computer books continue their never ending slide into the abyss, Apress and Manning seem to be leading the way. This book is one of the best works of fiction ever written. From incomplete and non-working examples to the many errors, the publishers would be better served by pulling this tome off the market and starting over. There is nothing "expert" in this text nor is there anything the least bit helpful. Well, ok, I will admit the UML diagrams are nice.
   
   Avoid this book at all costs.



2. The book provides really good information and I was able to build out an application after reading it. The only problem is the editing and I hope a 2nd edition is released with fixes and updates for Spring 2.0. There are good PDF presentations out there that give a quick overview and one good tutorial that's a working example. I would google for those and read them alongside with this book.



3. I completely agree with the reviewer who points out how almost chaotically the information is delivered in this book - for the most part. Generally, you need to skip from section to section and back a few times before you can get all the pieces together. That's unacceptable. It's impossible to use this book as a convenient reference since each example generally provides only partial answers, and you have to scan back and forth through the pages to look for the clarification on the missing pieces. Often, the coverage is quite superficial. The official Spring Reference Guide on the Spring site does not get into too much detail on Spring MVC, leaving out lots of important and interesting details. Nevertheless, much more - and better - information is indeed available on-line today - at no cost. I haven't yet seen a perfect one-stop source for Spring MVC, but this book is definitely a waste of money. It may have been okay a couple of years ago when much less info was available online, but certainly not today.
   
   The only part of this book that is very well written is the chapters on Spring Web Flow. Indeed, it appears that the chapters were written by someone other than the authors of the rest of the book. Someone who understood and appreciated the importance of a very thoughtfully organized FLOW of any sequence of logical steps, be it a software application, or a flow of information such as an instructions manual, or a tutorial. That's why Colin Yates, the apparent main contributor to Chapters 11 and 12 (on Spring Web Flow), does a much better job than the rest of the authors. Unfortunately, those Web Flow chapters are largely obsolete today. Some code in the book won't work. You'll immediately see that the classes in the org.springframework.webflow.test package you get with your latest Webflow distribution differ from the ones used in the book's examples. What's even worse is that the flow configuration XML files in the examples apparently use the old/obsolete XML schema. That means you shouldn't use them as examples for your own code. Just compare the code from the latest Spring [on-line] Reference Guide and the examples in the book and you will instantly see the difference.
   
   For a very good introduction to Spring Web Flow, see the Spring Reference Guide (http://static.springframework.org/spring-webflow/docs/1.0.x/reference/introduction.html) and the article by the author of Spring Web Flow at http://www.ervacon.com/products/swf/intro/index.html, which is excellent.
   
   Do not waste money on this book! Honestly. ;)



4. The book was great pre-release book, but like most programming books for specific frameworks becomes almost useless within a few months



5. I bought this book with the hope of getting a better idea of how I should build the Web Flow flows in my Grails ( [...]) application. I know it is my own fault, and that I should have more carefully read the excellent reviews of this book, but I was a little disappointed to discover Web Flow was the topic in just two of twelve chapters when it is approximately 50% of the book's title.
   
   If anyone knows a good source of reference on how to design Web Flow flows so that my web app has a nice natural user experience (e.g. able to use the browser 'back' button having gone though a flow's end state without getting in a mess) then please let me know. I want to aim for the sort of experience I have when using the amazon dot com shopping cart, not the sort of experience I have when using an ERP solution. So far with Web Flow my efforts have tended towards ERP quality :(

5 comments about Next Generation Java Testing: TestNG and Advanced Concepts.

1. College-level libraries strong in Java programming guides need NEXT GENERATION JAVA TESTING: unlike many Java programmer's guides, it provides a pragmatic discussion for Java developers interested in building stronger code for applications, and packs in chapters discussing testing methods, tradeoffs associated with testing, applications of testing theory and rules, analysis of partial failures and remote invocation, and more. In-depth and extensive code examples throughout also differentiate NEXT GENERATION JAVA TESTING from competitors, making it a top recommendation.
   
   Diane C. Donovan
   California Bookwatch



2. At last a book that deals with testing applications (in java) that seems to be written by author's who have worked with real life, non trivial projects(TDD with adding two money objects together, anyone?).
   This book describes using TestNG along with some advanced TestNG concepts and goes on to show how to use the framework to test out JEE projects. There are also chapters showing the developer how to integrate TestNG with other frameworks (like spring, DBUnit, jwebunit etc) which is useful as this is perhaps the only place where JUnit is better than TestNG. Inspite of the fact that TestNG documentation is pretty good, this book is worthwile buying (even if you use JUnit as your testing tool of choice).
   There is useful coding and refactoring advice along the way(also a commentary on TDD), and a miscellaneous chapter of sorts which seems to have been written by Hani and edited by Cedric to remove all profanities!.
   I do hope the author's expand the testing enterprise application bits to cover more testing scenarios and examples in later additions.



3. Very nicely written keeping real world requirements in mind. Could have had some more examples.



4. This book is not really about testng. it's more about the author's opinions about testing, which are for the most part valid, but I bought this book mostly for the testng part, and I guess I'll have to wait to find something more targeted towards teaching just testng.



5. This book does a great job of introducing TestNG, showing how to use its features to set up tests for code that (inevitably) depends on various JEE APIs, and how to perform different kinds of testing (browser, database, performance etc).
   
   There are some claims that I found hard to follow: For example, the authors advise against using mock objects to stub out external classes, then later state that servlets are hard to test outside of a container because they depend on a few external classes -- never mind that these are simple to mock out, and that the Spring testing library (which they mention elsewhere) even provides mock implementations for these classes. There are also some minor factual errors that should have been caught in the reviewing process (e.g. contrary to what is claimed, annotations can be inherited).
   
   Then there is the "Digressions" chapter, which, as others have pointed out, should have been posted as a series of blog posts. Instead, there are some areas where more detail could have been provided. e.g. on how groups work in TestNG, or the exact semantics of the parallel test execution options. Now that TestNG has been out for a while and gained a lot of popularity, I'm sure there is also a lot more information on common problems that could be included in a future 2nd edition!

5 comments about Holub on Patterns: Learning Design Patterns by Looking at Code.

1. I have been programming procedurally for over 6 years, this book was my plunge into the object oriented world. This books starts out with an enlightening introduction to object oriented concepts, this makes it accessible to people with incomplete knowledge of OO techniques.
   Until I read this book I thought I knew OO and was convinced that I was practicing it for the last couple of years, turns out I was deeply mistaken and this book taught me just how little I know.
   Two involved examples are given; my initial reaction to the UML and pattern diagrams given was that of confusion. But as Allen walked me through, the confusion faded and I was struck by the depth of their meaning, from then on I use UML a lot more extensively.
   At the end of the book there is a short reference to all of the patterns, this 50 page reference is worth the price of the book just by itself.
   Awesome stuff, this book is a must read for anybody looking to take the plunge into OO, it has definitely made me a much better programmer. I have read it twice and intend to read it a few more times in the future.



2. „Holub on Patterns" by Allen Holub is a complement book to the well-known GoF's Design Patterns book.
   
   Allen starts with on overview of object orientation and design patterns and basic design principals like programming with interfaces and define patterns versus idioms.
   
   In the main part of the book all 23 design patterns grouped in creational, structural and behavioral patterns are introduced while setting up two applications: „The Game of Life" and „Implementing Embedded SQL". During designing these applications the author discusses the design patterns in a practical way giving many detailed code snippets and UML diagrams.
   
   The appendix lists all patterns in a brief overview with the most important facts: the context, what problem does it solve, pros and cons, often confused with, reference to similar patterns and implementation notes and examples.
   
   The 432 pages are full of helpful information understanding the well-known design patterns and seeing them in practical usage accompanying with each other. Allen gives very valuable hints to understand the backgrounds and the details of all patterns.
   
   Allen assumes the reader to have basic java and UML knowledge. This book serves a wide audience: beginners and also experts will find very valuable information.
   
   The author also gives very specific information and hints on design flaws like the design of the JEditor Pane in Java Swing. He also gives an excellent own solution how he would design the component. Also he does not hide his opinion e.g. about Microsoft technology.
   
   This wonderful book did a great job for me. I read Allen's point of view with his clear words. The book is a real discussion not only a boring list of patterns. I love the practical usage in the given scenarios. Although in my opininion the two example applications are growing to big.
   
   I really hope the author writes other books. I love his style and would like to further profit from his knowledge.
   
   The book published by the excellent publisher Apress is an absolutely must-have!



3. I have read so far only one chapter out of the four of this book I may update my review later.
   
   This book has a lot of very good material. It does require you to know how to program in Java in order to follow Allen's thread as the book is written as a series of monologues where intimate Java knowledge is assumed. The tone is engaging, however the book goes downhill when Allen uses dumb examples about Microsoft and Bill Gates which only reflect that he's got an immense amount of hatred for MS. I have no problem with Allen's feelings except for the fact that he encumbers the reader into separating the real topic from the hatred he exudes. This anger puzzled me and I googled Allen only to realize that he used to write for MSJ way back in 97... Wonder what happened...



4. After reading the first chapter of this book, I felt that Mr. Holub had a very unique way of explaining things which kept me going on. Sure enough, at the end I can say that this was the most interesting and informative book on design patterns that I have ever read !!! He often seems opinionated about how things are implemented in the OO world but he justifies them with relevant real world examples. The design patterns are explained with an example implementation along with a reference of the pattern in the Java API. This makes a lot of impact since most of the readers are familiar with the API and helps in correlating and remembering the patterns easier.
   
   Some of the golden rules suggested in the book that I will always keep in mind from now on:
   
   1) Dont ask for information from an object, rather give the object the information it needs and ask it do the work for you.
   2) Getters and Setters are evil because they compromise encapsulation.
   3) 'extends' is evil as it can cause fragile base classes.
   
   My only complaint about the book is the example of 'Game of Life' (Chapter 3) that was chosen. If you are one of those that havent heard of the game earlier, you would find it a little difficult to follow the code. It would have been better if the author had chosen any other real world application similar to the SQL Interpreter application that was explained in Chapter 4.
   
   The Appendix section is a great ending with concise descriptions about each one of the patterns. I am sure I will refer to this book for a long time and it definitely deserves a space on every serious Java developer's book shelf.
   
   Happy reading....



5. Holub on Patterns focuses on applying design patterns, as they exist in the real world. That is, many overlapping patterns, tangled up, and deliberately so. Holub teaches patterns by example, rather than the encyclopedia-style format we're used to. There's a strong "real world" focus, and it's both a unique and compelling format. It's also a great deal of fun. Holub's a strong writer, and very opinionated. He also advocates a purist's form of OO design, which I happen to agree with: don't use getters/setters, don't use extends, etc. If you aren't used to real OO programming, that'll also take some adjustment, but it's time VERY well spent.
   
   You'll need to be a java developer, or at least comfortable with the language, and have some familiarity with design patterns.

5 comments about The Object of Java: Introduction to Programming Using Software Engineering Principles (2nd Edition) (Visual Quickstart Guides).

1. The BlueJ IDE is less than impressive, and my copy (1st edition?) has plenty of errors (diagrams and/or codesamples have typos or are "wrong" with respect to the main text) ... however ... this book teaches OBJECTS using Java, not just how to program in Java. The excercises use problems that are optimally suited to object oriented solutions. The book was never boring or hard to understand. I love this book!



2. Let me say first: I love the BlueJ environment. It is by far and away the best environment I have ever seen for learning or teaching Java. I was facinated after reading the tutorial that comes with it (from www.bluej.org), and I got this book.

   This book is okay, and has some good points to it, but the 'BlueJ' tag on the front cover is a bit misleading. I got the impression that it was added as an afterthought, and does not make really good use of the BlueJ environment.

   BlueJ opens many fascinating possibilities (calling methods directly on an object!) and not much of this is used in the book. A bit disappointing. Otherwise the book is okay.




3. The Object of Java by David D. Riley
   
   This book is less than impressive. It exhumes the need for elucidated text in the field of computer science.
   
   I am compelled to correlate this book with the awkward ramblings of Vizzini to Westley in the movie, "The Princess Bride".
   
   Reading this book was more than a slight burden. Only one who is versed in reading the writings of such authors as Joseph Cambell or Henry David Thoreau can comprehend the confusion of word and sputter heavily peppering this book.
   
   Allow me to illuminate:
   
   1) This author finds it fit to include typos and syntax errors in the example code as to completely change the meaning of the code. Only one already experienced in programming will catch such errors. Others will wallow in confusion as to why the program is not working properly, after all, they copied it from the book word for word, it should be working, right?
   
   2) In several instances, the author uses programming syntax and variable naming methods in his text that has nothing to do with the code explaination at hand. He actively titles the beginning of each sub-section as if it were a class or variable. IE: DivisionOfRadians()
   NO THAT'S NOT A CLASS! :D
   This is a common practice of David D. Rileys throughout the book, and not only for chapter sub-sections. He uses such writing methods all too liberally.
   
   3) This genius author also uses an arbitrary library called aLibrary. Good for him, he designed his own library! Since this whole book is based on the aLibrary, any real world application have just been made void. I mean seriously, try convincing your co-workers that this aLibrary is the next big thing. What happened to the commonly used AWT and Swing libraries? Hmmm, oh, it's shoved in the back index. Right where you would expect commonly used every day libraries.
   
   4) His code snippets and actual text are seperated by font style. Only problem is, you can't tell at all. His method of referring to code, methods, arguments, classes etc in his text is extremely easy to miss without paying impossibly close attention. His text is filled with inconsistencies and problems. I DO NOT recommend this book. If at all possible, avoid it entirely. For those of you who are using this book as a college text, well, all I can say is, I'm very sorry.
   
   On the bright side, his explaination of objects and classes is ... decent.



4. i had to get this book for a course i was taking at the college i go to. i cringe every time i read it because the title is a bit misleading. I thought i was going to be learning JAVA insted i'm learning how to take someone elses class files to apply them to completely meaningless projects that really dont teach anyone anything about how to program, let alone about the inner workings of the programs your working with. the teaching style is more of a top down approach rather than explaining whats going on at the lower level and you learn to program with classes to make programs at an upper level. This may work for some, it definately doesnt fly with me.
   I have read many books on C, and C++, and have paged through some promising java books (like Sun's own books on the subject).. if it werent for the requirement for this book in the class i would have passed it up INDEFINATELY!!! Peice of Krap!!!
   
   do{
   if(The object of JAVA==pickup){
   The object of JAVA = Leave it the hell alone!!!;
   else if(The object of JAVA == buy)
   {
   do{
   Beat head with stick && knock sence into head;
   burn book || return to store;
   }while(book==posession)
   }while(@bookshelf)



5. This book was a required text for my java class. In conversing with my classmates, we all agree that this book wasn't of any help. I would recommend any other book, this one is just too abstract for a beginner. It's difficult to apply the concepts, and the flow is jagged. With the addition of a teacher, and reading this book from front to back, my java class sucked hard because i didn't have that solid foundation I needed.

5 comments about Large-Scale C++ Software Design (Addison-Wesley Professional Computing Series).

1. I read this book back in 1998. It is the foundation for my understanding of the design of object oriented software. Prior to reading this book I programmed in C++ for more than 8 years. It was apparent to me that there were gaps in my understanding of how to design medium and large scale object oriented systems. This is a huge and dense book, but as I read through it, many times a light went on in my head (those ah ha moments).
   
   The book also gives specific details about consideration for the C++ language. C++ has changed over the years, and the examples do not use newer language features. I do not feel that this is important. The code clearly illustrates the ideas, which are not limited by the state of C++ at the time the code was written.
   
   Regardless of the object oriented language you use to develop software this book will teach invaluable concepts that I have not found explained elsewhere.



2. This book assumes you're already proficient in C++ and basic OOP design principles, and considers design at a level one higher than individual classes. You'll learn how to arrange your classes into modules and packages, and then how to organise communication within and between these higher-level constructs. Nonetheless, the book never forgets that the important thing is working C++ code, not diagrams and acronyms, so it's always practical.
   
   There are two core advantages to the designs discussed in this book: maintaining the correct level of abstraction, and reducing recompilation times. Performance issues always run the risk of becoming outdated fairly quickly, and to a certain extent, some of the timing material is no longer relevant. In particular, Sutter and Alexandrescu, in C++ Coding Standards, explicitly disavow the advocated method of external header guards. Additionally, although namespaces are mentioned, they are not used much, and the older method of using prefixes is recommended instead.
   
   The last part of the book drops down to more low level concerns, such as Schwartz counters, operators, and function arguments. This leans heavily on the likes of Effective C++, C++ Strategy And Tactics and C++ Programming Style, and to be honest, you'd be better off looking in more modern books for up to date best practices. For example, in this book assignment is implemented through the copy-and-destroy idiom, which is nowadays considered to be a mistake.
   
   But this is a big book, and you won't be buying it for the lower-level stuff, but for the large amount of higher level material that makes up the bulk. The main practices and metrics remain extremely relevant, the text is clear and well written. And there just isn't many other places where you can go and read about this sort of stuff. It's a must-read.



3. This is a superb book on software design. While clearly intended for those working on large-scale projects with a broad base of users, the principles discussed are rock solid for even the smallest project. It illustrates a higher level of C++ where objects are not just used because they can represent complex concepts nicely but because proper object-orientation is insurance against many coding evils - exactly the evils which can sabotage large-scale software projects.



4. I'll start with some negative points. Due to the age of this book, much of the example code is out ot date. In particular, no bool and namespaces. This means that the advice about not polluting the global namespace, and to use structs with static members instead ought to now be advice to use namespaces. There's little on the standard library. Coverage of templates (and their potential for code bloat and link time explosion) isn't great. Another issue is the enormous improvement in computer performance since this book was written. At the time, 100MHz single core subscalar CPUs were the order of the day. Now we have 2-3GHz multicore superscalar CPUs that are of the order of 1000 times faster. What sould have taken a week to build would now take.
   
   Some of the terminoligy used doesn't match that which I'm used to. For instance, I would tend to use composition and aggregation where Lakos uses HasA and HoldsA. I don't agree with what he calls internal linkage - basically it is everything that is not extrnal linkage. I'd add a third category, no linkage (e.g., macros, typedefs).
   
   Now some more positive comments. Part II is good stuff. There is a lot of detail on why components can become dependent, and ways of breaking those dependencies. He also explains quite well the disadvantages to such insulation (generally more code and/or slower). Unfortunately, I'm not aware of any easily available tools that generate the metrics that Lakos uses. Without such tools, you either have to perform lengthy analysis (or develop your own tool), or just guess roughly the state of your own system. The end of Part II goes off the boil a bit. Packages are just bigger components, and what is true for packages is also true for components. This leads to a bit of repetition. The section on startup issues is a bit fuzzy as to whether it is a logical design issue or a physical one.
   
   Part III is good enough, but a bit off topic I feel (again getting to logical design, whilst I think the book should have stayed more with physical design). Again, there are a few things that I don't entirely agree with. For instance, advice is given to be 'const correct' [good idea in my opinion], but to only use 'int' and to avoid unsigned types. My opinion on this is that just as you should be 'const correct', then you should also be 'sign correct'. You will have a hard time using just int in real C++ code. size_t is unsigned on all of the platforms that I know, and this is the type of sizeof, the dimension of arrays, returned by strlen and so on.



5. I have to admit, this book is nothing like I thought it would be. It has more C++ than anything else. It is not "large-scale software design with few examples in C++", no sir, it is "design of large-scale software specifically in C++" !
   
   Although not all of the ideas are restricted to C++, many of them do and the book is full of C++ code. Since I haven't done active C++ development for a while (currently digging into Python), it was rather difficult to read.
   
   In a single sentence, the book is about modularization techniques in C++. The purposes of such modularization are different, from speeding up the build process, having the program better understood or refactored, to allowing modular testing or reusing code. And the techniques are different in each case too.
   
   But it is all in C++. Friendship, inlining, const-correctness, abstract interfaces, .cpp and .h file naming, private/protected/public members and/or inheritance, pimpl idiom, initialization of static objects, signed vs. unsigned, that sort of thing. All this has rather limited usability unless you are practicing serious C++ right now.
   
   Again, many of the ideas behind do apply universally, but it is difficult to find them in the thick of C++. I have found a few interesting new ideas, but I have also skimmed over many chapters because it looked too C++-ish to read through.
   
   Worth noticing is that the book is dated (1996) and therefore does not cover such essential C++ features as namespaces and templates.
   
   Only if you are doing serious C++ development. Then it would be great.

5 comments about User Interface Design for Programmers.

1. This book has a number of problems.
   
   First, the writing is amateurish - hardly what I'd expect from someone trying to impart knowledge on a professional audience. It reads as a high school book report, not a reference for software engineers. I expect elegance in material I read, if for nothing else but to gain confidence in the author's intelligence and experience.
   
   Second, much of the information is clearly lifted from books such as 'Tog on Interface' (which I highly recommend). Take for example chapter 10 from User Interface Design for Programmers - 'People Can't Control the Mouse'. Spolsky's ideas on the problem of small mouse targets, as well as his solutions, are almost a direct copy of Bruce Tognazzini's (which I might add were presented much earlier). As another reviewer mentioned, not only are the ideas un-original, but they are presented haphazardly and with little supporting information.
   
   Overall, this book is not worth a penny. It is simply the ineloquent regurgitation of other's ideas.



2. This thin book is a good introduction to the idea of that you should make good software interfaces, but doesn't tell you how to do that. For that, Spolsky provides an excellent bibliography at the end.
   
   If you already have even a little bit of experience with good interface design, this book isn't for you. It's there to enlighten the programming masses that so far don't care or haven't been told that users matter.
   
   You can get this book for free online starting at Joel on Software (I think Amazon deleted the URL I put in there, but google for the book title and you'll find it).



3. I rarely give out 5 stars, but this book deserves it.
   
   Well written, on the light side, but serious about providing best practices for UI design with good examples to back it up.



4. First off, I'm not a (professional) programmer, and I'm not particularly interested in user interface design. I decided to read this book because I've read quite a bit of Joel's other work and I find his thought process illuminating, regardless of the subject. Also, most of the other stuff I've read by Joel is generalist in nature, and I wanted to see if his style would work in a deep dive into a subject. This book isn't a silver bullet in UI design, but it gives a few hints as to how to adjust your thinking to sympathize a bit more with the user. And despite the title "...for Programmers", there isn't much in the book that is programmer-centric, so it's useful for testers, product managers, and others in software development communities who aren't UI designers.
   
   It's interesting reviewing this book in 2008, seven years after it was originally published. Visual design is such a time-sensitive thing, and this book being pre-Web 2.0 looks dated. It's nostalgic in some ways (screen shot of Napster!) but that doesn't diminish from the overall value of the book. While some of the examples Joel uses are no longer novel, most of the principles that Joel writes about still hold true. The messages that are constantly reinforced basically come down to using real life metaphors and respecting the user.
   
   But therein lies my only real criticism of this book. Joel is prone to calling out statements like "users can't read" and "people can't control a mouse" as chapter titles, section headings, and even on the cover of the book. These statements run counter to his overall message of respecting the range of users of an application. What he really means is that "users don't have time to read all your documentation" and "people aren't always using a good pointing device". Reading the full text makes the positive messages obvious, but they are a bit overshadowed by the bolder, more negative statements.
   
   And a point on Joel's writing: Joel is at his best when he's taking examples from his life experience and applying them to whatever he happens to be writing about. There's plenty of that in this book, starting with his experience working in an Israeli bread factory and extending to studies of well designed non-software products. Joel is a master at putting his inspiration into words, and he doesn't disappoint here.
   
   Whether you're a programmer or not, if you're looking for a primer on UI design, this is a solid choice. It's a light, easy, entertaining read and packs plenty of value into it's 140 pages.



5. This book is aimed at programmers who don't have the time or inclination to do research on user interface design, and it has some good suggestions, but you shouldn't take anything he says on faith because he is flat out wrong a good 25% of the time. Spolsky is very intelligent and the book can be fun to read at times, but he also comes off as really really arrogant and narrow minded. He is particularly and undeservedly venomous towards the Linux / OSS community, and this is really inexcusable.
   
   Here is the executive summary: users can't read dialog boxes, they can't use the mouse, the don't read instructions, they have an idea of how the program is supposed to work, and most of the time they can't be bothered to learn how the program "does things differently," so be consistent and imitate programs your users are already likely to be familiar with.
   
   You can lump all of this under the general heading "reduce user effort" which is a pretty good design philosophy. It really only breaks down when your users include other software developers. Developer software has its own set of user interface rules that are completely different (use man pages, don't produce output if everything is OK unless you are testing or the program is doing version control) but Spolsky doesn't appear to understand or appreciate this, so you'll just have to learn it on your own (you can start by googling unix philosophy).
   
   This book gets 4 stars because the average computer book is AWFUL, so this book easily gets into the 80th percentile.

5 comments about Network Security: The Complete Reference.

1. I'm working in Information Security, and I was looking for a good security book, fortunately my decision was the best. This book is very complete and not only explain the concepts of network security but Information Security in the general context. The topics are technical as well as administrative. Explain how the security should be implemented and assessed or audited. I really improved my knowledge and my productivity in my job.



2. Network Security: The Complete Reference is simply an awesome security book.
   
   It has just about everything you need to know when it comes to infosec.



3. A true bible for network security. Also covered are items on risk management, network security policies etc. The book includes simple to advanced topics on network security



4. This book wasn't required, but suggested for one of my classes. I am so glad that I bought it. I'll be referencing it for years. So much info in it. Why is it so cheap?



5. I bought this book for a class but will definitely keep it afterwards. A lot of well organized information on computer security, from policy to implementation.

5 comments about Pro SQL Server 2005 Reporting Services (Pro).

1. I began this book with limited Reporting Services experience, not really knowing what to expect. What I found in every chapter was that the authors really took the time to explain the nuances of this technology that can only be understood from working with it in the real-world and not on a sample database with simple reports. I also learned much more about basic and advanced queries that really helped me out with parameters and stored procedures. I would definitely recommend this book for everyone new to reporting services and those who would like to get answers to detailed reporting scenarios.



2. This book has been well written. Concise, but to-the-point. Coverage on Share point portal and Microsoft CRM is the most comprehensive comparing all the other SRS books in the market. I would recommend you buy this book as well as Wrox to be complete.



3. Well not a good book at all. If you don't have anything else in the office to read or do...and just want to know what Reporting services is all about, you can go throught the book in few hours.



4. This books serves as a great learning tool and reference for people learning RS or for those of us that use it on a daily basis.



5. 
   Loved the writing style. I really appreciated that instead of boring us with an introductory chapter to RDL (Report Definition Language), they sneak it in here and there, keeping the info flowing at a good pace. Plus they wrote the book based on a real-world project they worked on, which makes it easier to grasp the concepts. I give this an A+ and will look for Apress books first from now on ;)

4 comments about MPLS Fundamentals.

1. This is a fairly exhaustive book on cisco MPLS implementation. The name "MPLS Fundamentals" gives an idea that this is a good place to start with, ut unfortunately not. It starts at a basic level, but in no time dives in deep. Use this book only if you want to understand specific areas in depth and not for an overview. Also, if you have access to your own lab, you will find it much easier to follow along.



2. This is a very good book, running from the fundamentals to more advanced topics about MPLS. Easy to read.



3. MPLS Fundamental book contain essential information for any expert CCIP and CCIE.
   However, the book contain the following items that make it complex and unsuitable
   To a junior IT staff reader:
   
   1. The lab/demos don't use one lab design. Learning each chapter (and sometimes
   Any page) with a new lab design, make the self study learning hard.
   Although the author tried to avoid this issue, the issue reoccur in each chapter.
   
   2. Each into/overview after chapter 6 doesn't cover the learning purpose and the
   Important information that the reader will learn .
   
   3. The "Who Should Read This Book?" section should provide information that
   Expert in routing (especially in BGP 4) is a pre-requirement to learn MPLS.



4. This is a book where you are given not only an in depth what it is and how its implemented of the protocol but you are also given great insight as to the why its done this way. You are given all of this in a very readable format. I agree with another reviewer that this is an exhaustive text into the internals of MPLS. I love the level of detail it goes into.