5 comments about Programming in the Key of C#: A Primer for Aspiring Programmers (Step By Step (Microsoft)).

1. Charles Petzold, a veteran of technical book writing, proves himself in this book (again) to be a brilliant teacher. At around 420 pages it's slim in comparison to other Microsoft text books. Part of the reason is that, concentrating solely on the C# language, no screen shots take up space that is more effectively used to explain key concepts of this language & how it fits into OOP. If you're a VB programmer, (as I was) looking to get into C#, this is a great starting point. It does begin at the beginning, (Variable types etc) but don't let this discourage you as there are some subtle differences that you need to learn about which could save confusion in the future, for example, that there is much less in the way of implicit conversion of certain types & this must be taken care of in code. However, this section is a brisk read, & Petzold's clear explanations are enlightening. He really makes it easy to understand how to use this language with some good examples throughout the book. There is nothing about the IDE or controls & just enough on the Framework, but what he does introduce, he explains in depth. This approach keeps his focus on the language which is what this book, after all, is all about.
   
   You will need more once you've read this, but it's an excellent starting point, won't take you months to work through & most importantly, you will `understand' it at the end unlike other books which confuse the explanations with assumptions that you already know some C++.
   
   If I have any problems with this book, it is only that he didn't cover Indexers & Delegate creation as these are not particularly difficult concepts & are important & I'm sure his explanations would have been excellent, but you'll will have to read further to learn about those. Developers coming from a C++ background may want to read something else which encompasses the framework, but for a VB'er, it's a perfect starting point & an excellent reference.



2. Programming in the key of C# aims to introduce the programming language, C#, at a basic level. It covers fundamentals of modern objective programming features such as namespaces, classes and instances. It also reassures readers of what basic data types are supported in C# which follows the footsteps of .NET Framework.
   
   The book is more of a primer than specific (i.e., a book could be based on data structures or producing games). If you are looking to buy a book, and you are an elementary programmer you will find this book very very helpful in terms of learning C#. If you are a regular java, c and c++ developer you will also find this book somewhat helpful in terms of understanding some of the core technologies behind .NET Framework and C#'s language features. Otherwise, if you are looking for something that cover much more integral aspects of C# this book perhaps, isn't for you.
   
   In prelude, it states that the author tried his/her best to avoid making assumptions about any prior programming experience - thus the coverage of some elementary level basics of modern objective programming features.



3. Petzold's 'Programming in the Key of C#' is absolutely for beginner programmers and is written with them in mind both in terms of style and content...sort of.
   
   Late to the C# party, I decided to learn the language prior to a couple of new job interviews. I saw this and grabbed it, thinking it would be just what I'd need. Already knowing Java, C/C++, JavaScript and a bit a Visual Basic, I'm a bit disappointed that the subtitle isn't more specifically addressed to beginning programmers. Programming is a very large subject and all developers/programmers are each at his/her own level. We are all 'aspiring', aren't we? A 'primer' can be quite technical, but this one surely isn't and I blame myself for a wrong purchase -- I should have read a few more paragraphs prior to buying this book.
   
   To wit, the book doesn't even begin discussing arrays (the most basic data structure of them all) until chapter 18. This is not necessarily a bad thing, but many beginning language books address arrays far, far earlier. It's difficult to learn much about a language's capabilities or learn much general information about programming without knowing about and having some experience with the array (specifically the ability to store objects and the ability to create dynamic data structures). The book doesn't even breach linked lists except for one quick mention in passing near the very end of the book. For another example, Petzold only gives one cursory example of recursion (the ubiquitous factorial program) and doesn't really go any deeper than that. Anyone who is an 'aspiring' (absolute beginning) programmer really should be given more than this when presented with such basic material.
   
   Nonetheless, the writing is in a good, easy-to-read style and I've enjoyed skimming through it. Petzold presents background information about the language and uses real-life examples and good little toy programs to illustrate the programming concepts he is discussing. It's altogether a good, easy read. Most of the main topics needed for a very general understanding of the language are presented such as virtuality, inheritance/polymorphism, parameter passage, constructors, etc. and all in a logical sequence that builds up the reader's knowledge.
   
   One serious flaw with this text is the lack of questions at the back of the chapters. In learning other langauges, I've found that a series of questions at the close of a text's chapters helps to hit home the concepts that chapter is teaching. Walter Savitch's Absolute C++ is a very good example of an excellent text that gives the reader much more in terms of small programming assignments, quiz questions, and review lists of terms and concepts.
   
   Although I already know much of the material here, I'm giving this book only 3 stars not because its content is so simple; rather, it is too simplistic. Beginners need a thorough grounding. Since this is the audience for this text, I expect one can do better.



4. The book is very easy to follow. The first chapters are really
   for beginners. But I regret that the classes methods are explained with
   trigonomety examples not that easy to follow even if the explanations
   are there. Also it will have been a better idea to explain objects , classes first then later try to explain a class method class. The book is nice but most of the examples use by the author are maths examples and trigonometry, the last think i was expecting is a trigonometry example to explain to me how a method works. Easier method can b e found in : C# 2005 for dummies. Actually the purchase of both books good be a wise idea.



5. A lot of people are interested in C# now thanks to XNA Games Studio Express and a lot of us have never programmed before. I sat at the book store and read the first few chapters of every C# book I could find and this one is by far the best for beginners like me. I'm through chapter 4 now and realize that if you're looking for a starting point with C#, this is it! It's clear, simple and seemingly written for idiots like me. :)

3 comments about Sams Teach Yourself Ajax, JavaScript, and PHP All in One (Sams Teach Yourself).

1. Firstly, when a book is about a constantly changing web-programming technology like AJAX, you expect it to be up-to-date, right?
   
   Well, two chapters in, and I've already spotted several typographical errors. What's worse is the outdated nature of some of the technologies depicted in the book. Let me illustrate:
   
   Chapter 1: When illustrating assorted web browsers the text uses IE6. I'm sorry, but IE7 has been officially released for nearly two years now, and you couldn't be bothered to upgrade the screenshots in that time? This book was published June 2008, with a 2009 copyright, and you're using screenshots that were outdated in 2006?
   
   Further, the fact that the screenshot of Firefox in the first chapter shows that at the time of the screenshot, Firefox 1.0.7 was the current release shows that that was taken mid-2005, as Firefox 1.5 was released November 2005.
   
   I'm sorry, but these over-two-years-old screenshots of antiquated technologies featured in a text, and the fact that it seems to feature IE6 throughout already has me somewhat turned off to the book. If this is the attention to detail that they have paid thus far, what will have slipped through the cracks in the programming portions, and what other techniques were already antiquated by the time this book was published?



2. As has been said in a previous review, this book already seems quite dated after only the first two chapters. Having completed the book, I can say it only got worse. Much of the basics are covered fairly well, but as the book progresses into more complicated areas, where more detailed explanations are really needed, it fails to deliver. Some of the example code will not even run without error. It seems the book is a "best of" compilation thrown together from bits of previous books, but purported to be a new work.



3. No previous Ajax programming experience is needed to use this book, which provides step-by-step lessons on using Ajax, programming with JavaScript and PHP, and understanding their technological foundations. The cd includes a complete Ajax programming starter kit with all tools needed to set up a learning and testing environment, while the pages of black and white screen shots and applications provide all the detail necessary to follow through. Both computer libraries and college-level courses will find it a winner.
   
   Diane C. Donovan
   California Bookwatch

2 comments about Java Concepts for Java 5 and 6.

1. Unlike most Java textbooks, this one actually does a reasonable job of downplaying the reliance on I/O and throwing everything into one method. Test methods are separated from methods which actually do computation.
   
   (Two stars is about twice what I rate 90% of the intro-Java texts out there :-)



2. I needed this book for a CSIS class in programming Java. The book does the job and is easy to understand.

5 comments about Ant: The Definitive Guide, 2nd Edition.

1. This book can take you from zero Ant knowledge to being productive in a matter of days. After starting with some simple examples, it builds up the following concepts very well: properties and types, compilation, deployment, testing with JUnit, working with CVS, and Eclipse integration. I skipped chapters 8, 9, 10, and 12 because I did not anticipate a need for them right now. However, if I need to know about web deployments, working with XML docs, optional tasks, and extending Ant I know that this book covers these things too. To get the most out of the book, you need to download ant to your computer along with the example code from the book's web site. It is very easy to modify the code and see how different options for the various tasks work.



2. This book provides a good enough introduction to Ant, but it only takes you to the point of knowing how to use Ant and not the point of knowing how to use ant on a project of any size. As an introduction it works well. You learn how to get up and running with Ant very early on in the book, and you learn all of the key tasks rather quickly as well. Everything is explained clearly, and it seems reasonably organized. What it lacks is really any explanation of various best practices for using ant, whether on a small program or a large one. For a book of this size, I was surprised at the absence of this info and ultimately I felt that it was only a bit more useful than the free online docs for ant.



3. Apache Ant is the primary build tool for Java projects and this book is excellent introduction to it. Although the title is misleading - this is not really a definitive guide (its not really reference book for starters), it is well written and easily understood. If you work through this book from start to finish then I'm confident that you'll come out the other end as an Ant expert.



4. Web research on Ant revealed a lot of explanations, but they were very hard to understand. And I didn't want to waste time scratching my head. This book explained what Ant is and how it works in an approachable way without insulting my intelligence. The author obviously has a lot of experience in Ant and many of the other technologies it interacts with. While other comments have pointed out that it's not a reference, I can easily get those other details on the internet. This book got me up and running with Ant quickly and painlessly. It contained useful examples that actually worked when I tried to follow them.



5. This book is a regurgitation of O'Reilly web material. This book had a real opportunity to discuss Ant internals or at least something that can't be found on tech sites or the software documentation. Project wikis will undoubtedly replace the need for tech books of this sort.

5 comments about Agile Software Development, Principles, Patterns, and Practices (Alan Apt Series).

1. After reading this text, I feel it deserves the attention of other great texts such as Design patterns and Refactoring, even though much of it's content expounds upon the ideas of these two classics. It's my opinion that this text has two strong points: it explains the ideas and details of agile development very clearly, and it does an excellent job of explaining the most popular patterns originated by GOF, plus a few more. The authors style was very good, with most of the examples in Java. Being a C++ programmer, I would have liked to see more examples in that language, but this is not any fault of the author.



2. I bought this for my brother. Got for a good deal on Amazon. Very happy with the fast delivery by Amazon.



3. It's a great book. As a senior developer with more than 5 year's experieces of Object-Oriented Design, I think this is a valuable pragmatic book about how to do in a practical project.



4. Reader,
   
   This book addresses some of the key reasons software continues to fail. It firmly ends the discussion that was never relevant of 'Agile means you do not have to REALLY known OO design'.
   
   Indeed to be 'Agile' and not create iteratively 'crap', the only real way is via your mastery of OO Design. Long term systems that withstand change do not happen via accidential discovery with a lack of vision and core design at the core.
   
   You can work in software with a lot of gaps, but the content here defines what is mandatory for even moderate levels of interesting work.
   
   Do you agree in the following as a common value of `good' for software?
   
   FROM: http://articles.techrepublic.com.com/5100-10878_11-1050347.html
   
   Good design
   
   Well-designed applications offer software components that are more robust, more maintainable, and more reusable. Such applications should be able to adapt changing business needs without affecting design. For example, a banking application should be able to support new types of accounts without a change in the existing design.
   
   Three key points of good design are:
   
   Maintainability, which is the ease with which a software system or component can be modified to adapt to changing environments, improve performance, correct faults, or other attributes. Well-designed applications require fewer resources for maintenance and changes.
   
   Reusability, which is the degree to which a software module or components can be used in more than one computing program or software system. Reusability of software components helps ensure faster development of software applications.
   
   Robustness, which is the stability of software applications in extreme situations (e.g., maximum load conditions, erroneous user inputs). Robust applications have less downtime and can reduce maintenance costs.
   
   Bad design
   Nobody plans to create ill-designed applications. It often happens because of a lack of experience or because the app was designed quickly to meet an extremely tight deadline. Poorly designed applications usually have these problems in common:
   
   They're rigid. A design is rigid if it cannot be easily changed. For example, a single change to heavily interdependent, rigid software could begin a cascade of changes in dependent packages. When such a program grows in size, the designers or maintainers cannot predict the extent of that cascade of change, and the impact of the change cannot be estimated. This makes the cost of the change impossible to estimate.
   They're fragile. Poorly created programs have a tendency to break in many places when a single change is made. Simple changes to one part of the application can lead to failures in other parts that appear to be completely unrelated. Fixing those problems leads to even more issues, and the maintenance process begins to resemble a dog chasing its tail. Such fragility greatly decreases the credibility of the design and maintenance organization, which leaves users and managers unable to predict the future quality of the product.
   
   
   They're not reusable. A design is difficult to reuse when its desirable parts are highly dependent upon other details, which aren't desired. If the design is highly interdependent, other designers will also be daunted by the amount of work necessary to separate the desirable portion of the design from the parts that aren't reusable. In most such cases, the cost of the separation is deemed to be higher than the cost of redevelopment of the design.
   
   Still with me? Ok..
   
   
   .NET developers historically have lacked (as compared to other OFA (one framework only) developers) at the very, very least) acceptable OO Design skills. I mean even remotely `predictably' acceptable. Sure I worked with many teams who were exceptions but they were all from other (Java/Smalltalk) environments. Even C++ developers can slant to a master of C, deep internals, and Fragile Base Class disaster (grin). So Microsoft would have been nuts as they have always know this to put multiple-inheritance into C#. I digress... This is relevant to the book I swear....
   
   Uncle Bob Martin created a masterpiece here that is still just as (more?) relevant. It is utterly transformative for anyone who wants to be even remotely productive on a team of best-practice types.
   
   FYI this is the book used when I teach 'Core Object Oriented Design for the C# Developer' around the country.
   
   NOTE: Do not let the word 'Agile' fool you. This is a book about best practices in software design and development. Agile just assumes you already know this material, yet most I work with do not.
   
   He provides definitive coverage of the most critical reasons for failure if you skip then. For example, inheritance in OO is wrong for most cases used today in .NET.
   
   Liskov substitution principle
   Read this (covered in detail in this book):
   
   
   Kind Regards,
   Damon Wilder Carr
   http://blog.domaindotnet.com



5. This is an excellent introduction to the Agile Software Development concept for anyone who learns best from examples. Mr. Martin's book is essentially a collection of introductory concepts and principles he has spoken or written about elsewhere. Much of it may be available on the web with some searching but here it is organized logically into 3 major approaches to learning: concepts, principles, and case studies. In the first chapters Mr. Martin takes us on a high flyover of Agile Software concepts such as extreme programming and test-driven development practices. Next he takes us through Java and C++ examples to demonstrate programming with key principles in mind such as "The Single-Responsibility Principle" and "The Interface-Segregation Principle." Finally he sums up the concepts and principles by examples using several real world case studies.
   
   Mr. Martin is a master at this sort of approach to teaching software design. Those familiar with his work will immediately recognize his hand. Some (perhaps most) learn well from this approach and the organization of the book lends itself well to a classroom study or self-directed learning. This is an excellent introduction to an important and timely topic.

5 comments about HTML for Dummies.

1. A few years ago I wanted to learn basic HTML. I figured the best way to do this was to buy "HTML For Dummies" and use it to set up a basic Web site for my church. That way I got both theory and hands on practice. This is exactly what I did, and the book came through for me. I learned enough HTML to set up a basic, but working, Web site for my church.
   
   The only thing I wanted to learn but never could figure out from the book was frames. I settled on tables for navigation since all my attempts at frames failed.
   
   I have since gone on to do a Web site for my cats, a text based site on the subject of the Sabbath, and a Web site to track my weight loss and measurements. I even coded my own little blog at one point.
   
   The next thing I want to learn is some basic CSS to have better control over the Web sites I've created.
   
   I recommend this book to anyone who doesn't know anything about HTML and wants to learn it.



2. I ordered this book along with Web Design for Dummies expecting to get started writing simple web pages. These books are not for dummies. It offers very little explanation of html tags; it doesn't offer pros or cons of the tag usage vs. another tag; examples are not near the explanation-you need to open the cd to view the eample in question. It spent too much time promoting tools and services outside of the "Dummy" concept.
   
   I was very disappointed with this book...I bought another book which out-performed the Dummy series.



3. This is a very user friendly book.
   On another note, I am impressed with the speed that I received my books.
   Thank you Amazon



4. Well I /was/ originally looking greatly forward to this book. I had been a fan of the "... for Dummies" books for a while now. Unfortunately I found this one to be a disappointment. Although I can appreciate having sections on good web page design, I felt it was too much to wait until chapter 4 to code your first page. Plus, there's just too much design-based content in the book overall, and not enough of actual HTML tag-based exercises.
   The examples on the CD ROM are awful. They really don't give any good insight as to how the tags work. Plus, many of the example files are identical. For example, TFOOT.HTM, THEAD.HTM and TR.HTM are the exact same file. That's just inexcusably lazy. How hard could it have been to exhibit some of the attributes of those tags?
   I give it two stars because if you already know HTML, it can be a pretty useful reference. Also, the troubleshooting chapter (chapter 16) was pretty good.



5. I'm never disappointed with Dummies books and this one is no exception. Great read, easy to learn.

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?

4 comments about Programming Applications for Microsoft Office Outlook 2007.

1. Anyone who develops on Outlook should buy this book -- even if you don't have Outlook 2007. The beginning chapters review best practices and underlying architecture that every Outlook developer should understand, regardless of which version of Outlook you're using. Plus, you'll see all the great new stuff in 2007 which you'll want, so you can convince your stakeholders to upgrade. Later chapters drill into the technical details with surprising depth so you can find out what you need with only minimal trips to MSDN. Code samples are generous, albeit limited to only managed code... but that's understandable given the obvious advantages to using it for rapid application development.
   
   The difference between this book and previous attempts to document the Outlook development experience is like night and day. Kudos to Randy and Ryan for understanding what we face and doing an admirable job at enlightening us.



2. This book provides a good basic understanding of the process for programming Office Outlook 2007 plug-ins. It has a good spread of information about all the underlying office/outlook types and objects, although only briefly touches on their use. Demo's of using these objects are provided, covering typical basic tasks, but more advanced functionality is not really shown, though alluded to. The book makes extensive use (for C# programming) of a Shim Wizard which provides the interlinking functionality between the managed code and the COM interfaces. Unfortunately this wizard has been extensively modified since the book was published, and some of the instructions provided are out of date, resulting in the plug-in not functioning correctly. As very little information is provided with the book (and with the Wizard) working through these issues takes some time. The book's website does not include any errata to indicate the correct use of the modified wizard, though the site does contain links to the latest version of the wizard. Other than that the book is well worth it.



3. I found this book quite helpful since I am familiar with C# yet new to Programming with Outlook. My current assignment is to use VS 2008/C# to integrate with Outlook 2003 and 2007, I could apply some of the examples to my needs. Since I need to use VS 2008, then some of the steps are different and stick with events that would work for both Outlook versions, however, I have managed to figure them out.



4. If you're writing add-ins for Outlook, then this book is essential. The small cost of the book will save you days of trying to work out the best most appropriate ways to do things with the new object model.
   Programming Outlook 2007? Writing an add-in? Want to speed up the development time? This is the book for you...

5 comments about The Art of SQL (Art of).

1. I originally really liked the idea of comparing database design to the ancient "Art of War" classic, but the more I read the book, the more annoying and overly cute this tactic became.
   
   Amongst all the verbiage there appears to be really useful information, but extracting that information became too much work for me and I gave up on this book. And there were almost no concrete examples or case studies to back anything up.
   
   So far the most important book I've read is Sql Tuning by Dan Tow. It takes some work, but it is very, very worth it. Try that one instead.



2. I'm torn in giving stars to this book. On the one hand there a number of fascinating topics covered, topics not found in other books in my library. They tend to be of a quite academic nature, discussing the internals of how the optimizer and the DBMS engine work. From that standpoint this book would earn 5 stars.
   
   On the other hand, I purchased the book because I have real-world problems to solve in my job. Despite what the quotes on the back cover and first pages say, virtually nothing covered in this book is of any value in solving real-world problems. The book introduces what seems like a promising new sql construct or optimization idea, describes it in detail, and then unfailingly proceeds to state all the disadvantages of using the new idea and concludes that you shouldn't bother with it. I was interested in finding new techniques to apply to real-world problems, and came away instead with a long list of new techniques to forget about. From a practical standpoint this book would earn 1 star.
   
   So overall I give it 3 stars, an interesting read, but of little value on the job.



3. This book review was submitted by a Roanoke Valley SQL Server Users Group member as part of the Book Review Program.
   
   Reviewed by Jerry Ellis
   
   The Art of SQL does not fall into the trap of becoming "just another reference" for SQL users. It tackles real world problems with the point of view that you know how to write SQL code, but may need help in the proper tactics to most effectively handle them. What is refreshing is that it does not say here is a piece of code that will do this...it says, that may work, but here is a better way and why.
   
   This is the book to have if you want to discover better practices for your SQL.
   
   Jerry Ellis



4. This book is very well written and goes into depth on the practical reasons behind best-practices as well as real-world examples.



5. This is a book in a somewhat-similar vein to Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition) (Addison-Wesley Professional Computing Series): it spends most of its time shining light on the dark nooks and crannies of database design and query optimization, and assumes that you've already at least learned that those dark nooks and crannies exist.
   
   It is also written with the database programmer in mind, rather than the database administrator. There are not many books written for us, and I'm really pleased that one of them is a book this excellent.

No comments about SAP FI/CO Questions & Answers (with CD-ROM)(Computer Science) (Business) (Computer Science).