5 comments about Python Pocket Reference (Pocket Reference (O'Reilly)).

1. I concur with the other reviewers that this book contains useful information but IT HAS NO INDEX, and FINDING that useful information is non trivial.
   
   What were O'Reillys thinking? If a third edition ever appears, and if it has an index I'd be glad to buy it as the book does seem to pack a lot of information into a small compass.



2. This is a great book for anyone who uses Python, especially for programmers at that level of Python competence after the beginner stage but short of a master's fluency. It provides a brief but clearly organized summary of Python basics: the language, primitive data structures, printf and other control codes, and the basic, everyday subset of the support libraries. And, since the editors apparently listened to criticism of earlier editions, the third editions includes a useful index as well as table of contents.
   
   Some readers will be disappointed that it's not the book that it never meant to be. It never meant to be a tutorial or text book, it never meant to be a full specification of the language and libraries, and it never meant to be an encyclopedic description of the many available libraries. Decide what you want: if that's a quick reminder of Python's most useful basics, then this book will meet your needs.
   
   -- wiredweird



3. I read various reviews complaining about the lack of an index. Well, it does have one now and it complements perfectly what is a fantastic quick reference for many of your Python needs, from built-in modules to regular expressions. Of course, it does not include the formal grammar of the language, a complete reference of libraries available or anything other than quick pointers for someone who already knows what Python is but is not a guru yet (although anyone can forget how to open a file from time to time).



4. After reading the excellent C++ Pocket Reference, I decided that this book was worth a try, but I was disappointed.
   
   The last half of this book is a list of module functions, that are MUCH more easily accessed thrugh the online documentation. I wish it was more a reference about the language than about the built-in modules. I don't remember (and I can't find it in the book index!) reading explicitly how to add an attribute to a class, or other language-specific operations.
   
   Being a pocket reference, the language should be concise, but sometimes it is so obscure to be nearly incomprehensible.
   
   Let me also point out that it is more than three years old, so it was not updated to cover Python 2.5, and of couse the upcoming 2.6 and 3.0. Furthermore it tries to cover many versions, with even some references to the 9-year old 1.5 release. I believe the latest would have been enough.
   
   In no way this can replace the modules online documentation, not even as a quick reference.



5. Python is a fast and easy to use language, though learning how to think in python, especially if coming from a more c-style language can take a while regardless of what book you're reading. This book won't help you with that. What it will do, is provide you with most (if not all) of the most-advanced features of python in a way that is really easy to digest for an intermediate/upper-beginner level python programmer. This book explains things that are not easy to find on the web or not apparent that they even exist in python (because, let's face it, python can be pretty magical at times). This book can be the catalyst that puts you well on your way to becoming an advanced python programmer. And all that from a tiny reference book!

5 comments about Agile Retrospectives: Making Good Teams Great.

1. I refer to the activities in the book all the time. It really gives a fresh look at the retrospective and keeps the team engaged. It's very easy to come out with some actions to carry forward which the team is committed to doing.



2. This year, I found myself leading an agile development team. While I've been in the software industry for several decades, I'm new to agile. I was lucky enough to attend the Agile 2007 conference, where I participated in a session with Esther Derby and Diana Larsen. That's where I first learned about retrospectives - from the co-authors of this book.
   
   First, the idea of retrospectives, as opposed to post-mortems (are our projects really dead?), as an ongoing process is challenging and exciting. Rather than waiting until the end, reviewing not just progress but the state of the team makes great sense.
   
   Then, the way that they put it all together - stating the value of the process, giving an outline for how to conduct a retrospective - makes it something you can indeed do right from the book.
   
   But as much as anything, the exercises/activities that make up a large part of this book are a tremendous value. Rather than trying to figure out "what should we do/say in a retrospective?", we are guided through combinations of activities to help us achieve the most effective results.
   
   And it's not just about agile. While the concept has developed through the growth of agile development practices, this is a tool that can benefit any organization of any type doing anything.
   
   It's a quick read with benefits that far outweigh the time it takes to read it. Ready to change the life of your organization? Introduce retrospectives.



3. This is a really useful book. Most practical. Being into scrum (sort of) for 3 months, we've tried to change our retrospective meeting agenda applying methods from this book. We did this just once as yet, and applied only a single combination of methods from virtually countless variants possible. The result is great: retrospective meetings became more meaningful and fun.
   
   Every scrum master (and anyone leading retrospective meeetings) should read this book.



4. I have read at least 10 books of the Pragmatic Series and this is the first one I couldn't finish because it was so terrible (I actually threw it out). This book is exactly what is wrong with corporate culture. Placating overly sensitive employees who need emotional coddling instead of trying to improve the process of software development. I prefer to work with adults, that have the maturity to get their emotional needs fulfilled outside of work, so time at work can be spent being productive. This book should have been titled "Cloy Retrospectives" or "Agile Dianetics". If you are looking for a worthwhile, and even entertaining, book on software management see Managing Humans by Michael Lopp.



5. This is one of those "common sense" books. It's full of really obvious practical advice. The difference I found however is in the multitude of simple and practical exercises it contains.
   
   The book is a really quick and easy read. It's now constantly on my desk as a reference. I plan to use a few of the exercises in our next retrospective in a week.
   
   Whilst this is an agile/scrum focused book, many of the exercises could be easily adapted to other "review" type situations in business and teaching.

No comments about New Perspectives on HTML and XHTML 5th Edition, Comprehensive (New Perspectives (Paperback Course Technology)).

5 comments about Mastering MATLAB 7.

1. I use this book everyday. It is easy to find what you need right away. Although, MatLab has demos that you can use to write programs or m-scripts, the book has features that are not in the demos that will make writing scripts much easier. It doesn't go into great detail with more difficult plots but allows for the those who just need 1-D, 2-D and simple 3-D plots to plot data points easily and fast. This is definitely the bible for first time users of MatLab.



2. I purchased this textbook for the matlab course taken in university. I always can find something interesting or useful inside of it, and knowledge inside of it was all written in details.



3. This book was presented at a much lower level than I expected. I would find it hard to "master matlab" using this book, but I suppose it is good for people with very little programming background. If you know how to program and simply want a book to quickly bring you up to speed look elsewhere - this book is a somewhat watered down and slow.



4. This book is very good if you are a not familiar with matlab. From the beginning it gives you the possibility to understand matlab world with many practical examples. However if you are looking for a detailed description of specific arguments i.e, polynomial interpolation, p.d.e., neural networks, then it's better to give a look to other books.



5. This is a huge and comprehensive book about MATLAB but definitely not for beginners. It can also be used as a reference. It covers everything you need to know about MATLAB - even classes and object-oriented programming. However, if you are just beginning to learn MATLAB, you may want to check the book "MATLAB for Beginners: A Gentle Approach".

5 comments about XML in a Nutshell, Third Edition.

1. O'Reilly's XML IN A NUTSHELL is, like all entries in the Nutshell series, a desktop quick reference. It provides concise information about nearly all matters of XML, and is split into roughly four parts. The first introduces XML, the concept of tags, well-formedness, Unicode, DTD's and schemas, namespaces, and so forth. The second provides an overview for the many formats that are built upon XML, such as XHTML, XSL:FO, Docbook, etc., and technologies that plug-in into XML, namely XSLT, XPath, XLinks, XPointers, XInclude, and CSS. The fourth covers DOM and SAX, the APIs for dealing with XML. Finally, the book ends with a "Reference section" for various technologies covered earlier in the book, structured much like O'Reilly's pocket guides. I found the Reference section somewhat inconvenient, it causes flipping back and forth when each section could have been simply integrated with the previous discussion of the relevant technology earlier in the book. Furthermore, the book ends with a long series of Unicode character tables, which are of limited utility, as they cover only a portion of Unicode, which has already expanded in the time since, and these tables simply bloat the book a little.
   
   This third edition is especially admirable for its advocation of schemas, whereas many other XHTML publications would mention only DTDs.
   
   XML IN A NUTSHELL is emphatically not a tutorial for XML, in spite of the friendly introduction to the markup language that opens the book. For each of the technologies mentioned herein, you'll want a separate book. For XPath especially, O'Reilly's XPATH AND XPOINTER is worth getting. XML IN A NUTSHELL instead provides only a quick reference for matters the reader is already acquainted with. Now, much of this quick reference information can be freely had on the Web. I'd recommend the book only to those who are fortunate enough to have someone else cover their book expenses, or can get it from their library, or those who simply adore print documentation.



2. This book claims to be your only needed guide in XML and related topics. It covers almost all you can imagine. I liked it very much and glad, that I have a book, that I can use like XML reference.
   I have just nothing to say about this book except it contains ALL information one can need on XML.



3. This book is by far the best book I've read on XML. Typical of O'Reilly "In a Nutshell" books, the converage of XML is fast paced and complete. Your money will be well spent on this book. I even think most beginners will do well with this one!



4. XML: the grab-bag, so-what-you-will, make-it-up-as-you-go-along, there-are-rules-strict-rules-(sort-of) technology that bends you to its will as much as you can bend it to yours. And this book is a decent round-up of the most common, widely-deployed implementations -- with enough general knowledge to help you sort through the more specific ones (or help you in creating your own).
   
   A better title for it might have been: "XML: A Developer's Almanac". (Which, I suppose is a good-enough alternative title for any book in the O'Reilly "Nutshell" series.)



5. The book is a reference for all XML standards ( XML , XPath , XSLT , XLink , XSL-FO , XML Schema , DTD , Xpointer , Xinclde , CSS ) and also covers DOM and SAX for manipulating XML , although the book covers the basics of XML in the first five chapters , the rest of the book assumes you have experience with the XML standards and need a complete reference for them , and the book do thr right job for that :) , it's the best reference available for XML .

5 comments about Adobe ColdFusion 8 Web Application Construction Kit, Volume 1: Getting Started (Web Application Construction Kit).

1. ColdFusion Web Application Construction Kit: Volume 1 is better than "ColdFusion for Dummies" or the "ColdFusion MX Bible". The authors describe how to use coldfusion tags, databases and SQL language to build applications. The descriptions and samples are easy to understand, and good tips are given throughout the book. Even experienced developers will learn how to create multi-tier applications. Can't wait to get Volume 2 and 3 for my bookshelf!



2. Having paid $30 for this book, I expected to have more than what it had in it. It had some pretty good examples and explainations, but just didnt have enough in the book for what I paid for it. I have 4 books on Coldfusion and this is the one I probably use the least. But one reason for that is that a lot of the features they talk about in the book are new to CF8 and my website is running on CF7 so I cant deploy many of the applications in the book. But still had great practice applications I can test on my Development server and see the new features though.



3. I have been coding CFML since Coldfusion 5, and I have long used the Cold Fusion MX book as a reference in my daily work, so I was happy to get the new books to help with using some of the newer features.
   
   So this is a large jump from my book for version 6, there is a lot more in the book, but also a lot less. I went ahead and got all three books in the series, and one of the things that I found was missing was the CFML tag reference at the end of the book. I know that sometimes I do work while on the road, and so do not have internet access, but they seem to only want to have that information on-line.
   
   In my review of Volume 3, I did complain about half the book being on-line only and not actually in the print book. When you buy a book, it is nice to actually get the book.
   
   I am far from a new user of Coldfusion so I can not speak of how well it teaches the language, but as a long time user, I do find this series as a nice reference. One things that does seem to be missing is talking about which of the features are new to 8, which were added in 7, and so on. I know that in my development, I need to constantly support customers who are on old version of Coldfusion, so that would be a great thing to have with the Tag reference.
   
   Hope this helps people out there...



4. The book is filled with typos and missing information. It references files and folders that do not exist and doesn't explain where to get them. It is a waste of time expecting to learn anything from this disaster of a book. If you've already bought it, return it and try another book, because this one is garbage.



5. If you are brand new to Coldfusion and the database side of web, this book will make you a little crazy. I'm about halfway through the book and have had to jump online several times to find our why things weren't working out for me the way they were outlined in the book. Several small, but VERY important steps are left out. Overall, it's not a horrible book, just be prepared to supplement your reading with online help if you are a beginner.

5 comments about Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software.

1. After the first chapter I was skeptical. After the second I was depressed.
   
   This is the kind of humour that I imagine really motivates low level techies who assemble computers for a living and makes them feel superior to the entire world because they can plug in a video card. Remember the tech guy that insults you from "Saturday Night Live"? To be clear its intellectual arrogance about stuff that's not that intellectual.
   
   This is the field I'm going to base my life's work on. I don't need to read how hard it is. I want to read about successful projects and how ppl coded great applications. I mistook this book for "Beautiful Code" which I'm guessing is a lot closer to something I'd like to read.
   
   I wish I could send this book back but it was bought as a gift for me in an airport. Its seriously demotivating for an aspiring programmer and I imagine that the author is quite pompus for somone stating some pretty obvious stuff.



2. If you are interested in software development...read this book.
   
   If you aren't interested in software development...read this book.
   
   If you've always wondered why software development is such a tough thing to manage and predict completion...read this book.
   
   Did I say that you should read this book? :)
   
   The book is not a detailed "how to"...it is a story that follows the development of "Chandler", a software product that was going to 'change the world'....but of course, the product never really materialized. The team worked on the product for more than 5 years and never produced what the founder, Mitch Kapor of Lotus 1-2-3 fame, had envisioned. 5 years, over 4700 bugs and two dozen programmers with very little to show for the effort.
   
   Take a look at the Related Articles below...you'll see that Chandler is just now coming to be a "1.0" release after 7 years of development. Interested story and a great book.
   
   If you find yourself perplexed about the process of software development, this book might help you move a little closer to understanding the complexity of this process.
   
   Definitely recommended reading.



3. 
   I just finished reading an amazing book: "Dreaming in Code" by Scott Rosenberg. Like many good, recent non-fiction books, it alternates between a specific narrative with colorful real people, and general background information. In this case, it's the story of Chandler, a personal information management tool, and the team who are building it, led by Mitch Kapor.
   
   The general background explains far more about real, contemporary software, how it is built, and what it's all about, than anything I've read before. Everyone learning to be a software engineer, or who wants to understand what software engineers actually do, should read this book.
   
   In only 355 pages, Rosenberg discusses, in clear language that's easy to follow, at least the following:
   
   * What working on a software project in a team is like, the subjective experience
   * Open software, and the "Cathedral vs. Baazar" concept
   * Doug Englebart's ideas (very germane to Chandler)
   * Famous software fiascoes
   * Computer languages, especially Python and how it compares to others
   * Reusable software, software libraries, build versus buy
   * What "geek" really means
   * CVS, Bugzilla, and Wikis
   * Why user interfaces are so hard to design
   * Dependencies between parts of a system and how they block work
   * Release management and scheduling
   * Specifications and their nature
   * Layers of abstraction
   * Scaffolding
   * Code reviews
   * WebDAV and CalDAV
   * Microsoft FUD
   * Requirements analysis
   * Methodologies: waterfall, agile
   * The gist of No Silver Bullet and The Mythical Man-Month
   * Ruby on Rails
   * Software engineering, its history and what it means
   * Complexity
   * Late binding
   * Object-oriented programming
   * Recursion
   * The halting problem
   
   The story of Chandler and the team is compelling and instructive. On page 173 of the book, he says: "By now, I know, any software developer reading this volume has likely thrown it across the room in despair, thinking, `Stop the madness! They're making every mistake in the book!'" I did indeed feel that way by page 173. Here's my sense of what went wrong, based on the account in the book:
   
   * They did not have one architect (Brooks makes a very good point about why there should be a single person)
   * They didn't work out the architecture in advance, and they went back and changed it many times
   * They had a very flexible data concept/model, in which items change type frequently in a user-visible way, which they didn't work out until quite late
   * They kept changing their mind about their UI substrate: wxWidgets? Mozilla internals?
   * The software ecosystem changed around them after all those years, and using a Web UI now made sense, but it was too late for them
   * They could not figure out what database technology to use (they finally decided not to use the Zope Object Database, although their reasons for that decision don't impress me)
   * It was originally supposed to be peer-to-peer, but they could not figure out how to make that work, so they changed it to be server-based, a major change very late in the design
   * They had to design a security model for all this
   * It was all extensible, which is great but takes a lot of work to do right
   * There were complicated semantic issues with sharing, "chain-sharing", etc. which were not worked out early.
   * They wanted to have extensional and intensional collections, like iTunes, but also wanted to combine the two (the so-called "exclude Bob Marley" feature), which makes the semantics a lot harder
   * Their internal terminology was inconsistent, symptomatic of a lack of architectural integrity
   * They did serious requirement analysis only late in the project
   * It was putatively open-source, but it was much too immature to really get outside developers involved
   * They were too focused on doing "the right thing" instead of getting something out fast; see Gabriel's "Worse is Better" paper
   * They released much too early, partly because of the glare of publicity due to Mitch Kapor's involvement
   
   I see that they are still in "preview" releases. This has been going on for six years now! They have no projected release date for 1.0. It will be free, under the Apache license.
   
   I have always wanted a good personal information manager, and a lot about Chandler looks very promising. Someday I may be a happy user. Right now, I think I'll wait until release 1.0.
   
   I hope they have moved beyond the problems illustrated in the book and are running smoothly now. Kudos to the whole Chandler team for letting Rosenberg be so involved, being so honest with him, and letting him produce this unique, spectacular book.



4. i'm a sucker for any book on the margins between philosophy, social issues and computers, how and why they are shaping us and our communities.
   
   this is kind of what the book is about.
   to get a decent quick view of it, read chapter 10- engineers and artists, i think that the main points are on display here.
   
   a few new words like dogfoodable.
   a few new ideas i want to follow up on: leaking abstractions
   
   it is a watchful eye on a software projection-chandler with the other eye on what it all means. why is interfacing people with machines hard? what is slippage and why it always happens? but basically a beginning analysis of why writing software poses some curious philosophic and practical issues.
   
   i liked the book, a worthwhile read, look at chapter 10 and see if it warrants your time as well.
   thanks for reading this review.



5. I've not enjoyed a book this much since I read Steven Levy's "Hackers" - the behind-the-scenes stories and discussions are just great. I'm not a programmer by trade, but I dabbled a bit in high school and got some more in-depth training in college, but it wasn't my major... a book like this makes me realize not only the fun I may have missed but also the stress I may have dodged. The book definitely provides the ups and downs of the software development business. I especially enjoyed getting a deeper understanding of the Open Source movement and discovering that it too has its built-in problems and isn't the wonder-tech that some books and articles might try to paint it.
   
   The best part of the book was reading along with each release of Chandler... .4 then .5 then .6... and now I visit the actual website and see that they did make their 1.0 release! The book just made my investigation of the actual product and its support/help/website that much more fun.
   
   Great book! I'd love to see similar books done like this down the line.

5 comments about Beginning C ++ Through Game Programming, Second Edition.

1. First of all you have to keep in mind that the purpose of this book is not to teach game programming, but C++ programming. With that in mind, don't expect to learn graphics, AI or anything like that (except for some extremelly basic concepts).
   
   However, in teaching C++ it succeeds. But it doesn't go much deep into anything and it is somewhat disjointed. If you can't be motivated by anything but game programming and can't stand to learn any other way, then pick this book - if you really want to learn pick another and this book to give you some (very basic) basics on game programming.



2. Seriously this book is the best I have read yet when I first started it I was a newbie programmer but the way micheal dawson explains the c++ fundamentals keeps things fun and exciting this is one of the only c++ books you can find that isnt dry or boring think of it like being in a game industry school he has you apply your new skills in projects by the end of the project you learn what you need to learn and quick you wont want to miss this book I guarantee it!



3. This book was nothing more than another poor purchase decision on my behalf. Written towards the audiance of those who ought not be reading it in the first place this book takes on an annoying simplistic tone. Reading it is like sitting through the basic trig review before taking multi var calculus, the most complex example is a cheap command line version of blackjack.
   
   If you have any computer knowledge at all and you purchase this book I can guarantee you that it will be one of the ones that just sit on the shelf and make you look smart, never to be opened.



4. (In reference to 1st Edition) As my title suggests this book is a pretty good introduction to C++ using basic games as the subject of the examples and exercises. Its main focus is on teaching the fundamental aspects of C++ for beginners and how to use the Standard Template Library (STL). Creating games is not really the focus as much as the the chosen subject of the examples and lessons. That said, what this book does, and does fairly well in my experience, is give a good overview and introduction to C++ and how it can be used to create the basic flow structure of a game program. Console text output is the focus, not windows programming. Those with more programming experience and looking for material on 2D or 3D graphics, or event scripting and control using C++, would be better served by another text as it does not address these subjects at all.
   
   I have used this book successfully to help teach teens fundamental C++ and the basics of game programming (within the limits described). It is an easy step from here to go to basic text adventures and RPGs, and a then onto adding graphics, etc. as a more advanced topic (using other texts). This is really a natural progression for someone who wants to learn programming and games, but perhaps not for someone who wants to design games from an art or interaction perspective. More advanced topics such as AI, graphics, and scripting can really only be learned after one understands basic programming (in C++ or another language) and the basic of how game programs are structured.
   
   I have found many students do not necessarily understand what it means to "program games" or how programming relates to game design and implementation. Beginning C++ Game Programming is a good text but if you are already a programmer and/or not interested in the basic code structure of games then perhaps you should find another book.
   
   Bottom Line: Good choice for a real beginner, who is really interested in learning programming because of games, but not a good choice if you are an experienced programmer or want to make your own 2D or 3D video game "right now".



5. A friend bought me a copy of this book through amazon.
   Both of us (my friend and I) started to learn C++ together through the internet before having this book.
   
   The book is amazingly good, very good structure for teaching the programming language, C++.
   Everything is done in a very interactive way, giving you concepts on how game developers do it, how stuff run in more advanced program.
   And what use every function has.
   
   While it doesn't go into deep details of every possible library and function in C++, it teaches you enough to get on your own and go from there.
   
   After finishing this book, it was very easy to go on and move to DirectX, Allegro and SDL libraries.
   
   Very recommanded!

5 comments about Inside Microsoft SQL Server 2005: T-SQL Programming (Pro-Developer).

1. This book is a must-have, even for those who uses other SQL Databases... Totally Amazing!



2. This book has lots of sample code for developers to follow. I bought a book "Advanced Transact-SQL for SQL Server 2000" written by Itzik Ben-gan about five years and loved the book. This book did great job in the SQL Scripts where you might need to spent sometime read through it.
   
   This book is a gem for SQL developers!!! Highly recommanded!!!



3. You should think of this book as of the second volume of the two-volume set on the 2005-Server SQL. If you get this one, you'll get the other one too; neither tome is self-sufficient; in fact there's a lot of explicit interdependence. This book, Programming, deals with slightly more esoteric features than the first tome, Querying -- although I can't say you must read the first entire volume before touching this one. Both books can be read at the same time (but see what I say about the target reader below).
   
   So, real quick:
   
   1. Target reader: someone with a good grasp of the 2000 Server wishing to learn the new stuff that came with the 2005 server (there's a lot: the 2005 product is _much_ better than the previous: covering new features is probably the only thing that's unequivocally good about this book). This is NOT your first, nor second, nor third book on SQL in general or MS SQL Server in particular. You must have a good grasp of the basics to be able to overcome this book. I say 'overcome' advisedly; more on it below.
   
   2. Content: Data-type subtleties (datetime, xml, CLR user-defined types -- a lot of CLR in this volume); temporary tables, cursors, dynamic SQL, views, user-defined funcs, stored procs, triggers, a bit on transactions, exception handling, a bit on service broker.
   
   3. Very clean technically: no technical errors (and while we're here: I found no typos either).
   
   4. Depth vs breadth: the book is more extensive than deep, although on average it's (inevitably) more in-depth than the first volume. Some reviewers here say it's very deep or difficult -- and difficult is true, although not because of PhD anything. This, unfortunately, brings me to the next point:
   
   5. Writing: ABHORRENT. (Both volumes, Querying, and Programming, in about the same degree). That's why it seems difficult, PhD and so on -- except this difficulty isn't due to, say, conceptual complexity of the subject matter. It's the authors' extreme inability to use the English language to explain things that makes reading this book such a chore. There is also conceptual muddle (unsurprisingly: people write as they think).
   
   Now, experience taught me to forgive literary incapacity to a _technical_ author (to a degree; and I do take notice and, if possible, avoid him in the future). In cases like that I put the blame squarely on the publisher, especially if otherwise I know the publisher to be solid. I have a pile of books from Microsoft Press and I consider them a good publisher, so what's the matter?
   
   Although (strangely) a bit better than the first volume, this book (Programming) is also strewn with unimaginable, fantastic garbage of every possible kind, from grating usage errors to a pervasive lack of unity, coherence, and logical connectedness on the page/paragraph level, to a frequent lack of the overall unity. When I bought this book and read it a bit I was so p-off I almost sent it back (I got as far as getting an RMA from Amazon). I did keep it though. Both of them, actually.
   
   Do I recommend this book? It has been useful to me (especially the UDF section: there's a lot of new stuff, all very handy), so -- with great reservation, and only to the right reader -- yes, kinda. And please check out what else is available (there's tons of books on the 2005 server these days). The Programming book is part of the three-volume update and extension of the server-2000 version by Delaney. Delaney's server-2000 book was extremely useful and quite decently written. I wish they let her write the new version, even though it's now three books instead of one, and I suppose it's difficult for one person to do it all.



4. Please see review by C. Mialaret. S/he is spot on.
   
   One gets the impression that the author may have been more focused on impressing you with his eruditeness, rather than writing a practical book with useful examples and clear explanations.
   
   Affecianados of Kalen Delaney's 'Inside SQL Server 2000' will be disappointed.



5. Book actually has very limited T-SQL. Mostly triggers, USP, functions, but little actual code.

5 comments about C Primer Plus (5th Edition).

1. I tried couple of C books but, never worked.
   C Primer start from the scratch and go through
   all the topics which a beginner should know
   very well.
   The book is thick and has lot of assignments.
   It helps new C student to grasp the language
   easily.
   I recommend "C Primer" for the beginners of
   'C'.



2. I have just started reading this book the day before yesterday and I'm only on pg.124 in ch.4 but I already know that this book is a must have for any beginner in C and with their index in the back of the book tells me that it is a great reference guide for veterans of C. I have read other programming books like Teach Yourself Visual Basic 2005 in 24 Hours (which is bad book-doesn't teach very well) and I have to say that this is one of the best programming books out there and it is a must own for any C programmer!



3. This is simply put the best beginner book I've found on C.
   
   I've been reading it for over a year, and have yet to finish it all of it.
   
   It covers all the C language aspects (and also the C99 extensions) and provides lots of exercises to train your skills.



4. Over the years, as I've flirted with the idea of really sitting down to learn C, I've looked at a variety of intro-to-C type books; I've even bought a couple - only to set them aside to collect dust. This book (C Primer Plus, 5th ed.) is, frankly, one of the best intro books I've seen. I've read the first 13 chapters thus far and have been very pleased with the content. Topics are presented logically, explained well, and include numerous sample programs in the text body to reinforce newly introduced ideas. If you take the time to walk through the sample programs, look at the review questions, and work on the end-chapter programming exercises, you'll be in good shape. This book is worth every bit of the purchase price; it will stay in my personal library for years to come and I will highly recommend it to friends and colleagues looking to learn core C programming skills.
   
   Note: I do have basic programming skills in other languages, but I think this book would be fine for any "true" novice as long as they gave themselves time and diligently worked through the exercises.



5. This would be a great book if not for the fact that the first 100 pages are about printf() and scanf(). The beginner does not need to read technical specs on these two functions. That's what the C99 spec is for. It just goes on and on and on. What the author should have done is very gradually introduce these important functions over the course of several chapters, mix it in with control statements, expressions, operators, etc. with a more complete and in-depth coverage saved for an advanced chapter on functions.