2 comments about Sams Teach Yourself Visual C# 2008 in 24 Hours: Complete Starter Kit (Sams Teach Yourself -- Hours).

1. Foxall gives us a quick coverage of C#, well suited to a neophyte. The book seems equally divided between the explanations of graphics and non-graphics. The latter means traditional aspects of any programming language, as in the use of if-else, while and for loops. Here, you might as well be studying C in 1980. These are fundamental constructs that any language needs.
   
   What is perhaps more distinctive of C# are the graphic components, widgets. Foxall shows how to quickly write short programs that can make a few widgets and lay them out in a window for the user to interact with. En route, he teaches about event driven programming, where if you use graphics, the user can interact with the program in many ways. Hence the structuring of code to handle this is quite different from programs lacking a GUI. The use of widgets also lends itself well to you understanding object oriented coding.



2. I found this book to be very well written and informative. He starts at a level almost anyone can understand and expands from there, covering event driven programming, good examples. I specially liked the section on publishing your applications.

3 comments about LINQ Unleashed: for C# (Unleashed).

1. One of the author's stated goals for this book was to make learning LINQ interesting. I believe he succeeded. Whenever he had a chance to use less mundane examples to illustrate LINQ applications, he did so. This is also the first published book on LINQ that had interesting chapters on LINQ to XML.



2. I higly recommend this book. It is easy to read and keeps you interested.
   It is the first book that tries to describe the Entity Framework in one of its chapters.
   The author gives a thorough description of hundreds of ways to make a select statement. Update, insert, and delete are described in very few paragraphs which seems a little bit thin.



3. I purhased that book a couple weeks ago, and man, I love it so much. The author has done an execellent job in explaining the subject. If you really serious about learning Microsoft Language Integrated Query (LINQ), I highly recommend that you buy that book and let the journey begins.

5 comments about C++: The Complete Reference, 4th Edition.

1. Nice book if you want to learn c++. I bought also thinking in c++ by bruce eckel but it is difficult reading and understanding. If you really want to learn c++ search no further, buy this book.



2. Most of my work is done at a low level using C with occassional C++ work usually with certain parts of C++ heavily restructed due to performance and maintenance problems. So recently when I needed to brush up on all of C++ for some application level work where I knew I would be code reviewing and or writing using some of the more beastly aspects of the language I went through my 8 or 10 C++ books to pick one to spend some time with and remind myself of the particulars of things I don't normally use. I chose this book and was happily surprised. It is organized properly, clearly written, and accomplished what I needed it to do in a minimum of time.



3. This was my first purchase from amazon and I was totally impressed by the quality of the product and the service!



4. Herbert Schildt's "C++: The Complete Reference" is a gargantuan tome indeed. It fully covers the C++ syntax, and gives useful, working examples that demonstrate each of the language's features. If you're a professional (or hobbyist) working on a project and need to quickly look up how to use some part of C++ syntax, then this book is absolutely perfect. If you're a developer who has spent his/her life working in C and want to (or need to!) learn C++, then you'll find this book's content well organized and you'll be able to find what you need instantly.
   
   Also, this book seems as though it could function as a tutorial for the complete beginner. Now, I didn't learn C++ from this book initially, so I can't really speak from experience, but the book DOES cover the entire syntax and it does so in an unpretentious and very clear manner. The only thing that it's missing for newbies is exercises -- but if you're really serious, you'll make up your own little tasks, or try to extend/modify the examples.
   
   I program video games as a hobby and have used this as a reference countless times in various projects. I've obviously bought other reference books ("C++ in a Nutshell", and Stroustrup's tome), but I find that this book is my most used and most beloved reference.
   
   So, if you're looking for a clear, easy to understand reference on C++, I reccomend this tome. If you're a true C++ neophyte, then perhaps you should purchase this book along with Schildt's "C++: A beginner's Guide" or "C++ from the Ground Up" (also by Schildt).



5. My older references are in storage and I thought it would be neat to have a c++ ref on my kindle. It says reference and the reviews are good, so I bought it.
   
   I wanted to be reminded of how to use variable numbers of parameters for macro defines. Forget whether this is a good idea. It's a language feature and I want to know how it works.
   
   #define with parameters is handled in one paragraph which doesn't even include the possibility of multiple parameters, let alone any details. Given this, I was curious to see if there was any discussion of the continuation-line functionality in the preprocessor. Nope. Not there.
   
   I'm sure this is a wonderful c++ primer as the other reviews indicate. My spot check demonstrates that this is in no way a complete reference.
   
   Even if you don't like a coding style, completeness allows you to read the code of others.
   
   So I'm out $28 bucks and my question isn't answered. oh well.

5 comments about OpenGL(R) Shading Language (2nd Edition) (OpenGL).

1. The OpenGL Shading Language is without doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. As one of the primary contributors to the development of the language, Rost provides a clear and well-written explanation of the language and how to use it.
   
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders.
   
   The book ends with a handy comparison of GLSL with other shading languages, such as Cg and HLSL, and a couple of appendices providing a language grammar and API reference.
   
   If you're doing shader development with OpenGL, you'll definitely want this book on your desk. My only complaint about it is that it was written before GLSL was officially promoted to the core. When that happened, a number of important things were changed that aren't reflected in the book. However, determining the differences isn't difficult, so don't let that deter you from picking this up.



2. Twenty years ago, I used to program graphics on an Evans and Sutherland PS340. It was then one of the top of the line graphics computers (costing $100k). It could labouriously do shading, but only Phong and Gouraud. Nowadays, many PCs have this ability, and much faster. But a problem still persists, where often the shading methods are restricted to what is implemented on the graphics chips.
   
   In contrast, you have the approach in this definitive book on OpenGL Shading Language. This lets you implement in your code, shading routines of your own devising. To be sure, given the same shading method, one done in this language, and one in the hardware, then the latter will have better performance. But it turns out that today's computers are fast enough, and have enough RAM, that the difference in response might not be appreciable.
   
   The book describes an extensive set of built-in convenience functions that come with the language. And the language's API is explained in detail. The author rightly recommends that you come at it with some experience in the standard OpenGL.
   
   Since the language is still quite new, you are more or less on your own, when looking at development tools. This dearth is expected to be remedied in a few years. But right now, you'll have to rely on your wits. Along with a chapter that gives general principles of how you should develop your own shader. What may be even more use, however, is the second half of the book. Devoted to case studies of many shaders. Understanding these may be more beneficial than any IDE.
   
   Oh, as you might expect from a graphics book, there is a lovely set of colour plates in the middle of the book, showing what custom shaders can do. Treat it as inspiration if you wish.



3. The recent trend in graphics hardware has been to replace fixed functionality with programmability in areas that have grown exceedingly complex (e.g., vertex processing and fragment processing). The OpenGL Shading Language has been designed to allow application programmers to express the processing that occurs at those programmable points of the OpenGL pipeline. Independently compilable units that are written in this language are called shaders. A program is a set of shaders that are compiled and linked together. The OpenGL Shading Language is based on ANSI C and many of the features have been retained except when they conflict with performance or ease of implementation. This shading language is without a doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. The author was one of the primary contributors to the development of the language, and he provides a well-written and insightful explanation of the language and its use.
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders. The book ends with a handy comparison of OpenGL Shading Language with other shading languages, such as Cg, HLSL, and Renderman and a couple of appendices providing a language grammar and API reference.
   I particularly liked chapters 6 through 8, which take you from a simple shading example -"brick"- through the specific steps of shader development that you would need to master regardless of the API you are using. Also the chapters on procedural textures and noise and the accompanying code examples helped clear up some matters that were murky when I read "Texturing & Modeling: A Procedural Approach" by Ebert et al. In summary, I highly recommend this book to anyone interested in implementing software shading, both from the standpoint of OpenGL and from the standpoint of the design process itself. I notice that Amazon does not show the table of contents for the second edition, so I do that here:
   Chapter 1. REVIEW OF OPENGL BASICS
   OpenGL History; OpenGL Evolution; Execution Mode; The Frame Buffer; State; Processing Pipeline; Drawing Geometry; Drawing Images; Coordinate Transforms; Texturing;
   
   Chapter 2. BASICS
   Introduction to the OpenGL Shading Language; Why Write Shaders?; OpenGL Programmable Processors; Language Overview; System Overview; Key Benefits;
   
   Chapter 3. LANGUAGE DEFINITION
   Example Shader Pair; Data Types; Initializers and Constructors; Type Conversions; Qualifiers and Interface to a Shader; Flow Control; Operations; Preprocessor; Preprocessor Expressions; Error Handling;
   
   Chapter 4. THE OPENGL PROGRAMMABLE PIPELINE
   The Vertex Processor; The Fragment Processor; Built-in Uniform Variables; Built-in Constants; Interaction with OpenGL Fixed Functionality;
   
   Chapter 5. BUILT-IN FUNCTIONS
   Angle and Trigonometry Functions; Exponential Functions; Common Functions; Geometric Functions; Matrix Functions; Vector Relational Functions; Texture Access Functions; Fragment Processing Functions; Noise Functions;
   
   Chapter 6. SIMPLE SHADING EXAMPLE
   Brick Shader Overview; Vertex Shader; Fragment Shader; Observations;
   
   Chapter 7 OPENGL SHADING LANGUAGE API
   Obtaining Version Information; Creating Shader Objects; Compiling Shader Objects; Linking and Using Shaders; Cleaning Up; Query Functions; Specifying Vertex Attributes; Specifying Uniform Variables; Samplers; Multiple Render Targets; Development Aids; Implementation-Dependent API Values; Application Code for Brick Shaders;
   
   Chapter 8. SHADER DEVELOPMENT
   General Principles; Performance Considerations; Shader Debugging; Shader Development Tools; Scene Graphs;
   
   Chapter 9. EMULATING OPENGL FIXED FUNCTIONALITY
   Transformation; Light Sources; Material Properties and Lighting; Two-Sided Lighting; No Lighting; Fog; Texture Coordinate Generation; User Clipping; Texture Application;
   
   Chapter 10. STORED TEXTURE SHADERS
   Access to Texture Maps from a Shader; Simple Texturing Example; Multitexturing Example; Cube Mapping Example; Another Environment Mapping Example; Glyph Bombing;
   
   Chapter 11. PROCEDURAL TEXTURE SHADERS
   Regular Patterns; Toy Ball; Lattice; Bump Mapping;
   
   Chapter 12. LIGHTING
   Hemisphere Lighting; Image-Based Lighting; Lighting with Spherical Harmonics; The *erLight Shader;
   
   Chapter 13. SHADOWS
   Ambient Occlusion; Shadow Maps; Deferred Shading for Volume Shadows;
   
   Chapter 14. SURFACE CHARACTERISTICS
   Refraction; Diffraction; BRDF Models; Polynomial Texture Mapping with BRDF Data;
   
   Chapter 15. NOISE
   Noise Defined; Noise Textures; Trade-offs; A Simple Noise Shader; Turbulence; Granite; Wood;
   
   Chapter 16. ANIMATION
   On/Off; Threshold; Translation; Morphing; Other Blending Effects; Vertex Noise; Particle Systems; Wobble;
   
   Chapter 17. ANTIALIASING PROCEDURAL TEXTURES
   Sources of Aliasing; Avoiding Aliasing; Increasing Resolution; Antialiased Stripe Example; Frequency Clamping;
   
   Chapter 18. NON-PHOTOREALISTIC SHADERS
   Hatching Example; Technical Illustration Example; Mandelbrot Example;
   
   Chapter 19. SHADERS FOR IMAGING
   Geometric Image Transforms; Mathematical Mappings; Lookup Table Operations; Color Space Conversions; Image Interpolation and Extrapolation; Blend Modes;
   
   Chapter 20. REALWORLDZ
   Features; RealWorldz Internals; Implementation; Atmospheric Effects; Ocean; Clouds;
   
   Chapter 21. LANGUAGE COMPARISON
   Chronology of Shading Languages; RenderMan; OpenGL Shader (ISL); HLSL; Cg;
   Appendix A. Language Grammar
   Appendix B. API Function Reference



4. I'm not a fan of the 'group of papers' style of book. But this book pulls it off nicely. The text is consistenly good throughout. And the illustrations and formulas are high quality and presented nicely.
   
   I would have liked full color throughout, but I accept that it would have been cost prohibitive on a book of this heft. Speaking of heft, yeah, this is a doorstop of a book. I think some of the text could have been edited down and the formatting tightened up to reduce bulk.



5. I definitely recommend this book for anyone working with OpenGL's new Shading Language. I would, however, say that probably the most difficult part of working with GLSL is getting it working in the first place. Especially on Linux, this is somewhat confusing - some cards support GL 2.0, some don't, but still support the GLSL if using the ARB function calls. I would also make sure to point out to new users that GLEW is close to essential when working with the GLSL - you can download it from sourceforge. It might be worth mentioning in future versions of the book, along with ARB functions which are the same as the GLSL standard functions shown in the book.

5 comments about Learning XML, Second Edition.

1. Most O'reilly books are praised for describing computer programming concepts in a very readable way for an educated audience. Although, Erik Ray's book is engaging enough, he has left out so much detail in the language definitions and real examples that, after reading this book, it is not possible for even an experienced programmer to actually use the material. For example, the book explains the definition of schemas (without enough detail) but how do I use a schema in a project? The intended audience for this book appears to be people who already use xml that want a refresher at an elementary level. Very disappointing.



2. I am amplifying a prior review (Daniel McKinnon's) in order to balance a misperception as to the intent and execution of the book.
   
   This is not XSLT or XPath or "DOM processing in Firefox" or "node traversals with Java", it's an introduction to XML. If you need a solid foundation upon which to base further study, I wholly recommend the book. Unlike other reviewers, I am not in search of the One Canonical Tome on a subject, because I know it doesn't exist in any genre. My needs for learning XML were basic and required a grasp of fundamentals, which you will achieve with this work.
   
   It also has numerous points of interest that a reader can use to further a study of specific issues, such as processing XML using a scripting language, or weighing a schema for implementation, and so forth. As a result, the reader is well-armed to continue learning on the specifics that are of personal interest.
   
   Ir requires a third edition to correct errors and update content, but that doesn't diminish the value of the book for anyone who wants to comprehend what XML is and is not, and what the major issues and challenges are.
   
   -Fred



3. full of nonsense in whole book.
   For example, xml schemas chapter is from page 108 to 164 about 60 pages, but realy useful w3c xml schema only take less 8 pages, others, useless, forget them.
   Hi my dear author,
   you have a lot of work to do, from simple to complex, how can you just give a long example and finish. Do you know "learning" means ***FOCUSING ON CORE***



4. 1. YOU WILL NOT TOUCH A KEYBOARD USING THIS BOOK, IT DOESN'T NOT WALK THROUGH EXAMPLES- for those books, try "XML step by step" by Young (Microsoft), and for more advanced, "XML in Action - Web Technology" by Pardi.
   
   2. THIS BOOK IS GREAT: because it teaches in a fundamentally different way. Most of what we see of XML is tags, attributes, the structure of the data in the elements, etc. But this book focus on the DOM. This crucial focus helps understand XML with its uses, XPointer, and transformation.
   
   3. If you want to do a lot with XML, beyond RSS feeds, buy this book along with a walkthrough, like the books listed above.



5. This book taught me a lot about XML and how it is used in the digital publishing world. XML is not limited to web sites and is a great resource for businesses institutions and other publishing needs where a common format is needed for each and every document.
   
   I recommend this book for anyone wanting to learn more about XML and how it is used.

5 comments about The Object of Java: Introduction to Programming Using Software Engineering Principles (2nd Edition) (Visual Quickstart Guides).

1. The BlueJ IDE is less than impressive, and my copy (1st edition?) has plenty of errors (diagrams and/or codesamples have typos or are "wrong" with respect to the main text) ... however ... this book teaches OBJECTS using Java, not just how to program in Java. The excercises use problems that are optimally suited to object oriented solutions. The book was never boring or hard to understand. I love this book!



2. Let me say first: I love the BlueJ environment. It is by far and away the best environment I have ever seen for learning or teaching Java. I was facinated after reading the tutorial that comes with it (from www.bluej.org), and I got this book.

   This book is okay, and has some good points to it, but the 'BlueJ' tag on the front cover is a bit misleading. I got the impression that it was added as an afterthought, and does not make really good use of the BlueJ environment.

   BlueJ opens many fascinating possibilities (calling methods directly on an object!) and not much of this is used in the book. A bit disappointing. Otherwise the book is okay.




3. The Object of Java by David D. Riley
   
   This book is less than impressive. It exhumes the need for elucidated text in the field of computer science.
   
   I am compelled to correlate this book with the awkward ramblings of Vizzini to Westley in the movie, "The Princess Bride".
   
   Reading this book was more than a slight burden. Only one who is versed in reading the writings of such authors as Joseph Cambell or Henry David Thoreau can comprehend the confusion of word and sputter heavily peppering this book.
   
   Allow me to illuminate:
   
   1) This author finds it fit to include typos and syntax errors in the example code as to completely change the meaning of the code. Only one already experienced in programming will catch such errors. Others will wallow in confusion as to why the program is not working properly, after all, they copied it from the book word for word, it should be working, right?
   
   2) In several instances, the author uses programming syntax and variable naming methods in his text that has nothing to do with the code explaination at hand. He actively titles the beginning of each sub-section as if it were a class or variable. IE: DivisionOfRadians()
   NO THAT'S NOT A CLASS! :D
   This is a common practice of David D. Rileys throughout the book, and not only for chapter sub-sections. He uses such writing methods all too liberally.
   
   3) This genius author also uses an arbitrary library called aLibrary. Good for him, he designed his own library! Since this whole book is based on the aLibrary, any real world application have just been made void. I mean seriously, try convincing your co-workers that this aLibrary is the next big thing. What happened to the commonly used AWT and Swing libraries? Hmmm, oh, it's shoved in the back index. Right where you would expect commonly used every day libraries.
   
   4) His code snippets and actual text are seperated by font style. Only problem is, you can't tell at all. His method of referring to code, methods, arguments, classes etc in his text is extremely easy to miss without paying impossibly close attention. His text is filled with inconsistencies and problems. I DO NOT recommend this book. If at all possible, avoid it entirely. For those of you who are using this book as a college text, well, all I can say is, I'm very sorry.
   
   On the bright side, his explaination of objects and classes is ... decent.



4. i had to get this book for a course i was taking at the college i go to. i cringe every time i read it because the title is a bit misleading. I thought i was going to be learning JAVA insted i'm learning how to take someone elses class files to apply them to completely meaningless projects that really dont teach anyone anything about how to program, let alone about the inner workings of the programs your working with. the teaching style is more of a top down approach rather than explaining whats going on at the lower level and you learn to program with classes to make programs at an upper level. This may work for some, it definately doesnt fly with me.
   I have read many books on C, and C++, and have paged through some promising java books (like Sun's own books on the subject).. if it werent for the requirement for this book in the class i would have passed it up INDEFINATELY!!! Peice of Krap!!!
   
   do{
   if(The object of JAVA==pickup){
   The object of JAVA = Leave it the hell alone!!!;
   else if(The object of JAVA == buy)
   {
   do{
   Beat head with stick && knock sence into head;
   burn book || return to store;
   }while(book==posession)
   }while(@bookshelf)



5. This book was a required text for my java class. In conversing with my classmates, we all agree that this book wasn't of any help. I would recommend any other book, this one is just too abstract for a beginner. It's difficult to apply the concepts, and the flow is jagged. With the addition of a teacher, and reading this book from front to back, my java class sucked hard because i didn't have that solid foundation I needed.

5 comments about Programming Microsoft ASP.NET 2.0 Applications: Advanced Topics.

1. Basics of .net framework is presented in a clear and lucid style. This book is a joy to read and . by the way there is not much difference in content wise between applied .Net framework programming and this book. My only worry is the speed at which microsoft is pushing .net versions as if there is no tommorrow! [Subsequently the catch up I have to do on reading all this!]



2. The two books of this series (Core Reference & Advanced Topics) offer broad and deep coverage of ASP.NET.
   
   All the important topics of ASP.NET web sites are covered in a mostly tutorial with a little reference fashion. The books are well researched. The coverage of what really happens during compilation, request processing, and expression evaluation is excellent. The books avoid being an MSDN rehash. By carefully pointing out which ASP.NET versions support which features, the books will be useful for working with any ASP.NET version. No matter what you're working on you'll find something useful in these books. Note that web services are not covered.
   
   The terms "core reference" and "advanced topics" (which MS press is using on all the non beginner books) make no sense at all with these books. If you're serious, you need both books. Think of them as volumes 1 and 2 of a single book.
   
   I do have some issues with these books. The biggest mistake was recommending the use of GDI+ (through the System.Drawing namespace). This is not supported. The System.Drawing namespace page in MSDN states "Classes within the System.Drawing namespace are not supported for use within a Windows or ASP.NET service. Attempting to use these classes from within one of these application types may produce unexpected problems, such as diminished service performance and run-time exceptions."
   
   I didn't enjoy Dino's writing style. It's verbose (at times), he uses odd words to describe things, and was boring even by tech book standards.
   
   The chapter on configuration was difficult. It would have better to cover configuration throughout the book, in the context of what was being configured, instead of a single all configuration and only configuration chapter.
   
   The section of asynchronous pages was confusing and didn't really explain why asynchronous pages improve scalability.
   
   Despite my reservations, there is much that's good about these books. Anybody who's serious about ASP.NET should consider getting both of them.



3. I bought this book specifically for the 100+ pages on creating custom web controls. That is the only portion of the book that I have used.
   
   The book does not come with a CD for the source code examples, and I have been unable to find them online.
   
   That means I have to type in the examples. I normally don't mind, as it helps me learn. But his sample control, SimpleGaugeBar, has code scattered across two chapters (#13 and 14), all in bits and pieces. The code is intermingled with alternate code examples that (I think) he isn't using in the class, plus code from other classes apparently unrelated to SimpleGaugeBar.
   
   The sample control is also buggy. Of course, it's my guess as to the code that is supposed to be contained in the control, because there is no single definitive listing of the code in the book. I suspect the sample code is simply buggy because the event sequencing the control responds to does not match the way the control was coded.
   
   He separated the creation of the internal list of control objects and the styling code into two routines. That's probably a good idea. But, and this is a killer, if you programmatically change the properties of the control, the internal list of control objects is created *before* the new property value is set, and applies styling after the property is set. This will cause the control to fail, because the styling code will refer to objects that were not created based upon the prior property settings.
   
   The styling code also refers to objects in the internal list of controls by array index number instead of by their id. That's bad form and very prone to error.
   
   I'm not a happy customer.
   
   That said, there is a lot of material on custom controls, and I learned a lot going through it. There are not a lot of resources out there that cover this topic in any depth, and this is one of the few. So, muddled, buggy and disorganized as it is on this topic, I would recommend it (until I found something better).



4. This book rocks! I cant find anymore words to say this :D
   
   I keep this book by my computer all the time. Dino has once again provided us with some great information.



5. So whilst you are waiting for the 3.5 version you can get this one second hand.
   
   It covers loads of usefull day-to-day tasks that most web devs have to search google for. Not sure that "Advanced" is the correct choice here, but its tasks that all my senior devs are capable of.
   This said, it's a must have for any web developers desk. All of the 2.0 stuff still applies to 3.5 cant wait till the new version that would be more complete.
   However, just using his examples expressed in Listview/Datapager controls using LINQ will yeild plenty till his new book comes out.
   I can understand why the 3.5 version is delayed (seeing 4.0 is due in December), there is plenty of 'advanced' issues in using MVC to content with, then add microsofts version of Spring/NHibernate to the mix (not stable yet where as the open source Spring/NHibernate is) then you can see why there is a delay.
   
   "ASP.NET 3.5 Applications: Advanced Topics" is a moving target and will be for 6 months(conjecture) or more(features in consenus use a >12months away?).
   
   So why get "ASP.NET 2.0 Applications: Advanced Topics"?
   It will make your life easier and get projects out the door faster.
   All that you learn in this book can be applied to your 3.5 projects (we just use VS2008 and VS2003 for legacy - VS2005 has no further use).
   Likewise if your are a commerical C# developer you would use the VSTS version of 2008 due to the productivity gains unless you work in a sweat shop where labour is cheap.
   
   Related:
   
   Using ReSharper4 Power Programming with ReSharper: Optimize .NET Development with the ReSharper Add-In to Visual Studio 2008 (Wrox Briefs) offer substantial benefits for C# 3.5 users this too will have you get quality code out the door faster.
   
   Programming Microsoft ASP.NET 3.5 is a welcome addition as Dino really knows his stuff (ASP.NET/AJAX/UI)

5 comments about C# Cookbook, 2nd Edition (Cookbooks (O'Reilly)).

1. If you are just coming into C# or have been doing it for a while - it doesn't matter - BUY THIS BOOK!!! Oreilly as we all know, makes very good tech/programming books and this one is one of the best I've had so far. This will be a book that will spend much less time on my shelf and much more time next to me on my desk.



2. I came across a project that had to do with XML, and I came to love this book. It has a lot of suggestions that helped me jump start my project.
   
   I wouldn't recommend this book to learn C#- (pick up John Sharp C# step by step for that.)



3. I'm an intermediate coder, familiar with programming and I have about 1.5 years programming C#. I've already used this book(C# Cookbook 2nd edition) to write C# code navigating in and around directories and files. The examples in the book regarding "Directory Info" and "File Info" were so clear and concise, I was able to complete my programming task with almost no lost time to the learning process. What I like most was that there was not one example, but many examples for the most used functionalities. This book has already paid for itself when I consider the time it saved me the first time I needed it!



4. This is a good intro book that eliminates the need for some of the first books I bought on C#. When compared to other "cookbooks", however, this book is incredibly weak (see: XSLT Cookbook, SQL Cookbook). If you have used C# for more than 6 months, you will know how to iterate over an array, to use String.IsNullOrEmpty, get the index of a value within a string, and use a generic arraylist. These are just some of the junior "recipes" you'll see in this book. The "recipes" just exercise the fundamentals (i.e. how to boil water) rather than how the fundamentals work together to solve complex problems in elegant ways. The easier the concept, the more information. There isn't really any analysis or best-practice justification present. I'd like to see some performance analysis of generics or at least some depth on partial methods. Nothing to see here for mid-level developers. Not written or organized poorly, just simple. If it were titled "Intro to C# by example", I'd give it a higher score.



5. [Reviewed by XPSD member Steve Grubbs]
   
   Summary
   
   I wanted to check out a C# cookbook after developing in C# for almost a year. I figured I should get a basic understanding of the language and the .NET framework by using it for awhile before I buy such a book. That said, I wish I could go back in time and tell myself to get the C# Cookbook the day I started developing in C#.
   
   Overall Review
   
   I see two main criteria for reviewing a programming language cookbook.
   
   1. The quality of each "recipe"
   2. The recipes chosen for the book
   
   The C# Cookbook handles each recipe very well, which we should definitely demand of a cookbook. It has a very simple 4-section format, Problem-Solution-Discussion-See Also. The problem is briefly stated first. The solution is almost entirely code samples, with minimal commentary. The discussion is usually short and sweet, with a few exceptions. The "see also" points to reference topics in the MSDN help, which is of questionable usefulness, since you can search the topics yourself; but, is short enough to skim over easily.
   
   The recipes chosen for the C# Cookbook range from very useful to trivial. One of the trivial examples would be something like, converting degrees to radians. The only language specific feature here is Math.PI, which I don't think is worth the page it's printed on. What I found surprisingly useful were some code samples that I spent time coming up with on my own before reading this book, like a custom trace class that outputs in XML. Fortunately, most of the examples were in the useful category.
   
   A few glaring topic omissions are remoting, ADO, and advanced object serialization.
   
   Per-Chapter Review
   
   * Numbers - somewhat trivial
   * Strings and Characters - good introduction to the C# string
   * Classes and Structures - good stuff on interfaces, casting, converting, COM interop
   * Enumerations - simple, but short and useful
   * Exception Handling - an underrated topic that I'm happy to see covered
   * Diagnostics - a surprisingly useful set of tools to help with debugging
   * Delegates and Events - very good intro for the new C# programmer
   * Regular Expressions - very good intro for the new C# programmer
   * Collections - a little simple, could have more useful samples
   * Data Structures and Algorithms - simple, but good if more advanced types are required
   * Filesystem I/O - very good examples of file I/O in C#
   * Reflection - a necessary intro to reflection, but a bit simple
   * Networking - biggest complaint: Why is there no remoting?
   * Security - a good survey of various security issues in C#
   * Threading - a good intro to threads and basic synchronization in C#
   * Unsafe Code - I tore out and burned this section
   * XML - good intro to reading/writing XML in C#

5 comments about Programming Microsoft® Visual C#® 2005: The Language (Pro Developer).

1. Like many other reviewers, I purchased this book alongside the MS Press 70-536 Training Kit. This book really can only be useful for an experienced C# developer who is looking to fill in any knowledge gaps concerning the language itself. Such a person would be able to spot the numerous errors and move past them without harm done. However, I could not, in good conscience, recommend this to anyone actually seeking to learn the language.
   
   As an example, on page 21, the unary operators are described with examples for each. However, the postfix increment "++" and postfix decrement "--" operators have their examples swapped. Once again, someone already in the know wouldn't be too bothered by this and would figure it out immediately, but for others, it could result in quite a bit of confusion.



2. As an MCAD, I think this book provides excellent coverage of C#, and would recommend it to anyone looking for a reference for the language.
   
   I think some reviews on this book were looking for more of an introductory step-by-step sample format, which this is not. This is most appropriate for those with some programming background, who want to add C# to their list of languages.



3. Not only is this book a complete reference, it has relevant examples. This author seems to have years of real experience and it shows. The sections are logically ordered so that everything i'm looking for is in easy reach. This book has saved me a lot of time.



4. WAY TOO MUCH FLUFF. Buried in all of this filler text are obfuscated details of the language. There are no real examples that can be followed. I wish I could get a refund because I really feel like I wasted my money.



5. I ordered this product coz in Mexico i just couldn't find it... It seems that the best titles are only in the US and it's a good thing that we can make international orders for them.
   
   This little piece of art it's one of the bests i've had. It's very well explained and also serves as reference for specific methods.
   
   highly recommended
   
   Carlos Silva

5 comments about Creating a Web Page with HTML: Visual QuickProject Guide.

1. I have other books by Liz Castro, and she continues to make life easier for all of us who want to know more about coding and controlling our own web sites. Great introductory book on XHMTL and CSS.



2. I have been messing around for a year(!) trying various WYSIWYG software to create the simple website that I wanted. The software was much harder to master than was HTML as Elizabeth Castro explains it. I first did the projects in this book, then with the help of her HTML, XHTML & CSS book, I have finally been able to make the site I've had in my head for so long. If you are using a PC, I have one suggestion--use Notepad instead of Word to create your web pages, because it's harder to mess up on Notepad. Three cheers for Elizabeth!



3. This is a wonderful book that allows you to execute and learn good habits instead of walking you down a tutorial path. Its a quick read and excellent reference for basic tasks.
   
   If you do want to buy this book, consider getting the series.
   
   Web Page Visual QuickProject Guide Colletion (Paperback)
   by Elizabeth Castro (Author)
   
   The series was rewritten in 2006 and has the corrections to the errors in the 2004 books of the same name.
   
   The series has the HTML quickproject, Flash quickproject, and Dreamweaver quickproject. Flash and Dreamweaver are MX 2004 based but happen to have the same commands and keyboard shortcuts as the CS3 and 8 versions.
   
   Dont make the same mistake I almost made and buy this individually. I paid $1 and got it all! Its was cheaper and I obtained two other books.



4. Bought this book for a person who wanted to learn how to make simple web pages and it was a bad choice. New users benefit most from straight forward instructions and limited toolsets. This book imagines the user to be familar with (and own) photoshop as well as other tools. It would be much simpiler if the author stuck with simple, freely available tools.



5. I knew little more than how to use a MySpace type HTML editor before looking at this book, and was quite apprehensive about learning the modern hyroglyphic language called HTML. However, after reading this book, I began to see more of a language rather than a jumble of texted mess. It's simple, project based approach made understanding HTML quite easy. From beginning a website to publishing on the web, Elizabeth Castro provides a simple, yet solid foundation to learn the language of web design. Before reading it, I had no idea that you could create a website without an HTML editor like Dreamweaver.
   The author does expect you to know a little bit of image editing (i.e. Photoshop), but already knowing a good amount of Photoshop myself, the tecniques they used are simple and are among the first things you learn in any Photoshop book you pick up. Besides, if you can't edit the elements you are putting in a website anyway, HTML knowledge or not, your website will have limited potential depending on it's intended purpose.
   While any aspiring web designer will have much more to learn to create a superb site, it's very easy to see why they say you could make a web site after reading this book. If your planning on learning Dreaweaver and Flash based web techniques later, or just want to make a simple website, this book is where you need to begin your journey!
   
   I HIGHLY RECOMMEND IT!!