Customer Reviews

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

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

 

 

I'm working through this, and even in the first chapter, I ran into quite a few errors. Some of the code does not compile as presented, and some examples use syntax that is not explained anywhere that I can find.

Obviously, that makes learning F# from this book much more difficult than it should be, but when the author takes the time to explain something, it is explained fairly well. When the examples work, they help to illustrate the point. Most of the time, I've been able to get the code to compile when there are errors in the code because of the explanation that goes with it. Some of the time however, the combination of unexplained syntax and buggy code leaves me in a bit of a bind.

This book could have been much better with a better proofreader.

For a reader who already knows some F#, I think this book could be helpful. In the 100-page language tutorial, it seems to give a wide (though necessarily shallow) coverage of the syntax and programming paradigms of F#. Since there is a lot to the language, many readers will find something new to consider here. Then there are several chapters of applied F#: extremely brief explanations and samples of an ASP.NET app, a WinForm app, etc, written in F#. I'm suspicious that these chapters would be very useful to anyone: to those new to .NET, there is really not enough information here to get oriented; to working .NET programmers (which must be the widest audience for this book) there's just very little to learn here.

Now, as someone completely new to F#, I found reading this book consistently frustrating. While the author obviously knows the subject, the presentation is not very accessible. The main problems I see are: (1) example code usually *follows* its explanation, which just confounds me why an author would do this; and (2) the prose is hard to read, containing tedious explanations of syntax, and an odd over-use of the second-person "you" when walking through an example that I found disorienting.

Ultimately I spent a lot of time feeling frustrated trying to figure out what the author was saying, and wondering why it wasn't said more clearly. Judging from the sample chapters of Don Syme's book on his blog, I know that F# can be made accessible to the beginner. This book needed more editing to get there.

Every computer programming book begins with "Hello World". This one, too. The only problem: "Hello World" program doesn't work. It generates cryptic message saying that some DLLs must be linked, but how linked?... God knows. It took me a week of detective work to figure it out that on page 307 there is compiler command that should be used. Now I am having next problem, and after a week of detective work still don't have solution.

It seems that F# is being developed faster than books are printed, and books are talking about version of language and tools than don't exist any more.

The same problems with other F# books...

The author may know what he's talking about but the book fails to communicate. aPress should have (at a minimum) had an editor translate the text into (readable) English.

Foundations of F# presents the F# language, a functional programming language that runs on the .NET platform. The language is from the ML family, mostly similar to OCaml, and is a functional language with a decidedly pragmatic orientation. It is a great tool for two kinds of people: 1) .NET programmers that want a more productive and expressive language, incorporating more recent advances in programming language technology; and 2) functional programmers that want a language that has many good libraries and can integrate effortlessly with a platform as widespread as .NET.

The book is clearly targeted to the first group, but is useful to people from the second one as well. The first six chapters present the language, and the three main paradigms it embodies: functional, imperative and object-oriented programming. Chapter 6 is a useful look at program structuring, covering modules, namespaces, annotations and quoting. The next chapters are devoted to libraries available to the F# programmer, including Windows Forms, Windows Presentation Foundation, ASP.NET, network programming, web services, and data access. This pretty much covers most of what's necessary in real applications. The examples show very well how to use the libraries from the .NET platform, even if you have never had contact with them. I guess these chapters will be the most heavily used in my copy of the book.

Then comes Chapter 11 on Language-Oriented Programming using F#: Metaprogramming and Domain-Specific Languages. Creating language processors is one of the main application areas for languages like F#, and this chapter is a good showcase for it. It covers lexer and parser generation, quotations and an interpreter for a little arithmetic language. The final chapter covers details about how to use the F# tools and is mostly for reference purposes.

Overall, it's a good book for people new to functional programming and/or the .NET platform. It has many examples to present the main aspects not only of the language, but also of its enviroment (.NET). It doesn't go very deep into most of the topics; I would have liked more about quotations, reflection and metaprogramming, for instance. But then, it's not an advanced book, so it was to be expected. The advanced book on F#, Expert F# (Expert), is about to be published.

Want an F# book by Pickering? Get his recent Beginning F# instead of this outdated one.

As much as I have enjoyed and learned from this book in the past 2.5 years, at this time I can only rate it one star, because the F# language has changed a lot since this book was published in 2007.

I Strongly Suggest: do not get this older F# book. Instead get a newer F# book.

Here are your new-enough choices on Amazon today:
Smith Programming F#: A comprehensive guide for writing simple code to solve complex problems (Animal Guide)
Syme Expert F# 2.0 (The Definitive Guide)
Pickering Beginning F#
Petricek Real World Functional Programming: With Examples in F# and C#
and lastly a pre-order-only until June 30: Neward Professional F# 1.0

F# is much newer than many programming languages, for example Python. At this point in Python's history, if you wanted to study Python, you could get by with a book on Python 2.x, rather than a book on current Python 3.x - in fact a lot of shops are still using Python 2.x

But nobody is using F# 1.x anymore! And here in the year 2010 you will hit many more difficulties learning F# from an old F# 1.x book than you would learning Python from an old Python 2.x book.

This old book is based on early versions of F# 1.x - get a newer book unless you can find this old one for cheap on a remainder table.

My suggestion applies to all F# books: avoid the old ones unless they are on sale for really, really cheap. Specifically: Pay regular price for any F# book published after October 1, 2009. Anything older, pay only a wicked cheap price.

Today June 7, 2010 I received my pre-ordered copy of the new Don Syme F# 2.0 book Expert F# 2.0 (The Definitive Guide). A good day.

Overall I think this was a good book. It served it's purpose well, and even goes through how to create a lot of objects using the programming language. The samples, demos, and explainations were pretty good as well. If you are looking at reading this book, I recommend looking over chapters 8-11. Those are really the meat of the book and where most of your time will be spent.

The things I didnt like were that the examples sometimes were hard to follow. Code would be above or far below the explaination and that was confusing. The other thing is this book is NOT for the beginner level. Its more on the intermediate to expert level. You'll want to have a good understanding of .NET before you pick up this book.

Overall if you are interested in learning F#, I would definately recommend this book.

Foundations is geared toward IT professionals who want to get up to speed on F# quickly. In general, I found the organization of the book and the presentation of F# syntax very programmer friendly.

I really appreciated the high density of programming examples and the detailed explanations that generally followed.

In general, I only have two complaints about the book:

1) While the book demonstrates the syntax well-enough, I don't believe it emphasizes enough on functional programming style, such as how to replace Java-like design patterns with functional programming techniques. As a result, most programmers without prior functional programming experience will end up writing C#/Java code in an F# syntax.

Its hard to sell a language without showing how it helps programmers write complicated applications more effectively. (Perhaps design patterns are outside the scope of this book?)

2) The book is not accessible to beginners. I've been programming for 10 years, and it took some effort on my part to keep up with the pace of the book. A beginner would not be able to learn F# as their first programming language from this book.



The best reason to buy this book is to keep up with the continuing evolution of programming languages. C# 2.0 has generics (parametric polymorphism), true closures, and allows programmers to pass functions as first-order parameters to other functions. C# 3.0 introduces type inference, lambda functions, LINQ (analogous to list comprehensions), etc. However, functional programming in C# is awkward and verbose. If you want to write functional applications, you'll do yourself a favor by using a real functional language like F#.

I would recommend buying this book if you want to supplement your programming skills with a beautiful and expressive language, although you may want to supplement it with books on Haskell and ML to get the most out of functional programming as a whole.

I found most of the this book to be a rehash of the F# manual and F# blogs.

When presenting a new language like F#, one must address the biggest problems associated with it:
*getting a feel for the language
*showing how to do real tasks (WPF, WCF and ASP.Net being the most common nowadays)
*showing how to interoperate with the rest of the world (languages "out there" need to play nice with libraries and other languages)

This book does all this with great explanations and sufficient detail.

Just one warning: the F# language is a moving target, so a few minor differences here and there will definitely be encountered, due to the changes in the language. Also, learning a new language like F# is a wonderful experience, even for those programmers who will not use it: the benefit to one's abilities for reasoning about code will be immediately evident; this said, functional languages are harder to learn for mainstream programmers who expect the next C/C#/Java/Python clone...