Customer Reviews

Real World Functional Programming: With Examples in F# and C#

5 star:		(10)
4 star:		(2)
3 star:		(1)
2 star:		(3)
1 star:		(0)

 

 

A hallmark of this book is a very pragmatic, Rosetta stone approach to F#.

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 comes for free in FP (e.g. the "visitor" pattern).

I usually don't like tutorial-style books, but am finding this one invaluable. More than the other F# titles to date, it explores at length what makes functional programming different, and what this means in a .NET context. A unique feature is the running comparison of F# with both traditional and "functional style" C#. Code listings are nicely labeled with arrows pointing out important details. The book is not intended as a language reference, and only lightly touches on the imperative and object-oriented sides of F#, or contents of standard .NET libraries, but this allows a more leisurely and thorough treatment of the distinctively functional concepts and their implications for program design. Highly recommended.

Functional Programming for the Real World, by Tomas Petricek and Jon Skeet,
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.

This book goes out of the way to make C# developers feel comfortable with the new .NET language. I would recommend this book to anyone who is trying to get out of the same old boring stuff and move on to something truly innovative and exciting! I've read most of the F# books out there and this is by far the best. Thanks to the authors for taking the time to write this!

I agree with other reviewers that this book is great in getting you through the ins and outs of why things are done the way they are in F#. I have not read the entire book, but so far my impressions are that it does a better job at explaining "why" than Expert F#, which is Don Syme's book.

On the other hand, this book should not be your first F# book, even if you know C#, which the authors draw parallels to throughout and very successfully. The reason for this is that often times you can't follow exactly the examples in the book to get snippet of code runnning. This forces you to go and find other sources to complement the sample code in the book to get it to run and solidify your understanding on the topic. You may like or dislike this.

As a first book I like beginning F#, which is indeed a great companion to this book as in this one, you can actually follow the samples in the book and almost always get running code. Plus Beginning F# has great merit on its own. I will do a review on this book soon.

Beyond that, there are other books which complement this one very well, a few of them are:

* F# Wikibook at [...]. This is a great book by awesome princess.
* Professional F# 2.0: I have not read this one entirely, but what I read I liked.
* Programming in Erlang: This one by Joe Armstrong is not F#, but Erlang shares a lot in common with F# in areas like tuples, list comprehensions, pattern matching and the message passing model. So even if it is not F#, reading this one will give you "portable" knowledge on the concepts mentioned.
* Expert F#: Don Syme's book, nuff said.

Excellent, in depth, very ideological - in a good meaning of this word, - book. If you're passionate in your desire to understand and feel functional principles - which are spreading everywhere now (in C#, F#, and Scala, for example) - it's a must-read. I really love this book's approach of comparing implementations of functional algorithms in F# and C#. Just add Scala (Programming in Scala, 978-0981531601) to the game - and you are good!
I bought this book directly from Manning while it was still in beta and participated in its error-fixing, improvement as much as I could. It was exciting experience.
I highly recommend everybody not only to buy this book, but also go to Tomas Petricek's blog at (...) you'll find a lot of interesting stuff there. (I'm not talking about Jon Skeet just because everybody already knew about him. (...)

Functional Programming for the Real World, by Tomas Petricek and Jon Skeet, has been a very helpful book for moving to F# from C#, as the authors do a fantastic job of helping to explain the differences between OOP and FP.

For a tutorial this is much easier to read, while getting a great deal of information than another fantastic book, Expert F#. The difference is that Expert F# is a much harder book to read, as it is so technical, whereas this book is designed to be more of a tutorial, to help walk an intermediate C# programmer to the world of FP programming, using F#.

Once you have finished this book and you want more depth, short of reading the specification, then Expert F# is a great choice, but if you are just interested in moving to F# from C# then this is a great first book to use.

This book is more than just a really good introduction to functional programming and much more than just a primer on F#. It succeeds in being one of the really excellent programming texts.

The book is focused around teaching the core concepts of functional programming and the practical applications thereof. In the process, the reader gets to learn F#, but also to do functional programming in a primarily imperative, object-oriented language: C#.

As a result, one will learn the programming paradigm, readily see its utility, and thereby get trained to identify applications for it. And, as a bonus, have a good grounding in coding functional solutions.

There aren't too many good books on functional programming, and this one does not help with the situation. Examples are far too trivial to be of real use, and author's attempt to be pedagogical is closer to boring chatter. C# is bad choice for demonstrating concepts in functional programming. I started by learning F# from Syme's book and was writing production code in just two weeks, though I have to admit it isn't really an introductory book.

The title should read "Introduction to F# coming from C#, with some real-world examples in functional programming."

If you're interested in functional programming, but you're not a C# looking to learn F#, you can safely skip this book.