2 comments about Computational Finance Using C and C# (Quantitative Finance) (Quantitative Finance).

1. This book has to be more densely populated with formulas than any I have read before - it reads like Cliffs Notes of a mathematical finance book. The C/C# component is less interesting; I have not examined the included CD, but code excerpts in the book were matrix computations that could be implemented in any other language, and were presented just OK. Think of Paul Wilmott meeting Justin London - definitely more London than Wilmott - and wonder how Levy's book stacks up against the combo of theirs, and against Levy's own 'Computational finance'. (I don't know the answer, and don't want to penalize the book with a less-than-five-stars rating).



2. This book is going to require that you have had a few semesters of Calculus under your belt, but if you have this looks like interesting reading as far as the math is concerned. The writing is a little dry and the author pretty much runs through his mathematical proofs and then sometimes he writes a short code clip illustrating the proof; he certainly knows his subject matter but as a programming book I found it lacking. First of all contrary to what the first reviewer wrote there is no CD included with this book; perhaps that was written by one of the author's friends and he never actual saw a retail copy of the book, I don't know. Second of all, all of the source code is not included in the book nor is it published on the publisher's web site free of charge; you are required to pay additional money for the source code which I found rather cheap on their part. Also, as of the last time that I looked a week or so ago the source code was not available on the web site even for a price which is very poor management on their part. This not a cheap book as far as normal programming books are concerned, it is priced like a college textbook and being more expensive they should throw in the source code for free. Increase the price of the book if you must but only one price, not a second hidden price after the fact.
   
   This is a complicated subject and no book is going to give you a functional knowledge in just 384 pages. If you are looking a book that covers some of the mathematical theory of finance then perhaps this is a good book for you, if you are looking for a finance library that you can plug into your applications then this is not the book for you and may be in fact way over your head.

5 comments about C# Class Design Handbook: Coding Effective Classes.

1. Excellent book if you are looking for a reference on coding C# classes. Explains all aspects of class containers very well but only one chapter is devoted to class design concepts. A little more depth into this subject could have been better.



2. Let me start by saying that I found this book to be fantastic. I would recommend this book to any intermediate programmer that's feeling a little stuck in where to go next.
   The book starts off with the basics, the same way that most C# programming books do. It starts with the difference between value types and reference types, but what I found as I read into the first chapter was that this book went way beyond any other that I have read. It has simple examples to differentiate between the two types but then has you view the IL for the examples and starts to explain why value types and reference types are handled differently. That was just the beginning.
   The Class Design Handbook takes you through short, easy to understand examples that enforce the goal of the book but then as in the first chapter it goes on to explain why things are done a certain way, why a good design my incorporate or avoid something and what is actually happening behind the scenes.
   The other aspect of the book that I've found to be exceptionally useful is chapter 6. Events and Delegates; this book contains the first concise explanation of the .NET event handling model that I've seen. It takes you through the code that .NET creates to represent a delegate class and through IL shows you what is really happening.
   This book sits on my desk at work and when I know I'll be writing C# at home, it travels with me.
   Simple explanations, easy to understand code examples and straight-forward text make this an excellent reference book, although I read it cover to cover (geek). I use this book especially during the design phase of any project and recommend that anyone that feels like they need a little boost in the learning department will enjoy this book.



3. This book is intended for the intermediate C# developers who want better understanding of OOP (Inheritence and Polymorphism). The book wastes very little text and gets to the point. This book is clearly not intended for the beginners. The book covers the following:
   
   1)Defining Types
   2)Type Members
   3)Methods
   4)Properties and Operators
   5)Constructors and the Object LifeCycle
   6)Events and Delgates
   7)Inheritance and Polymorphism
   8)Meta data
   
   The book doesn't contain any sample problems or questions. If it did, then I would have given this book 5 stars. I consider sample problems (and answers) crucial in truly understanding a computer language.



4. The book gets to the point and covers the details of the CLR and how classes are represented. The MSIL representations are very enlightening providing good insight into how the class will perform. The example source code from the website is helpful and offers a good place to experiment.
   
   I bought this in 2004 and the cover is worn and faded the pages are dogeared and from time to time I see other programmers digging through it. If anything would be a reference to the books value it would be the amount of wear it has compared to my other books.



5. This book is a great example of the quality literature one expects from Apress. It delves into topics covered in most books on C#, but with an eye strictly toward class design and functionality. The authors have done a great job and the book reads as if it was written by one voice instead of five. A must read for all beginners.

5 comments about C# Unleashed.

1. This is a good introductory book on C#. The author covers most of the topics by code which I like. The book is focussed on the C# language itself without much coverage on other .NET topics ( ADO.NET,ASP.NET,Remoting) rightly so. In short a good starter book on C#



2. This is a excelent book, my husband and enjoy it. We find this a little deeper that the usual C# books. I will recommended to you.



3. I came from a shallow programming background of VB.Net and C++, and this book was excellent for the transition. This book is great reference material for the language and the .net framework in general. Almost every aspect of C# is covered in this book, which makes this book is a must have for any person programming in C#. It is wonderful to have a book to be able to turn to instead of searching the internet.



4. This Book does what it says it will ;)
   It definately helped me!!



5. This book presents a good introduction to C#. After reading this book I have the good understanding of C# and ready to move on to advanced books.

No comments about Microsoft Visual C# 2005, An Introduction to Object-Oriented Programming.

5 comments about .NET and XML.

1. This book has probably all you need to know about reading, writing, formatting and sending XML over the wire with C#. Standout chapters for me were chapters seven, on XSLT, and nine, on web services. That being said all of the non-reference chapters were evenly written, easy reads and neither rat hole nor pander to the reader. The code samples are numerous but they are hilighted with bold to emphasizes the portions that a critical to the narrative.

   C# is the only imperative language covered in the book even though most .NET authors cover both C# and VB.NET. In the introduction the author calls C# the central language of .NET and says it's the best language for the job. I don't have big issues about that but other potential .NET readers may, especially considering the popularity of VB.NET. Personally I prefer when the author chooses one language and then leaves the other to the site or the CD. I think VB.NET example code fragments on the O'Reilly site probably would have been a safer bet.

   It's this one language approach in the dual language .NET environment that kicks the rating from five down to four.




2. Over the years, I've found it increasingly difficult to buy technology related books simply because of the speed in which they become obsolete. So now I look at each book as not only an instructional tome, but whether or not it will be useful 6 months down the road as a reference. This book (like many of O'Reilly's titles) has easily earned a place in my library.
   
   Mr. Bornstein's method of writing seems to fit very well with the way I learn, and his coverage of the subject matter makes this book a great resource when I'm trying to remember the exact syntax of a specific method call.



3. Note that I decided to write this review because I could not believe that so many people wrote so nice reviews about this book. My assumption is that someone or some people are really trying to sell this book, because this book is definitely not that good whatsoever.
   
   Actually, this book is definitely not what I expected from a .NET/XML book. I was expecting a practical book with some theory, a good description about .NET's XML implementation and good examples. This is not what this book included. I'm very flexible with books. It's impossible that every book will be perfect. Actually, most aren't, so you have to get used to it, but again this book is for the most part terrible, unless you only want to get a general idea of how to use XML with .NET, otherwise get a different book. Again, I don't know where the reviews for this book came from, because this book is really not that good.
   
   To name a couple of things that I find wrong with the book, lets start with the examples included. Two words: they suck! Each chapter is pretty much like this: here is the general theory, some of it unnecessary like the constant reference to W3C stuff; then, here are a few lame, simple examples without much substance; now, lets go to the next chapter.
   
   The first time I looked inside the book I was looking for information about how .NET did Xml Validation, and it is just terrible. I actually found more information out of general .NET books I already had, than from this one. And when you are working on a project where you need this information, and you have a book that's suppose to help you with this stuff, it is very disappointing to find out that the book is pretty much irrelevant.
   
   You would assume validation is a very important XML topic, among many others, but there's really not a lot of info on it. Actually, if you look on the book's index, you'll see that about half the related info is in the reference section, which you could get out of MSDN anyway. BTW, almost half of the book is simply reference for the different .NET XML namespaces. Again, the same data you could get out of MSDN.
   
   In any case, I know there's not much else to choose from, but pretty much anything else might be as good or possibly way better...



4. i was looking for example on using the System.xml.serialize name space. This is the example copied from the book
   public enum AddressType {
   Home,
   Office,
   Billing,
   Shipping,
   Mailing,
   Day,
   Evening,
   FAX
   }
   If you'll look again at Example 9-7, you'll see that each state is actually listed by its full name, not the abbreviation as listed in the State enumeration. Here I've added an XmlEnumAttribute for each state name. Note that I've skipped some in the interest of space:
   
   public enum State {
   [XmlEnum(Name="Alaska")]
   AK,
   [XmlEnum(Name="Alabama")]
   AL,
   [XmlEnum(Name="Arkansas")]
   AR,
   [XmlEnum(Name="Arizona")]
   AZ,
   // ...
   [XmlEnum(Name="Washington")]
   WA,
   [XmlEnum(Name="Wisconsin")]
   WI,
   [XmlEnum(Name="West Virginia")]
   WV,
   [XmlEnum(Name="Wyoming")]
   WY
   }
   The Address class has one attribute, type, and four elements. Here I've added XmlAttributeAttribute and XmlElementAttribute, as appropriate. The AttributeName and ElementName fields of each attribute are used to set the names of the XML attributes and elements, respectively:
   
   public class Address {
   [XmlAttribute(AttributeName="type")]
   public AddressType AddressType;
   [XmlElement(ElementName="street")]
   public string[ ] Street;
   [XmlElement(ElementName="city")]
   public string City;
   [XmlElement(ElementName="state")]
   public State State;
   [XmlElement(ElementName="zip")]
   public string Zip;
   }
   Similar to Address, the TelephoneNumber class has one attribute and three elements. Again, I've decorated each member with the appropriate attribute. Note also that here, as in Address, I've set the names of the attributes and elements to match the ones in the XML; that is, they all start with lowercase letters:
   
   public class TelephoneNumber {
   [XmlAttribute(AttributeName="type")]
   public AddressType AddressType;
   [XmlElement(ElementName="areacode")]
   public string AreaCode;
   [XmlElement(ElementName="exchange")]
   public string Exchange;
   [XmlElement(ElementName="number")]
   public string Number;
   }
   Now we come to the meat of the personnel record, the Employee. This class has three attributes: firstname, middleinitial, and lastname, which I've treated with the appropriate attribute. However, the Employee class also has two additional elements, addresses and telephones. These two elements actually contain nested arrays of elements, so I've used the XmlArray and XmlArrayItem attributes to help the serializer figure out what to do with the XML elements it reads:
   
   public class Employee {
   [XmlAttribute(AttributeName="firstname")]
   public string FirstName;
   [XmlAttribute(AttributeName="middleinitial")]
   public string MiddleInitial;
   [XmlAttribute(AttributeName="lastname")]
   public string LastName;
   
   [XmlArray(ElementName="addresses")]
   [XmlArrayItem(ElementName="address")]
   public Address [ ] Addresses;
   [XmlArray(ElementName="telephones")]
   [XmlArrayItem(ElementName="telephone")]
   public TelephoneNumber [ ] TelephoneNumbers;
   
   [XmlAttribute(AttributeName="hiredate")]
   public DateTime HireDate;
   }
   Here's the document element, personnel, which is decorated with XmlRootAttribute. Although the Employees member is an array of Employee objects, it is not a nested array, like addresses and telephones. By adding the XmlElement attribute directly to the member, the XmlSerializer knows that this member is to be serialized as an array of employee elements, without a separate top-level element:
   
   [XmlRoot(ElementName="personnel")]
   public class Personnel {
   [XmlElement(ElementName="employee")]
   public Employee [ ] Employees;
   }
   Finally, I've made some changes to the Serializer class, which I introduced in Example 9-5. Serializer's Main( ) method still uses the CreatePersonnel( ) to create some personnel records, but it then instantiates an XmlSerializer to deserialize the objects it created back out to a file:
   
   public class Serializer {
   public static void Main(string [ ] args) {
   Personnel personnel = CreatePersonnel( );
   XmlSerializer serializer = new XmlSerializer(typeof(Personnel));
   using (FileStream stream = File.OpenWrite("Personnel.xml")) {
   serializer.Serialize(stream,personnel);
   }
   }
   }
   
   notice its in java??? for crying out loud if your going to say .net and xml use .net examples not JAVA



5. A careful reader would have noticed the "using" keyword in the code sample, and realized that this is C#, not Java. I found this book a good supplement to the MSDN; its well-conceived examples got me off to a good start in this area.

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 Experienced Programmers (Deitel Developer Series).

1. It's not for Experienced Programmers. If you are a VB programmer then this is a good book for you but if you are working with C, C++ or Java then get another one like Professional C# or C# and the .NET Platform.



2. I found this book great for getting up to speed on .NET and C# in a short time but certainly not for experienced programmers.



3. 
   I work many years with C++, and needed a good book to
   give me a solid and educational foundations of C# in
   a solid way, and the book helped me a lot with the great
   examples. The educational approach helps you to get the
   core of the language, and then you can use the online
   manuals to complete the little details
   
   Recommended for experienced programmers who move to C#



4. This book is what you need if you do not know C# or .Net and need to write a non-trivial application in C# soon. I picked it up when I was already an experienced Java developer with a good knowledge of OO and UML. While some topics covered in this book seemed to be way too trivial to be included in a book with 'experienced' word in the title, it does it job pretty well.



5. Although Deitel's "How to Program" books are primarily intended for use as textbooks in intro-to-programming college courses, the books tend to be around 1,500 pages long and contain a lot of code examples and breadth of coverage of more advanced programming topics, making the books useful to experienced programmers wanting to learn a new language. But unlike college students who are required to purchase a specific textbook for their programming class, professional programmers are less willing to pay exorbitant prices, so the "Deitel Developer Series" offers slightly cheaper, abridged versions of the "How to Program" books, targeted at professional programmers.
   
   "C# for Experienced Programmers" is one of two abridged versions of "C# How to Program." The "C# for Experienced Programmers" book retains full coverage of the more advanced topics while condensing treatment of basic intro-to-programming concepts, such as control structures and arrays, and removing the end-of-chapter exercises. Chapters on control structures and arrays are still there, albeit in condensed form, so if you need to know, for example, how to declare an array in C#, you can look it up. Object-oriented programming is covered in full, in case you're not already familiar with it from another language like Java. More advanced topics covered include exception handling, multithreading, networking, graphics and multimedia, SQL, ADO .NET, XML, ASP .NET, and Web Services.
   
   Although "C# for Experienced Programmers" is essentially an abridgement, it does contain one (1) chapter not included in "C# How to Program." The chapter is about Microsoft Mobile Internet Toolkit, which is used to develop applications for wireless platforms such as cell phones. Also, "C# for Experienced Programmers" includes all of the appendices in printed form, whereas "C# How to Program" has many of the appendices in electronic form on an accompanying CD. If you buy a used copy of "C# How to Program," the CD might be missing, in which case you would not have access to these appendices. However, the appendices are mostly nonessential or not directly related to C# programming. For example, there are four (4) appendices on writing HTML and XHTML.
   
   The other abridgement, "C# A Programmer's Introduction," focuses more on basic programming skills like control structures and arrays, and omits or condenses treatment of more advanced topics like ASP .NET and Web Services. Experienced programmers and anyone familiar with basic programming concepts and the C++/Java/C# style of syntax will probably want to avoid "C# A Programmer's Introduction" and choose either "C# for Experienced Programmers" or "C# How to Program."
   
   So which one is the better buy for an experienced programmer? I ultimately decided to buy "C# for Experienced Programmers": it's cheaper and includes the full, unabridged content of the later chapters and appendices, minus the exercises. "C# How to Program" has a lot of introductory material on basic programming concepts that you don't really need (although I suppose it's easy enough to skip over stuff you already know). Plus, "C# How to Program" isn't even in full color like previous Deitel "How to Program" books. Full color makes reading code examples easy (e.g., comments are in green), but "C# How to Program" instead uses a black, white, and red color scheme. "C# for Experienced Programmers" is in black and white, which I personally prefer over monochromatic red. "C# for Experienced Programmers" also has sturdier pages than "C# How to Program" -- the only downside is that the pages are also thicker and cause the book to be much larger and somewhat unwieldy.
   
   There is also a second edition of "C# How to Program" now available, updated for the new version of .NET. Apparently the Deitels decided that it was too confusing having two "for programmers" versions of their "C# How to Program" text, so instead of "C# A Programmer's Introduction 2/e" and "C# for Experienced Programmers 2/e," there is only one second-edition "for programmers" book, called "C# for Programmers (2nd edition)." As with the two first-edition "for programmers" books, the end-of-chapter exercises are missing from "C# for Programmers 2/e," but otherwise the only difference I noticed in comparing the tables of contents available from the Deitel website was that "C# How to Program 2/e" has a few more sections in the very first chapter, one of them entitled "What is a Computer?"

4 comments about Beginning Visual C# 2005 Express Edition: From Novice to Professional (Beginning: from Novice to Professional).

1. This is a book that introduces you to the C# language using Microsoft's Visual C# Express Edition (which is now free to download).
   
   Things I liked:
   - Author's style of writing is on the casual side and it is engaging.
   - The range of topics covered is especially chosen to give you a good idea of what you can acheive with VC# Express Edition. So, not only are the basics of C# covered, but you also get coverage on how to use Windows Forms, databases/ADO.NET, Wev Services and XML in VC# Express Edition.
   - Aside from Chapter 7 (see below), I didn't find too many typos in the book.
   
   Stuff I wasn't so thrilled about:
   - Chapter 7, "How C# Express Helps You Code" is based off of the beta edition of C# Express. A lot of the keyboard shortcuts, along with a few other items, are not the same in release version, thus taking away some of the usefulness of this chapter.
   - Not a good choice for those new to programming. Despite its claims, this book is best for someone who's programmed before.
   - Don't expect to go "From Novice to Professional". If you're a novice, you'll still be one even after reading this book. It's short intro. book after all.
   - A few of the chapters covering more complicated topics, could use a few more examples to expound on the key points and drive them home.
   - The summaries of chapters are not very good at highlighting key points. While this is not so important when you're reading through a chapter, it's very important when you're going back to review a chapter. A tabular summary of key points and mini code examples would be much more useful. Even review questions would be helpful.
   
   Bottom Line:
   A good book if you're a programmer who's new to ASP.NET or C# and wants to have some fun with MS Visual C# Express Edition.



2. With the advent of the "Express" addition of Microsoft's Visual Studio tools, it doesn't take a small fortune to start learning their environment. In fact, it doesn't cost you a dime. They're free. Peter Wright takes advantage of that fact in his book Beginning Visual C# 2005 Express Edition: From Novice to Professional. It's a good book, but I think I would have titled it somewhat differently...
   
   Contents: Welcome to C# Express; The Basics of C#; Working with Variables; Classes and Object Orientation in C#; More-Advanced Object Orientation; Handling Exceptions; How C# Express Helps You Code; Building Windows Applications; Windows and Dialogs; Lists; Menus and Toolbars; Delegates - Events Internals; Lists and Generics; Files and Streams; Working with XML; Database Programming; The Internet and C# Express; Threading; Where to Now?; Index
   
   You can pretty much view this as a tutorial to the C# language... how it's structured, how it works, and what you can do with it. The "Express Edition" part comes into play in terms of what IDE he uses to teach you the language... Visual C# 2005 Express Edition. Being that you can download it free from Microsoft (it's even on the CD included in the book), you don't have to plunk down a wad of cash to get into the game. In fact, the Express Edition of the software does most of what you'd need for personal projects and programs. I wouldn't want to try and run an IT department on it, as the features for the "real" version of Visual Studio address that market. But Wright uses this great option to get you familiar with the world of .NET and C# in particular. There are plenty of screen shots and code examples to work from, so there's no reason why you shouldn't be able to ground yourself in the fundamentals here.
   
   In the opening, I mentioned that I thought I would have tried a different title. The one that was used makes the book sound as if it's a tutorial on how to use Visual C# 2005 Express Edition as your IDE. Instead, it's really how to program in C# using the Express Edition IDE. It may sound like a minor point, but it might throw a few buyers. If I already knew C# and wanted a book on the IDE, the title here would lead me in the wrong direction...
   
   Even with that minor quibble, it's still a good approach to start down the C# path if that's where your programming interests are leading you...



3. Being a programmer for many years, this is one of the good books, which I would recommend a novice programmer to start of with. I also see it as a C# transition platform for C/C++ programmers.
   
   I like Peter Wright's "down to earth" and personal approach guiding the readers.
   
   A good book to have for beginners and intermediates.



4. One thing that was striking about this book is the author's definition of polymorphism. He says that Polymorphism is the ability to create many methods in a class with the same name but with different signatures. In my my knowledge, that concept is called method overloading. Polymorphism is the ability to call the same method on objects from different classes that inherit from the same superclass or interface.

5 comments about Sams Teach Yourself Microsoft Visual C# .NET 2003 in 24 Hours Complete Starter Kit (Sams Teach Yourself).

1. I just finished reading this book cover to cover and I'm afraid I don't know C# much better than I did before I started. I am now an expert in using the (really cool and powerful) Visual Studio.Net Integrated Development Environment, but I hardly learned a thing about programming. So, if you want to be able to create cool applications by dragging and dropping and using menus, this book is great. If you want to have a clue about the code behind your applications and/or learn some lessons in Object-Oriented Programming, you'll need another book. (...)



2. The book does a decent job of covering visual C# material. But the way it is organized is so bad for new programmers that I can only give it one star. You keep getting "write this code, I will explain later" that most newcomers to programming will give up withing the first three chapters as all they do is point and click and write tons of code they have no ideah how it works. This book was obviously written by a programmer who doesn't teach new students. We have this book at work and none of the 4 people who used it had any success in learning to program in C#.
   
   This is odd for a SAMS book, as they are usually excellent learning books. I would recommend the Teach Yourself C# in 21 days as a better tool for a new programmer to grasp the language.
   
   Even for experienced programmers (and I have been one for 18 years), the book is hard to follow. Phrases like "now add this code ..." whithout saying where (you are stuck looking at pictures in the book and your source code file to finally figure out where the code is suppose to go) doesn't help one bit.
   
   This is a teach yourself book, it should take you from scratch and teach you. All it does in the first few chapters is confuse you and discourage your from learning. I suspect this book was bought my many who ended up leaving it on their bookshelf thinking they cannot learn to program while the problem is not them at all. That is unfortunate!



3. As I am new to programming, I thought I would go down the Sams publishing route and find a book that would teach me the basics and foundations for C#. And this is what the book did. I felt the author didn't scare you with technical jargon and slowly introduced you the more high-end stuff. The book is designed at beginner level and was pleased with the purchase.



4. In pursuing to update my technical knowledge, I decided to purchase this C# .NET 2003 book written by James Foxall. I was impressed at the level of detail and easy to understand content. What I was mostly impressed by is how the Author personally answered some of my questions without hesitation. That's something that I haven't been able to obtain from other book author.
   
   I will definetely pursue purchasing from this author in the future.



5. James Foxall has written a book that clearly elucidates the mysteries of the Visual Studio.NET environment. Written in five well-organized sections, this book leads the reader through a step-by-step approach to building basic Windows applications. Using a "nuts-and-bolts" type of approach, the author presents the concepts of object-oriented Visual C#.NET programming via a series of brief, but effective projects found in each of the 24 chapters.
   
   Starting with the fundamentals of objects, Foxall shows how to build a user interface using forms and controls. He then adds menus and toolbars to create workable applications. While performing these tasks, the reader begins to grasp the concepts of properties, methods, and events.
   
   From the user interface, the reader learns the basics of C#.NET by writing brief lines of source code and how to manipulate data. Finally, the concept of designing custom objects using classes fulfills the author's objective of teaching the user how to design their own applications.
   
   This text is indicated as a user guide for the beginning. However, I found it to be ideally suited for any one with even a modest programming background. To an aspiring Windows programmer, this text has good introductory value to satiate even the most curious.

5 comments about Windows Developer Power Tools: Turbocharge Windows development with more than 170 free and open source tools (Power Tools).

1. I'm big into using the right tools for the right jobs. One can find a gazillion of tools out there on the internet, so it's hard to decide which ones are actually worth checking out. This book remedies that by giving you a consolidated list of tools that everybody developer should at least have a look at.
   
   I also blogged about this book at:
   http://claudiolassala.spaces.live.com/blog/cns!E2A4B22308B39CD2!356.entry



2. [...]
   
   Until reading this book, I did not realize how much productivity I stood to gain.
   
   When I first agreed to review this book I didn't know what I was really getting into. I expected a brief catalog of fairly standard, well-known tools which would only come as a surprise to fresh graduate. I expected I getting a small pocket-sized book which I could devour in one train ride. I could not have been more wrong.
   
   The book covers over 170 Open Source tools across a wide variety of development domains from Windows Forms and Web Development, to working with Databases and XML data. Each tool will in some way enhance your productivity in some way, allowing you to do the things your really enjoy about writing software on the Microsoft Windows platform. The productivity gains vary from being able to generate the tedious 80% of your project to those 5 second boosts which all add up and prevent RSI.
   
   Each of the 23 chapters is targeted at a particular issue or development task and opens with one or two pages describing this task. These are so well written that I think the opening of Chapter 9 [Analyzing Your Code], which gives a quick explanation of code metrics, is my favorite section of the whole book. This means that the book is not just an encyclopedic reference of tools, but also of modern development techniques.
   
   After the introduction a very brief description of each tool follows. These are great memory refreshers once you have read the book and are repeated on the companion web-site. Each tool is then given its own section and the chapter closes with a bibliography for people interested in finding out more.
   
   This structure of "Introduction, Overview data, Full text, Where to get more information" is repeated for each tool. The overview data includes such information as:
   
   The version covered
   The home page
   The license type
   Which versions of the .NET Framework are supported
   A collection of related tools for cross-referencing purposes
   
   The full text of each tool explains where to get the tool, how to install it and how to get started using it allowing you to jump straight in and leverage the tool. This section is often littered with useful screenshots which give you a glimpse at the experience you will find when using the tool. The text for each tool closes with instructions for getting support on the tool and often a brief passage from the tools creator explaining the thinking behind creating the tool.
   
   If that weren't enough, the book also has a companion website at www.windevpowertools.com where all of the tools are listed and tagged, each with a download link enabling you to download one straight from the site. You can even create your own "toolbox" and add tools from the site to it, allowing you to quickly and easily provision new machines from the web site itself.
   
   All in all I have thoroughly enjoyed reading this book. I would have liked to have seen more information about the selection process for the tools and readers would do well to remember that a tools inclusion (or lack of inclusion) in the text is not necessarily an indicator of its maturity or usefulness. Be sure that you have a lot of time if you buy this book as you are likely to download, install, and play with many of the tools. If you do then using a virtual machine is highly recommended. None of the tools did anything harmful to my computer, but having 170 tools running at once just isn't advised!



3. Windows Developer Power Tools: Turbocharge Windows development with more than 140 free and open source tools (Power Tools)
   
   Overview
   
   Open-source and free developer/performance tools can be found in abundance on the internet today but one of the few issues that generally comes up after you've gotten hold of one is "how does this work?".
   
   On occasion you'll start to use a tool or add-in only to find out later on that there's a much better way to utilise the power you suddenly have at your hands - but by then, you've spent hours already "mis-using" the tool.
   
   This book arms you with information, tips and tricks, how-tos and descriptions on a host of known, and possibly unknown, tools that will seriously help you speed up your development - so why not be the hero of the office and start developing smartly!
   
   Over the last couple of years i've been in and out of windows and web development and felt that i was comfortable in both arenas. But after reading this book I knew that I could have been a much more efficient developer if only I'd known about the tools it explores.
   
   The book is divided into suitable chapters, making it very easy to use the book for fast reference if you suddenly remember that you once read (somewhere?) about a tool doing exactly what you're trying to achieve in the old fashioned way - doing it yourself from scratch.
   
   Each chapter (or tool/tip/add-in) is presented in an easily to understand english, with a logical order that makes reading this book a pleasure. Some books comes across with technical jargon without explanations for the varied levels of developers out there, but this book can easily be enjoyed by both the experienced developer and the starting rising star.
   
   Some of my most favorite tools are included in this book, such as Anthem.Net, which encapsulates web forms and extends AJAX capability without having to write a single line of JavaScript.
   
   Other tools which was new to me, included CopySourceAsHTML, and the experience with which i've had with posting code over the years, or including snippets in documentation, has just been greatly improved.
   
   Conclusion
   
   What i found most pleasing about this book, is the consistency in which it presents each topic for you. The authors has gone to great length to make it a flawless experience in reading this book and even though many has contributed to the content, the layout is flawlessly simple.
   
   A very easy read and a bookshelf essential! Five stars...



4. 'Windows Developer Power Tools: Turbocharge Windows development with more than 170 free and open source tools' is one of the most cost-efficient books I have ever read in my life. As the title says, this book is jam-packed with some of the most helpful and needy tools that you can ever find for Windows all put into one huge TOME of a book (1250+ pages).
   
   Spread over 23 chapters, content is broken up into topics like Windows Form, creating documentation, testing, bug tracking, XML, etc. etc. etc. etc. etc. There is so much here is would take quite a while to read but that's not a bad thing in this case. If you are an administrator, developer, or just anyone that wants to learn to use Windows more efficiently, you NEED to pick this book up today.
   
   Love it Love it Love it Love it Love it!!!!!
   
   ***** HIGHEST POSSIBLE RECOMMENDATION



5. DISCLAIMER: I personally know both authors.
   
   The book presents an exensive list of tools available to the .NET programmer. I agree with one of the reviewer that indicates that as soon as the book is published it is out of date; hence, some of the tools may be significantly changed or replaced by better tools. However, this problem is not unique to this book but applies to any book, particularly in technology. In spite of this obsolescence, the book provides a summary for what each tool can do and provides a starting point to do research on a tool that will help the reader perform their job more eficiently.
   I highly recommend this book because it is very comprehensive. In addition it has a number of Windows tools that are also very helpful in tasks that every developer has to do but are not related to writing code.