5 comments about Advanced Mac OS X Programming (2nd Edition of Core Mac OS X & Unix Programming).

1. Although this book is well written in concept, the editing of the final product is awful. There are a great deal of grammatical errors which seemed to me a basic word-processor would have caught.
   
   The book should be titled, more correctly, "Unix Programming for OS X." Unix system programmers will find almost nothing new in this book (gcc, gdb, file-systems, signals, libraries, etc. - although, the Objective-C examples can be helpful in understanding how to implement things in new ways, and also the chapter on Subversion was a nice introduction for me.)
   
   If you are just learning how to program on a Unix platform, I'd recommend this book unequivocally. I paid full price for mine ($70), without taking a hard enough look at the contents and found myself with an expensive, redundant book on my shelf.



2. If you're a Mac OS X developer and want to get serious about it, this book is mandatory. It is always on my desk right by the computer, and really is that perfect reference. Nothing really compares to this book, the previous Aaron Hillegass book is rather basic but is more of an introduction. I have a BS degree in CS and even though a lot of this has been covered, the rest of it is done in graduate school. So if you're looking for that little bit extra, give it a shot.



3. This book fills in most gaps you might encounter while learning about the low-level BSD/Mach aspect of Mac OS X and Darwin. Mach and BSD iokit is described in detail, and there are tons of useful code examples all over the book. This book even explains ipc and pipes very well, and isn't the size of the bible, like other books. It gets to the point as soon as you get past the TOC.



4. If you are a Programmer not in College, this is a nice book. As I read it, I learned several new things but then when I took Operating Systems Programming, I realized that we went over everything in the book, more in depth, and then some. If you aren't a Computer Science Major and you want to really program on the Mac, buy this book. However, if you are going to College, save your money. Let your professor teach it to you.



5. Don't expect to learn to code from this book, but once you know how this book will help you solve any problems that you run across.
   I don't think that I'll ever read it cover-to-cover, but I know that it will always be in my library.

No comments about SAP FI/CO Questions & Answers (with CD-ROM)(Computer Science) (Business) (Computer Science).

5 comments about Ajax in Action.

1. It's amazing how much the JavaScript world has changed.
   
   This book has a relaxing style, and it was enjoyable to read. However, it no longer represents what I think of as "modern" JavaScript. For instance, it doesn't cover closures until appendix B, and even then it tells the reader to avoid them. These days, having studied Dojo, jQuery, and Douglas Crockford's videos, it's clear that closures are at the heart of how modern JavaScript is written.
   
   The copyright for this book is 2006, yet the index doesn't even mention Firebug, YUI, dojo, or jQuery which are now staples of the JavaScript community. Although, dojo is at least mentioned in the list of Ajax frameworks and libraries.
   
   This book is an interesting piece of the history of JavaScript, but for those wanting to learn modern JavaScript, I recommend watching Douglas Crockford's videos instead.



2. i am very interested in AJAX learn and this book is essential for any person that work in the web, how web developer, web desginer and others. you can learn the structure and the metodology about AJAX and JavaScript too. It is great and interesting



3. I've bought the portuguese version of this book (AJAX em Ação), and I agree that it was incorrectly named.
   I have a good experience with AJAX, and I was looking for an "AJAX bible", with hacks and something like this... but, like other people here, I am disappointed.
   The book is excellent as a guide for project patterns that can be applied not just to AJAX, but to any web project. But the title, "AJAX in Action", suggest another type of content.



4. Looking for the latest DHTML tricks and Javascript libraries? You came to the wrong place: this was published in 2005.
   
   But I really liked this book. All you need is competence with HTML, CSS and Javascript, and Ajax in Action will help you understand what makes Ajax different from the traditional client-server architecture of web apps. It also introduces some design patterns and other basic considerations, e.g. cross browser issues. The second half of the book has several examples that illustrate what Ajax can buy you.
   
   If you're already doing Ajax, there's not likely to be much here of any practical value, and a lot of the basic issues have been finessed away with the more common Javascript libraries. But if you're looking for a higher-level overview of the principles of Ajax and the issues involved in delivering the Ajax experience across browsers, this is still very relevant.
   
   Reading Ajax in Action is not going to make you an expert. But this (or something like Head Rush Ajax) is a very good introduction.



5. This book covers lots of ground coming in at 600 pages of real content. I almost gave this book 3 stars until I re-read it. It may seem verbose for the more experienced programmer, but I think would be a perfect read for the novice Javascript programmer. It really is packed full of great implementation ideas and good practices, such as the use of software patterns (MVC, singleton, adapter) and extensive code refactoring. There are tons of screen shots, images, diagrams, code examples and snippets, and external references. Although the AJAX protocol is server-side neutral, the author implements the backends in Java, C#, PHP, and VB.NET.
   
   The biggest drawback is security coverage. Security issues in the AJAX world have really unfolded since this book was first published. This title does dedicate about 30 pages (chapter 7) to security. The author touches on the basics, like securely parsing XMLHttpRequest response data. However, I would highly recommend Ajax Security for a more in-depth study. "AJAX Security" is almost the size of this book, but entirely dedicated to security and about 2 years newer.
   
   The book concludes with five big example applications. The fourth example implements a live search. It employs XSLT for XML parsing and presentation, which really piqued my interest. For me, the live search example is the highlight of the book.

5 comments about Pro LINQ Object Relational Mapping in C# 2008 (Pro).

1. I originally gave this book two stars, because of the lack of source code and support. To the author's credit, he jumped right on those criticisms and has resolved those problems. In light of that, I rate this book four stars.
   
   This book gives a pretty good overview of LINQ to SQL--it's not a bad starting point for those (like myself) who prefer the conventions of Domain-Driven Design. The book isn't really a good primer on DDD, but it isn't meant to be. For that, I'd recommend Applying Domain-Driven Design and Patterns: With Examples in C# and .NET.
   
   The book includes a case study, 'The Bank of Pluto'. Source code should be available on the Apress website. You will want to have it to go through the last half of the book, which shows excerpts from the code but doesn't always give enough context to be able to figure it out. While it isn't a complete reference application, the Bank of Pluto example has enough detail to get most programmers up and running.
   
   The book covers both LINQ to SQL, the basic ORM provided by Mictosoft, and the ADO.NET Entity Framework, a more robust framework that can be used as an ORM. It separates it's discussion of the two technologies, which is a good thing. The initial release of the EF is proving quite controversial, with many DDD enthusiasts complaining that it is too database-oriented and "not ready for prime time". Given the controversey, I am passing on EF until Rev. 2.0, at least, so I skipped the EF chapters in the book. That still left me with a good discussion of LINQ to SQL that stands well on its own.
   
   As the text points out LINQ to SQL works pretty well in small-to-mid-size applications, and it can be used successfully in domain-driven designs. It does have problems with complex, enterprise-level domain models. Nonetheless, if you are a domain-driven designer, this book provides a nice introduction to LINQ to SQL and how to integrate it into your application architecture.



2. The first two chapters of this book start out with a discussion of Domain-Driven Design (DDD) Principles, what Object-Relational Mapping (ORM) Tools are, the role of ORMs in DDD-informed application development, and criteria for evaluating ORM tools. Chapters Three through Seven then provide a quick tour of LINQ to SQL and ADO.Net Entity Framework (Beta 3 Version) basics. It's not until Chapter Eight that things become interesting (at least to me). After describing the functionalities that he wants to implement in the running banking application sample, the author provides plenty of code demonstrating the comparative strengths and weaknesses of the two ORM tools, potential gotchas and workarounds, lessons learned, and recommended best practices in architecting N-Tier Applications. The author's writing style is conversational, which is good most of the time, except for those few occasions when he seemed to have switched from one topic to another rather abruptly. Overall, a great book!



3. Overall, I think this is a really good book. I am fairly new to programming and this is a great introduction to domain driven design and object relational mapping using Microsoft tools. The author really captured an interesting case study which helped make digesting a complex topic simpler. The framework, which is largely based on Billy McCafferty's Nhibernate framework is usable and something that I can see implementing on any number of projects. Overall it's a good book and an easy read for .NET data access developers. [...].



4. I read a majority of this book, and it is a very good overview for using Linq to Sql and Entity Framework as a Data Access Layer. It does a good job of going through several scenarios. The only lacking thing in this book is something that you will learn in practice using this stuff in a real world application, and finally learn some of the limitations of EF and Linq To Sql. But what it does cover is very solid, but expect to learn some nuances with EF on your own.



5. I must confess that when I read the title of the book "Pro LINQ Object Relational Mapping with C# 2008" I had big pretensions about the book. ORM, as the author mentions in the introduction, is not a subject commonly treated for the .NET world and I was expecting a deep technical book. This has definitively conditioned my final opinion about it.
   
   The book is divided in several parts. You can see below the main ones.
   
   · First one provides you with a fast overview about the ORM concepts. It explains the problematic between database and conceptual models, problems addressed with ORM, laziness, persistence ignorance, etc.
   
   · Second one presents LINQ to SQL and EF explaining the features each one provides.
   
   · Third part does a "complete" implementation of a sample application which provides you some insights about what it does mean working with LINQ to SQL and EF.
   
   The biggest worth of the book is probably the third part, where the author instead of only write some excerpts of code, he has written some requirements and use cases to later on implement them as a developer would do in the "real world", including even some unitary tests.
   
   What I didn't like is that, regardless it presents a wide range of concepts none of them is deeply treated, it always remains on the surface, which in my opinion has made of the book a "sugar free" version of what it could be.
   
   I didn't like either to find certain technical errors like "...the CLR is doing the heavy lifting for you by translating your queries into method calls...". This is incorrect since the Common Language Runtime (CLR) does not translate the LINQ queries into methods; instead each language compiler is responsible of that conversion. With this sentence the reader can think it is better to use the method syntax instead of the LINQ syntax to avoid the translation performance cost during runtime, when it is not the case as it occurs during compilation time.
   
   Therefore if you are looking for a deep technical ORM, LINQ to SQL or EF this is not your book. Instead if you have heard noise about these technologies and you are searching for a text to help you with an overview of what is what and the possibilities they offer, Pro LINQ Object Relational Mapping with C# 2008 can be what you need.

5 comments about Agile Software Development, Principles, Patterns, and Practices (Alan Apt Series).

1. This book covers the most common, and usefull design patterns. Each patter is presented in plain egnlish, with full examples.
   
   In addition to patterns this book covers the principles surounding patterns that make them truely usefull.



2. After reading this text, I feel it deserves the attention of other great texts such as Design patterns and Refactoring, even though much of it's content expounds upon the ideas of these two classics. It's my opinion that this text has two strong points: it explains the ideas and details of agile development very clearly, and it does an excellent job of explaining the most popular patterns originated by GOF, plus a few more. The authors style was very good, with most of the examples in Java. Being a C++ programmer, I would have liked to see more examples in that language, but this is not any fault of the author.



3. I bought this for my brother. Got for a good deal on Amazon. Very happy with the fast delivery by Amazon.



4. It's a great book. As a senior developer with more than 5 year's experieces of Object-Oriented Design, I think this is a valuable pragmatic book about how to do in a practical project.



5. Reader,
   
   This is a book about far important topics than Agile (and Agile is darn important).
   
   It is far more valuable than any other book today on Agile for the development trenches to read.
   
   If you hate the word Agile (you likely either have incorrect ideas what it means or only the buzzword exposure) this book still will fix youor showstopping lack of knowledge if applicable (and if your not sure, you do not have it, I promise).
   
   You can work in software with a lot of gaps, but the content here defines what is mandatory for even moderate levels of interesting work.
   
   Do you agree in the following as a common value of `good' for software?
   
   FROM: http://articles.techrepublic.com.com/5100-10878_11-1050347.html
   
   Good design
   
   Well-designed applications offer software components that are more robust, more maintainable, and more reusable. Such applications should be able to adapt changing business needs without affecting design. For example, a banking application should be able to support new types of accounts without a change in the existing design.
   
   Three key points of good design are:
   
   Maintainability, which is the ease with which a software system or component can be modified to adapt to changing environments, improve performance, correct faults, or other attributes. Well-designed applications require fewer resources for maintenance and changes.
   
   Reusability, which is the degree to which a software module or components can be used in more than one computing program or software system. Reusability of software components helps ensure faster development of software applications.
   
   Robustness, which is the stability of software applications in extreme situations (e.g., maximum load conditions, erroneous user inputs). Robust applications have less downtime and can reduce maintenance costs.
   
   Bad design
   Nobody plans to create ill-designed applications. It often happens because of a lack of experience or because the app was designed quickly to meet an extremely tight deadline. Poorly designed applications usually have these problems in common:
   
   They're rigid. A design is rigid if it cannot be easily changed. For example, a single change to heavily interdependent, rigid software could begin a cascade of changes in dependent packages. When such a program grows in size, the designers or maintainers cannot predict the extent of that cascade of change, and the impact of the change cannot be estimated. This makes the cost of the change impossible to estimate.
   They're fragile. Poorly created programs have a tendency to break in many places when a single change is made. Simple changes to one part of the application can lead to failures in other parts that appear to be completely unrelated. Fixing those problems leads to even more issues, and the maintenance process begins to resemble a dog chasing its tail. Such fragility greatly decreases the credibility of the design and maintenance organization, which leaves users and managers unable to predict the future quality of the product.
   
   
   They're not reusable. A design is difficult to reuse when its desirable parts are highly dependent upon other details, which aren't desired. If the design is highly interdependent, other designers will also be daunted by the amount of work necessary to separate the desirable portion of the design from the parts that aren't reusable. In most such cases, the cost of the separation is deemed to be higher than the cost of redevelopment of the design.
   
   Still with me? Ok..
   
   
   .NET developers historically have lacked (as compared to other OFA (one framework only) developers) at the very, very least) acceptable OO Design skills. I mean even remotely `predictably' acceptable. Sure I worked with many teams who were exceptions but they were all from other (Java/Smalltalk) environments. Even C++ developers can slant to a master of C, deep internals, and Fragile Base Class disaster (grin). So Microsoft would have been nuts as they have always know this to put multiple-inheritance into C#. I digress... This is relevant to the book I swear....
   
   Uncle Bob Martin created a masterpiece here that is still just as (more?) relevant. It is utterly transformative for anyone who wants to be even remotely productive on a team of best-practice types.
   
   FYI this is the book used when I teach 'Core Object Oriented Design for the C# Developer' around the country.
   
   NOTE: Do not let the word 'Agile' fool you. This is a book about best practices in software design and development. Agile just assumes you already know this material, yet most I work with do not.
   
   He provides definitive coverage of the most critical reasons for failure if you skip then. For example, inheritance in OO is wrong for most cases used today in .NET.
   
   Liskov substitution principle
   Read this (covered in detail in this book):
   
   
   Kind Regards,
   Damon Wilder Carr
   http://blog.domaindotnet.com

5 comments about Test Driven: TDD and Acceptance TDD for Java Developers.

1. This book is one of the best books I have ever read. It's easy to understand and well-written. It dives deep into TDD without complicating things, and shows with good examples why you should do TDD.
   
   Highly recommended.



2. "Test Driven" is geared toward Java developers interested in writing better JUnit tests. Despite the title, it is useful whether you want to write test first or test last.
   
   The first part of the book covers the softer aspects of testing such as how to decide what tests to write first and spikes. The rest of the book covers writing tests for common Java components including servlets, data access code and Swing. Examples were for things that we frequently want to test. They included "hard" things such as testing times and threaded code.
   
   I particularly liked the sections on design and testing patterns. There was good coverage of different JUnit extension libraries with examples including dbunit, jmock, easymock, jemmy and abbot. There was also a full chapter on FIT.
   
   I got a sense of "in the trenches" realism from the book. Tradeoffs of techniques were clearing mentioned. The chapter on adopting TDD shows the experience of someone who has done it many times. The section on how to fight resistance really spoke to me.
   
   This is the first book I have read using JUnit 4, which was useful for reading well written tests. While there is an appendix "tutorial" on JUnit 3.8 and 4.0 (two page annotated classes), you really should feel comfortable with one version of JUnit before reading this book. While a few sections pertained to specific technologies, such as Spring, the concepts apply to everyone. I highly recommend this book.



3. Great book. I've read Kent Beck's book, but his book is a bit dated these days. I found Test Driven to be a nice, timely refresh of the TDD and refactoring topic. I've done some mentoring and teaching on TDD and refactoring lately and I've been evangelizing this book to my students/participants. Well worth the money.



4. This book is an great resource for Java developers wanting to get started on TDD. It covers the majority of tools and techniques available, along with useful tips and best practices.
   The first part is already worth the book's price. The author presents TDD and its benefits, shows how it works with a lot of coding, and ends it with an excellent chapter on concepts and unit tests design patterns. By the end of it you'll feel eager to, at least, give the practice a shot.
   The book proceeds showing how to test technologies commonly known as "hard" to unit test, like web components, database access code, threads, and swing. Although the author doesn't go into too much detail in any of them, he presents good solutions to make their testing easier.
   The last part is a very good introduction to Acceptance TDD and how to write tests with Fit. It is not as thorough as the TDD introduction, but will give you a very good understanding of what ATDD is, how it should be done and how it can (and should) be complemented with unit testing.
   Essential reading for Java developers looking for ways to improve the quality of their code.



5. Bas has already done a good job outlining the content. I won't repeat that here. Instead I will say that TDD is hard. It took me several years of trying before it all came to together for. In the past few months I've recommended this book to more than a few developers in the past six months.
   
   In at least two of those cases it has been the turning point in their understanding of Test Driven Development. Net result - I'm can spending my time coaching/mentoring in other areas.

5 comments about C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (C++ In-Depth Series).

1. This book is a very readable reference book. The authors have read several books and condensed the best coding rules to prevent many errors. If you code in any language other than C++, read this book because many of the hints are useful. (If you code C++, then all of the hints apply.) And if you don't like rules and guidelines, then just read the "exception" section provided in each entry to be sure that your code meets the exception.



2. It's Sutter! It's Alexandrescu! It's both of them together! And the dark lords of C++ have combined forces to produce... er, some coding standards.
   
   Yes, another book of best practices. Some readers may therefore be a tad disappointed that the combined fruits of the authors' labours will not be shattering their puny human minds with the sort of C++ that cause lesser compilers to accidentally create black holes that destroy the entire universe.
   
   But let's evaluate the book on what it sets out to do, which is to give 100 bite-sized pieces of advice on C++ coding. And it's very good. You might prefer to see it as an annotated guide to the state of the art in intermediate C++ programming, in particular to Sutter's Exceptional C++ trilogy, which has become sufficiently sprawling that a reorganisation of the material, plus pointers to which book said what, has become quite welcome.
   
   Yes, it's true that C++ is hardly short of books telling you when to pass by value. But take a look at the bibliography - it's a synthesis of all those other tomes (the Effective series, Sutter's own Exceptional series of course, and older books like C++ Strategy and Tactics) plus magazine articles, into a neat and compact whole.
   
   Few of the items are longer than one or two pages. This is good because the advice stays simple, clear and direct. On the other hand, some of the items feel a bit squeezed into the available space, with discussion deferred to the books in the references, which is a little frustrating on occasion. After all, a lot of the best parts of the Exceptional C++ and Effective C++ series and their ilk is not so much what to do (or not to do), but the why behind it. There's plenty of the former, but not so much of the latter.
   
   If you've read any other coding convention books (like those in Steve McConnell's Code Complete) then the first quarter of the book may feel like the same old same old. And of course with there being exactly 100 items, some are more heavyweight than others. But there's definite C++ meat here, in particular with the items on Exceptions and the STL.
   
   C++ Coding Standards is as well-written as you'd expect from the authors - their friendly, slightly conversational writing styles mesh nicely and I couldn't tell who wrote which bits. And it's a great summary and unification of C++ best practices that someone just starting out could easily refer to in their initial forays. Perhaps even more experienced hands will discover a few tips, implications or issues that they hadn't considered before. It could also be a good way to ensure that a team are all up to date on best practices.
   
   Essential for those with a large C++ library? Probably not, but it does the job it sets out to do very well.



3. If you own the 3 "Exception C++" books, do not buy this book. It is just a mirror copy of those. And the explanation in this book is brief. Typically, if you are familiar with the content of this book, it works as a quick reference manual or pocket book.



4. I had high expectations about the fruit of the association of 2 authors that I appreciate but the result did not meet these expectations. Basically this book provides 101 rules or guidelines that you can get for free by looking at the table of content. Each of these rules is then followed by a very short explanation (1 or 2 pages usually). In my opinion, most of them are common wisdom that you can get from other sources. This is it. That is all you will get from this book. For that reason, I recommend to skip this one except if a convenient and compact collection of common knowledge is something that you are looking for.



5. I think this is one of the most useful C++ books one could have if working in a team. Most companies don't have a very large set of coding standards, and every now and then there will be a discussion about which is the best way to implement something. That is the time to when this book shines:
   
   1) You can show your co-workers the page for the related item, and the explanation for the underlying rationale will be so concise, they can read it while standing.
   2) Every item is backed with heavy references to standard works by the top names in C++.
   
   Basically it is a tool for effectively ending discussions in the most constructive way possible.
   
   It's the supreme index into the world of collected C++ knowledge.

5 comments about Learning PHP 5.

1. If you're in a Windows shop, save yourself a lot of pain: download EasyPHP (mentioned on p. 261). Then substitute a version 5.2 php for C:\EasyPHP\php (which is version 4.3) . HINT: EasyPHP uses the php.ini in the conf-files dir, not the one in the php.



2. If you can't install all the Perl modules you want (say on a $12.99/month commercial host), give PHP a try. It has weaknesses and strengths vis-à-vis Perl, but you can use both! They work well together, and with XHTML, CSS, and MySQL. Who says you have to choose one over the other?
   
   After scouring the web for tutorials and sample code, I think this book is the quickest way to get up to speed. It is concise with excellent code samples, warnings of pitfalls, and techniques for thwarting adversaries (hackers). It is straightforward without annoying cuteness or humor.
   
   PHP code lives entirely within a web page. Some advantages:
   1. You don't have to make print statements for all the HTML on the page; the PHP code can be inserts in the HTML.
   2. Flow control. A page can include its own associated programming logic for easier maintenance and an uncluttered webroot directory. A form page can recursively call itself, instead of a separate script, for processing, and can call other pages.
   3. It's embarrassingly *EASY* to learn with this book!
   
   Some instructions just changed names (split is "explode," next is "continue") but other instructions are new and super-handy for the web! Sessions and cookie-handling are built in to the language (chapter 8). Scope rules and data structures are different; you can't shift, pop, or test for undef, but you get two-dimensional arrays.
   
   If you go this route I guarantee you will have read this entire book, plus some of the online PHP manual, by the time your site is done. This book is not comprehensive but selects an excellent breadth of features.
   
   One typo is unforgivable, and for that I unapologetically deduct a star: the very first database example in Chapter 1 shows $db->numrows() without the parentheses, which does not work. I spent two days trying to figure out what was wrong. Very confusing since the old way of doing it (before PHP's PEAR extensions) was mysql_num_rows <--without parentheses.
   
   TIP: Do NOT assume that your host is on PHP 5! Though mine advertises 5, they put you on 4 unless you ask for 5. This one-line program will tell you which version you're on:
   
   TIP #2: Blank web page got you down? You can see the syntax error by running it from a command line, like this: php5 mypage.php



3. I cheated. I looked in the back of the book for the answers so I could understand the programmer's mind behind the solution. I'm getting so much out of this book! Now, I'll think of a problem I need to solve, and because I took the time to learn some fundementals, I can piece together solutions in my head, which test positive when coded and loaded. A very satisfying experience all around. Reverse engineer is the way to learn!
   
   May the parse be with you!



4. Easy read. There are also so many examples, that I just want to test each one out. I highly recommend for anyone who doesn't know anything about PHP.



5. This books is amazing for the people who want know the new features in PHP 5

5 comments about CSS Pocket Reference (Pocket Reference (O'Reilly)).

1. Great little reference book. It is not intended to be a learning tool. If you want that, try the Head First book on HTML/XHTML/CSS that O'Reilly also publishes.
   
   It's a super little time-saver, and also makes for a quick read when designing a new page or project, to see if something you haven't used previously could benefit your work.



2. Large books, by their very nature, can have good points and bad points. After all, if you have a couple or several hundred pages worth of material, you are bound to get some things right and some things wrong.
   But these pocket reference books from O'Reilly are great. They aren't for learning, rather they are what they say they are: a pocket reference. (Nice to see some truth in advertising for a change.)
   If you buy this book you will use it. A lot. Period.



3. I used this book as a reference to take a certification exam without ever touching CSS and scored in the 96th percentile... enough said.



4. I'm doing a lot of CSS work these days and figured this guide would be a good book to have on hand to quickly pull out when I can't remember a selector or how to write a certain pseudo-class, etc. And it *is* a decent little guide for the most part. It gives a short description of each element and what browsers support it (although no version information included) and even has a basic CSS tutorial included. Certainly not substitute for the full length book, but okay to quickly refer to.
   
   The thing I didn't like about the book is that it just often seems to take a little time for me to find things in it. There are just so many different ways a "pocket guide" could be done that would make it a matter of seconds to find the element you need information on...with this one I'm often resorting to using the index to find what page it is on. Since the entire book is black-and-white and there's no page separation of element from element, it all just kinds of blends together and just visually is not very pleasing to use. If you are familiar with Visibone web developer cards/sheets I find those much more useful as a quick-reference due to how well the information is presented. While the material is not as comprehensive as what this book includes, I find myself pulling it out more often than this book simply because I can literally get the information I need in a second versus spending time just trying to locate it in this book.
   
   So final score...it's a decent book and worth considering. If you've used other O-Reilly pocket books and like them, you'll probably like this as well. But I personally think there are easier "pocket guides" available.



5. Small, Informative, and easy to use. It does everything it needs to do.
   
   I would very quickly buy this book again.

4 comments about C# 3.0 Cookbook.

1. Are you an experienced C# or .NET developer or just a novice user? If you are, then this book is for you. Authors Jay Hilyard and Stephen Teilhet, have done an outstanding job of writing a book that is designed for users of all levels, and provides solutions to problems that developers face every day as well as some that may come along less frequently.
   
   Hilyard and Teilhet, begin by covering Language Integrated Query (LINQ) and its usage with objects, ADO.NET, and XML. Next, the authors cover both String and Char data types. Then, they discuss recipes dealing with both class and structure data types. The authors also focus on the generics capacity in C#, which allows you to have code operate uniformly on values of different types. They continue by examining recipes that make use of collections. Next, the authors show you how to use two features of C# to solve very different programming problems. Then, they focus on the best ways to implement exception handling in your application. The authors also present recipes that use data types that fall under the System. They continue by showing you how delegates, events, and lambda expressions can be used in your applications. Next, the authors cover a useful set of classes that are employed to run regular expressions against strings. Then, they deal with file system interactions in four distinct ways. The authors also show you ways to use built-in assembly inspection system provided by the .NET Framework to determine what types, interfaces, and methods are implemented within an assembly and how to access them in a late-bound fashion. They continue by covering how to access a web site and its content as well as programmatically determining web site configuration. Next, the authors explore some of the uses for XML and how to program against it using LINQ to XML, the XmlReader/XmlWriter, and Xml-Document. Then, they explore the connectivity options provided by the .NET Framework and how to programmatically access network resources. The authors also explore areas such as controlling access to types, encryption and decryption, securely storing data, and using programmatic and declarative security. They continue by addressing the subject of using multiple threads of execution in a .NET program; issues such as how to implement threading in your application; protecting resources from and allowing safe concurrent access; storing per-thread data; and, how to use the synchronization primitives in .NET to write thread-safe code. Next, the authors discuss recipes for those random sorts of operations that developers run into over and over again, such as determining locations of system resources, sending e-mail, and working with services. Finally, the authors focus on the numeric and enumeration types and recipes on using enumerations that consist of bit flags.
   
   This most excellent book is laid out with respect to the types of problems you will solve as you progress through your life as a C# programmer. In other words, each recipe contained in this book is designed to help you quickly understand the problem, learn how to solve it, and find out any potential trade-offs or ramifications to help you solve your problems quickly, efficiently, and with minimal effort.



2. This book covers all the needs for those who want to learn a little bit more of C#.
   
   I'm very pleased the way the author examplifies using design patterns, 3.5 features and explaining all the time the pros and cons of the code given.
   
   As bottom note I should recommend this for all you who wants to gather a little more experience in c#.
   
   Greets from Brazil, Diego.



3. This book is perpetually on my desk, whenever I cannot easily figure out how to do something, I check this book before going to MSDN, etc. Critical member of my bookshelf.



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.