2 comments about Professional Windows PowerShell Programming: Snapins, Cmdlets, Hosts and Providers (Wrox Professional Guides).

1. I've been developing PowerShell cmdlets for the past year and half for the PowerShell Community Extensions project. I really wish I had this book when I started. It would have saved me a ton of time. Having everything documented in one place alone would have been a huge timesaver. The examples in the book are really good and should give any would-be developer of PowerShell cmdlets or providers a huge jumpstart. One minor quibble is that the formatting on some of the sample code output wraps making it harder to interpret the results. Other than that it is a fantastic compendium of the knowledge necessary to start knocking off some heavy duty cmdlets and providers.



2. This very well may be the only decent book regarding PowerShell programming beyond the ordinary PS scripts. If you want to create your own CmdLets, Providers, etc this is the only book I've found that gets you there.
   
   With that said, despite the authors' efforts the book feels more like a reference than a tutorial. The authors' expertise is so deep sometimes they forget to explain all the "obvious" things.
   
   For example, when the PSObject class gets presented to the reader the details are outstanding, as always, but there's very little effort devoted to explaining why this class is needed at all. I've seen other books do better in that matter.
   
   A different example: If you've created your own CmdLets, you already know you can derive from CmdLet or PSCmdLet, the latter being a subclass of the former with additional features but additional requirements. The book totally avoids this discussion (did I miss it?) and PSCmdLet gets used exclusively all over the chapter without telling the reader why.
   
   Don't get me wrong, this is a wonderful book and honestly, I may come back in a few weeks to update this review and give the book an additional star. But I'm the kind of guy that always needs the "Why" before the "How".

5 comments about Beginning C# 2008: From Novice to Professional (Beginning from Novice to Professional).

1. I have to say that I am not very impressed with this book.
   
   The early section which try to cover the C# basics are very much incomplete and therefore of little use to a beginner. I find the authors use of analogies to describe language features very irratating throughout.
   
   I feel it tries to address too much ( e.g. Architecture, Language Basic and advanced features ) in only 450+ pages which is impossible.
   
   Think carefully before buying this book it is not up to the usual Apress high standards



2. Having been out of the programming world for eight years I though that I would never be able to get back into this world as the pace of technology, tools and languages changes so rapidly, however after reading Beginning C# 2008 From Novice to Professional my outlook on this has changed. Even though I have always kept up in terms of what was going on I became less and less aware on how it was done. I always felt that the task was just too big.
   
   Looking at this book you might be forgiven in thinking, how can you read through this monstrous book of over 500 pages, and for me I still have not read it all in detail. I have however used the book to focus on getting started and it has definitely without a doubt help me do just that. I didn't know where to start. Now I have more confidence and I am beginning to delve more an more into the details of C# and the Microsoft .NET platform.
   
   One thing about technical books, they typically fall into the category of reference books, books that have rehash online manuals, and other with just examples. This book was different it explained everything that I needed to know step-by-step and with each step clear examples. It is clearly written, easy to follow and most of all not some reference book that didn't teach you how to apply the information provided. In saying that, this book is an excellent reference in getting up to speed on specific C# constructs etc.
   
   For me as a Novice wanting to learn what there is about C# and .NET I didn't want to fork out all the money for the tools for something that I might not actually intend going through with. The book assumes that you are using the free version of .NET (Visual Studio C# Express Edition) which is great. Too many books make the assumption that you are already a programmer or if not still have access to the full tools.
   
   The examples were very easy to follow, simple and clear steps (that you can skip over if you are familiar with those areas already) and the illustrations clearly annotated. At the end of each chapter it gives you some point to remember and some additional activities. I strongly recommend that you do the extra activities by trying to answer the questions. This helps cement your knowledge and understanding of a given topic.
   
   The chapters are organised to follow in sequence building upon one another. As you work through the chapters you level of understanding increases by focusing on the 'essentials' and 'fundamentals' without distracting the reader with lots of fluff or very tecky stuff.
   This book achieves what it sets out to do, that is, bring someone with no skills and knowledge in C# and bring them to a point where they can create a well structured application in Microsoft .NET. Anyone can learn new techniques on the job, but in my opinion learning the fundamentals is more important. You can always build upon sound fundamentals and principles.
   
   I think this book is excellent for a student starting out in programming, someone want to tinker with these tools or a person wanting to make a career out of programming. This book will give you all this and more. On the negative side I would have liked to see more about best practices in writing 'secure' code or possible touching on some 'professional' best practices like unit testing using JUNIT, or as a minimum touch on these topics to get the reader interested in these areas. The chapter about Multithreading was particularly interesting as it started to introduce the concept of 'design patterns' and in this day and age of multi-core CPUs this information can be very helpful.
   
   Overall this book is excellent, it is an engaging read and very informative. I didn't get bored with the material. Most of my reading was at night after work and my goal was to get through 1-2 chapters a week. I would highly recommend this book for anyone wanting to learn C# and working with Microsoft .NET tools.



3. On the first read through of the book, a few things hit me:
   
   1. There are way too many analogies that became increasingly frustrating and tedious to read through. Personally, I want to learn what, why, and how -- not just what and then be given analogies as to why and how. This is a personal gripe and may not hold true for others.
   
   2. Some things are not completely explained. Ex. pg 61: When explaining hashcodes, no information is given on what exactly the value is derived. An analogy about wine glasses is given rather than the exact reasons.
   
   3. I've got to say there are definitely some gems in this book because of the way it is presented. At the same time, the presentation is the downfall of the book. I don't want to seem overly critical, but I would have liked more facts rather than analogous views on why things work the way they do. It's like digging through mud to get to the gems, though the good information this book provides is worth it. These gems include common real-world examples and advanced features in the IDE.
   
   4. The book definitely holds your hand and never over-immerses you. This is a plus. Though, sometimes, I felt that if I didn't have a programming background I would have had to re-read passages many times (this could just be due to the learning curve of programming in general).
   
   5. I fell in love with the end of each chapter. It gives you questions that may seem impossible to answer with what has been given you in the chapter. The answers can be found online and are in depth. These questions and answers completely further the learning!
   
   Thanks for writing this book! Although, I can't say I agree with the use of analogies, I can understand it from a teaching perspective.



4. After reading some parts, especially the part about inheritance and polymorphism, I have to say that this book is not for beginners, even not for advanced developers. This book leads people to wrong way to design. For example, The Shape, Rectangle and Square relationship is discussed in very complex and abstract way that the readers can't understand even if they read that portion 10 times. The author tried to explain the "good" way of component level development using that example and spend a long time on comparing different approaches. While summarized that all approaches have shortcomings if simple inheritance and polymorphism is used, he suggested using a new way called "component level design". But, believe me, he didn't provide the component level solution for this problem finally and you will be left totally confused. If you check another examples in this book, you will find them very uninteresting and ugly.
   Don't buy this book if you want to learn something.



5. I am totally dumbfounded at Apress. I have the VB version of this book. And from these reviews I can tell both books are similar. Meaning after reading some sections you will be left saying to yourself, "what just happened"?
   
   As several have noted thru the constant use of analogies, the author takes you far down a beaten path that is typically very far from where you want to be. You end up trying to think exactly like him to try to understand what his analogy is trying to explain. Very bad writing style.
   
   The examples he does use to try to demonstrate programming principles are bad also. I have been working in Java for sometime. So I have an understanding of Interfaces vs. Inheritance. With a good understanding of this particular topic, I found myself very confused reading some of his chapters that try to discuss Object Oriented principles.
   
   If you check some of the other books this author has written you will see a general overall rating of 3 at best due to his poor writing style.
   
   I used to heavily recommend any Apress book on any given topic. Seeing as Apress is coming out with a 2nd edition of this throwaway book, I can no longer abide by that. Will never buy an Apress book until I've had a chance to read some samples in a bookstore, or read several reviews.

5 comments about Programming SQL Server 2005.

1. As a new student to the field of SQL Server 2005, I was hoping to obtain a book learning the various methods of programming in SQL Server 2005. I was initially hearted by the first paragraph in the preface:
   
   "You don't need to be an experienced SQL Server 2005 programmer to use this book..."
   
   which is indeed the case if you intend to use it as a paper weight.
   
   The book suspiciously looks like the syntax guide found in most MS products: the procedure name and inputs followed by a description of the inputs. It is not for the beginner/intermediate learner and is somewhat of a disappointment comming from the O'Reilly range ("SQL on SQL Server 2005" is an excellent counter point to the book being reviewed from the same publisher). This book serves mainly as a reference (which on page 7, it clearly states that it is not a reference) to new doctrine in the SQL Server evolution.



2. This is definitely one of my best SQL programming books. It covers the newer programming concepts; such as XML storage and handling in SQL 2005, very well.
   
   I would definitely recommend this book to anyone who is serious about SQL Server 2005 programming.
   
   It also covers CLR programming in SQL Server. Good book.



3. User does not have to be experience SQL Server 2005 programmer to use this book; as it is designed for users of all levels. This book also suggests that user does not have to be experienced with SQL Server 2000. However, I disagree with that. This book only covers new features of SQL Server 2005. Understanding of fundamental relational database concepts is helpful to digest and accept the concepts introduced in this book.
   
   This book covers following perspective of SQL Server 2005 new features.
   * Tools and utilities
   * Data types
   * T-SQL enhancements
   * Programmability enhancements
   * XML support
   * Native XML web services
   * SQL Management Objects
   * SQL Server Integration Services
   * SQL Server Reporting Services
   * SQL Server Notification Services
   * SQL Server Service Broker
   * Replication Management Objects
   * SQL Server Agent
   * SQL Server Mobile Edition
   
   The code used in the book is available for download on O'Reilly web site. I always like this as I really do not like to retype examples from the book. Most of the examples of this book use C# code and Visual Studio 2005. One good thing about this book is it uses AdventureWorks sample database, I always prefer book which uses samples database which comes along the SQL Server, this makes it easily useable by developer. This book is also Safari enabled.
   
   Appendix of this book has in depth explanation of the ADO.NET 2.0, which can be quite useful to users interested in the topic. There are very few good books which covers this topic such in depth.
   
   Rating: 4 stars
   
   Summary: This book is quite good for new learning; I enjoy reading it and learning new concepts from this book.
   
   Pinal Dave
   Principal Database Administrator
   (blog.sqlauthority.com)



4. This book is very inaccessible, not because it is too complex, but because it is poorly written. If you'd like to actually learn SQL Server programming I'd recommend Professional SQL Server 2005 Programming (Programmer to Programmer).



5. This book covers nearly all topics on SQL Server programming. It begins with the differences between the SQL Server 2000 and 2005. 2005 has new tools (SSMS, Profiler, BIDS, command line), data types, xml support, and .NET integration. Chapters 1-4 go over these topics in turn. The next series shows the reader how to program using the Visual Studio IDE, deal with XML programming, and web services (Chaptes 5-8). Chapters 9-14 are on programming SQL Server management and reporting tools plus interfacing with the objects exposed by SQL Server through .NET. The remaining chapters are on programming services: SS agent, intergrations services, broker, notification services, and analysis services.
   
   The book is quite thourough and has a large number of examples, code, and pictures for each topic. The book is generally easy to read and well indexed. Programmers will feel right at home with all the extra help provided by the book.
   
   Folks who have no programming experience of any kind will likely struggle with the information in the book. Basic SQL is shown but not explained. It is clear the book is meant for people programming and/or automating SQL Server topics rather than just running basic queries. That being said, the chapter on XML was very helpful even from just a querying point of view. Using XML as a bulk load technique was particuarly useful and turned out to be very fast when loading text based data to the server. Querying XML data was covered by using both FOR XML statements and using XQuery type statements. The chapter sovering SSIS was also very useful as there is not much material on SSIS yet.
   
   This book is a must have for SQL Server DBAs, programmers, and professionals.

5 comments about Expert .NET Delivery Using NAnt and CruiseControl.NET (Expert's Voice in .Net).

1. I picked up this book last week and within a few pages already had major ideas for my build system. I had been struggling by with a very basic, very weak continuous integration system using CruiseControl.Net and NAnt, but I had no idea the kind of power these tools give you, nor did I have a real understanding of what a good enterprise build system should do.
   
   Well, that problem has been rectified. After reading most of this book I was armed with the knowledge I needed to go out and put together a build system I can be proud of, one that presents real value to my development rather than just being there so I can say "ya...I use continuous integration" - a situation that I suspect is not uncommon.
   
   So if you are doing any signigicant development work with .Net you definitely should read this and learn how to make a build system that works for you and provides real and significant value.



2. I picked up "Expert .NET Delivery Using NAnt and CruiseControl.NET" as a developer familiar with the original open source projects, Ant and CruiseControl, from the world of Java development. I have been long interested in how "the .NET people" do things even though my personal experience with .NET technologies has been limited to doing a day of training every now and then. From this perspective, I have to say I find a lot of good stuff in this book but it's still missing that something. The author, Marc Holmes, clearly states in the introduction that the book's goal is not to be a comprehensive guide for the tools being used. Instead, his focus has been to show the reader a practical approach to tackling problems involved in "delivering software." I had some difficulty seeing that focus while reading.
   
   The first chapter titled "A Context for Delivery" is actually an excellent albeit short overview of the variety of aspects involved when discussing how to manage software configuration, the build process, and the deployment process. The next couple of chapters
   introduce the NAnt build tool and its essential built-in tasks. As a tutorial to NAnt, these chapters felt a bit too lightweight. Chapter 2 is an excellent tutorial for getting started with NAnt and chapter 3 briefly enumerates the most important built-in tasks available. These first three chapters were definitely the ones I liked the most.
   
   Chapter 4 presents a simple case study, getting a GUI application for performing XSLT transformations to build with a NAnt script. The author follows through creating the script from scratch, all the way from the classic "clean" target to checking out the project from Visual SourceSafe, incrementing a version counter on assemblies, running automated tests, static analysis, and packaging the build output into a .zip file for deployment. There's some discussion of NAnt features that weren't illustrated in the previous chapters but not much more than that.
   
   Chapter 5, titled "Process Standards", talks about the case study team refactoring their build scripts towards a structure that supports a "standard" build script to be used throughout the company's .NET projects. Very little meat in there. Most of this chapter seemed to present a topic of interest only to move on right away, without giving solutions beyond tiny snippets of NAnt tasks. As someone not familiar with most .NET concepts, I found it very difficult to follow.
   
   Chapter 6 brings continuous integration into the picture. After a brief explanation of why one would want to implement a continuous integration process, Holmes proceeds to describe CruiseControl.NET and how to configure it to build your .NET project. Again, only superficial coverage of the configuration options available which is consistent with the stated goal of the book not being about the tools themselves. Yet, at this point I realized that the good stuff had all been about the tools -- NAnt and (to a smaller degree) CruiseControl.NET. This pattern continued through chapter 7 which talks about extending NAnt with your own custom tasks. In fact, this chapter does a good job in showing the ropes through developing a FxCop task.
   
   Chapter 8 is a good one. It talks about techniques for dealing with the database schema in the context of continuous integration and incremental development. The example scripts do leave a sense of "magic" happening that I would've liked to know more about, but even as such this chapter can be useful for getting started with automated integration of the database alongside the application.
   
   Chapter 9 talks about code generation (with XSLT and CodeSmith) and how to incorporate it into the build process. The examples were a bit difficult to follow and there wasn't much background on the tools (CodeSmith and XSLT) themselves.
   
   To finish off, chapter 10 presents some closing thoughts as a summary for all the things discussed in the body of the book. Good stuff, makes a lot of sense. I find it interesting, though, that beyond the first and last chapters I found very little content that I could associate directly with practical delivery other than from the tool perspective.
   
   As a summary, I consider "Expert .NET Delivery Using NAnt and CruiseControl.NET" to be a nice tutorial for NAnt and CruiseControl.NET. Having said that, a large part of the book seemed to be somewhat disconnected from the stated goal of showing a practical approach to problems in delivering software.



3. Holmes gives you a very motivated guide to using NAnt and CruiseControl.NET. I'm from the linux/Java world, and am familiar with Ant. So the NAnt discussion was very relevant to my experience. Holmes explicitly says that this book is not a comprehensive guide to the abilities of either package. But in some ways, while not comprehensive, it may well be better than a text devoted to either [or both]. You can see in Holmes' text, very plausible ways for why and how you can use those packages. Going through the chapters, he delves into a detailed practical application. Helps you build a context in which you might use the tools for yourself.
   
   I was unfamiliar with CruiseControl.NET. But ended up being impressed with how it lets you do this agile, continual integration. On the broader issue of explicating issues in code delivery, I tend to agree with a previous reviewer, Koskela. Who stated that the book doesn't give a bigger view than that of the tools. Though it certainly does that well.



4. This book is simply arduous to read. I kept looking to the "About the Author" section for a hint that perhaps this was a translation from the Russian original, or something. Vague sentences, paragraphs, and overall structure haunt this book, and make it a task to read. Did this book even have an editor?



5. This serves as a good introduction to NAnt and NAnt contrib. Working through the excercises was helpful. The introduction for CC.NET is also good.
   
   I recommend this for anyone new to NAnt and CruiseControl. I caution the use of Continuous Integration. It is an excellent way to immediately identify build and integration issues; however, you have to beware of "false positives". For example, an auto-build everytime something is checked in will determine if that checkin causes a build failure with everything else that is checked in.... however, you need to do some soul-searching to determine if this is what you really want. Do you want to trap failures and correct them, or determine a development strategy ahead of time that will prevent these surprises? The continuous build isn't a bad idea, but it becomes troublesome if you are substituting that for a good development and integration plan.

5 comments about Sams Teach Yourself the C# Language in 21 Days (Sams Teach Yourself).

1. This book is just fantastic. You can really learn a lot from it. I am only 14 and already know how to create a simple program. I'm looking to get into the gaming industry and this book will definently help me get there. I recommend it to everyone who wants to learn C# without the hassle of using up a lot of time. 5 Stars.



2. This book was awesome! I just finished reading it today and I am amazed of how much I learned.
   
   I disagree with the comment that rates it bad for not talking enough about Visual Studio.... There are good books about "Visual C#" which target this audience, however the best developers are those who learn how to build software from scratch without fancy tools.
   
   Trust me, before this, I had no idea what was all the code Visual Studio (and even SharpDevelop) generated by default.
   
   Recommended path:
   I read 1 chapter a day; then took the chapter quiz, and did all the exercises.
   
   Also play with the "Type and Run's", they are a lot of fun!
   
   I am now writing my own C# applications (Console, Windows-based, Web, and even for my Pocket PC).
   
   Excellent book, great job Brad Jones!



3. Could not put it away until finished reading it.
   Book is very well written, with detailed explanation of every topic and has very good examples, I also liked excersizes and questions at the end of each chapter. I am not afraid now to program on C# and hopefully will find job using C#!



4. This book is a great book for beginners. If you happen to be a programmer the first couple of chapters are a review but the later chapters make up for this. I would have preferred a little more about creating windows applications but this is still a great book. I recommend this book.



5. It is important to realise that this is a book for beginners. If you are an experienced developer wanting to cross-train from C++, Java, VB.Net etc then this is not the book for you. I pretty much speed-read the book in three days (I would have been quicker but I had other things to do as well), typing in code when it looked like it might be a useful exercise. As C# is largely an amalgam of bits from other popular languages it is easy to plough through this book at speed if you do know other object-oriented languages. If you are a complete beginner then I suspect this book is probably at about the right level and for complete beginners 21 days could be about right.
   
   As well as the language itself, the book gives the basics of console input/output, file handling, windows forms, database access and some web stuff. As the author says a number of times, the libraries used for .Net programming are so large, you couldn't do more than skim the surface even in a book of this size.
   
   A few other things to note about this book...
   
   This book does not teach you about the Visual Studio integrated development environment (IDE), or about the code generated by the IDE. Instead it works from first principles - no use of a forms editor here, this is typing in instructions to add a control, position the control, set the control colour, handle the related events etc, rather than having the basis of that automatically generated. Useful to know how to do it manually, but I suspect most people would rather take the IDE route. Personally, I do like to know both, so it is good for me the way it is.
   
   There are a number of typographical errors in the text, most of which are unimportant, but they have also crept into at least one source listing, although that was easy enough to spot.
   
   The errata on the author's web-site is incomplete and hasn't been updated recently. The errata on the publisher's web-site is, well, missing. Just to repeat that bit - it isn't there (or not anywhere that I could find it). Don't bother registering on the publisher's web-site - registering doesn't suddenly provide access to the errata. Thankfully none of the errors that I spotted in the text were serious.
   
   The example code at the end of "Week 2" is a blackjack game. Nothing too bad about that, other than it fails to use the most interesting bits from week 2. It also mixes naming conventions throughout the code, which is really annoying when you are typing the code in. Use camel notation, use all lower-case, use Hungarian - it doesn't matter, but it would make life easier if the author was consistent. The whole example was poor and could have been replaced with something more relevant to the week's work.
   
   All in all, quite a good book for beginners, with the caveats that it doesn't teach you about the Visual Studio IDE and that the chapters on web-development might assume too much knowledge for a complete beginner. Not the right book for an experienced developer cross-training from another object-oriented language.

No comments about Beginning C# 3.0: An Introduction to Object Oriented Programming (Wrox Beginning Guides).

5 comments about Microsoft Visual C# .NET Step by Step--Version 2003 (Step By Step (Microsoft)).

1. Coming from a VB background I chose two books to step up to C#. The first was Charles Petzolds excellent book, programming in the key of C#. My second book was this one. While this fills in many holes left out of Petzolds book, (mainly to do with the .NET framework & the .NET IDE, since Petzold deals purely with the C# language) it does so at the expense of clarity & in depth explanations as to `why' we do certain things. Often this book uses explanations dealing with as yet explained methods or objects, hence its flow is not contiguous, & the information supplied shallow. Had I not first worked through the `Key of C#' book, I would have been left scratching my head with this one. As in one example, it uses the conditional ternary operator statement having not yet explained this simple yet enigmatic little piece of code. (Fortunately I'd learnt this in the previous book). At other times, it gives examples that don't result in anything of value as code methodology. In another example the authors declare a property as 'money' without any prior indication of creating a money class, which led me to search MSDN online documentation for a non existent money data type that i may have overlooked. Not good. They have a skill of muddying simple concepts with overly complex examples. I came away thinking this book would be more for the experienced C++ developer, however, it doesn't really supply any ground breaking information on C# or its framework; it only skims over what could be discovered by yourself with a bit of exploration.
   As I said originally, it does serve to fill in some gaps left out by other books, but I would steer away from this book if you are a beginner or even new to OOP. Another thing that in fact annoyed me about this book was its false claim that the .NET guidelines recommend against ANY use of Hungarian Notation at all. In fact the guidelines only recommend against using hn for exposed members. Private variables are still up to the team to decide upon. This was personal point of view & not related to true recommendations.
   
   This book may better well serve as a reference but definitely not as a step by step beginner's book. It will leave you with more questions than answers. I would go for a book more dedicated to a particular facet of .NET, rather than this `all in one' step by step. For that reason, I'd probably choose Petzolds if you're looking to learn the C# `language', (It is also an excellent start in learning about OOP, though it doesn't touch upon Interfaces). There are also other excellent books on OOP, ADO & the .NET framework.
   
   The style of this book leads me to believe it was written with the C++/Java developer in mind who want a quick jump to C#, rather than the VB developer who needs to adapt to the new framework. I'd only buy it if what you're looking for is a brief overview of the lot.



2. One of the best book I have seen on the subject for people new to C# .Net, but know some other language.



3. It starts out in the first ten chapters explaining the concepts pretty well, and then it turns into an example-fest without any consideration for its namesake ("step by step"). All the examples are incomplete using "..." to signify previously exampled code. Its like a freaking jigsaw puzzle (especially CH 15) unless you have a laptop and are following the source from the cd), but why must you use both? The book itself should be self-contained.
   I read some other reviews and felt the same criticisms reading it in the book for the first time (especially on the "ternary operator statement" from the review by ANT).
   THE BOOK IS NOT FOR BEGINNERS.
   I still don't fully understand what struts or interfaces are. In places, it uses allegories instead of definitions. The book is just bad. I think Im writing this review mostly for venting frustration about the amount of time I spent reading it.



4. this is pretty good book for a beginner who has some programming experience and wish to learn C#. i have read some of the comments such as "Definitely Not For Beginners". i would like to say, probably the reader doesn't know how to program at all. the example is easy to follow. i have to admit that i didn't test on all the sample code from CD, but with the thorough elaboration learned from the book, it's enough for me to write my own testing code. For example, there is some topic about ArrayList and the book provide a sample for playing card, instead of using the sample provided, i rather write my own to test it out.
   
   this book is not for those who want to learn windows programming in c# or web development. if you already know c# but want to know more about windows / asp.net programming. this is not the book for you.



5. This book does, indeed, take you through C# step by step. It does a farly good job of introducing concepts and showing them in action. Usually by opening a file and entering the code. My biggest complaint about this book and the vast majority of other programming books that I've encountered is the lack of exercises. It's all well and good to demonstrate a while statement and the data types but just saying, "Type in the following lines", doesn't teach you to write a program.

5 comments about C# for Programmers (2nd Edition) (Deitel Developer Series).

1. 1. This book teaches the syntax of C# -- that is why I purchased it. 2. This book also attempts to teach the reader UML. 3. This book also fancys itself a "best practices" reference giving tips and recommendations (which they sometimes don't follow in their code examples).
   
   From the title, I was expecting an intermediate to advanced book designed for people who already knew what a variable is or a control structure. This book is more of an introduction to programming than a book for programmers.
   
   This book tries to do too many things and as a result does not do any of them particularly well.
   
   Recommendations - Cut the book down to 300 pages or so for someone who already knows how to program. Leave the UML to the OMG experts. There are plenty of good UML books without cluttering up this one. I would also recommend removing most of the tips and helpful hints. A developer can get better information from "Code Complete". These tips are distracting, disjointed and not particularly well presented. If the authors REALLY feel compelled to add helpful hints or a UML guide, I recommend putting them in the appendices or adding supplementary volumes each with a different emphasis.
   
   This book was not what I expected from the title.



2. I have been programming for over 18 years and this is the book
   I turned to when it was finally time to learn C#. The book
   features a large number of sample programs that are easy to
   understand. Each sample is followed by paragraphs that explain
   what the code is doing, line by line.
   
   The best way to use the book is to read a section, and then
   build the sample program from scratch. There are a few instances
   where the text is not perfectly clear on which elements to place
   on the form, and there are a few errors in the sample programs.
   In case you get stuck, all the sample programs are avaiable
   (compiled) on the Deitel web-site.
   
   I give the book 4.5 stars.



3. This book is a good blend of computer science and programming C#. I especially appreciated the treatment of UML. Of course, like any other book of this nature, it can't teach all you need there is to know on the subject. It is a very good starting point for learning programming. It's up to the reader to take the knowledge gained from the Deitel book and build upon it. Overall this is a very good book.



4. This book is very comprehensive yet thorough for programmers who are new to C#. I enjoy the nice explanation of XML concepts at the conclusion of most of the early chapters although I have only read up to chapter 7. If you are late on the concept of object-oriented programming, it also gives a detailed explanation of how real-life objects can be applied to programming (go figure the concept object oriented-programming).



5. In general, I like this book because it covers a lot of material fairly systematically. As a tech writer, though, I've got one observation I haven't seen here before - I use the index quite a bit and I find that, in many instances, the page listed has nothing to do with the index topic. That's pretty bad. A reference book should have a better index.

No comments about ASP.NET 3.5 AJAX Pocket Guide.

5 comments about Practical Guidelines and Best Practices for Microsoft Visual Basic and Visual C# Developers (Pro-Developer).

1. In the [...] environment there are many different ways to accomplish the same result. This book provides information from people who are indisputably knowledgeable in the area that helps enormously in choosing between the various options. One of the most useful parts of it is the explanation that is provided for why one option has been chosen above another, which is to say, why it's a "best practice." I would recommend this book to any .Net programmer who wants to acquire concrete data that will help him in making his programming decisions.



2. John Robbins on the foreword of this book wrote "..No matter how you use Practical Guidelines and Best Practices, it will save you a tremendous
   amount of time by helping to reduce those insidious bugs and performance problems in your
   code. I've been using it with all my projects, and it's certainly made me a much better developer.."
   
   I'm a simple .Net developer, how can i say more, from when i bought this book it is ever on my desk like the Holly Bible.
   
   I had the honor of met both Francesco Balena and Giuseppe Dimauro it was like a normal violinist could talk with two Paganini.



3. This book was referred to me by a friend that is a very talented developer. I now see why he keeps this text on his desk while developing. The author provides excellent code examples in multiple languages. This is one of the best books that I have purchased in years !



4. As a compendium, making for efficient reading, among the best. Definitely one of my fire exit books. Can't wait for the sequel for .Net 2.0/3.x.
   Congratulations to the authors for winning an Excellence Award from the Society of Technical Communication.



5. This is very much guide to best practise in your dev team. It will help any team and sure helped mine.
   Its easy to absorbe and it makes a different.
   It can also be dipped into when you need 'advice' and for us was a first port of call when we were setting up best practise in our department.
   Might be one to get second hand and ensure that it circulates in your department.