Customer Reviews

Expert F# (Expert's Voice in .NET)

5 star:		(13)
4 star:		(3)
3 star:		(2)
2 star:		(3)
1 star:		(2)

 

 

The Good

- Practical.
- High example density.
- Broad coverage of a lot of practical F# topics.
- Good depth on all the important practical stuff.
- I felt like I learned a lot, not only about F#, but about some cool C# features too.
- I felt like I'd be a lot more productive as a programmer if I could master the language.

The (not so) Bad

- Structurally, I initially got lost with some of the more complex examples. And it was straining to page back and forth re-reading things until I grasped the concepts. The density of information in the text sometimes makes it less valuable as a teaching aid and more valuable as a reference.

The (not so) Ugly

- I could not get one of the async examples to actually compile. I had to search the web for some hints to add declarations that seem to have been omitted from either the example code or F# implementation itself. In short, the example code, my development environment, F# itself, of some combination thereof was missing what appears to be an extension method for WebRequest.GetResponseAsync. I had to code it myself. But once I did, it worked! (This might not be a criticism of the book.)

This book is the perfect companion to bring along on your adventure into the world of F#! I had the pleasure of proofreading Expert F# several months ago and so, while it just became available at Amazon today, I've already spent many happy hours with it.

F# is a wonderfully expressive and practical language and, at the same time, very elegant. This book will help the reader to apply this newfound power and to appreciate how even the most obscure features all seem to "hang together" so beautifully.

The first half of the book teaches the language with an excellent example-driven approach; making it fun and useful from the start. Separate chapters cover each supported programming paradigm: functional, imperative, object-oriented and language-oriented; along with chapters on solid engineering techniques such as encapsulation and packaging, and working well with other .NET code.

The second half of the book applies the language to various technologies (WinForms, web, database, ...) and to various very interesting domains including lexing and parsing, asynchronous and concurrent programming (a particularly strong suit). My absolute favorites were the symbolic differentiation and propositional logic samples in chapter 12 - these left me in a state of awe! Also, the second half covers more engineering concerns such as testing and debugging, interop and library design.

Throughout the book are sprinkled many little nuggets of wisdom from the authors; especially helpful to those who (like me) are struggling to rationalize experience in OO and imperative programming with the functional mindset.

The book contains an enormous amount of information; an essentially complete coverage of the language. However, it simply can't cover everything. Some topics missing include application to some specific technologies such as WPF and Silverlight. Also, functional data structures and meta-programming (with the extremely powerful F# quotations mechanism) are only lightly covered.

It's a very well written and well organized book. It makes for a great read when you're first mastering the language and makes for a great reference to keep on your shelf thereafter.

When a new programming language arrives and manages to make an impact, books about it will certainly appear. However, most often the books will be geared to beginners, to people that is either not very experienced in programming or in the programming paradigms embodied by the language. For a experienced programmer, these books stop right when the fun would begin: the advanced stuff, the corners, the details are left out.

Expert F#, as suggested by its title, is not like this: it is aimed at more experienced programmers. The book will not teach you, for instance, what is functional programming or hammer to your head the best ways to use lists, an ubiquitous data structure in functional languages. But it explains how the things work in F#, so that programmers already familiar with other functional languages will have no trouble picking it up. F# also has object-oriented capabilities, which are explained in a chapter, without however going much deep into OO concepts; the book is about the language, not the paradigms.

And it does this well. Roughly half of the book is about the language itself, the other half are examples of applications and how to use some important libraries. As I was already familiar with OCaml and Haskell, I mostly skimmed through chapters 1 to 4, reading more closely starting with chapters 5 (generic types) and 6 (how objects fit into F#). From chapter 7 (encapsulating and packaging your code) on, the book starts to get really interesting; the next one is about common techniques, and chapter 9 is the best in the first part, explaining language-oriented programming, an area where functional languages really shine.

There are mandatory chapters about Windows Forms (11), Web programming (14) using .NET and data access, including how to use LINQ in F#, but I really liked chapters 12 (working with symbolic representations), and 13 (concurrency and asynchronous workflows). The former includes two cool examples: a symbolic differentiator and a verifier for logic circuits based on BDDs (Binary Decision Diagrams). There are other important and advanced chapters treating topics like interoperation with C and COM, debugging and testing F# programs, and F# library design.

All in all a very good book about the best current functional language to use in the Windows platform. I have two minor quibbles about it, though: the first few chapters about the language really could be made more interesting (although it didn't affect me much, as I only skimmed them) and some of the more exciting new features of F# could be explained in more detail. Specifically, workflows and active patterns. They are quite recent additions to the language, however, and there is some additional material promised to feature in the book's site.

Anyway, I will keep this book nearby when programming in F#. It is this kind of book that you'd want to keep around, even after learning the language.

This book doesn't just teach you how to program in F#. I teaches you how to be a better .NET programmer. It discusses generics, how to write "generic algorithms," all forms of sequences (and how to elegantly program with them...immensely practical), workflows, LINQ, parsing (I loved this chapter), concurrent programming, Windows Forms...you get the idea.

However, this book is *packed* with information. So, if you do get this book, and have difficulty...just try to write some code and re-read sections after you do some experimentation. You can't learn F# by reading about it. It is too elegant and subtle for that...you need to actually do it. So, read this book in your computer chair, not your easy chair, and TRY STUFF OUT...TAKE YOUR TIME ...there is a lot of information on each page. You'll be a better programmer in ANY language after going through this book.

F# is basically OCaml for .net. This book covers details of F# for .net. However I felt confused about some syntax of F# which this book does not explain clearly. After looked up tutorials for OCaml on the internet, I found there are materials which can help you to better understand fundamentals of OCaml(F#). If you are new to F#, make sure you go through several OCaml tutorials first before you start exploring this book.

This is a good introduction to F#. I would rate it at 4 stars for its content, but I wish I had known, however, that the kindle version of the book does not scale the font size at all for the many code samples included. Even worse, the font used for the samples is tiny. I have to hold the kindle about 6 inches from my face in order to read the samples. Note that the trial chapter that you can download does not show the problem, it only happens in later chapters.

This book states in the beginning that you don't have to know functional programming in order to understand the material. I would argue that this is not true.

I've taken a course in functional programming and so not much was new to me. Having read some of the other reviews, I realised that the book is not very friendly to people who are professional programmers with no past experience of functional programming (though you could argue that one cannot be a professional programmer without such experience!).

That said, this book covers so many different topics in addition to the core concepts of the language. This shows you, time and time again, how you can use F#. It gives you plenty of ideas. So, this book is really good, no doubt about that.

I own the three F# books out there: [FF], [FS] and [EF] (this one).
[FF] is the one that got me started, probably because I share some personality traits with the author (based on the way he writes) and that flattened the learning curve.
Then [FS] is the book that got me excited about F#'s representational power, mainly because I'm mathematically and scientifically oriented.
But from all of them, Expert F# is the one I keep coming back to and the only one that never leaves my desk.
This book is hands down the best reference material available. You will find information in this book that you won't find anywhere else, not even in the language's draft specification (which is still work in progress).
If you are going to be doing serious F# development you'll need this book, bottom line.

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.

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.