Real-World Functional Programming: With Examples in F# and C# Paperback – Jan 25 2010
Customers Who Bought This Item Also Bought
No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
Getting the download link through email is temporarily not available. Please check back later.
To get the free app, enter your mobile phone number.
About the Author
Tomas Petricek discovered functional programming as a graduate student at Charles University in Prague. He has been a Microsoft C# MVP since 2004 and is one of the most active members in the F# community. In addition to his work with F#, he has been using C# 3.0 in a functional way since the early previews in 2005. He interned with the F# team at Microsoft Research, and he has developed a client/server web framework for F# called F# WebTools. His articles on functional programming in .NET and various other topics can be found at his web site tomasp.net.
Most Helpful Customer Reviews on Amazon.com (beta)
Since F# lives in .Net, and .Net is inherently object-oriented; it makes sense to understand something of the mapping that takes place behind the scenes when F# code is mapped into the .Net world.
Many of the interesting new features introduced into C# are actually hand-me-downs from FP (functional programming). This includes generics, LINQ, anonymous methods, lambdas, type inference, etc.. Since many programmers need to use C# in the work-a-day world, it makes sense to understand the functional elements of C# by seeing them in a functional language like F#, where they can be seen in their purest (least hobbled) state. Once these concepts are understood, it is then much easier to understand how to wield these tools effectively in C#.
That said, there are also limits to how much functional programming can be done in C# (and how effectively it can be accomplished). This book clearly demarcates the boundaries of what is (and isn't) feasible in C# vis-à-vis functional programming.
One of the things I liked best about this book is the discussion on why functional programming makes code easier to read, write, and verify. This discussion does not appeal to what might be (for many) inaccessible theory (i.e. denotational semantics, category theory, etc.). Instead it is demonstrated in amazingly simple, straightforward ways! This discussion is very effective.
Another facet of this book's approach that I applaud is the demonstration of lambda calculus. Why would a practical book dabble in theory? There's actually a very pragmatic payoff in doing this: functional programming has a lot of underpinnings in lambda calculus. Those that have been exposed to lambda calculus will feel right at home in F#. Those that haven't are likely to feel more "culture shock" when being exposed to concepts like currying and lazy evaluation. Functional programming really does represent a substantially different way of thinking about computation.
This book also features an excellent discussion about design patterns; comparing and contrasting how they are implemented in OOP (object-oriented programming) versus FP. Some classic design patterns in OOP essentially come for free in FP (e.g. the "visitor" pattern).
An example of what I mean by 'verbiage' - on page 156:
....Let's now analyze how it works in some more detail.
6.4.3 Evaluating the example step by step
It can take some time to become confident with high-order functions like these,
especially when they are nested. We're going to examine how the code from the
previous listing by tracing how it runs for a few sample inputs. Moving from the
abstract question "What does this code do in the general case?" to the concrete
question of "What does this code do in this particular situation?" can often help
to clarify matter
This does not actually say anything - it just introduces what it's going to be written after - that you are going to read in any case. This is a page I opened at random - the book is full of this - constantly telling you what you just read and what you are going to read.
On top of this some more advanced stuff like continuations gets short (and not very illuminating) explanations - that is sort of galling in the middle of all this redundant stuff.
It could have been a good 200-300 pages book, instead it is a mediocre 500+ pages ones.
The book definitely delivers on both fronts. There is a solid discussion of F# syntax, what it does, how it supports a functional way of thinking and how you can improve C# code to benefit from these ideas. I will be re-reading and experimenting with variations of examples in this book for months. In other words, you get a *lot* for your money.
I found this book a little strange and difficult to read for the following reasons:
1) It explains functional programming concepts as if the reader is completely new to it. I found myself skimming through lots of text that I felt was obvious from the F# code snippet.
2) It spends way too much time talking about applying functional thinking to C# code. I found this unnecessary because F# and C# are different tools for different applications - I'll use F# when I think a functional approach is right. A couple of lines of text that describe roughly what one would have had to do in C# to achieve the same effect (plus perhaps C# snippets in an appendix) would have been sufficient.
3) The flow of the book wasn't right for me because I like to get the syntax out of the way before tackling everything else. A small chapter at the beginning that offered a "crash course on F# syntax" would have greatly improved the book for me.
But I don't think that is the kind of book the authors set out to write.
WHY READ IT?
This book won't get you up to speed with F# quickly. The examples aren't from the real world. You cannot use this as a reference book. Strictly speaking, it's not even a book about functional programming.
This is a book about functional *thinking*, written for those who know your typical C, C++, Java or PHP. A better title for this book might have been "Functional Thinking for OOP/Imperative Programmers: From C# to F#". It is a functional programming book for those who haven't taken a CS class using a functional language.
If you are looking for a book that will help you add F# to your language toolset, this is not it. But if you're the type that often writes a line of code and wonders why the language looks the way it does, it doesn't get any better. This is a timeless book that I will refer to whenever I write a line of F# and wonder: "why does it do that?"
introduces the functional programming paradigm by comparison to more traditional
imperative programming techniques. The first part of the book goes through many
common programming tasks and compares how you would implement them in the C#
programming language and then re-introduces the problem from a functional
perspective using F#. It introduces simple ideas such as recursion and how to
use recursion to simulate many iterative constructs to the idea of higher-order functions, all the while keeping the explanations and examples very clear. The
author also strives to instill good functional design practices in the reader by
introducing different ways to think of functional programs and common design
patterns that can assist in clean implementations.
The second half of the book dives into more advanced functional concepts, such
as lazy evaluation, efficiency, and continuations. It also takes a look at
using functional programming for practical tasks. Overall, this section is more
suited towards someone who understood the majority of the first half of the book, or to someone who is already familiar with functional concepts.
I would recommend this book to newcomers and intermediate programmers who are
looking to learn about or refine their functional programming skills. The
authors do a good job of covering the core material and also introduce a good
amount of advanced material towards the end of the book.