3 comments about Windows Server 2008 Active Directory Resource Kit.

1. I've received my books on time in perfect condition
   Keep up the good work!



2. Just as Mr. Mulcare wrote the definitive resource for AD on Win2K3,
   Active Directory for Microsoft Windows Server 2003 Technical Reference (Pro-Technical References) he has done it again with this resource kit. His knowledge of the product and ability to pass along critical information on Active Directory is exceptional. Keep up the good work and I look forward to whatever you write for Win7!



3. I wrote a couple of sidebars for this book and enjoyed reading it when I received my copy. If you're looking for a book to give you a good picture of the Windows Server 2008 AD landscape including the various services which have been branded as part of AD (e.g. Certificate Services, Rights Management, etc), this is a good title to pick-up. There are plenty of screenshots and procedural walkthroughs as well as advice from the standpoint of Microsoft. If you're looking for something super detailed and in-depth, this may not be what you're looking for.
   
   --Brian Desmond
   Active Directory MVP

5 comments about Head First EJB (Brain-Friendly Study Guides; Enterprise JavaBeans).

1. This is a absolutely easy going book. You can read it for hours and not feel any stress. The methods they have used are so good that you will never forget the concepts.



2. This book is out-of date. It does not cover EJB 3 which is the current paradigm. For EJB 1 & 2 it is a good book, but these are not used. If you are preparing for SCBCD this is not the book to use



3. This was a great book for me, ( had to use wrath of EJB 2.1 in several projects =( ). So when EJB 3 came out and i went through EJB 3 ( via Oreilly's book ) i was amazed, pleased and overjoyed.
   
   The new Exam covers EJB3. However if you are still planning to give EJB 2.X exam, this is BEST book you'll buy. It guides you step by step towards steep learning curve that EJB comes with and makes it real easy to remember things.
   
   I am usually critical of Head First "Kids" like format, but this book justifies that because of the subject being such. EJB 2.x deserved this kind of book, where one go one step at a time to understand things.
   
   Book Covers :
   
   1. ) Transaction Management
   2. ) All kinds of Beans ( what you do, what container does etc etc. )
   
   What it does not Cover :
   1.) EJB 3
   2.) Deployment to JBOSS container ( these days with EJB 3 more and more people are adopting JBOSS AS ), neither does it cover deployment specifics of Websphere. ( And in reality Why should it ever do that? this book is only for certification etc. )
   
   If you want to earn SCBCD ( old one ) or if you are working for EJB 2.X project, do yourself the favor of buying this book
   
   Regards
   Vyas, Anirudh



4. This book helped me to understand what is enterprise how they fit together how to create EJB 2.0 actually it let you have a strong understanding of J2EE concepst.the authors are very experienced and their books are really the best and should be best ev er selling



5. Had high hopes for the book, with cartoons and all. But they got into lots of agonizingly boring technical detail without putting it into a clear context. The explanations could have been much clearer by providing that context.

3 comments about MCTS Self-Paced Training Kit (Exam 70-502): Microsoft® .NET Framework 3.5 Windows® Presentation Foundation.

1. I like the book in general, though if you are using Visual Studio 2008 on Windows Vista 64-bit, you should be aware that the VB lab for Chapter 5, Lesson 2 does not work. This is a problem because this lab is used as a basis for labs in subsequent chapters & lessons. In order to get this lab to work properly, I had to install VS 2008 on my old XP machine, where it compiled and ran without a hitch. I'm guessing it will work fine on Vista 32-bit, though I haven't tested this yet.
   
   Update: when I changed the Project Properties, Advanced Compiler Options, Targe CPU to "x86", the project for the Chapter 5 lab (lesson 2) compiled and ran perfectly.



2. If you are considering a good start to enter the world of WPF, and at the same time prepares yourself for taking the exam (70-502) to be (MCTS .NET Framework 3.5 - WPF), then this training kit is more than a good start.
   
   The author assumes a solid background about using one of the .NET main languages (VB, or C#) in addition to a practical expertise in building and deploying desktop applications using Windows Forms 2.0 and Visual Studio .NET 2005. Having this knowledge will help the reader to better understand the new features of WPF and the new solved problems.
   
   Although the exam objectives are well covered, the content arrangement was not in the best shape if you plan a comprehensive reading from cover to cover which may cause some frustration.
   
   The author has elegant and organized writing skills, which helped him to deliver ideas and explanations in a direct and plain way, without the need to spend pages and pages trying to explain simple point.
   
   Reading this book is like an exciting adventure, some chapters will amaze you with the new features of WPF like routed events, content model, 2D graphics features, multimedia integration, and last but not least data binding and validation. Some other chapters will assure you that your previous knowledge of WinForms was not a total waste.
   
   To sum up, although this book may not be the best start to learn about WPF, it is an adventure that takes you inside the world of WPF. If you consider this book as exam preparation guide, you are 100% at the right location.
   
   Mohamed Saif El-Nasr
   Microsoft Certified Trainer
   Microsoft Certified Professional Developer



3. The content of this preparation / training guide is quite sufficient to pass the MCTS 70-502 exam. The information is thorough enough that even persons with relatively little experience programming WPF applications will find the topics covered comprehensive, if a bit scattered. Despite this, it is definitely to one's advantage to have made one or two applications using WPF in order to get a good feel for the capabilities of the technology.
   
   The content itself is a bit scattered and has many forward-references. This is, however, understandable given that WPF is a fairly holistic technology that can't be easily dissected. As such, two passes of the book are highly-recommended to ensure a solid understanding of the topics - examples presented in the beginning of the book will take on better meaning after a full pass of the book. The chapters tend to group content appropriately and in great depth. It is very easy to understand the workings of WPF, which is really what Microsoft Certification is all about - understanding, not memorizing.
   
   As with most training materials, there were some mistakes, but these were limited to typos in the text - if you stick to the C# track, you will see almost no errors; the Visual Basic examples were more error-prone. The (few) chapter summary questions are simple, yet require the reader to have paid attention, providing good checks for later review.
   
   In terms of learning gaps, there were some aspects of the test that were not covered in sufficient detail, but they can easily be corrected with some MSDN reading. For example, XPS document creation is not covered, though opening XPS documents is touched upon. By-and-large, everything is at least mentioned, though. The practice tests will accurately identify which areas you need to read-up on using MSDN.
   
   Coming to the point of the practice tests, the engine was much improved over the 70-536 test software. Many of the questions are representative of questions on the exam and you will find several areas not covered on the book showing up as questions - these are the areas that merit additional reading. There was only one error in the test questions, but if you read the explanation, you'll find that you are probably correct.
   
   Overall, I found this to be an excellent resource that, in the end, gave me an exceptional understanding of WPF and prepared me well for the exam.

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

1. I concur with the other reviewers that this book contains useful information but IT HAS NO INDEX, and FINDING that useful information is non trivial.
   
   What were O'Reillys thinking? If a third edition ever appears, and if it has an index I'd be glad to buy it as the book does seem to pack a lot of information into a small compass.



2. This is a great book for anyone who uses Python, especially for programmers at that level of Python competence after the beginner stage but short of a master's fluency. It provides a brief but clearly organized summary of Python basics: the language, primitive data structures, printf and other control codes, and the basic, everyday subset of the support libraries. And, since the editors apparently listened to criticism of earlier editions, the third editions includes a useful index as well as table of contents.
   
   Some readers will be disappointed that it's not the book that it never meant to be. It never meant to be a tutorial or text book, it never meant to be a full specification of the language and libraries, and it never meant to be an encyclopedic description of the many available libraries. Decide what you want: if that's a quick reminder of Python's most useful basics, then this book will meet your needs.
   
   -- wiredweird



3. I read various reviews complaining about the lack of an index. Well, it does have one now and it complements perfectly what is a fantastic quick reference for many of your Python needs, from built-in modules to regular expressions. Of course, it does not include the formal grammar of the language, a complete reference of libraries available or anything other than quick pointers for someone who already knows what Python is but is not a guru yet (although anyone can forget how to open a file from time to time).



4. After reading the excellent C++ Pocket Reference, I decided that this book was worth a try, but I was disappointed.
   
   The last half of this book is a list of module functions, that are MUCH more easily accessed thrugh the online documentation. I wish it was more a reference about the language than about the built-in modules. I don't remember (and I can't find it in the book index!) reading explicitly how to add an attribute to a class, or other language-specific operations.
   
   Being a pocket reference, the language should be concise, but sometimes it is so obscure to be nearly incomprehensible.
   
   Let me also point out that it is more than three years old, so it was not updated to cover Python 2.5, and of couse the upcoming 2.6 and 3.0. Furthermore it tries to cover many versions, with even some references to the 9-year old 1.5 release. I believe the latest would have been enough.
   
   In no way this can replace the modules online documentation, not even as a quick reference.



5. Python is a fast and easy to use language, though learning how to think in python, especially if coming from a more c-style language can take a while regardless of what book you're reading. This book won't help you with that. What it will do, is provide you with most (if not all) of the most-advanced features of python in a way that is really easy to digest for an intermediate/upper-beginner level python programmer. This book explains things that are not easy to find on the web or not apparent that they even exist in python (because, let's face it, python can be pretty magical at times). This book can be the catalyst that puts you well on your way to becoming an advanced python programmer. And all that from a tiny reference book!

5 comments about Agile Retrospectives: Making Good Teams Great.

1. I refer to the activities in the book all the time. It really gives a fresh look at the retrospective and keeps the team engaged. It's very easy to come out with some actions to carry forward which the team is committed to doing.



2. This year, I found myself leading an agile development team. While I've been in the software industry for several decades, I'm new to agile. I was lucky enough to attend the Agile 2007 conference, where I participated in a session with Esther Derby and Diana Larsen. That's where I first learned about retrospectives - from the co-authors of this book.
   
   First, the idea of retrospectives, as opposed to post-mortems (are our projects really dead?), as an ongoing process is challenging and exciting. Rather than waiting until the end, reviewing not just progress but the state of the team makes great sense.
   
   Then, the way that they put it all together - stating the value of the process, giving an outline for how to conduct a retrospective - makes it something you can indeed do right from the book.
   
   But as much as anything, the exercises/activities that make up a large part of this book are a tremendous value. Rather than trying to figure out "what should we do/say in a retrospective?", we are guided through combinations of activities to help us achieve the most effective results.
   
   And it's not just about agile. While the concept has developed through the growth of agile development practices, this is a tool that can benefit any organization of any type doing anything.
   
   It's a quick read with benefits that far outweigh the time it takes to read it. Ready to change the life of your organization? Introduce retrospectives.



3. This is a really useful book. Most practical. Being into scrum (sort of) for 3 months, we've tried to change our retrospective meeting agenda applying methods from this book. We did this just once as yet, and applied only a single combination of methods from virtually countless variants possible. The result is great: retrospective meetings became more meaningful and fun.
   
   Every scrum master (and anyone leading retrospective meeetings) should read this book.



4. I have read at least 10 books of the Pragmatic Series and this is the first one I couldn't finish because it was so terrible (I actually threw it out). This book is exactly what is wrong with corporate culture. Placating overly sensitive employees who need emotional coddling instead of trying to improve the process of software development. I prefer to work with adults, that have the maturity to get their emotional needs fulfilled outside of work, so time at work can be spent being productive. This book should have been titled "Cloy Retrospectives" or "Agile Dianetics". If you are looking for a worthwhile, and even entertaining, book on software management see Managing Humans by Michael Lopp.



5. This is one of those "common sense" books. It's full of really obvious practical advice. The difference I found however is in the multitude of simple and practical exercises it contains.
   
   The book is a really quick and easy read. It's now constantly on my desk as a reference. I plan to use a few of the exercises in our next retrospective in a week.
   
   Whilst this is an agile/scrum focused book, many of the exercises could be easily adapted to other "review" type situations in business and teaching.

5 comments about Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software.

1. After the first chapter I was skeptical. After the second I was depressed.
   
   This is the kind of humour that I imagine really motivates low level techies who assemble computers for a living and makes them feel superior to the entire world because they can plug in a video card. Remember the tech guy that insults you from "Saturday Night Live"? To be clear its intellectual arrogance about stuff that's not that intellectual.
   
   This is the field I'm going to base my life's work on. I don't need to read how hard it is. I want to read about successful projects and how ppl coded great applications. I mistook this book for "Beautiful Code" which I'm guessing is a lot closer to something I'd like to read.
   
   I wish I could send this book back but it was bought as a gift for me in an airport. Its seriously demotivating for an aspiring programmer and I imagine that the author is quite pompus for somone stating some pretty obvious stuff.



2. If you are interested in software development...read this book.
   
   If you aren't interested in software development...read this book.
   
   If you've always wondered why software development is such a tough thing to manage and predict completion...read this book.
   
   Did I say that you should read this book? :)
   
   The book is not a detailed "how to"...it is a story that follows the development of "Chandler", a software product that was going to 'change the world'....but of course, the product never really materialized. The team worked on the product for more than 5 years and never produced what the founder, Mitch Kapor of Lotus 1-2-3 fame, had envisioned. 5 years, over 4700 bugs and two dozen programmers with very little to show for the effort.
   
   Take a look at the Related Articles below...you'll see that Chandler is just now coming to be a "1.0" release after 7 years of development. Interested story and a great book.
   
   If you find yourself perplexed about the process of software development, this book might help you move a little closer to understanding the complexity of this process.
   
   Definitely recommended reading.



3. 
   I just finished reading an amazing book: "Dreaming in Code" by Scott Rosenberg. Like many good, recent non-fiction books, it alternates between a specific narrative with colorful real people, and general background information. In this case, it's the story of Chandler, a personal information management tool, and the team who are building it, led by Mitch Kapor.
   
   The general background explains far more about real, contemporary software, how it is built, and what it's all about, than anything I've read before. Everyone learning to be a software engineer, or who wants to understand what software engineers actually do, should read this book.
   
   In only 355 pages, Rosenberg discusses, in clear language that's easy to follow, at least the following:
   
   * What working on a software project in a team is like, the subjective experience
   * Open software, and the "Cathedral vs. Baazar" concept
   * Doug Englebart's ideas (very germane to Chandler)
   * Famous software fiascoes
   * Computer languages, especially Python and how it compares to others
   * Reusable software, software libraries, build versus buy
   * What "geek" really means
   * CVS, Bugzilla, and Wikis
   * Why user interfaces are so hard to design
   * Dependencies between parts of a system and how they block work
   * Release management and scheduling
   * Specifications and their nature
   * Layers of abstraction
   * Scaffolding
   * Code reviews
   * WebDAV and CalDAV
   * Microsoft FUD
   * Requirements analysis
   * Methodologies: waterfall, agile
   * The gist of No Silver Bullet and The Mythical Man-Month
   * Ruby on Rails
   * Software engineering, its history and what it means
   * Complexity
   * Late binding
   * Object-oriented programming
   * Recursion
   * The halting problem
   
   The story of Chandler and the team is compelling and instructive. On page 173 of the book, he says: "By now, I know, any software developer reading this volume has likely thrown it across the room in despair, thinking, `Stop the madness! They're making every mistake in the book!'" I did indeed feel that way by page 173. Here's my sense of what went wrong, based on the account in the book:
   
   * They did not have one architect (Brooks makes a very good point about why there should be a single person)
   * They didn't work out the architecture in advance, and they went back and changed it many times
   * They had a very flexible data concept/model, in which items change type frequently in a user-visible way, which they didn't work out until quite late
   * They kept changing their mind about their UI substrate: wxWidgets? Mozilla internals?
   * The software ecosystem changed around them after all those years, and using a Web UI now made sense, but it was too late for them
   * They could not figure out what database technology to use (they finally decided not to use the Zope Object Database, although their reasons for that decision don't impress me)
   * It was originally supposed to be peer-to-peer, but they could not figure out how to make that work, so they changed it to be server-based, a major change very late in the design
   * They had to design a security model for all this
   * It was all extensible, which is great but takes a lot of work to do right
   * There were complicated semantic issues with sharing, "chain-sharing", etc. which were not worked out early.
   * They wanted to have extensional and intensional collections, like iTunes, but also wanted to combine the two (the so-called "exclude Bob Marley" feature), which makes the semantics a lot harder
   * Their internal terminology was inconsistent, symptomatic of a lack of architectural integrity
   * They did serious requirement analysis only late in the project
   * It was putatively open-source, but it was much too immature to really get outside developers involved
   * They were too focused on doing "the right thing" instead of getting something out fast; see Gabriel's "Worse is Better" paper
   * They released much too early, partly because of the glare of publicity due to Mitch Kapor's involvement
   
   I see that they are still in "preview" releases. This has been going on for six years now! They have no projected release date for 1.0. It will be free, under the Apache license.
   
   I have always wanted a good personal information manager, and a lot about Chandler looks very promising. Someday I may be a happy user. Right now, I think I'll wait until release 1.0.
   
   I hope they have moved beyond the problems illustrated in the book and are running smoothly now. Kudos to the whole Chandler team for letting Rosenberg be so involved, being so honest with him, and letting him produce this unique, spectacular book.



4. i'm a sucker for any book on the margins between philosophy, social issues and computers, how and why they are shaping us and our communities.
   
   this is kind of what the book is about.
   to get a decent quick view of it, read chapter 10- engineers and artists, i think that the main points are on display here.
   
   a few new words like dogfoodable.
   a few new ideas i want to follow up on: leaking abstractions
   
   it is a watchful eye on a software projection-chandler with the other eye on what it all means. why is interfacing people with machines hard? what is slippage and why it always happens? but basically a beginning analysis of why writing software poses some curious philosophic and practical issues.
   
   i liked the book, a worthwhile read, look at chapter 10 and see if it warrants your time as well.
   thanks for reading this review.



5. I've not enjoyed a book this much since I read Steven Levy's "Hackers" - the behind-the-scenes stories and discussions are just great. I'm not a programmer by trade, but I dabbled a bit in high school and got some more in-depth training in college, but it wasn't my major... a book like this makes me realize not only the fun I may have missed but also the stress I may have dodged. The book definitely provides the ups and downs of the software development business. I especially enjoyed getting a deeper understanding of the Open Source movement and discovering that it too has its built-in problems and isn't the wonder-tech that some books and articles might try to paint it.
   
   The best part of the book was reading along with each release of Chandler... .4 then .5 then .6... and now I visit the actual website and see that they did make their 1.0 release! The book just made my investigation of the actual product and its support/help/website that much more fun.
   
   Great book! I'd love to see similar books done like this down the line.

5 comments about Business Process Change, Second Edition: A Guide for Business Managers and BPM and Six Sigma Professionals.

1. This is about the best Business Process book I have read so far. I worked in a IT transformation for a big Telecommunications company which entailed adopting a new approach to Business Process and Operational Process Development and I found this book very useful. This book with the book Business Process Management - Practical Guide to Successful Implementation provided me with most of the knowledge needed.



2. I think this is the best book that I have seen that allows an organization to consider business process at the enterprise and department level. I have been engaged in business process management in the government for years, trying to define the processes, trying to communicate them, trying to improve them. This is by far the best treatment and guide I have seen. This is what I have been looking for and couldn't find.



3. Business Process Change provides a very clear and comprehensive discussion of the methodologies surrounding successful business process management. This has become my new guide for developing a BPM Group within our organization. I very much look forward to more writings by Paul Harmon.



4. I really liked the first edition of this book. It has an overall approach plus a toolkit to start a business process redesign project. This second edition have only a very overall approach. It puts together many things not well integrated. It seems the author didn't select the topics, just included it.
   
   Yes, the approach in three level is an interesting framework, but it's not enough for what is missing from the first edition.



5. Paul Harmon's book is quite simply a masterpiece, one of the best technical books ever written. He writing is lucid and every page contains nuggets of insight. Unlike most technical books this one actually provides useful examples that you can immediately put to good use. Harmon begins the book with a masterful background into the business process field (worth the price of the book alone) and then gets into the nitty gritty laying out a methodology for analysis and change. An essential book for anyone remotely interested in business process change.

2 comments about Professional Visual Studio 2008 (Wrox Programmer to Programmer).

1. If you're a Visual Basic programmer, which I am not, then you might get a lot out of this book. I was hoping that the authors would provide examples in both Visual Basic and C#, but unfortunately that was not the case. There are a few examples that use C# but not nearly enough to even come close to enabling me to understand the Visual Studio framework and .NET development environment.
   
   Perhaps this is an excellent book, but for me it was a major disappointment.



2. Let me start with a disclaimer: I know Nick Randolph and Dave Gardner personally through my involvement with the Perth .NET user group. They are both very talented and skilled developers and active in their support of the developer community. I tried not to let this fact bias this short review too much!
   
   I reviewed the Visual Studio 2005 predecessor of this book some time ago, and I think the new 2008 is an improvement. It's a big book and not just by its size. It covers a huge amount of material and could probably have been subtitled `everything you wanted to know about Visual Studio 2008 but were afraid to ask'! The Visual Studio 2008 Integrated Development Environment (IDE) is a complex beast, and worth getting to know well, if like me, you spend most of your working life in it! You could, of course, still do most of your development in Notepad, but you could also wear a hair shirt...
   
   The primary focus of this book is on the IDE itself, rather than the specific languages that can be used within .NET or indeed the .NET Framework itself. I'm not going to give a chapter by chapter account of what is contained in this book, mainly because it would take a loooooong time, but also because I fear my head might explode! Seriously though, I have read around 75% of it. The writing style is clear and I doubt whether you could make any book about Visual Studio more engaging than they have achieved.
   
   The authors' goals, as stated, were not just updating the Visual Studio 2005 version of this book or simply to explain how to use Visual Studio, but also to create a set of productivity best practices and recommendations on how to use Visual Studio features in an effective way. I think they have achieved that goal.
   
   One of the first Amazon reviews was not favourable, but that reviewer was looking for a book that would teach C# and an introduction to the .NET framework. As Dave mentioned in his response to that reviewer, although both authors do have a bias towards Visual Basic, approximately 40% of the code samples are written in C#. There is also a chapter that provides coverage of F# (http://mitch-wheat.blogspot.com/2008/09/new-net-f-ctp-release.html)
   
   It is probably not the sort of book you would read cover to cover, but rather delve into specific chapters to gain insight into particular features. It's great for quickly finding out what features are available. The first day it was on my desk at work, I used it to quickly find a debugging gem that might have otherwise remained undiscovered.
   Kudos goes to Nick and Dave for producing a great resource for developers.
   
   There is a companion website and blog here: http://www.professionalvisualstudio.com/

5 comments about C Primer Plus (5th Edition).

1. I tried couple of C books but, never worked.
   C Primer start from the scratch and go through
   all the topics which a beginner should know
   very well.
   The book is thick and has lot of assignments.
   It helps new C student to grasp the language
   easily.
   I recommend "C Primer" for the beginners of
   'C'.



2. I have just started reading this book the day before yesterday and I'm only on pg.124 in ch.4 but I already know that this book is a must have for any beginner in C and with their index in the back of the book tells me that it is a great reference guide for veterans of C. I have read other programming books like Teach Yourself Visual Basic 2005 in 24 Hours (which is bad book-doesn't teach very well) and I have to say that this is one of the best programming books out there and it is a must own for any C programmer!



3. This is simply put the best beginner book I've found on C.
   
   I've been reading it for over a year, and have yet to finish it all of it.
   
   It covers all the C language aspects (and also the C99 extensions) and provides lots of exercises to train your skills.



4. Over the years, as I've flirted with the idea of really sitting down to learn C, I've looked at a variety of intro-to-C type books; I've even bought a couple - only to set them aside to collect dust. This book (C Primer Plus, 5th ed.) is, frankly, one of the best intro books I've seen. I've read the first 13 chapters thus far and have been very pleased with the content. Topics are presented logically, explained well, and include numerous sample programs in the text body to reinforce newly introduced ideas. If you take the time to walk through the sample programs, look at the review questions, and work on the end-chapter programming exercises, you'll be in good shape. This book is worth every bit of the purchase price; it will stay in my personal library for years to come and I will highly recommend it to friends and colleagues looking to learn core C programming skills.
   
   Note: I do have basic programming skills in other languages, but I think this book would be fine for any "true" novice as long as they gave themselves time and diligently worked through the exercises.



5. This would be a great book if not for the fact that the first 100 pages are about printf() and scanf(). The beginner does not need to read technical specs on these two functions. That's what the C99 spec is for. It just goes on and on and on. What the author should have done is very gradually introduce these important functions over the course of several chapters, mix it in with control statements, expressions, operators, etc. with a more complete and in-depth coverage saved for an advanced chapter on functions.

5 comments about Expert F# (Expert's Voice in .Net).

1. As an experienced programmer, notably in C#, Scheme & Haskell, with no prior F# exposure, I've found Expert F# a joy to read and its level just right. The book reflects the language F# itself: it's elegant, fun & practical.
   
   Genuinely interesting, the code samples never appear contrived, as is usually the case in a text presenting a language. Actually, Expert F# goes well beyond teaching F#: it is a compelling demonstration of effective functional programming and I am sure I've grown as a programmer by reading it. It's also a book I've found myself coming back to, gaining new insights at each careful reading.
   
   My favorite chapter is Introducing Language-Oriented Programming (ch.9), which is packed with fascinating examples: probabilistic workflows, schema compilation by reflecting on types, and using F# quotations for error estimation (though see a correction to the math here: http://cs.hubfs.net/forums/5508/ShowThread.aspx), to name just the three most striking.
   
   In short, I enthusiastically recommend Expert F#, specially if your task requires you to program on the .NET platform. Though C# is OK, F# is more elegant, more fun & more productive -- you won't be looking back.



2. For a background about the reviewer, I am a software developer with 5 years of experience. I have programmed in C# and C++ only.
   
   This is one of the first books to be written about F#. Taking into consideration that F# works on top of the .NET framework and all previous .NET Languages didn't include a functional language, most intended audience should be expected to have little or no background of functional programing while having a good background of imperative programming.
   
   Functional programming is a whole new world for imperative programmers, a world with new restrictions and new ways of thinking. Unfortunately this book doesn't give a good explanation for functional programming concepts, it is explaining the language syntax most of the time. Even when explaining language syntax it is always missing things that you find explained in discussions and tutorials online. This book acts more as a syntax reference more than a book to learn from.
   
   If you have no background about F# or functional programming then this book will not make things easy for you. You have to use another source with this book, either a series of tutorials or some articles or a discussion board.



3. This is my amended review after reading the other reviews for the first time. I totally agree with Muhammad, who also gave this book a 2 star rating. I can't believe people are giving this book rave reviews (I think some of the reviewers are being paid). I read lots of computer books, and this one just isn't that well written in comparison. It is quite apparent to me that the authors do not write applications for a living. Instead of "Expert F#" it should be "Academic F#". From an expert, you expect advice on the best way to do things, things you should avoid, and alternatives. This book does not have any of this kind of information.
   
   Here is my original review:
   
   Functional languages are "hot" because of the promise of easy multiprocessing and reduced error rates. So great, I'll buy this book and convert my C# code, so it can work with all these multi-core chips.
   
   Be warned, this book falls short of real world examples and uses. Its examples seem more of interest to the academic community than business applications. Most if the book is of the nature, "this is what you can do" instead of "in this situation; this is the best way to do it."
   
   It also assumes a lot of background in functional languages. Yes, it states "Expert", but really how many OCaml programmers are there? It really could use numerous examples of C# or VB code rewritten in F#.
   
   This is not to say there is not a lot of good information here and there are not a lot of alternatives. It is nice having this information all in one place. I am still sold that F# and functional languages are the future of programming, but just be warned the learning curve will be high.



4. It's definitely a good book. I've read a few sections in it and have been impressed with what I've seen. The book is targeted toward specific implementations of F# in various settings. I like that but think other people won't. The techniques described are quite powerful. I'd say this is a must for experts in the .NET languages.



5. Expert F# does a great job explaining why and how you should use F#. It is not a general purpose tutorial on functional programming. The title "Expert" should be a hint that some (maybe... 25%?) of the topics are going to be advanced and move fast. If you're completely new to functional programming, Real World Haskell (already out) and Real World Functional Programming (Tomas Petricek, 2009) are good resources to get you in the right mindset.
   
   Regardless, this book covers the many aspects of F# and is the best general resource on F# so far.