Programming Books C Java PHP Python Learn more Browse Programming Books
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) Paperback – October 23, 2009

ISBN-13: 978-0596153649 ISBN-10: 0596153643 Edition: 1st

7 New from $46.42 30 Used from $1.54
Amazon Price New from Used from
Paperback
"Please retry"
$46.42 $1.54

There is a newer edition of this item:

Programming F# 3.0
$31.65
(5)
In Stock.
Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student


Frequently Bought Together

Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide) + An Introduction to Functional Programming Through Lambda Calculus (Dover Books on Mathematics)
Buy the selected items together

NO_CONTENT_IN_FEATURE

Shop the new tech.book(store)
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now

Product Details

  • Series: Animal Guide
  • Paperback: 410 pages
  • Publisher: O'Reilly Media; 1 edition (October 23, 2009)
  • Language: English
  • ISBN-10: 0596153643
  • ISBN-13: 978-0596153649
  • Product Dimensions: 7 x 1.1 x 9.1 inches
  • Shipping Weight: 1.2 pounds
  • Average Customer Review: 4.6 out of 5 stars  See all reviews (25 customer reviews)
  • Amazon Best Sellers Rank: #781,555 in Books (See Top 100 in Books)

Editorial Reviews

Book Description

A comprehensive guide for writing simple code to solve complex problems

About the Author

Chris Smith works at Microsoft on the F# team. His role as a software design engineer in test gives him a unique mastery of the F# language. Chris has a masters degree in computer science from the University of Washington.

You can read his blog, Chris Smith's Complete Unique View, at http://blogs.msdn.com/chrsmith/.


More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

4.6 out of 5 stars
5 star
19
4 star
3
3 star
3
2 star
0
1 star
0
See all 25 customer reviews
I highly recommend this gem of a book.
Andre M. Van Meulebrouck
The author presents concepts in a way that is easy to understand, and as a result I am absorbing the information very effectively.
W. French
If you are already comfortable with functional programming languages then F# should be pretty easy to learn.
Michael Taylor

Most Helpful Customer Reviews

30 of 31 people found the following review helpful By Michael Giagnocavo on November 10, 2009
Format: Paperback Verified Purchase
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#.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
29 of 32 people found the following review helpful By Justin M. James on May 1, 2010
Format: 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.
Read more ›
3 Comments Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
9 of 10 people found the following review helpful By Marc Sigrist on April 11, 2010
Format: 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.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Recent Customer Reviews


What Other Items Do Customers Buy After Viewing This Item?