5 comments about MCAD/MCSD Self-Paced Training Kit: Microsoft (2nd Edition) .NET Core Requirements, Exams 70-305, 70-315, 70-306, 70-316, 70-310, 70-320, and 70-300 box vol. set.

1. Ok here is the honest truth about this book. The biggest thing wrong with it is the title. The title suggest that after reading this book you will have the knowledge and skills necessary to pass the exam. NO WAY!! Not even close. The title should be "An Introduction to SQL Server" because it introduces alot of the concepts on a very non detailed high level fashion. I am taking a training class at this place called techskills and had it not been for them, i would have flunked the exam. Their practice questions are very very very similar to the real exam. When taking their practice questions i had to go to server books online to figure out the answers. DO NOT BUY THIS BOOK AS A STUDY GUIDE FOR THE 70-229 EXAM!!!!!!!!



2. I am displeased with the fact that there was not indication that this series of books is tied to Visual Studio 2003. I am working with Visual Studio 2005 so none of the examples match the version I am working with.



3. I think I must have read at least 3 of the books in a set (spend a chunk of my Caribbean vacation on reading those). I read very thouroughly but when it came to taking a practice test from Testking.com, I could not answer any sample questions at all. Also when reading the questions and trying to find an answer using one of the books in this set, I couldn't because a lot of important concepts are simply not there (for example Web Farms).
   
   The first exam I took was 70-305. I passed it the first time with a pretty high score. The book I used to pass and highly recommend is MCAD/MCSD Training Guide (70-305): Developing and Implementing Web Applications with Visual Basic.NET and Visual Studio.NET (Training Guide) by Mike Gunderloy. You can get a used one for under $20. It's worth every cent. Also I would like to recommentd to pair it up with sample questions from Testking.com.



4. read the books
   
   friends...reading this.
   
   I have one WORD?
   
   J2EE
   
   thats it!!!!!!!!!!!!!!!!



5. Very well written. I would recommend this series to anyone seriously considering getting their certificates.

5 comments about Information Theory, Inference & Learning Algorithms.

1. Uniting information theory and inference in an interactive and entertaining way, this book has been a constant source of inspiration, intuition and insight for me. It is packed full of stuff - its contents appear to grow the more I look - but the layering of the material means the abundance of topics does not confuse.
   
   This is _not_ just a book for the experts. However, you will need to think and interact when reading it. That is, after all, how you learn, and the book helps and guides you in this with many puzzles and problems.



2. I have used this to get a good background in the topics covered, especially inference theory, and in general I found it to be great book which fills a market gap. The only sins I see are sins of omission. I personally would have enjoyed seeing a more task driven organization. I seem to need these methods periodically but I never seem to need the same method twice. Also, many of the techniques are heavily iterative, i.e., monte carlo, neural networks, etc. This is fine but much of what I do is in the context of simulations where 100,000 step iterative methods don't work so well because of resource constraints. Historically, that has been the problem with many of these methods. They are useful for relatively small domains but don't necessarily work that well for "real" problems. That is probably why more task oriented books are not available. Of course the author is following the outline of the current research into the subject manner which in turn is largely determined by "interesting" and "doable" problems. The real progess in this field will come when the problems are formulated more by what is needed in the nontraditional domains of application. A good example of a useful compression (and identification in some cases) technique that is not covered is Principal Component Analysis. Technically, it is in none of the technique domains covered in this book, but it would have been nice to see some of the methods in the book compared with PCA. The author does make the statement at one point that image recognition is an interesting problem for which the method being discussed at the time is used. Nevertheless, this is a great overview of the subject manner and is very entertaining. That in the long run probably explains the problem: it is a textbook.



3. This is fantastic book. Really takes an intuitive approach to the material. The explanation of occam's razor is worth the price of the whole book. Highly recommended.



4. I find it interesting that most of the people reviewing this book seem to be reviewing it as they would any other information theory textbook. Such a review, whether positive or critical, could not hope to give a complete picture of what this text actually is. There are many books on information theory, but what makes this book unique (and in my opinion what makes it so outstanding) is the way it integrates information theory with statistical inference. The book covers topics including coding theory, Bayesian inference, and neural networks, but it treats them all as different pieces of a unified puzzle, focusing more on the connections between these areas, and the philosophical implications of these connections, and less on delving into depth in one area or another.
   
   This is a learning text, clearly meant to be read and understood. The presentation of topics is greatly expanded and includes much discussion, and although the book is dense, it is rarely concise. The exercises are absolutely essential to understanding the text. Although the author has made some effort to make certain chapters or topics independent, I think that this is one book for which it is best to more or less work straight through. For this reason and others, this book does not make a very good reference: occasionally nonstandard notation or terminology is used.
   
   The biggest strength of this text, in my opinion, is on a philosophical level. It is my opinion, and in my opinion it is a great shame, that the vast majority of statistical theory and practice is highly arbitrary. This book will provide some tools to (at least in some cases) anchor your thinking to something less arbitrary. It's ironic that much of this is done within the Bayesian paradigm, something often viewed (and criticized) as being more arbitrary, not less so. But MacKay's way of thinking is highly compelling. This is a book that will not just teach you subjects and techniques, but will shape the way you think. It is one of the rare books that is able to teach how, why, and when certain techniques are applicable. It prepares one to "think outside the box".
   
   I would recommend this book to anyone studying any of the topics covered by this book, including information theory, coding theory, statistical inference, or neural networks. This book is especially indispensable to a statistician, as there is no other book that I have found that covers information theory with an eye towards its application in statistical inference so well. This book is outstanding for self-study; it would also make a good textbook for a course, provided the course followed the development of the textbook very closely.



5. This is an unqualified classic, to shelve with the likes of 'Structure and Interpretation of Computer Programs', 'Concrete Mathematics' and 'Mathematical Methods of Classical Mechanics'. If you are involved with, or interested in, high-end data analytics, then you _need_ this.
   
   However 'high-end data analytics' does not even begin to do the book justice, so let me try again.
   
   This is a magnificient compendium of fascinating stuff presented in a coherent information-theoretic framework. It covers everything from how digital television data compression and CD error correction work to a detailed commentary on neural networks, and discussion of principled AI methods such as clustering, Gaussian processes and probabilistic graphical models, together with Monte-Carlo techniques and a bunch of statistical physics. It even throws in a complete course in Bayesian statistics. It reads like a really good 'popular' 'science' book (I often wonder where the scare quotes should be) that doesn't bother to try to be popular.
   
   In fact I bought this originally as bedside reading, for pleasure. It was only later that I actually used it for anything.

5 comments about RibbonX: Customizing the Office 2007 Ribbon.

1. Never having used XML prior to Access 2007, I was unsure of how I would learn to use the new Ribbon in the Microsoft Office 2007 products. RibbonX: Customizing the Office 2007 Ribbon, by Robert Martin, Ken Puls, Teresa Hennig, and Oliver Stohr has made the learning curve much less steep for me. The book is well organized and easy to read.
   After reading the book, I feel comfortable that the conversion of applications developed in prior versions of Access and Office, will be much easier with the knowledge they have shared in this book.
   I recommend this book to anyone that is creating applications in any of the Office 2007 programs.



2. This book is well written for users who have no prior knowledge of ribbon or menu programming in Office. The background information on how the new ribbon was developed is good for providing some insight on how it was developed and how to take advantage of it in your development work.
   
   Previously I have worked with VBA in Access and had no background in programming for the menu or ribbon. The VBA section of the book was most helpful in that the authors examples can relate your prior experiences.
   
   The coverage of the topic of XML is very good for getting through the parts you need to use in prograsmming the ribbon without overloading the reader.
   
   After having worked with the examples in RibbonX, I still like to use the book as a desktop reference. The use of well organized tables listing the functions and their optional and required parameters is very handy.



3. This books wraps up everything that's required to design and program the RibbonX for Office 2007. Even when it seemed like the authors didn't go into sufficient detail, the sample files provided the answers to all of my questions.



4. This book covers the new "Ribbon" interface used in Microsoft Office 2007. The Ribbon replaces the old menus and toolbars in Office programs, and unlike the menus and toolbars cannot be modified or added to easily. The new Office programs have only one toolbar, called the Quick Access toolbar, to which you can add toolbar buttons to run commands and macros; and there are no more menus.
   
   The book teaches you the difficult process needed in order to modify the Ribbon in each Office program. It is not an easy process, as it involves writing XML code in addition to macro programming code. And opening the necessary XML files in order to modify them isn't easy either.
   
   The book does a fairly good job of presenting the process, and documenting the various XML "tags" needed. However, it is not well written, and its explanations of the programming concepts are a bit muddled, especially for novices like me. The constant statements of "we'll explain this later" become aggravating after awhile; its like the authors themselves are feeling their way along with their readers. I guess by the end of the book, they have figured out what they were trying to teach; that should make the next edition a little better!
   
   One thing you should know if you want to modify the Ribbon in the Office programs is that there are programs out there that have been and are being written to automate the process so that you don't really need to know the details in the depth this book attempts to teach. (But having this book could be a help in using and understanding those programs.) There are two programs available now, one of which is called RibbonCustomizer (and is very well designed).
   
   Also, if you are a programmer using Visual Studio 2008, you can obtain from Microsoft a free addin called VSTO (Visual Studio Tools for Office) that contains features that allow you to write your own programs to modify the Ribbon. I'm not sure about this (I'm a novice programmer myself), but I think the free VSTO addin for VS 2008 eliminates the need to purchase the VSTO program separately. You had to pay a hefty price for the VSTO program needed as an addin for VS 2005, but it seems that now it can be added for free to VS 2008.



5. This book is very informative for learning the new Office
   program. Really goes into detail; therefore, even the novice
   user can understand the new menu bar.

5 comments about MicroC OS II: The Real Time Kernel (With CD-ROM).

1. A good book for who wanna learn about Real Time Operative Systems. Easy to read and full of interesting information



2. The book has brand new look and feel. Its very well maintained and delivered on time. Extremely pleased with the service.



3. This book is not only the documentation of the uC/OS-II RTOS. It also presents many of the general real-time programming concepts in a very pedagogical manner.
   I found the book very helpful.



4. I've learn more about embedded operating systems and kernels from this book and playing with MicroC/OS II than I ever had by working with uCos, vxworks, embedded Linux, and BSD.



5. I read this book after I have tested TOPPERS/ssp(smallest set profile), which is ITRON smallest set profile, first implementation.
   These are simillar concept "micro" or "smallest".
   "MicroC OS was certified in an avionics product by the Federal Avion Adinistration(FAA) for use in commercial aircraft by meeting the demanding requirements of the RTCA DO-178B standard"
   It is significant different.
   But I do not know what procedure is needed in certification.
   The book is not tell any more.
   But this source code is good understanding what operating system should be.
   BTW, I do not know microC/OS II is capable ISO osek OS.
   I want to know how to harmonize microC/OS II and ISO osek OS.

5 comments about Software Requirement Patterns (Best Practices).

1. Stephen Withall's "Software Requirement Patterns" can help any analyst write better requirements. The patterns Steve presents can help analysts ask the right questions to properly understand and specify requirements of many types at an appropriate level of detail. This book communicates a wealth of wisdom and insight for writing stellar requirements. The patterns point out the value of using a consistent style when exploring and documenting requirements. Even if you don't apply the patterns rigorously, Steve provides hundreds of practical tips for specifying better requirements.
   
   This book does not address the entire requirements development and management life cycle. You aren't going to sit down and read through the whole book, either. Instead, it's a valuable reference when you have questions about how best to explore and specify certain types of requirements. It will help you discover essential information that you wouldn't otherwise think to ask about. I used the "Report Requirement Pattern" this morning (literally) to get some new ideas about effectively specifying requirements for reports.
   
   This is the most comprehensive resource I've seen on thinking carefully through the information associated with effective functional, data, and quality requirements of many different kinds. I highly recommend it.



2. The purpose of this book is to help you decide and define what a new software system needs to do and to suggest what extra features to add to make it a very good system. It saves you effort and enables you to be more precise, by providing detailed guidance on how to specify individual requirements.
   
   Requirement patterns are encapsulated expertise, conveniently prepackaged for reuse. The book contains 37 requirement patterns, each of which describes an approach to tackling a particular type of situation that comes up repeatedly in all kinds of systems, but focusing on commercial business software. Only a fraction of any system is specific to its business area; the bulk occurs over and over again no matter what your system is for. These patterns cover more than half of all requirements in some systems, and even more if you add the extra requirements the patterns suggest. Each pattern conveys not only the basic information that a requirement needs to convey, it also offers guidance on supplemental information that you need in your requirements in order to make them complete, comprehensible, and properly cross-referenced. This book contains over 400 example requirements, many of which are suitable for applying unchanged to any system and others that are a useful starting point for a requirement to suit the reader's needs. These examples are the heart of the book. Currently, the product description does not show the table of contents, so I do that next:
   
   Part I: Setting the Scene
   Chapter 1. Synopsis of "Crash Course in Specifying Requirements"
   Section 1.1. What Are Requirements?
   Section 1.2. Where Do Requirements Fit in the Grand Scheme?
   Section 1.3. A Few General Principles
   Section 1.4. A Traditional Requirements Process
   Section 1.5. Agile Requirements Processes
   
   Chapter 2. Synopsis of "The Contents of a Requirements Specification"
   Section 2.1. Introduction Section
   Section 2.2. Context Section
   Section 2.3. Functional Area Sections
   Section 2.4. Major Nonfunctional Capabilities Section
   
   Chapter 3. Requirement Pattern Concepts
   Section 3.1. Introduction to Requirement Patterns
   Section 3.2. The Anatomy of a Requirement Pattern
   Section 3.3. Domains
   Section 3.4. Requirement Pattern Groups
   Section 3.5. Relationships Between Requirement Patterns
   
   Chapter 4. Using and Producing Requirement Patterns
   Section 4.1. When and How to Use Requirement Patterns
   Section 4.2. Tailoring Requirement Patterns
   Section 4.3. Writing New Requirement Patterns
   
   Part II: Requirement Pattern Catalog
   Chapter 5. Fundamental Requirement Patterns
   Section 5.1. Inter-System Interface Requirement Pattern
   Section 5.2. Inter-System Interaction Requirement Pattern
   Section 5.3. Technology Requirement Pattern
   Section 5.4. Comply-with-Standard Requirement Pattern
   Section 5.5. Refer-to-Requirements Requirement Pattern
   Section 5.6. Documentation Requirement Pattern
   
   Chapter 6. Information Requirement Patterns
   Section 6.1. Data Type Requirement Pattern
   Section 6.2. Data Structure Requirement Pattern
   Section 6.3. ID Requirement Pattern
   Section 6.4. Calculation Formula Requirement Pattern
   Section 6.5. Data Longevity Requirement Pattern
   Section 6.6. Data Archiving Requirement Pattern
   
   Chapter 7. Data Entity Requirement Patterns
   Section 7.1. Living Entity Requirement Pattern
   Section 7.2. Transaction Requirement Pattern
   Section 7.3. Configuration Requirement Pattern
   Section 7.4. Chronicle Requirement Pattern
   Section 7.5. Information Storage Infrastructure
   
   Chapter 8. User Function Requirement Patterns
   Section 8.1. Inquiry Requirement Pattern
   Section 8.2. Report Requirement Pattern
   Section 8.3. Accessibility Requirement Pattern
   Section 8.4. User Interface Infrastructure
   Section 8.5. Reporting Infrastructure
   
   Chapter 9. Performance Requirement Patterns
   Section 9.1. Response Time Requirement Pattern
   Section 9.2. Throughput Requirement Pattern
   Section 9.3. Dynamic Capacity Requirement Pattern
   Section 9.4. Static Capacity Requirement Pattern
   Section 9.5. Availability Requirement Pattern
   
   Chapter 10. Flexibility Requirement Patterns
   Section 10.1. Scalability Requirement Pattern
   Section 10.2. Extendability Requirement Pattern
   Section 10.3. Unparochialness Requirement Pattern
   Section 10.4. Multiness Requirement Pattern
   Section 10.5. Multi-Lingual Requirement Pattern
   Section 10.6. Installability Requirement Pattern
   
   Chapter 11. Access Control Requirement Patterns
   Section 11.1. User Registration Requirement Pattern
   Section 11.2. User Authentication Requirement Pattern
   Section 11.3. User Authorization Requirement Patterns
   Section 11.4. Specific Authorization Requirement Pattern
   Section 11.5. Configurable Authorization Requirement Pattern
   Section 11.6. Approval Requirement Pattern
   
   Chapter 12. Commercial Requirement Patterns
   Section 12.1. Multi-Organization Unit Requirement Pattern
   Section 12.2. Fee/Tax Requirement Pattern
   
   This book is very good at taking a dull subject - software requirements and their specification - and making it interesting and accessible. Highly recommended.



3. Stephen Withall should be congratulated for slugging through about 300 pages of examples of requirements. Many of them are quite good. For that alone, I recommend the book for all those who want to know what a fairly well written requirement might look like. If you want to know what a very well written requirement looks like, then you should go attempt to read Tom Gilb's book Competitive Engineering. I say attempt because Gilb is not an easy read.
   Withall is honest from the beginning in that this is a book of examples using a pattern language. I don't have much enthusiasm for pattern languages, they seem to confuse me, but that is probably a personal problem. There is little to explain what requirements are or how to get them. This book focus is on writing them down. He does have a really brief (very, very brief) intro to requirements with more promised on the web. I didn't read the web stuff.
   What I did learn, and colored my whole perception of the book, is that the working definition of requirement is focused flat on functional requirements. Yes, there is a nod to not functional requirements but they get a short shift throughout the book. Frankly, functional requirements are not that interesting. Yes, they are needed but they are typically really easy to get. It is the not functional requirements that get teams into trouble. It isn't that the software doesn't do what you want, it just does it in a way that you hate.
   This is clear in the section on User Function requirements where (even if he told us earlier to specify the problem, not the solution) the examples are full of solution. "The system will refresh itself" and "Whenever a sound is played for the purpose of alerting the user, a visual cue shall also be invoked". Why I ask you? That is solution talk.
   Now to be a bit more fair, problem and solution is a relative area so, without a clear description of the context, I can't say what those two examples really are, but my money is on solution. A problem UI requirement for the above is more like, "The user will correctly recognize an alert within X seconds 95% of the time" or something like that.
   Bottom line, if you want to have a book of lots of examples, not to bad. In those examples are some good questions. But there is much more to do than to write them down.



4. This book provides a great "kick start" for specifying large system requirements. The patterns provide food for thought along with a very useful standard approach to specifying requirements. It should be in every system analyst's toolkit.



5. It's ok if you are starting to have the concepts and everything in a general level. If you are looking for some specifics guides or examples to apply in the reality... mmmhhh... I don't think this book is the best option to have that. And... it's expensive. My best advice... don't buy it.

5 comments about Pro PHP: Patterns, Frameworks, Testing and More (Pro).

1. This book focuses on some advanced technologies and latest developments related to php. The targeted readers are those who already know php programming but would like to know how to work with php in a way to adopt mainstream software and Internet development technologies.
   
   For example, the book collectively describes about phpdoc, phpunit, xdebug, as well as subversion, phing, and xinc. The examples and steps provided in the book allow the reader to follow through relatively at ease. Nevertheless, the reader may want to know that all install and setup described in the book are based on Linux environment.
   
   In the chapter of Reflection API, the reader will get a chance to study some use cases about this advanced extension that normally only java or C# programmers could enjoy through their build in language features today. The chapters about Standard PHP Library (SPL) give the reader the ideas of how to apply OOP libraries for php programming. For instance, instead of using a set of low-level file manipulative methods, the reader now might think about using SPLFileInfo object to represent and access file info. The book also covers some design techniques on php such as exception handling, MVC paradigm, and a few design patterns, which are informative.
   
   The topics of Zend framework and Web 2.0 including ajax, web services, soap, and certificate authentication, provide a good entry point for those who want to know how to associate php to web design architecture and how php play its role within web deployment.
   
   For about 300 pages, this book covers a lot of info. The topics are explained in a clear and straightforward manner for easier read. Additionally, the reader may find the writing is pretty concise in general and still leaves room for the reader to further investigate the issues outside the book. The companion download-able source code from the website is as expected and helpful.
   
   Needless to say, some sections could be better organized. The Part 1 OOP and Patterns only list a few out of many common regarded patterns and OOP ideas, and other Parts of the book also mention some other patterns along their ways.
   
   Overall, this book deserves a score 8 out 10 and should be as an eye opener and handy for those who like to see some advanced php subjects demonstrated in one place.



2. I have been developing web-based, database-driven applications for 12 years using Perl, Java, and, for the past 3 years, PHP. I was a late-comer to PHP because, quite frankly, its early iterations sucked. The committers finally got it right with 5.2 and 6.0 looks like they are staying on-track.
   
   I went through any number of online tutorials and "Learn PHP in 24 Hours" books in the beginning and they were fine for "Hello World" applications. But as my need for sophistication rapidly grew, I found a distinct lack of good, readable texts that could function not only as tutorial but as reference as well. I went through a disappointing array of O'Reilly, Manning, Osborne, Addison-Wesley, etc. books, each of which lacked that crucial combination of clarity, accuracy, and scope. Then I happened to chance upon Apress' publication of "Pro PHP Development."
   
   I just finished reading "Pro PHP Development," and when I say I "finished reading" it, I mean exactly that - I read it cover-to-cover. Kevin McArthur has the uncommon talent of writing a technical manual in prose. Unassuming vernacular makes reading easy, instead of the more typical struggle with every idea and re-reading sentences and paragraphs after that "HUH???" experience forces wonder at the author's point and intent. Concrete, concise, and useful examples demonstrate the textual subjects in clear unambiguous source code. And where appropriate and useful, McArthur introduces aspects of PHP 6.0. The coverage of some of the most useful objects in the SPL and the extensive treatment of the Zend MVC Framework is worth the price of admission in themselves.
   
   In summary, "Pro PHP Development" is right up there with the finest technical literature I've read and has earned a place on my bookshelf (lesser texts get relegated to eBay). It's a keeper. Until the next edition!
   
   Mark Galbreath
   Annapolis, MD



3. As an experienced PHP developer and author myself I was delighted that Pro PHP showed me a number of new techniques that I can apply to my own every day development tasks. This makes me confident that developers of all levels will gain value out of reading this book. I typically like to keep up with recently released books so I know the material that is available, but as somebody who has been programming PHP for almost 10 years I generally don't find new ideas that can be applied to general PHP programming.
   
   Two such examples of this in Pro PHP that helped me are array overloading with the ArrayAccess SPL class and the observer pattern using SplObserver and SplSubject. Firstly, ArrayAccess allows you to access objects (such as reading and writing) as you would with an array. One such example of this is in the PHP SimpleXMLElement class. Secondly, using the observer pattern allows one object to monitor the state of another object and react to these changes as desired. Kevin describes these to the reader and provides solid examples of using them.
   
   An interesting aspect of this book is the chapter dedicated to PHP 6. Although a stable version has not yet been released, Kevin covers the key features that we can look forward to such as namespaces, late binding and native Unicode support.
   
   The other thing that I like about Kevin's style and methods are that they are fairly similar to my own, meaning for the most part I agree with his methods and therefore recommend them to other users as well.
   
   On the whole I would have two minor complaints with this book. Firstly, there is a lot of "conceptual code" rather than practical real-world examples. Having said that, there are so many different ideas in this book that it would be difficult to fit longer examples for these ideas. Secondly, I would've liked to see some more extensive coverage of the Xdebug module. This is a module that I try to use but I feel like I am under using its potential. It is great that Kevin covers it in Pro PHP, but I would've liked to see some slightly more advanced usage for my own benefit.
   
   In summary, I would definitely recommend reading this book, especially if you have been slow to transition from PHP 4 to PHP 5, or if you use PHP 5 but know you don't take full advantage of its Object Oriented Programming features.



4. This book is quite a good book on PHP. I would by no means recommend it to beginners.
   
   I like how it dives into the zend frame work and different methods of testing. This book is not how to learn PHP at a advance level it is instead to learn how to use PHP in the formal software development approach. That's what makes this book so enjoyable.
   
   I would recommend it to people going to build a enterprise size PHP web application. It has all the tools, tips and trick you need to do it.



5. [reviewed by XPSD member Woody Zuill]
   
   One common technique I use when looking at a book I am thinking of
   buying is to flip through to a dozen or so random pages and read a
   paragraph or a bit of whatever is on that page. If most of these chance
   peeks reveal something interesting or useful to me, then I figure I'll
   probably get enough out of the book to make it worth buying. I did that
   with this book, and found plenty of interesting stuff. However, in the
   reading of the book I was a bit disappointed.
   
   First, the bad:
   The book attempts to cover too much for the number of pages. The Title
   is clear enough, but the subtitle ("Patterns, Frameworks, Testing, and
   More") coupled with the introduction, which states "In this book, you
   will learn how to make the most of your PHP programming, from a detailed
   understanding of OOP theory, to frameworks and advanced system
   interoperability" promises a great deal more than what the book
   delivers. For example, the "detailed understanding of OOP theory" is
   provided by a 7-page chapter on "Abstract Classes, Interfaces, and
   Programming by Contract" and another chapter covering static members.
   This is sufficient to describe a little about the mechanics of OOP in
   PHP, but it's a stretch to call it even an introduction to the theory of
   OOP. Pretty much the same can be said for the coverage of Patterns,
   Frameworks, and Testing. I am not exactly sure what "advanced system
   interoperability" is, I assume the author is refering to web services
   which is covered to some degree.
   
   To me, the book seems disjointed, and more like a collection of magazine
   articles than a cohesive book. There is unevenness in the level of
   coverage from topic to topic. Some chapters are thorough enough to be
   considered complete, or at least a good introduction, such as the
   chapters on Exceptions and Reflection, and all of "Part 3, The Standard
   PHP Library". Each of these chapters would make a nice article. Others
   contain a bare introduction, like the "Testing, Deployment, and
   Continuous Integration" chapter. In some cases, there isn't enough
   information to even consider it an introduction (such as the chapter on
   AJAX and JSON.) It probably would have been better to replace these
   chapters with more coverage of one of the other topics. Particularly,
   for example, there is a chapter on what is coming in PHP6. It seems
   very out of place and this sort of info can be easily found by a web
   search.
   
   Now, the good:
   Kevin McArthur writes cleanly and I found everything easy to read and
   understand. He is obviously very knowledgeable about programming in PHP
   and presents his ideas clearly. I learned a lot from the topics that
   were sufficiently covered (such as the chapters on Exceptions,
   Reflection, and the SPL.) I feel that there was enough substance to get
   me started on these topics.
   
   Additionally, I like Kevin's "Just the Facts" synopsis at the end of
   each chapter. In a paragraph or two he summarizes what was just
   presented in a very succinct manner without any of the fluff or filler
   we so often see in the typical programming book (like the "what's coming
   in the next chapter" blurbs: I find that I can easily turn the page to
   see what is "coming"!) Similarly, I enjoyed most of his chapter
   introductions - he did a good job of describing what he was going to try
   to cover.
   
   Should you buy the book?
   "Pro PHP" wouldn't be my first choice for a "PRO" level PHP book, but I
   got enough out of it that I don't regret having read it. How is that
   for a good sound bite?

5 comments about Special Edition Using Microsoft Office Project 2003 (Special Edition Using).

1. Tim Pyron's Special Edition Using Microsoft Office Project 2003 is enhanced with an accompanying CD and provides direct answers to effectively manage computerized office projects. Highly recommended both as an instructional guide and as a continuing reference, Special Edition Using Microsoft Office Project 2003 includes answers on project development and implementation, as well as tracking progress and adjusting to changes, developing final reports, and more.



2. I picked this up as I was in the middle of several complex Project plans for network upgrades and migrations, as well as a mass rollout of Office 2003. I'd used previous versions of Project before but never really learned how to use it.

   By the time I finished the first 10 chapters, I had already tripled my Project knowledge...and the really cool stuff was yet to come. Project, like Visio, is an extremely complex application that most people never crack the surface as far as usability goes. Anyone who is doing heavy Project Management needs to use Project, this is the book to learn by.




3. I have three other project books on my shelf but whenever I run into a tough situation, this is THE book I go to. No other books out there (not even the self proclaimed bible) explains features as in depth as this book does. I especially like the section on leveling and how it explains the 7 factors used to resolve conflicts. This is a must have for all serious users of MS Project.



4. Using Microstoft Project 2003 by Tim Pyron
   It's exactly 2.000 inches thick, which, I believe, must have been one of the publisher's criteria. If you've used Project for years on a daily basis and want to know even more, it's for you. If you want to learn Microsoft Project, don't buy this book. It's a direct violation of the "Say what you need to, as simply as you can" rule from 8th grade English. Do yourself a favor. Forget about MS Project and buy Mindjet's MindManager software. You can learn that in an afternoon and it's far more powerful software.



5. I am not a very experienced Project Manager.
   I bought the book as I was going to participate in Projects in my organization and planned to equip myself with everything I could about it.
   
   Also, I took 2 Microsoft Oficial Courses (beginner and intermediate) on Microsoft Project 2003 that costed my organization about $200.
   
   I give it 5 Stars because the book has every topic there is about Microsoft Project 2003 that I have come to need (and more).
   
   However, if you are new to MS Project consider that it might pay you more to take some courses. You will learn in them all the backbone knowledge to succesfully manage projects without having to spent alot of hours reading the book.
   
   Remember that this book is very extensive on each topic, it's excellent for reference or advanced use specially when you're an experienced project Manager since you will learn stuff you didnt know you could do.
   But if what you're looking for is learning Project 2003, I think its faster and more practical to take a course.

5 comments about Pragmatic Unit Testing in C# with NUnit, 2nd Edition.

1. You keep hearing about it.
   "Unit Testing, Unit Testing, Unit Testing"
   The time is now. Stop talking about and start becoming a more responsible developer.
   This book takes you through the scenarios. Well written, and easy to get going.
   This book has been the key ingrediant to get other developers at my company involved with NUnit testing.
   
   NUnit is freely available. If you have VS2005Pro, then plugging in NUnit make the most sense.



2. This is a great introduction to writing unit tests in C# with NUnit. The authors do a good job of explaining why unit tests should be created, how having unit tests are better than not having unit tests, and what exactly should be coded for in a unit test. The book is well-written, easy to follow, and includes helpful guidelines for things that might be confusing to developers.
   
   The real strength of this book is not the author's approach to writing unit tests, but rather they clearly illustrate what exactly should be tested in a unit test. The authors show how adhering to the guidelines they set forth results in unit tests that are well-written and fail at appropriate times. The authors then generalize this to some extent and provide an excellent discussion on the properties of a good unit test.
   
   My favorite section of the book was actually one of the appendices. In the first appendix, the authors go through a list of gotchas--both in writing unit tests in general and specific to unit tests in C#. This is a very short discussion (only 6 pages), but they identify some issues I've seen with poorly written unit tests.
   
   This is a great book as an introduction to writing unit tests. The authors clearly explain why unit tests should be written, they show clearly what should be tested in a unit test, and they describe some of the problems that have been avoided by writing intelligent unit tests.



3. The book is packed with practical advice on unit testing. Why should you do unit testing, what do you need to know to write good tests, how do you know if you're writing good tests, how can unit tests not only improve your code, but also your design, can unit tests doom a project (if not done right) --- you'll find answers to all of these questions and more. The authors also give numerous short code examples that help solidify the concepts. You'll also find extensive references and links to web-sites where appropriate. The authors' writing style is fluid. If you enjoy reading good technical books, you'll read this like a novel!



4. I have to respectfully disagree with all the fawning reviews. It's a chatty, drawn out, tedious read, something of an accomplishment given the fact that it's only ~200 pages long. Frankly, anything more then something like the O'Reilly Pocket Reference is overkill on this subject. NUnit is a snap to use and the freely available documentation and tutorials are more than adequate and not nearly so time-consuming to digest.
   
   The first passage that discusses actual test coding (~20 pages or so into the book) presents a simple case where a method should accept an integer array as a parameter and return the largest element. The book then explains how this function, if it behaves properly, should perform. A series of simple test cases are discussed before we get to the real toughie for all you computer scientists out there - a data set consisting of negative integers. A test vector consisting of the array [-9,-8,-7] is passed to the method and -7 is returned. The book explains 'It might look odd, but indeed -7 is larger than -9. We're glad we straightened that out now, rather than in the debugger or in production code where it might not be so obvious.'
   
   ARE YOU KIDDING ME?!? Just what audience was this thing written for? One would have thought that that little gem wouldn't have been necessary... but in fact that is the tone of the entire book. Expect to have your hand held in this manner throughout. If that's the sort of thing that appeals to you, you'll love this one. If, on the other hand, you're trying to learn to incorporate NUnit testing into C# development in an efficient, professional manner, save your money and time and read the NUnit docs.



5. This is a decent getting started book, but it doesn't give good coverage of things such as NUnit projects or using app.config files with NUnit.
   
   Unfortunately, this book isn't good as a stand-alone. I'll admit that it did help me get started, but it lacks so much that I can't give it more stars. A second volume that covers more advanced topics is suggested, or the next edition can add the missing parts.

5 comments about Microsoft XNA Unleashed: Graphics and Game Programming for Xbox 360 and Windows (Unleashed).

1. well this isnt realy the publishers \ writer fault but this book is written for XNA 1.0, and once 2.0 had been released some of the code in the book needs a bit of tweaking,
   
   i think that if you have some background knowledge about C# and programming, then this is the perfect book to take you into XNA.
   it has a much better approach then most, "teach yourself" books,
   and i recommand getting it,
   
   it only got a 4 out a 5, but if a new edition with XNA 2.0 will be release i would have givven it a 5.
   :)



2. At first I was hesitant to get this book since it based on the 1.0 refresh. However, I wanted to get started right away and seeing how this technology will simply continue to grow, there is no better time than the present to start learning.
   
   I have all of the current XNA Books available and this one is by far the best. I love this guy's coding style ... it is nice when an author using .NET is actually using .NET styled code. If there is only one XNA book you can buy -- get this one.
   
   I really enjoyed his perspective on performance. It helped me in my day job as well ... can you say Garbage Collector? I bought this book to do 3D and I have been happy with my results. I am using 2D to supplement my 3D game, but it seems the community is obsessed with 2D games at this point. The physics chapter is great. I also enjoyed the chapter on Artificial Intelligence. Both are short, but to the point and helped me know where I need to look for more information. The particle system is excellent. I liked the force field created by particles ... cool.
   
   I am a programmer by trade and have dabbled in computer graphics in the past, but it was just too much work to get anything valuable. With XNA and this book as a guide, I was able to go so much farther than I ever did with DirectX and the books I bought on that subject. I have created a full 3D game that I plan to put out on Xbox LIVE Community Games when it is available. There is no way I would have a completed game without this book -- sound, game states, input, polish -- it is all in here!
   
   I liked how the author didn't waste time on rendering a single triangle ... he did a rectangle (two triangles) ... and then later used that code to create a skybox. The chapter on the content pipeline was excellent. I enjoyed the advanced topics he has as well like Render Targets, Parallax and Relief Mapping.
   
   In regards to changes with 2.0, he has updated the code on his site and it runs with no issues at all! Fortunately, the code is about identical to what it is in the book even with new code. I guess it just proves that not too much had to change between 1.0 refresh and 2.0.
   I would buy this book again. In fact, I will when the author comes out with the 3.0 book.
   
   Get this book ... and don't waste any more time ... make a great game -- it really is within grasp!



3. This is a very well planned book with game development students in mind. Readers who complain that the writer takes off too quickly should keep in mind that the book is categorized as "Intermediate-Advanced" and quite accurately so.
   
   I'm using this as a recommended text for a module I am teaching to diploma students and it brings them up to speed on programming with XNA.
   
   You should get this if you have programmed in DirectX and/or C++; you'll find it a breeze and be amazed by how many things have been taken care / made much easier by the XNA framework and using a managed language such as C#.
   
   The author, Chad Carter, also actively responds to the questions in the book's discussion forums. This is especially important for a technical book such as this as technology is constantly evolving (we're at XNA 2.0 currently), and it helps to know which parts of the book need to be updated (or not).
   
   The only improvements I can recommend for the next edition (XNA 3.0) are:
   1. Consolidated list of errata on the author's website (xnaessentials.com) to make it easier to find and update my own copy / students' copies of the book.
   2. Teaching / supporting materials. However, I must admit that going through the exercises in the book will give you a good deal of ideas and inspirations already.
   
   In short, thanks Chad, please keep up the excellent work.



4. The book assumes you know C#, and basically takes you through the development of a 2D game and a basic 3D FPS style game. As new functionality is added, the book explains the code pretty much line by line. It therefore shows you two sets of simple game design patterns in some detail.
   
   It also makes the book very linear - as new functions are shown in the context of what has been built already, you can't easily just experiment with the different classes on their own. You really have to follow it through as a sequential tutorial.
   
   What I was more hoping for was a more systematic treatment of the various XNA classes, and more of the underlying theory particularly with respect to using transformations. Matrix and vector maths is barely discussed directly at all.
   
   The linear structure and practical focus also means that I didn't find myself able to "dip into" the book and learn more about XNA whilst watching TV for example.
   
   So if you want an extended tutorial on XNA game programming its fine. If you want to really "get inside" XNA and graphics programming, then its not the right book for you.



5. When i started to get serious about XNA i started looking for a good book to begin learning. Like most people (IMHO) i learn better through books and then self training than reading everything online.
   
   The Microsoft XNA Unleashed by Chad Carter is a great book as it is not merely a skim through from the top for XNA but is very detailed. I have just started and i dont think i will be done with the book very soon.
   
   I like his presentation style as well as the detail. I read all the reviews and sure some folks think it is a good book whereas some folks think otherwise. For me when i started reading through it i immediately liked the presentation style. I think (IMHO) that a good presentation style with good material leads to better learning.
   
   I will post an update to my blog as and when i complete this book. Based on my initial 80 or so pages, i like it a lot.
   
   See my blog http://ilovethexbox.blogspot.com/2008/06/microsoft-xna-unleashed.html for updates to the review.

5 comments about Picture Yourself Playing Violin (Picture Yourself).

1. YES!!! The PERFECT way the understand and learn violin! Take some advice from someone who has tried almost everything, GET THIS BOOK if you want to learn violin!



2. This book is a MUST HAVE to learn violin, I got this book with Mrs. Seidel's Beginner DVD Series, and we absolutly LOVE IT!!



3. This book is perfect. This is the most complete, comprehensive and concise introduction to the violin available.
   
   The book's breakdown is as follows:
   
   Chapter 1: Getting Acquainted with your New Best Friend
   Chapter2: Bowing Techniques
   Chapter 3: Fingering Techniques
   Chapter 4: Music Theory
   Chapter 5: Specialty Techniques
   Chapter 6: Beginner Songs
   Chapter 7: History
   Chapter 8: Continue the Journey
   
   Also included is a DVD that instructs you on every concept in the book as well as a performance, with metronome, of the beginner songs.



4. This is a pretty good product, but the DVD is definitely a do-it-yourself job. It's a bit hard to navigate the DVD menu which is not organized very well.



5. The book covers all the basics needed to learn and maintain your violin and very easy to use. The dvd is great companion to the book as well. Recommended for any beginning violinist.