Customer Reviews


25 Reviews
5 star:
 (19)
4 star:
 (3)
3 star:
 (3)
2 star:    (0)
1 star:    (0)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favorable review
The most helpful critical review


30 of 31 people found the following review helpful
5.0 out of 5 stars Easiest F# Book Available
As of Nov 2009, this is probably the easiest book out there on F#. Chris Smith doesn't approach the book assuming prior functional programming knowledge. He avoids getting overly complicated or using difficult terms. There was no point in the book where my eyes glossed over because it got too hard to follow.

The book is split into two parts. The first part is a...
Published on November 10, 2009 by Michael Giagnocavo

versus
29 of 32 people found the following review helpful
3.0 out of 5 stars Explains "how" but not "why", "where", or "when"
If you are looking to dip your toes into F#, this book is a good reference. Unlike any of the other reviewers here, this is my first experience with F# or an F# book other than a brief Fib generator when the first F# CTP was released. The fact is, I have a strong interest in F#. I learned Scheme ages ago (nearly 20 years ago, now that I think about it) and enjoyed it for...
Published on May 1, 2010 by Justin M. James


‹ Previous | 1 2 3 | Next ›
Most Helpful First | Newest First

30 of 31 people found the following review helpful
5.0 out of 5 stars Easiest F# Book Available, November 10, 2009
Verified Purchase(What's this?)
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
As of Nov 2009, this is probably the easiest book out there on F#. Chris Smith doesn't approach the book assuming prior functional programming knowledge. He avoids getting overly complicated or using difficult terms. There was no point in the book where my eyes glossed over because it got too hard to follow.

The book is split into two parts. The first part is a mainly a run through all of the F# syntax, getting you setup and writing F# code quite quickly. Even though I've been using F# for a couple of years, I still picked up a few new things. It's a book you can use as a reference for parts of the language, even though the actual product documentation is coming together. Of note is the section on lists, which I found particularly clear and easy to follow.

The second part of the book is where Mr. Smith takes it up a notch. The book says it's "applied" F# programming, which in many programming books means the author is about to go over some common APIs for you. Not so in this book. The second part shows some of the very powerful and practical things you can do with F#. The introduction to workflows (computation expressions) was excellent; I don't believe I've seen an easier-to-understand explanation for those who haven't dealt with such constructs before (and there's no use of the dreaded word "monad"!).

What really surprised me was that this book follows up on workflows with a great section on quotations. Not only does it give an overview of what they are, but it provides enough depth so that you can actually start processing and manipulating quotations right away.

Even the appendix is worth reading, as there's a part on F# interop. While F# runs on the CLR, there are certain constructs in F# that won't necessarily look pretty in C#. The appendix goes over how to avoid those problems and make clean ".NET-friendly" APIs.

Overall, I'm quite content with the book. It's a good purchase, even for an experienced F# user. If you're trying to learn F#, and don't have a functional background, this is the book to start with.

As a note, the content doesn't overlap excessively with "Functional Programming for the Real World". So if you're considering both, you won't be disappointed. They're actually so complementary, I'm not sure which one is better if you can only get one.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


29 of 32 people found the following review helpful
3.0 out of 5 stars Explains "how" but not "why", "where", or "when", May 1, 2010
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
If you are looking to dip your toes into F#, this book is a good reference. Unlike any of the other reviewers here, this is my first experience with F# or an F# book other than a brief Fib generator when the first F# CTP was released. The fact is, I have a strong interest in F#. I learned Scheme ages ago (nearly 20 years ago, now that I think about it) and enjoyed it for what I did, so I am not a total stranger to functional programming. But if you've never used functional programming before, this book really does not explain where it is better or how to really take advantage of it. Sure, it shows you at a syntactic level how to use F#'s functional features. But if you want to improve your application by using functional programming, this book isn't going to help you unless you are already well versed in functional programming. To be honest, I was extremely disappointed.

The parts on object oriented programming and interfacing with other .NET code make F# look positively miserable. All too often, it seems like I would not want to use F# for anything other than taking a set of primitive values in and spitting a primitive out if I ever need to interface with other .NET code. I don't know if this is a fair assessment of F#, but it is the impression that this book gave me. By focusing so much on things that F# is not great at and largely ignoring things that it should be good for (for example, why was there never an example of walking a tree *in parallel*?!?!), I came away feeling like F# is just a very fancy replacement for the switch/case system.

This book *is* well written and clear. Unfortunately, F# is a symbol heavy language and the author tends to explain a symbol once and assume that you understand it and why he chose it over something else, which made following the examples very hard. All the same, I was grateful that the author didn't rely on understanding highly technical ideas (continuations, memoization, etc.), and at the same time did a very good job at explaining them as they came up, and even gave some good examples.

If you are someone (like the other reviewers) who are already familiar with functional programming as a concept and want to learn how to do it within F# and the .NET ecosystem, this is the book for you. If you are not that person, this book won't help you beyond the F# syntax itself. I am going to check out "Real World Functional Programming" and see if it has the parts missing from this book.

J.Ja
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


9 of 10 people found the following review helpful
5.0 out of 5 stars A condensed, but complete introduction to F#, April 11, 2010
By 
Marc Sigrist (Zurich, ZH Switzerland) - See all my reviews
(REAL NAME)   
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
This book appeared only recently and is up-to-date with the upcoming F# 2.0 release. It was written by Chris Smith, Software Design Engineer in Test at the F# team. It contains a densely written overview of the complete F# language. The writing follows a systematic path from the simple to the advanced. There is always a short introduction of a feature, followed by an extensive example, followed by further comments.

In the introductory chapter, we learn that white space matters: I order to create hierarchies of scope in code, one simply uses new lines and indentations, not curly braces and semicolons. Functions can easily be nested in other functions, which can be nested again in still other functions ad infinitum. Each subordinated function has its own narrow scope, which eliminates an important source of bad programming design. Oftentimes, parameter types do not have to be declared, because the compiler can infer them automatically. If so, one can also avoid writing parentheses () for the parameters. Taken together, these features make the F# language nicely self-documentary. Even without looking at the details, from the tense, clear-cut, indented shape of the code alone, one can quickly get a sense of the logical structure.

Conceptually, you could do the same already in C# 2.0 by nesting anonymous methods within each other. However, even in C# 3.0/4.0, nesting lambdas, the code soon becomes convoluted. As a consequence, in C#, one tends to implement functions without applying the appropriate level of local nesting, or even to declare private methods where anonymous methods would be more logical, thereby violating scope. Declaring private types nested in other private types is not really an alternative, because the declaration has to be outside the method, and it all takes so many lines of code that the whole construct will finally diffuse its own purpose to the reader. The way I see it, by offering the feature of function nesting, functional languages promote the object-oriented principle of encapsulation in a more sophisticated and fine-grained way than object-oriented languages themselves.

As one continues reading the first three chapters, the thinking adapts more and more to the fact that functions are just like other values. F# allows you (through partial function application) to transform functions into other functions with less parameters, and (through "currying" with pipes) to build chains of functions in a natural, intuitive way. Discriminated unions are another productivity-enhancing feature: Imagine enums in C#, but with nearly unlimited freedom in defining (and nesting, and sub nesting...) each enum member. Discriminated union members can be matched to other values via typed pattern matching, another fascinating feature, something like a C# switch statement on steroids. Together, discriminated unions and pattern matching save many lines of code and of potential errors. They also make the code spontaneously conceivable-at-a-glance, without having to go back and forth through page after page in the code editor to understand the mapping logic.
Another interesting aspect of F# is the built-in special support of collection-like types. F# tuples internally rely on the .NET 4.0 Tuple<...> type (an ordered collection of differently typed, nameless values). F# records are like C# 3.0 anonymous types, without the anonymity (a collection of differently typed, named values). F# lists are read-only singly linked lists of equal types. Of course, F# also has built-in support for arrays and sequences. The language contains specific operators and other constructs to make the declaration, initialization, and general handling of collection-like types as intuitive and natural as possible, allowing you to "write the code the way you think" and let the compiler do the work of implementing your expressed intentions. It is also possible to use the generic collections from the .NET Framework.

Chapter 4 deals with imperative programming in F#, i.e., programming that alters data that is already in memory. This subject is presented in its own separate chapter, because, by default, F# values can never be null and can never be mutated, even if they are of reference types. The chapter explains how you can digress from the default behavior, including how to deal with .NET Framework members that request or may return null.
Chapter 5 explains object-oriented programming in F#. The author starts with a brief explanation of what object orientation is and why it is useful. These remarks are probably directed at proponents of so-called "pure" functional languages (such as Haskell), who might be skeptical about, or not accustomed to, object orientation. However, the author also mentions some shortcomings of pure object orientation. Among other things, it forces the developer to formally implement certain design patterns, which, in functional languages, are implicitly there without needing special consideration.
Chapter 6 shows how to do classical .NET programming with F#, with some fascinating extensions. For example, in F#, using object expressions, it is possible to create an "inline instance" of an interface type, without declaring a named, implementing type first. The chapter also explains how to declare and use standard .NET enumerations (instead of F# discriminated unions) and compares F# value types with F# records.

Chapter 7 deals with applied functional programming. It introduces units of measure and explains the usage of active patterns. Active patterns allow using functions inside the pattern matching. The author points out the three kinds of active patterns: Single-case, partial-case, and multi-case, and how they can be nested. The chapter also shows how to use F# lists in recursions. I was amazed by the fact that the F# compiler automatically generates code that avoids a stack overflow when the recursion is implemented in the "tail-recursive" style. A variation of this is the "continuation passing style", which prevents stack overflows even when two interdependent recursive functions are involved. The chapter goes on with examples with function currying and the forward pipe operator (for a list of F# operators, see here), followed by closures, memoizing, and lazy evaluation, which should be familiar for C# programmers.

Chapter 8 is about applied object-oriented programming in F#. Any arbitrary symbol my be defined as an operator. One can declare indexers, and also "slices", which return a sub range of a collection via slice notation. In addition to the generic type constraints known from C#, F# offers type constraints for delegate, enumeration, comparison, and equality conditions. As far as events are concerned, using the F# Observable module, one can define, compose, transform, merge, and map events in various ways. Chapter 9 demonstrates how to use F# as a scripting language. Even in scripted usage, F# is always compiled first, and therefore is faster than regular scripting languages. The chapter also contains a few pages about Microsoft Office automation with F#.

Chapters 10 to 13 contain more advanced F# concepts, which, coming from a C# background, were something like a revelation to me. Using computation expression builders, one can redefine the behavior of keywords such as while, return, yield, using, try/finally, etc., to create custom background processing for synchronous and asynchronous workflows. F# allows you to call asynchronous operations almost like synchronous ones. You do not need to apply the traditional Asynchronous Programming Model (APM) of the .NET Framework, which is not type safe, and depends on separate callback methods spread in the class. Fortunately, version 4.0 of the .NET Framework will contain Parallel Extensions for .NET (PFX) and thread-safe concurrent collections, which contain some further optimizations and can be used by any .NET language. Chapter 12 deals with reflection and declarative programming in F#. Using F# code quotations, one can access not only the static type information (as in classical reflection), but also the compiler's internally used abstract syntax tree (AST). This is conceptually similar to, but much more elaborated than, expression trees known from lambdas in C# 3.0.

I would like to recommend this book to experienced developers seriously interested in F#. Readers without a functional background had better not expect to understand everything immediately upon a light first reading. The content is quite condensed, and many concepts are new to object-oriented developers. However, once you open yourself up to new ways of thinking code, if you are like me, you will be more and more enthusiastic about the power and intuitiveness of this elegant new language.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


11 of 13 people found the following review helpful
5.0 out of 5 stars Ladies and Gentlemen, this is the book !, November 19, 2009
By 
PC (Seattle, WA) - See all my reviews
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
It has been a long time since I got excited about a programming book as much as I did with Programming F#. I have all the books on F# available in the market today(including the Manning MEAP - Functional Programming for the Real World: With Examples in F# and C#. But I should say that this is the best book for learning F# if you have no experience with functional programming. I am not sure how this book would be for a person who is totally new to programming (chances are they would find this ahead of their curve). But for a person who has good experience with imperative programming this book would get you up and running with F# in specific and functional programming in general.

The book by Don Syme Expert F# (Expert's Voice in .Net) (who invented F#) is also good but not as good as Programming F# for new functional programmers. But once you have read this book, Don Syme's book might be a good follow up.

The strongest point of this book is the clarity with which concepts are explained and the choice of good examples to explain a concept. They are concise and to the point. It also made the book surprisingly small (at a little less than 400 pages). But no worries, everything that you need to get a firm footing in F# is in here.

This is truly a 5 star book. Highly recommended.

The table of contents:
Part I. Multiparadigm Programming

Chapter 1. Introduction to F#
Chapter 2. Fundamentals
Chapter 3. Functional Programming
Chapter 4. Imperative Programming
Chapter 5. Object-Oriented Programming
Chapter 6. .NET Programming
Chapter 7. Applied Functional Programming
Chapter 8. Applied Object-Oriented Programming

Part II. Programming F#

Chapter 9. Scripting
Chapter 10. Computation Expressions
Chapter 11. Asynchronous and Parallel Programming
Chapter 12. Reflection
Chapter 13. Quotations
Appendix A. Overview of .NET Libraries
Appendix B. F# Interop

Index
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


6 of 6 people found the following review helpful
5.0 out of 5 stars The fastest way to get F# into your head (along with practice), October 28, 2010
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
I have several other F# books: Expert F# 1.0 and 2.0 by Don Syme, Real World Functional Programming by Tomas Petricek, F# for Scientists by Jon Harrop (now outdated, he has newer ones), and Foundations of F# by Robert Pickering. In my opinion, this book has the simplest explanations, the clearest and best-chosen examples, and the easiest to understand guidelines. Don't neglect the other books for deeper understanding or more information on certain areas (Syme's book has a chapter on interacting with COM, for example), but this is the one to start out with.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5 of 5 people found the following review helpful
5.0 out of 5 stars an elegantly concise survey of F#, January 21, 2010
By 
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
A hallmark of this book's approach can be summed up as: fun! Chris has an infectious enthusiasm for programming that he imparts to readers.

Chris really "gets it"; being able to step back from a subject matter in order to answer the proverbial question: "What does the sum total of these disparate parts mean?". In technical tomes, it's easy to get lost in a sea of details; no longer being able to see the forest for the trees. The real mark of a master is being able to explain things well, making the complex seem simple. That can spare the reader from having to learn things the hard way.

Learning a subject matter is like someone throwing coats at you: if you don't have a coat rack to put them on, they'll wind up on the floor. Chris gives you a great framework with which to organize the subject matter. Down-to-earth, well grounded: cuts right to the heart of matters.

This book is concise, yet accessible. I was surprised at how petite the book is physically: it's rather small and light for a technical book; but that's good. The information is well organized and balanced. The flow of the material is nicely coherent. This book can also serve as a reference: just the right size to be handy, and help you get your bearings. The index is quite good. The examples are well chosen, being just the right size to demonstrate each point without extraneous distractions.

There's a concept in extreme programming called YAGNI. ("You Ain't Gonna Need It!"; ergo don't broach details until they are proven to be needed.) This book could be considered "YAGNI-compliant" (if such a term exists ;-) because it tries not to overwhelm the reader with too many details. Overwhelming a reader could cause needless confusion and frustration. Conversely, a reader empowered with the big picture can easily fill in missing details (often via a simple internet search; indeed, all available F# materials are fantastic).

.Net programmers will get a great overview of the .Net framework from a unique perspective. One surprise for me was the section on WPF. It is very short. (It's in the appendix.) Yet, it cut to the chase immediately in a very refreshing way: what's the goal of XAML and WPF? It's to decouple the UI from the programming logic. How is that achieved? Through binding and resources. He then showed a trivialized example to demonstrate how this is done. That simple example, and the ensuing discussion, made the light bulb go on for me in a more profound way than from reading huge tomes on WPF. (Epiphany! What does it really mean to abstract your code from the user interface?)

People from a LISP or Scheme background should find this book delightful. Chris shows how F# possesses elegant simplicity of expression after Scheme's own heart. The section on continuations is awesome. This important (but potentially difficult to grasp) topic is very well motivated. If you had trouble groking continuations in Scheme, you'll be pleased with Chris's presentation.

Haskell programmers will likely enjoy the discussion on monads. Chris has a way of demystifying esoteric concepts, and showing their pragmatic applications.

All the important concepts of F# and functional programming are well presented, in order to get you on your way quickly. I highly recommend this gem of a book.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 2 people found the following review helpful
5.0 out of 5 stars Ageless Beauty, May 13, 2012
By 
Dan T (Boston area) - See all my reviews
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
It is May 2012 and this book still rocks! It will stay on my shelf, close at hand, for years to come.

Chris Smith's unique perspective as Tester on the F# Team explains how he can write with such breadth and just enough depth to bring me up the learning curve smoothly. I even enjoyed reading material I "already knew", because Chris' writing style and examples are fluid and enjoyable. He adds the glue knowledge that ties things together, too, like "Anatomy of an F# Program" in Chapter 2, and "When OOP Breaks Down" in Chapter 5, and "When to Use and Enum Versus a Discriminated Union" in Chapter 6.

I felt Chris was writing DIRECTLY TO ME when I got to Chapter 7: Applied Functional Programming. His justification for "Converting Modules to Classes" lifted me through a learning plateau that is a direct result of learning from small snippits and scripts. I was starting to see my own F# code as "an unorganized series of values". In the same chapter, "Tail Recursion" fully explained a key functional concept that makes me, in my own mind, a Functional Hotshot.

In the 2nd half of the book, Chris goes into more depth on increasingly advanced topics, like Asynchronous/Parallel Programming (Chapter 11) and Reflection (Chapter 12). I was able to read these chapters because the writing is crisp and interesting, but I'll be coming back to these later chapters again and again.

I'm glad Programming F# is on my bookshelf.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 2 people found the following review helpful
3.0 out of 5 stars Disappointing, May 2, 2012
By 
slo (San Francisco, CA United States) - See all my reviews
Verified Purchase(What's this?)
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
This is the first time I've been disappointed by an O'Reilly book. This may be good if you're already somewhat familiar w/F# and/or with some of the concepts that haven't really crept into your language of choice yet. However, it doesn't do a particularly good job of explaining the concepts and there are a number of places in which code snippet include symbols/structures that haven't been covered yet. In that the code snippets are supposed to illustrate a concept, if you can't follow the meaning of the code because it has stuff in it that is foreign to you, the expository value of the snippet is lost. It may be that my disappointment is colored by a realization that I don't really like F# - I guess I find value in punctuation - but I still feel like the language concepts could have been made clearer and the snippets less opaque.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


3 of 4 people found the following review helpful
3.0 out of 5 stars Review from a non-Functional programmer, February 20, 2011
Verified Purchase(What's this?)
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
I have to agree with one of the other reviewers (Justin James). For me this book was a great introduction to the F# syntax. The chapters were well written, stayed on topic and provided some decent examples. Being new to functional programming, I am REALLY struggling on how exactly F# fits into my development world. Examples showing a problem being solved in F# and then the same problem being solved in C# (along with the pros and cons of each) would have helped me see the light.
I did run across a video from Channel 9 of MSDN. It helped me, so maybe it will help you as well.
Luca Bolognese video on MSDN channel 9.
[...]
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


7 of 10 people found the following review helpful
5.0 out of 5 stars Great book for a foundation in functional programming and F#, October 28, 2009
By 
Verified Purchase(What's this?)
This review is from: Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) (Paperback)
Programming in F# by Chris Smith is an extremely clear and cogent treatment of Microsoft's promising new language, F#, and of functional programming overall. I have followed F#'s development closely, but from afar, as my background is in mathematics, and have lusted after using F#. With the release of beta 2 of Visual Studio 2010, we now have a very sturdy implementation of this functional language, and Chris Smith's book explains its deep beauty with clarity and imagination.
I highly recommend this book to anyone interested in learning the broad overview and the particulars of a new programming paradigm, one that treats humans as humans and computers as computers.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 2 3 | Next ›
Most Helpful First | Newest First

Details

Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide)
Used & New from: $0.19
Add to wishlist See buying options
Search these reviews only
Send us feedback How can we make Amazon Customer Reviews better for you? Let us know here.