1 comments about Accelerated SQL Server 2008 (Accelerated).

1. I've just finished reading the "Development in SQL Server" section of this book (i.e. 40% of the total book).
   
   I assumed the book related solely to SQL Server 2008. The book's introduction, forward, back cover content, and free downloadable chapter 1 led me to that belief.
   
   However, the book relates to both 2005 and 2008, and frustratingly it typically does not say what features belong to which database version.
   
   I wanted a book that showed me what was new in SQL Server 2008, I know what is in 2005, I have several books on it! I think the publishers etc have been very misleading with this book's title.
   
   That said, the content of the book is very good.
   
   The book is large (784 pages) and heavy. A book containing SQL Server 2008 only content would perhaps contain only 300 pages, and be more convenient to read and carry.
   
   The book's real title is "Accelerated SQL Server 2005 and 2008"

5 comments about Advanced Programming in the UNIX(R) Environment (2nd Edition) (Addison-Wesley Professional Computing Series).

1. This book is a fantastic starting point in life. Some how our public schools over look teaching the fundamental skills presented in this book. We learn how to play with toys on simple computers and never really learn what we are doing.
   
   The real strength of this book is in the definitions. We get to see the purpose and flexibility of system calls and functions. Not just use them but understand them. UNIX functions as job control or signals are explained in detail. Let's take just one item "waitpid":
   
   The waitpid function provides three features that aren't provided by the wait function.
   
   You will have to red the book to find out what they are. However there are examples also. Now for people with real systems like AIX all you have to do is ad a "k" to the front of the call and you have the AIX kernel function call "kwaitpid"; voila you now have an understanding that can not be found clearly in a Red Book.
   
   It does help some to have a preunderstanding of the system do you can use the book to fill in the education holes missed when necessary.
   
   The index is worth its weight in gold as you can find functions headers and concepts all in alphabetical order. My favorite is the definitions.
   
   As much as I am a fan of the internet it also pays to carry the information in the form of a book. And all this book has to do is save a couple of hours and it has paid for its self.
   
   Mastering UNIX Shell Scripting



2. This book is literally saving me right now in an Introduction to Operating Systems class I'm taking. We have projects to complete in the UNIX envrionment and the fact that this book gives you every real code example you could possibly need for all levels of systems programming is GOLD. It's laid out in a very straightforward way, has tons of code examples, and is overall awesome. Highly recommend if you're just getting into systems programming on your own, or as a school reference book.



3. This is one of the best books I've ever read about UNIX and programming.
   
   With its unique style, it serves as both a reference and a tutorial, and at the same time, it provides amazing detail and insight, always making the reader understand what's happening "under-the-hood". Fantastic job, Steven Rago and Richard Stevens!
   
   The only problem I had with this book was with the source code. It doesn't compile under MacOS X 10.5 Leopard, which is a certified Unix 03 system. It is a only a one-line change in the includes, so it's no big deal.



4. I occasionally need to fix broken IPC code and figure out behavior differences
   of legacy code between Solaris, Linux, etc., code written years ago by somebody
   else in C.
   
   This book, (and Stevens' earlier books before this) has been immensely useful.
   The code samples alone are worth their weight in gold :-). Seriously, this book
   has saved me many days of hard work, several times over.
   
   A quick browse of the book is usually enough to find the details (what I would
   call 'arcane details', but I guess this is because I'm not an expert C/networking
   programmer), figure out the problem AND how to fix the problem.
   
   This book has been a 'project-saver'. I cannot recommend this text too highly.



5. Its a very extensive book that covers concepts and advanced features of UNIX. It covers UNIX implementation of different features as a user point of view and how to access diffent services of UNIX like OSs. If you want to learn UNIX /Linux based programming this book a must read & must have for reference. I highly recommend this book

2 comments about Mastering Microsoft Visual Basic 2008 (Mastering).

1. 'Mastering Microsoft Visual Basic 2008' by VB expert Evangelos Petroutsos is a fantastic way to get up and running with one of the most popular programming languages in the world. Visual Basic has come so far since it's early days and now the reasons for using VB have gone far beyond just RAD (Rapid Application Development) as you can write world-class applications far beyond the most basic tasks you would have chosen VB for 10 years earlier.
   
   Everything that you would want covered is here in this book, from the basics of how to use VB to condition clauses to array and string access to database connectivity and the newest goodies .NET 3.5 has to offer. Written in a clear, concise manner that calmly takes you from one chapter to the next, I found this book to be an absolute joy to learn from. Sybex has a rich history of publishing easy to use computer books that nearly anyone can learn from and this text is no exception.
   
   Chapter Overview:
   
   01. Getting Started with Visual Basic 2008
   02. Variable and Data Types
   03. Programming Fundamentals
   04. GUI Design and Event-Driven Programming
   05. Vista Interface
   06. Basic Windows Controls
   07. Forms
   08. More Windows Controls
   09. TreeView and ListView Controls
   10. Building Custom Classes
   11. Working with Objects
   12. Building Custom Windows Controls
   13. Handling Strings, Characters, and Dates
   14. Storing Data in Collections
   15. Accessing Folder and Files
   16. Serialization and XML
   17. Querying Collections and XML with LINQ
   18. Drawing and Painting with Visual Basic 2008
   19. Manipulating Images and Bitmaps
   20. Printing with Visual Basic 2008
   21. Basic Concepts of Relational Databases
   22. Programming with ADO.NET
   23. Building Data-Bound Applications
   24. Advanced DataSet Oprations
   25. Building Web Applications
   26. ASP.NET 3.5
   27. ASP.NET Web Services
   
   My only qualm with this magnificent book is that I wish some color could have been introduced, especially in the sections that discuss the new WPF way of creating applications. These new style apps are meant to have a great look for the user and I feel the tried and true black/white/grey look hurts the book a little bit but this in no way lowers my rating of it.
   
   ***** HIGHLY RECOMMENDED



2. I am a non-traditional student right now (accounting), and I have taken some Excel courses where we used a tiny bit of VBA. This, along with a database application design course, piqued my interest to learn more about Visual Basic.
   
   It's been a few years since I did any programming at all, and I had no experience with visual programming environments. The last time I programmed was back in the 90's, with Pascal and C. And even though it's been a while since I programmed, I knew I didn't want a "raw beginner book." I wanted a book I could grow into. Enter "Mastering Visual Basic 2008."
   
   This is not a book for people who have no programming experience (although a bright, industrious person could probably do it). The basics of programming (declaring variables and basic programming constructs) are covered in two chapters. The rest of the book teaches the aspiring programmer how to work within the Visual Studio environment. The programming examples are useful and can become starting points, letting the reader add functionality as needed.
   
   The author does assume some previous experience, and occasionally leaves out some details here and there, which can be slightly frustrating at times. For myself, however, this worked out okay, because in hunting for the missing details, I actually learned more about the program than I might have if all the details were spelled out. (Yes, the cloud has a silver lining!)
   
   I'm not nearly finished with the book, but the content so far has me looking forward to working my way through all the chapters. Highly recommended!

5 comments about Beginning Programming For Dummies (Beginning Programming for Dummies).

1. Here's the deal with this book: it's for beginners, hence the title. A lot of reviewers knocked it down a bit because it did not use a "real-world" language like C++ or Java. There is a reason for that...those languages are much more cryptic and tougher to learn, you can get caught-up in just learning the syntax (among many other things) instead of basic programming logic and concepts. A beginners guide should not bog one down with frustration.
   
   The language that is used in this book is LibertyBASIC, which is similar to QBASIC, RealBASIC and other versions and just as easy to learn. I feel that it's necessary to mention here that the BASIC language is the most widely known programming language in the world. Microsoft (where I happen to work) created it's early software in BASIC and is currently still using it's own flavor of the language (Visual BASIC) in-house. Take a look at any college computer science or programming curiculum and you will notice that almost every one of them starts off by teaching BASIC (usually Visual Basic, which is even easier in my opinion). The reason, there again, is because it's simple to grasp and to learn important concepts early-on.
   
   It is true that LibertyBASIC specifically is not used widely in the "real world", but again that is NOT the point of this book. Instead, time is spent on concepts relevant to programming and why they are important. Boolean expressions, arrays, looping statements such as IF/THEN/ELSE and WHILE/WEND and subroutines (among other topics essential to programming basics) are all touched upon here. The point, again, is an INTRODUCTION. LibertyBASIC allows you to quickly get up and running with simple programs and to practice these central concepts without getting confused and frustrated.
   
   The book also touches on other programming languages that exist such as Perl, Python, Ruby, C++, Java and others. It spends a good deal of time giving a background and primer on what these languages try to accomplish and their popular uses. I think this book is ideal for people who are interested in programming but don't know where to start and for those who MIGHT be interested but aren't sure and need an overview of what they will be getting themselves into.
   
   From here, dive into other programming books with more centralized topics or higher-level languages. If this book really piques your curiosity and you decide to get into programming full-time, my personal recommendation is to enroll in a local community college and take C++, C# or Java courses. I think the learning is faster and it helps to have instructor interaction in case something goes awry in your learning.
   
   I hope this helps, and good luck!!!!



2. As a programmer, when I first read this book through I thought that it wasn't the best written of the Dummies books, but it was a reasonable introduction that gave a good overview of some of the basics. However, having seen people with no experience of programming at all try to work their way through this book, I've also noticed that the author has sometimes failed to really explain himself in the clear and thorough way that the Dummies books are so good at, and has lost sight of who the book should be aimed at - people with NO experience of programming at all.
   
   My biggest gripe of all is with the use of variable names, on two counts. Firstly, he'll sometimes use variable names that simply won't make any sense - names that have absolutely nothing to do with what the variable is actually being used for within the code. While this doesn't cause a problem with programming, and certainly won't confuse an experienced programmer within such simple coding, it can completely throw people who haven't used a programming language before - it adds unnecessary confusion to code that's mainly intended for complete beginners.
   
   It's also a bad introduction to naming conventions for anyone who'll write code for others to use, as people SHOULD try to make their choices of variable names make sense. It's a bad idea even if nobody else EVER reads it, because if you decide to come back to your code after a year, who knows if you'll still remember what "boing" was supposed to be?
   
   The second issue I have is that he'll repeat the confusion for newcomers by sometimes naming things too similarly. Experienced programmers, again, won't have a problem with this; but for the newcomers who're trying to become familiar with the language, it can confuse them - this is made more likely by the fact that many will already be struggling to come to terms with the code they're working through. Having a variable called test$ and a routine called [test] may seem fine to experienced programmers, but when test$ is actually the value of a radio button, there are much plainer and easier names that the variable could have been given to help avoid confusion for the novice programmer. It could simply have been thought through better, and more consideration should have been given with regard to who this book was intended for.
   
   When compared to some of the other Dummies texts, most of which people could work through from top to bottom without needing much or any assistance, this one falls short of the mark. Beyond just the confusion created by bad choices of names for variables and functions, some of the explanations are unclear - or leave some elements completely unexplained - leaving the unfamiliar programmer out of their depth, with no experience to call on to deduce what the commands or code may actually be doing.
   
   In the end, I simply wouldn't recommend this book to anyone who is trying to learn programming from scratch on their own. With some help, it provides a place for programmers to build, but too often the people I've seen work through this have ended up FEELING like Dummies as they became baffled and lost off by the book's sometimes careless style.



3. Well written, to the point, useful information made accessibe: a book that delivers what it promises. In spite of what one reviewer says above, the author goes out of his way to recommend that you use descriptive names for variables. My copy of the 2nd edition has this repeated on a "cheat sheet", printed on cardstock _just inside the cover_. At the top of page 2, under Tips for writing programs:" "-Use descriptive variable names". This book is a good introduction and overview to programming and I highly recommend Liberty Basic.



4. So I finally decided to try out the "For Dummies" books and must say it's a decent enough first step. I've always had an interest in learning some programming...mostly for fun but also because it seems that a basic understanding of computer programming is becoming more and more necessary...instead of taking a course I decided to learn a little on my own to see how it goes... The book is very easy to follow and explains things pretty well. I am definitely happy with the purchase and will continue studying programming. Would highly suggest for anybody with the desire to pick up a new hobby. Just purchased Robot Building for dummies...we'll see how that one goes.



5. A good overall explanation of programming in general. Becoming proficient in any of the languages taught, I think, will require additional reading. However, the basic concepts and building blocks of programming are well laid out for the reader. A great starter for someone with no experience in programming.

5 comments about Continuous Integration: Improving Software Quality and Reducing Risk (The Addison-Wesley Signature Series).

1. This book is a good one - it has lots of well stated reasons for doing a continuous integration system of some sort, including all sorts of little conversational snippets that help make the point. For example, "Jim: hey, the test server isn't working. Joe: Ah yes... I forgot to 'svn add' one of my source files." Doh!
   
   He suggests using one of those ambient orb gizmos to provide visual feedback on failed builds. That's probably a better idea than a sound alert - I found that having one of those go off every once in a while was just annoying. You can cut an email to everyone when a build fails, although that risks folks just routing them to a folder and letting them stack up.
   
   I was happy to see that the section on static analysis included lots of suggestions for using PMD and CPD. CPD, especially, is a handy tool; the ability to find duplicated code across a large codebase is very nice.
   
   One of the hard things about a book on CI is that CI touches so many different parts of a system - the database, scripting, code, tests, code analysis, etc. It's not the sort of book that lends itself to one big example; instead, you have to have a bunch of little config files and scripts and examples to help a person get rolling down the CI road. I think they did a nice job here of having a good mix of theory and practical code samples.
   
   So anyhow, I think this book is a good 'un. Go get it!
   
   As an aside, I was a technical reviewer for this book, so there's probably some bias there. But not too much!



2. Any software developer who has spent days in 'integration hell' handling a complexity of software components will appreciate the invaluable information in CONTINUOUS INTEGRATION: IMPROVING SOFTWARE QUALITY AND REDUCING RISK. From the initial concept of CI and its practices to over forty CI-related practices from database integration to development, this book covers the entire cycle of CI development and surveys all kinds of events, repetitive processes, and more. An outstanding guide any serious software development library needs.



3. This book is an excellent overview of why Continuous Integration is important and about more than just compiling frequently. The book helps you to understand why to do CI, what you can do beyond building, and how to do it. In addition to general principles, the book points you to some excellent tools and resources. This book is an excellent companion to Software Configuration Management Patterns: Effective Teamwork, Practical Integration; it provides teriffic information that support the build patterns in that book. You might already know some of the information in this book, but it is worth buying if you need to encourge CI in your organization for the clear discussion of why CI matters and the for the detailed advice on how to implement it.



4. As a software developer, you know that one of the critical period in a project is when you try to make integrate your code in the overall application and push it towards the final user. It is sometimes a long process that you would like to accelerate so that you could obtain a quicker feedback on the quality of your code. This book written by Paul Duvall, with Steve Matyas and Andrew Glover, will help you improve the way you build and deliver software.
   
   After a initial presentation of the continuous integration (CI) concepts and objectives, the content of the book goes far beyond the simple "continuous build" aspect to cover all disciplines concerned by CI: risk management, configuration management, database evolution, software testing, inspections, deployment. It is clear that CI is just not installing a suite of tools, but is mainly changing software development practices and process. Each chapter is well structured with practical examples related to real life situations. The book reach also nicely the objective of maintaining a balance between a somewhat tools- and language-neutral position, but still giving enough practical advice so that you could quickly adapt the advice to your own software development environment. Final appendixes give valuable information on CI resources and evaluating available CI tools.
   
   Finally, you can get more and updated information on continuous integration and download book's chapter two from the Web site associated to the book: http://www.integratebutton.com



5. As Martin Fowler says in his foreword to this book, all of this information is available on the internet. However, that should by no means demean the value of this book. This is an extremely readable and well-organized presentation of this important development practice. Often the organization and comprehensive analytical thought are themselves important contributions to a given topic, and that is what Duvall, et al deliver here. Highly recommended.

No comments about Microsoft Dynamics CRM 4 For Dummies (For Dummies (Computer/Tech)).

5 comments about C Programming: A Modern Approach, 2nd Edition.

1. This is the second of King's books I have purchased. It is also the second that I am very very pleased with.
   
   This book presents a quick systematic clear way of learning to program in C period. This has to be the easiest programming book I have ever read that goes beyond absolute basics.
   
   Frankly I don't understand the few negative reviews others have given the book. Yes it would have been nice to have answers to the exercises. However this is a programming book, you get the answers yourself by doing the work. Mistakes are readily apparent, simply because it won't work!
   
   In terms of difficulty, the exercises are doable. There have been a few that did stump me.....for a little while. With a bit of rereading and some experimenting, I have managed to answer all that I have attempted.
   
   Do yourself a favor if you are learning C and buy the book either as a stand alone or as a supplement to another book.



2. This is definitely the best book on C that I have ever read. King presents just about everything there is on the language in a clear and easily understandable way. One thing that I loved about this was King's mentioning the %g format specifier, which is something that has been very useful and that I haven't seen mentioned too frequently.



3. in order to really understand what was going on you need to intently read every single word. There are no solutions for the excercises which i thought were too difficult, and many times the means to find the answer could not be found in the chapter.



4. This book was an excellent complement to the professor I had for basic C programming. I'd venture to say that even someone with little to no computer experience could learn from it. One really nice feature is the Q & A section where obvious questions about the material are asked and then answered by the author such as: "Why is the C language so terse?" There is not an excess of information, but it gives a great deal of examples and even source code so you can see how the system compiles it. If I were teaching myself the C language, this would probably be the first book I went to.



5. I ordered K.N. King's ``C Programming: A Modern Approach (Second Edition)'' from Amazon for my recent birthday. Having had more birthdays than I care to admit, this gift to myself is right up there with a Lionel train set I got for my eighth birthday (not from Amazon, of course -- it didn't exist that long ago but passengers trains sure did :)).
   
   In this second edition, I think that KNK is now the logical heir to K&R. That's not meant as blasphemy -- Kernighan and Ritchie's still great volume is around 20 years of age and it's unlikely they'll be getting together for K&R3. The C language has undergone enough changes (with the amendment of 1994) and C99, that a ``Modern Approach'' really is needed.
   
   There's another author familiar to readers of the comp.lang.c newsgroup for his approachable, engaging writing style. That author is a wonderful writer but doesn't let the truth get in the way of good narrative. King, though, is an equally engaging writer but is obviously passionate about correctness and adhering to the C standard. He's also meticulous about portability so that the examples are written in pure C and not some platform-specific variant.
   
   I've the entire book and can find hardly anything even nitpick. Aside from a minor style difference about using parentheses with the ``sizeof'' operator, which King explains his rationale for doing so, that's about it.
   
   His explanation of C99 (and the differences from C90 are clearly indicated) made me aware of some really nice features of the current standard for the language (and makes me wonder why one very notable compiler implementer hasn't yet supported C99).
   
   In short, get this book. The Q&A sections at the end of each chapter are very well done. The exercises and programming projects help to amplify the material presented. And King's examples will teach you more about barcodes and ISBN numbers than you ever thought possible.
   
   If you can appreciate the work of a fine craftsman in film such as Martin Scorsese, you'll find that King is of that caliber in the realm of lucidly dealing with this technical subject.

5 comments about UML 2 Certification Guide: Fundamental & Intermediate Exams (The MK/OMG Press).

1. Good book to have for UML Certification...I wish every UML evangalist must have for reference.



2. This is a good book for preparing to the OMG UML exam. Each one of the most important elements of the UML metamodel are treated with a simplified view.
   
   The sample exam of the end is so useful. I recommend the book.



3. Before buying this book, I had no doubt that it would be instrumental in passing my certification exams. I did pass the the Fundamental exam in the first try itself and I don't believe I would've been able to do so if I had not laid hands on this material. Neither do I think there's a book out there that covers UML with the level of detail as this one does. After all, this guide is published by the same Group that sets the UML standards and administers the certification program! I'll be referring back to it again for my Intermediate-level exam. Thanks OMG!



4. Really complete book, clear and concise. It's a very good tool to pass both of the exams, as well it's a great resource for those who want to initiate and work with UML.



5. I want to purchase this book, but I've noticed its price here on Amazon has been switching between $30+ and $50+ a number of times every week, for several months now. What's going on with that? This strange and frequent price oscillation, and the significant price difference involved, is preventing me from purchasing the book, despite all the acclaims.

No comments about Linux Command Line and Shell Scripting Bible.

5 comments about Groovy Recipes: Greasing the Wheels of Java (Pragmatic Programmers).

1. So you're in a hurry to pick up Groovy, and you're not a big fan of books that while informative, fill you with more language theory than useful knowledge. This buck, while around 240 pages in length, manages to take you from Hello World! to Web Service programming and Grails rapid development in a short period. If you know Java, you'll feel right at home with Groovy, and will feel good about your skills after you're done reading this book.



2. 'Groovy Recipes: Greasing the Wheels of Java' is a typical Pragmatic release in that it is written well, free of bells and whistles, and jam full of relevant and useful information. There is 250+ pages of information here on how to use and implement Groovy, the wonderful Java addition that makes programming easier and more exciting for any and all developers!
   
   Content is spread over 12 chapters:
   
   01. Intro
   02. Getting Started
   03. New to Groovy
   04. Java + Groovy
   05. Command Line Groovy
   06. File Tricks
   07. XML Parsing
   08. Writing XML
   09. Web Services
   10. Metaprogramming
   11. Grails
   12. Grails + Web Services
   
   As can be seen by the TOC, this is a book for programmers of today living in a networked world. The focus is on writing efficient, good code that is fast and useful. This book is extremely beneficial to any and all Groovy developers that want to learn better and faster this wonderful technology.
   
   ***** RECOMMENDED



3. I got this book after hearing the author speak at JavaOne. His talk covers the content of the first chapter along with a few other items, but I didn't mind. It was quite helpful to read through the points and examples he made and try them out at my own pace.
   
   The book is driven by a series of insights rather than complete, formal coverage. I found this approach very useful to getting started and experimenting. The writing is clear, light-hearted, and relaxed, especially in the beginning.
   
   Towards the end of the book, the explanations wane a bit. The sample code is more often given without an introduction, beyond the section header. I was less sure what was going on in some of these cases, as I had gotten accustomed to picking things up very quickly in the beginning. The explanations that followed these code bits were good enough, but I missed that sense of the author's energy from beginning to end of each section.
   
   I don't understand at all why it's called Groovy Recipes. There aren't any. The examples illustrate very well the power of this tool, but I didn't see anything that amounts to, say, the Groovy way to mine a web page, create an IM interface, read mail, etc. If you are looking for code you can apply immediately to some series of problems, this isn't the one.



4. It is a nice little book to have by your computer, if you are working with Groovy. I give this book 3 star review because this could have done without first 5 chapters. I think Groovy is a great language, and in my humble opinion it is more useful to a Java programmer, then Ruby, however the quality of Ruby books is far superior to books available in Groovy.



5. Groovy Recipes is an excellent introductory book into Groovy programming. The first few chapters give clear instructions for learning how to use Groovy. The remaining chapters give clear instructions for using some of Groovy's cool features: using Groovy with Java, Grails programming, metaprogramming, working with XML, File manipulation, and web services).
   Much akin to the fun and energetic manner that Davis speaks in his presentations he writes Groovy Recipes.
   If you haven't heard him speak(and even if you have), do a quick Google Video search for Scott Davis Groovy and you'll find a presentation or two of his. I recommend them.
   One technique that I found especially useful is how Davis compared performing a simple task in the Java world, and then showed how it could be done in the Groovy world. Of course, it's easier in the groovy world for all the examples. It's nice to see areas where we can take advantage of Groovy's strengths.
   Groovy Recipes has enough content to sit on an experienced Groovy developer's book shelf, but the more novice Groovy people will find more value in Groovy Recipes.