No comments about SOA & XML Workshop General Session Presentation.

No comments about Overview of Web Services Security Presentation.

No comments about The Path to Successful Web Services White Paper: Navigating the Pitfalls.

No comments about Students with Special Needs in General Education.

No comments about 10 Coding4Fun Projects with .NET: For Programmers, Hobbyists, and Game Developers.

No comments about C# 3.0: The Complete Reference.

No comments about Introduction To Programming With C # . NET.

3 comments about C# Class Design Handbook.

1. This is from [...]
   Chapter 1 is at [...]

   "C# is Microsoft's new object-oriented language, specifically designed to take full advantage of the .NET type system. At the heart of .NET programming in C# is the task of building classes. All C# code participates in the .NET type system, because all code is contained in classes and other types which participate in the class hierarchy of the .NET framework. This book is a guide to help you design these classes effectively, by looking at what control we have over our classes, and how C# turns our class definitions into executable code.

   "Ask anyone: designing effective classes that you don't have to revisit and revise over and over again is an art. This Handbook aims to give you a deep understanding of the implications of every decision you can make in designing a class, so you are better equipped to take full advantage of C#'s power to create classes that are robust, flexible and reusable.

   "This book assumes that you are already familiar with the syntax of C#. It assumes that you have already used it to write code and that you are familiar with your chosen development tools and know how to compile and run C# code. You should also be aware of .NET's basic object-oriented mechanisms. In this book, we'll lift the lid on the simple syntax and examine what it really does behind the scenes."




2. Any exprienced C# programmer may not regard this "C# Class Design Handbook" as the best design tool, but almost all will acknowledge that it has got a lot of positive qualities. These attributes include: good coverage of .NET Framework Class Libraries, detailed recipes, and design interoperability.
   Apart from being down-to-earth, with its method of defining terms and concepts, it has an illustrative teaching pattern, which included a collection of problems and solutions.
   Also, this book contains code recipes, which program developers could use to improve their understanding of the C#; and subsequently, their overall programming skills.
   In summary, this handbook is a multi-purpose manual, which programmers should value for its complementary outlook.



3. On the whole, I was extremely pleased with C# Class Design. It has great organization, perfect length, and superb topic coverage. It is focused, in-depth, and challenging. This is a must buy and a must read for all serious C# developers. In fact, if I could mandate that all of my teammates read this book, I would do it in a heartbeat. Even those using other .NET languages could benefit from this book because many of the principles are not C#-specific, though some features discussed may not be available in other languages, such as VB.NET.

   I would not, however, recommend this book to a beginning developer unless he or she has a good foundation in object-oriented design and other core software development principles. It is by no means a primer, but rather is targeted at the intermediate to advanced developer who wants to excel in designing robust, reusable, and extensible classes for the .NET framework. Nor is it for one who simply wants a set of instructions on how to build an application in C#; rather, it is for the developer who wants to build the best applications because he or she has the best understanding of the effects of class design in the .NET CLR.

   On a more granular level, the table of contents provides a sufficient look at what each chapter covers, and each chapter delivers on what the TOC promsies, and more in some cases. Chapter One takes an in-depth look at reference and value types and, augmented by Chapter Three's discussion of method parameters, arms the developer with the knowledge needed to make the right choices between the two by providing a solid understanding of how they are handled by the CLR. Chapter Five is another essential read, covering object lifecycle and a few design patterns.

   Most of the chapters offer practical advice on best practices in bulleted format to encapsulate some common-sense deductions from the data covered in the chapter. And there are a few gotchas that this book can help you avoid, such as how the compiler handles constants (you'll have to read it to find out).

   There are only two things I'd criticize about this book. First, even though some of the topics covered are complex, I tend to think that it could have been considerably more readable in places, particularly Chapter Seven that deals with inheritance and polymorphism. Of course, part of the problem is that those topics cannot properly be covered in so short a space--they deserve (and have) book-length treatment. The second detraction is that Chapter Eight, while providing useful information, is somewhat off-topic, treating namespaces, assemblies, and documentation, which are only peripherally related to effective class design and are covered in several other books as well as the MSDN documentation.

   In short, this book is definitely worth the {money} that it costs . It is not an easy read and should only be taken up by developers interested in knowing more than the minimum required to build an application. One of the things I love about this book is its focused approach and, consequently, its readable length of only 347 pages. Most books that are longer, that is most developer books, are full of too many code examples and too much re-coverage of topics that other books have already covered. This is a notable exception. I highly recommend it to intermediate to advanced developers.

2 comments about Applied .NET: Developing People-Oriented Software Using C#.

1. If you have kept up with the .NET revolution, you have no doubt seen and read a lot of books on .NET and the .NET languages. Most of the books on C# deal with the basics of syntax with a couple of small samples applications. Very few, however, deal with any sort of real world situations.
   While this book does cover a few of the basics, it is more focused on the people aspect. I feel this is an important, often overlooked, aspect of software development and the fact that it is overlooked is why so much software is hard to use.
   If you are looking for a best practices book, this tome is not quite there. The same goes for a book strong on code. While you can use the CD to look at a good amount of sample code, the book is rather thin. This is not, however, the focus of the book; and, since so many other books cover this, the niche filled here is rather nice.
   If I had to pick the proper audience for this book, there would be two categories: 1) Anyone who has ever had a piece of software fail as the end-users never bought in, and 2) anyone who wants to ensure this never happens. While it is not an excellent book, I have to laud the publisher for taking a chance on this subject matter selling. I hope it does.



2. This book's title is misleading, as it appears to feed off the familiarity with the Applied Programming series of books from Microsoft Press. It is truly a mixed-bag, as the above editorial review admits. After expounding on the 'revolutionary' idea that software should be people oriented, it dives into pages of code that lays out an Asp.Net application. It then sandwiches in a C# fundamentals tour, and then dives right into more code. If there is a purpose to this book, I couldn't distill it. It truly appears as if each author wrote their portion of their book without talking to the other, and then the editor mashed them together the night before the deadline hit.

3 comments about C# Weekend Crash Course (With CD-ROM).

1. A one star rating is an overstatement of the value of this book. I believe the 15 hours is the time the author spent learning the language.

   It is not of value to beginning or experienced programmers. It does not serve well as either a review or an introduction. The examples are poorly chosen, (banking account), poorly explained. The other examples are lacking in clarity.

   Even when something that one knows well from other languages, such as the difference between ++i and i++ is mentioned - it is a mention without an example in a loop or a clear explanation.

   Look elsewhere to get started in C++. 15 hours would be too long to spend with this book. This was my first look at a "Crash Course"...... it looks like a train wreck.




2. Stephen Davis, C# Weekend Crash Course (Hungry Minds Press, 2002)

   A while back on one of the mailing lists to which I am subscribed, a chap popped up asking about books that cover programming console applications (you know, those things that when you run them, pop up in a command line box instead of running within Windows) in depth. My first reaction was "who on earth would want such a thing?" I still don't really know the answer to that, but if he's reading this, I recommend this book highly to him. Davis' whole book is devoted to console apps and DLLs.

   And therein lies its major fault. In a programming world where, let's face it, the GUI has won the day (be it Windows, Xwindows, BeOS, Apple, what have you), a book that doesn't even mention the existence of programming graphical forms is painfully outdated, no matter how recently it was released. (The other C# book I'm reading right now was published the year previously, before Microsoft had even finished the C# visual form designer, and still manages to devote a chapter to Windows forms in C#!) The omission is unforgivable in a book on program design in the twenty-first century, even more so when the books covers Microsoft's .NET technology.

   As for the program design itself, there's a decent amount to be learned here if you're trying to pick up C# after knowing another programming language. (As a longtime C++ programmer, I have no idea how total newbies will react; proceed at your own risk.) A few of the sections try to cram far too much into one thirty-minute session, especially towards the end (the Collections session is almost unreadable without a concordance of some sort; thankfully, I happened to be at the same portion of A Programmer's Guide to C# at the time, and it helped me figure things out without too much pain).

   Probably worthwhile as an adjunct, but I can't see it being a primary reference guide for any serious programmer. ** ½




3. If all you need is to learn C# *syntax* in a hurry this is a good book. That's all the book deals with, and therefore, it only has console (DOS-based) programs.
   
   The syntax it goes over is the basic stuff: data types, while/for loops, if statements, arrays. And creating classes, base classes, methods, and it introduces how C# implements inheritance and polymorphism.
   
   It does not teach anything out of the .NET Framework classes for Windows (forms, ASP.NET, ADO.NET, etc.). It is purely C# base code syntax.
   
   Starting at around Session 13, the book's editor started running out of gas. There was the occasional syntax error, grammar error, poorly worded explanation, or mis-matched examples.
   
   The examples are mediocre. The tone of the book simply presents a working program and picks it apart. It doesn't invite the reader to build the program him/herself, but to simply copy it out of the book or load it from the CD. The "Quiz" section at the end of each lesson usually asks really dumb questions like, "What is the most common of all looping constructs (see 'the for loop')?" There are rarely any exercises to actually write any programs that apply what was to be learned.