Product Description
This volume contains the papers presented at the latest Glasgow Workshop on Functional Programming, held in Portree on the Isle of Skye, 12-14 August 1991. These workshops have been held annually by the Glasgow Functional Programming group since 1988 and provide a valuable forum for members of the group and invited contributors from industry and other institutions to discuss current research work. The 29 papers contained in this volume, many of which have been rewritten since the original presentation, deal with both the theoretical and pragmatic aspects of functional programming, each paper summarising the central issues of its subject area. A variety of themes emerged from the workshop, including relational algebra and its application to hardware design, partial evaluation and program transformation, implementation techniques, and strictness analysis. Among the specific areas covered in this volume are: a new sharing mechanism for the TIM; evaluation order analysis for lazy data structures; extending deforestation for first order functional programs; a semantics for relational programming; abstractions in Ruby; and operational theories of improvement in functional languages. Functional Programming, Glasgow 1991 provides a comprehensive overview of current research in this field and will be of interest to anyone involved in the theory of functional programming or its application to practical problems. ... Read more

Product Description
This easy-to-use, fast-moving tutorial introduces you to functional programming with Haskell. You'll learn how to use Haskell in a variety of practical ways, from short scripts to large and demanding applications. Real World Haskell takes you through the basics of functional programming at a brisk pace, and then helps you increase your understanding of Haskell in real-world issues like I/O, performance, dealing with data, concurrency, and more as you move through each chapter. With this book, you will:

• Understand the differences between procedural and functional programming
  
• Learn the features of Haskell, and how to use it to develop useful programs
  
• Interact with filesystems, databases, and network services
  
• Write solid code with automated tests, code coverage, and error handling
  
• Harness the power of multicore systems via concurrent and parallel programming

You'll find plenty of hands-on exercises, along with examples of real Haskell programs that you can modify, compile, and run. Whether or not you've used a functional language before, if you want to understand why Haskell is coming into its own as a practical language in so many major organizations, Real World Haskell is the best place to start.

Customer Reviews (25)

A little flawed
Similar to some python books it focuses too much on the command line interpreter. Understandably you have to start somewhere but the chapters continue to revert back. The initial introduction doesn't really focus on writing fully running programs and then jumps to examples without laying the groundwork enough. The title "Real World" as opposed to academic as Haskell books tends to be as such. It mentions this in the introduction. Being as such this is not really a good introduction to the language but may be considered especially in the later chapters a expansion of what you learned prior with the language.

Not written for real-world use
Despite what the title suggests, the book was not written with real-world use in mind.

The biggest flaw in this book is the examples. I think the authors were so focused on "real-world" use that they come up with tortured examples that are both too simple to be "real-world" and too complicated to be instructive. In Chapter 3: "For motivation, we'll consider a few kinds of data that a small online bookstore might need to manage. We won't make any attempt at complete or realistic data definitions, but at least we're tying them to the real world." The book states this as though "tying them to the real world" is some sort of virtue.

At least the bookstore example is easily digested. The next chapter has a JSON parser. That's great if my "real world" application uses JSON. For everyone else, it means a lot of time trying to understand how JSON works rather than learning about how Haskell works. Subsequent chapters tell you how to replicate the globbing you'll find in a UNIX shell, how to replicate the UNIX find command, or how to parse some picture format. None of these are things I actually want to do, and seeing how someone else implements these things is not instructive--especially when you have to fight through all the details of globbing, or regular expressions, or some bizarre binary file format.

The problem with all these examples is that they take too long to understand. The book actually needs shorter examples--ones that illustrate a programming technique without losing the reader in irrelevant details. The bad examples would be okay if you could just skip them. Unfortunately, important details are buried in these examples--how to use the Haskell module system, for example.

All the examples make the book a tedious tutorial, but they make it an even worse reference. You can't jump into the middle of any chapter--or even the beginning of later chapters--because they rely on examples from earlier chapters. The first chapter on monads says hey, remember that thing we did when we were writing the parser for that picture format? Well, really, that was a monad.

The material is also not presented in a good, straightforward order. The most glaring example of this is in chapter 1: "Let's take a small leap ahead, and write a small program that counts the number of lines in its input. Don't expect to understand this yet..." So how is it instructive for me to read and paste code that I shouldn't even expect to understand? They say it is "fun" to make the computer do things, but if I want to make my PC show me things on the screen, I'll type "echo" commands into my shell.

Haskell has some concepts that take awhile to understand, and this book does not explain them well. The chapter on monads just left me scratching my head, while some Web tutorials (listed below) cleared things up quickly.

In short, every time I have turned to this book I have been disappointed. I originally thought Haskell was very difficult to learn, but it turned out that this book was holding me back. I'm not sure there are better dead tree books out there. Before you buy this one, check out the book's website and see if you like it. The full text is there; it could save you a lot of money.

There are several places I can recommend, and all of them explain things much better than this book:

"Learn You a Haskell for Great Good" is a web tutorial. It is very basic, but the material is presented in a logical order. He shows right away in a succinct manner how useful many of the functions in the Haskell Prelude are. The examples illustrate, rather than obfuscating as they do in this book. I recommend this as a first stop if you know no Haskell; it might even get you started if you know no programming at all.

"Yet Another Haskell Tutorial" is also available on the web. It covers much material that "Learn You a Haskell" omits, such as monads.

For more specific topics that this book covers quite poorly:

"IO Inside" is an article on the Haskell Wiki. I did not truly understand the rationale behind Haskell IO until I read this. "Yet Another Haskell Tutorial" also does a good job explaining IO.

"You Could Have Invented Monads" is someone's blog entry, but it is the best explanation of monads I have seen. It cleared things right up for monads. This book only confused me.

Overall "Real World Haskell" is a real disappointment. This and other subpar O'Reilly titles have soured me on the value of the O'Reilly brand. I will still look at their books but I cannot assume they are excellent or even as good as other, free stuff that is available on the Web.

Poorly organized, and not needed.
The book is very poorly organized, and for the life of me I can't think of an ideal audience. Some of the material targets beginners, and then the other seventy percent is completely out of reach to all but seasoned pros. The stuff targeting beginners is rather poorly worded -- the book claims no intro to functional programming is required, but the definitions of fold[lr] will send any beginner scrambling to find a decent explanation.The book has a good share of technical rants that serve to do little more than side-track: "Ok, so you've learned foldr, now for good example and test of knowledge I'll tell you it can be written in terms of foldl" -- no further explanation provided. The definitions are all around bothersome. Ultimately, I don't think I learned much at all from this book, and I'd put in the top two worst O'reilly books I've ever read (following CGI Programming with Perl). This book seems to be a really poor mix of these non-existent books: Beginning Haskell, Advanced Haskell, and the Haskell Cookbook -- and with all this said, Haskell comes off as the most difficult language I've attempted to grasp thus far.

I should add I read through this book twice, and didn't learn much the second time around either.

A ton of the book is devoted to a JSON parser, which is rather tiresome. The other "real world examples" are equally poor like a bit-shifting checksum algorithm.

Go read Learn You a Haskell if you're looking to learn the language. If not, you can try this book -- but I'm going to predict your attempt will be fruitless.

Rich with info, but VERY uneven
The good news is, this is probably the best Haskell book yet.The bad news is, it's still a frustratingly confusing jumble.It starts out well, introducing expressions, type inference, recursion, pattern matching, algebraic types, and higher order functions, with an emphasis on maps and folds (the way real world Haskell code is actually written), and it contains exercises that range from simple to challenging.The first four chapters alone are worth the price.

Unfortunately, the problems start in chapter 5, and rarely let up.It starts by introducing a datatype for JSON data for the purpose of pretty-printing it.The way the pretty-printer is rolled out is confusing -- it constantly jumps between code snippets that won't even compile, because a type they depend on is not defined til nearly the end of the chapter.And while it stays away from excessive cleverness, function names are confusingly named.In fact the entire nature of the pretty-printer revolves around a "Doc" abstraction that is never clearly explained or rationalized.

Later chapters are also rich with useful information, such as explanations of various GHC language extensions to the type system (which are really de facto standard Haskell nowadays).Unfortunately (there are many "unfortunatelys" to use in this review) I would never have been able to follow these explanations had I not already known a little about them -- unlike the rest of the examples in the book, the examples stop being "real-world" and instead devolve into meaningless metasyntax like"Foo" and "Bar".

By the time monads are finally introduced (late, but rightly so -- I consider this delay in introducing them to be a plus), the reader has had to suffer through some very tedious projects, such as parsing an obscure binary format.The book really begins to redeem itself again here, and makes monads clear as a datatype that captures common concepts of encapsulating and sequencing, and completely avoids cutesy visual analogies (no spacesuits or toxic waste here!).

I've not finished the book (I'm still in Chapter 14) but I am eagerly looking forward to its later chapters introducing monad transformers, parallel programming, and software transactional memory.You get a lot of book for the price, but you'll need the support of the always-friendly haskell community on IRC or email to make the most of this tome, or even make any sense of several parts of it.

Better than others, but still not good enough
Haskell books are in general among the worst I have seen for any programming language, which is really a pity for such an interesting language. I was really excited when I got this book because of all the good reviews, so I thought I would finally understand what a monad is and learn how to make practical programs.

I would like to mention that I have been a C++ programmer, currently work at a research institution, and my main tool at work is now Modelica: I think I am not completely dense and have experience with different programming paradigms, so I suppose my problems may not be limited to me.

Having read The Craft of Functional Programming, I had some background on the first chapters, which sail along nicely on their own; map, filter, fold, partial application and type classes are really nice and well explained.

There are entire chapters dedicated to case studies, in which the authors clearly favoured quantity versus quality: these example chapters are long-winded, nebulous and downright boring. JSON data? Parsers for some godforsaken image format? The authors clearly ignored the basic fact that examples need to be simple to be pedagogical, and lost themselves in details instead. Which would be tolerable if the case-study chapters could be skipped, but new stuff is introduced in these, so one has to follow through.

The coding style is mediocre: as unfortunately common in Haskell textbooks and resources, variables are often identified with single letters, originating cryptic code. It appears that the authors of those code snippets never wrote production code (i.e. code that has to be maintained down the road, possibly by others), given the total lack of semantics; if they did, someone now maintaining their code must be hating their guts. An argument should be named "state", "name", "address", "previous", not "x", "y", "z". In other cases, the choice of function or argument names is plainly misleading, such as in the case of the parser examples.
A terrible quote (approximately): "A SimpleState is actually a state extractor ..." so what about naming it "StateExtractor", instead of ending up with a bunch of misleading function signatures? Were their fingertips hurting, or did they want to save ink?

However, as customary for Haskell documentation, the worst comes with monads. Introduced early because of the IO monad, which is necessary for basic I/O operations, they are however left unexplained until chapter 14, during which time the reader is left to wonder what they are.
The usual foggy buzzwords are then thrown unsystematically around: "side effects" (what side effects could the Maybe data type or lists have? Yet they are monads), "actions", messy function specifications, confusing "examples" that raise more questions than they address.

I tried hard to wrap my brain around these concepts, I read and re-read the relevant chapters at various time over a month, but in the end I threw the book into the recycle bin - at some point I had to cut my losses. I stress this is the first time ever I throw a book away. Well, actually the second, because the first time I threw it away I recovered it because I got a bad conscience about it.

Sorry if I sound bitter, but I am really angry at myself for wasting so much time and effort for a language that will however never be of any practical use. Now, I'll rather learn Python, thankyouverymuch. ... Read more

Product Description
The second edition of Haskell: The Craft of Functional Programming is essential reading for beginners to functional programming and newcomers to the Haskell programming language. The emphasis is on the process of crafting programs and the text contains many examples and running case studies, as well as advice an program design, testing, problem solving and how to avoid common pitfalls.

Building on the strengths of the first edition, the book includes many new and improved features:

Complete coverage of Haskell 98, the standard version of Haskellwhich will be stable and supported by implementations for years tocome.

An emphasis on software engineering principles, encouraging adisciplined approach to building reusable libraries of softwarecomponents.

Detailed coverage of the Hugs interpreter with an appendix coveringother implementations.

A running case study of pictures emphasizes the built-in functionswhich appear in the standard prelude and libraries. It is also used togive an early preview of some of the more complex language features,such as high-order functions.

List comprehensions and the standard functions over lists are coveredbefore recursion.

Early coverage of polymorphism supporting the "toolkit" approachand encouraging the resuse of built-in functions and types.

Extensive reference material containing details of further reading inbooks, journals and on the World Wide Web.

Accompanying Web Site supporting the book, containing all theprogram code, further teaching materials and other useful resources. ... Read more

Customer Reviews (16)

Good Book
Simply one of the best books on Haskell you can purchase. Very well written with a tone of good examples. Perfectly structured, avoids the trap of being too introductory or too advanced. If you want to learn funcational programming you can start with this book and learn enough quick enough to be productive with it in a short time.

Good book for beginners
Good book for beginners, not so exciting if you're an intermediate-to-advanced level programmer. Then again, it doesn't claim to cater to that level, so your mileage might vary.

A good book for the advanced programmer or the absolute beginner, but bloody confusing for intermediate college students.
I got this book for a CS class in college but never used it (professors just love you to waste your money that way). I recently came back to this book after getting really into Python, especially the functional features.
The approach the book takes is more or less instructing someone who knows absolutely nothing about programming in the ways of functional thinking. This makes it perfectly easy for an absolute beginner with no imperative or OOP prejudices to learn Haskell--just as if they were taught hex before decimal they'd catch onto hex real quick.
This is also a great text for someone who's had some functional programming experience (map, filter, reduce, monads) and for whom recursion is a friend. I've become a much better Python programmer (and a better programmer in general) from just scanning the book every time in the bathroom.
However, for a student who's been doing Java or C/C++ for a year or two, this will be extremely confusing. They will already have adopted a certain way of thinking and will have trouble going through this text. This is why this book was useless to me for several years.
But for the advanced guys or the absolute n00bs I'd definitely recommend this book. As far as functional programming books go it's downright lively. My only complaint is that it doesn't really show me any practical things I can do with Haskell (these examples seem hard to find anywhere), such as database or GUI stuff. I mean sure it's cool to do a graph walk incredibly succinctly, but that's not something I'm going to use for work . . .

Great overall, no need for other books, though Monads still ill-explained
Very good introduction to Haskell and functional programming in general. Covers Haskell's type inference system and unconventional syntax in a comfortable, clear way. Lazy evaluation and its effects on the language are likewise explained in an clear approachable way.
There's lots of SICP-like exercises to practice with if you want, though their placement makes the book a bit confusing at times if you don't as it's hard to tell the exercises and the material apart sometimes.
I haven't looked at competing Haskell books, but after reading this one, I don't see the need to. This book doesn't explain monads particularly well (though most other explanations, besides one explanation in a reddit comment I saw, are equally not understandable, so that's no great fault).
Overall, a great book for programmers who want to get into functional programming or quickly learn Haskell.

Good gradual introduction; good value for money
This book makes an excellent gradually-paced introduction to Haskell, with plenty of examples and exercises, for those who are a little overwhelmed by the online "Gentle Introduction to Haskell".My only complaint is that it proceeds a bit too slowly for my taste, taking 150 pages to get around to discussing higher-order functions and other advanced topics that make Haskell worth learning.This is understandable, since it's intended to be usable as a textbook for a first programming course, but it's also frustrating for someone who already has programming experience.The other feature of the book that stands out is its price, which is quite reasonable for a textbook.All told, this is an good-quality Haskell textbook suitable for either new programmers or (by skimming the first several chapters) more experienced programmers looking to learn functional programming. ... Read more

Product Description
This book explores the role of Martin-Lof s constructive type theory in computer programming. The main focus of the book is how the theory can be successfully applied in practice. Introductory sections provide the necessary background in logic, lambda calculus and constructive mathematics, and exercises and chapter summaries are included to reinforce understanding. ... Read more

Product Description
This volume contains the proceedings of the FifthInternational Symposium onProgramming LanguageImplementation and Logic Programming (PLILP '93), held inTallinn, Estonia, in August 1993. The series of PLILPsymposiums was established to promote contacts andinformation exchange among scientists who share commoninterests in declarative programming techniques, logicprogramming, and programming languagesimnplementation.Researchers from the fields of algorithmic programminglanguages as well as logic, functional, object-oriented,andconstraint programming constitute the audience of PLILP.The volume contains three invited talks and 24 selectedcontributed papers grouped intoparts on: integration ofdifferent paradigms, constraint programming, staticanalysisand abstract interpretation, grammars, narrowing,parallelism, and implementation techniques. The volumecloses with six abstracts ofsystems demonstrations andposters. ... Read more

Product Description
This volume contains the papers accepted for presentation atthe Fourth International Symposium on Programming LanguageImplementation and LogicProgramming (PLILP '92) held inLeuven, Belgium, August 26-28, 1992.Theaim of the symposium was to explore new declarativeconcepts, methods and techniques relevant for implementationof all kinds of programminglanguages, whether algorithmicor declarative. The symposium gathered researchers fromthe fields of algorithmic programming languages as wellaslogic, functional, and object-oriented programming.The topics discussed in the volume include:- Declarative implementation techniques;- Implementation of declarative concepts and modules;- Compiler specification and construction;- Program transformation;-Programming environments for declarative languages;- Amalgamation of logic programming with algorithmic,functional, or object-orientedtechniques;- Executable specification. ... Read more

Product Description
This book presents new compilation, analysis, optimisation and evaluation techniques for implementation of lazy functional programming languages on sequential computers. As a framework for developing these techniques, the authors use the equational language (pioneered by O'Donnell, Huet and Levy) wherein programs consist of functions defined by pattern matching equations of the form pattern = template Interpreted as left-to-right rules. ... Read more

Customer Reviews (1)

Gentlest Possible introduction to Lambda Calculus
Very easy to understand. Has the added bonus of solutions to all the questions. Unlike Hankins book you really can teach yourself Lambda Calculus with this. If you see a copy available grab it. ... Read more

Product Description

Customer Reviews (15)

The fastest way to get F# into your head (along with practice)
I have several other F# books: Expert F# 1.0 and 2.0 by Don Syme, Real World Functional Programming by Tomas Petricek, F# for Scientists by Jon Harrop (now outdated, he has newer ones), and Foundations of F# by Robert Pickering. In my opinion, this book has the simplest explanations, the clearest and best-chosen examples, and the easiest to understand guidelines. Don't neglect the other books for deeper understanding or more information on certain areas (Syme's book has a chapter on interacting with COM, for example), but this is the one to start out with.

good book
It would help to highlight some negative sides of F#, however I did not see that

A pretty solid F# guide
Aside from briefly playing around with Erlang, I had little experience with functional languages.This book brought me up from zero to the point where I could write something useful in F# in about 5-7 hours, giving a tour of most of the useful features of the language.

Explains "how" but not "why", "where", or "when"
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. Unfortunately, F# is a symbol heavy language and the author tends to explain a symbol once and assume that you understand it and why he chose it over something else, which made following the examples very hard. All the same, I was grateful that the author didn't rely on understanding highly technical ideas (continuations, memoization, etc.), and at the same time did a very good job at explaining them as they came up, and even gave some good examples.

If you are someone (like the other reviewers) who are already familiar with functional programming as a concept and want to learn how to do it within F# and the .NET ecosystem, this is the book for you. If you are not that person, this book won't help you beyond the F# syntax itself. I am going to check out "Real World Functional Programming" and see if it has the parts missing from this book.

J.Ja

Simplicity -> Perfection
I've embraced F# from the first moments upon discovering its existence. Before pulling the trigger on Programming F#, I had picked up Pickering's Beginning F# and Harrop's F# for Scientists. Of course, F# for Scientists is tailor made for science and related disciplines and while it does have an intro, I'd say it's not ideal for an introduction unless you're already familiar with another FP language. Pickering's book is quite good, yet I still needed something a bit more ... and less is sometimes more.

It is likely that you have owned and read > 50 technical references during your career/education. Some productions are great while others are so-so or utterly dreadful for obvious reasons. This book is more than the basic introduction of the language, features and guiding principles of FP. With Programming F#, Chris Smith has mastered the technical reference.

It's physically slender yet large in scope, delivering everything required to learn F# as software development pro. Nothing more or less than what you need. Like the language itself, it is succinct, terse and elegant. Chris delivers the fundamentals expertly then immediately yields :) the next subject. The code samples are easy to follow and, remarkably, complex enough to give the reader an idea of the expressive power essential to F#. I wish I could give it 6 stars.
... Read more

Product Description
This book gives a lucid and thorough account of the concepts and techniques used in modern functional programming languages. Standard ML is used for notation, but the examples can be easily adapted to other functional languages.The book is aimed at advanced undergraduate or graduate level students who are familiar with another high-level language and discrete mathematics. It will also be invaluable to professional programmers who wish to explore the new possibilities opened up by functional programming. ... Read more

Customer Reviews (2)

Great book on functional programming
Functional programming is very powerful. Now that many popular programming languages are functional (like Ruby or Python and even C++ with functors), a good programmer needs to be conversant with the main concepts.

This book is a very good introduction to what makes FP powerful (ex. higher-order programming, symbolic processing, lazy evaluation, powerful typing systems, etc)

Still a great book on functional programming....
This book is one of the most complete references on functional programming out there. At least that you can buy.. there are others that are out of print and darn hard to get. This book contains enough material to take you from absolute beginner to writing your very own interpreters and compilers (including a nice discussion of the SECD machine... dont worry if you dont know what that is though :) . )

If you dont know what functional programming is, read Hudak's book "School of Expression". If you do, read this one to learn more..

This book uses SML instead of Haskell, but then again it was written a while ago, and there is nothing wrong with learning something new (or old...). Even though SML is an eagerly evaluated language, this book discusses lazy versions as well, including some issues with I/O. (Again dont worry if that last bit didnt mean anything toyou, these things are described well in the book.. thats where I learned them from!)

Cheers! ... Read more

Product Description
This textbook provides a basis for a PhD course on domain-theoretic semantics of functional programming languages and their meta-mathematical properties. It introduces basic domain theory and the technique of logical relations as developed by Scott and Plotkin. The solution of recursive domain equations is explained in detail. A complete discussion of the famous full abstraction problem for PCF (a functional Kernel language due to Scott and Plotkin) is given including a construction of the fully abstract Milner model using Kripke logical relations. A final chapter introduces computability in Scott domains and shows that this model is fully abstract and universal for appropriate extensions of PCF by parallel language constructs. ... Read more

Product Description

Functional programming is perhaps the next big wave in application development. As experienced developers know, functional programming makes its mark by allowing application builders to develop solutions to complicated programming situations cleanly and efficiently. A rich history of functional languages, including Erlang and OCaml, leads the way to F#, Microsoft's effort to bring the elegance and focus of functional programming into the world of managed code and .NET.

With Beginning F#, you have a companion thatthat will help you explore F# and functional programming in a .NET environment. This book is both a comprehensive introduction to all aspects of the language and an incisive guide to using F# for real-world professional development.

Reviewed by Don Syme, the chief architect of F# at Microsoft Research, Beginning F# is a great foundation for exploring functional programming and its role in the future of application development.

What you'll learn

• Gain a deep familiarity with the tenets and advantages of functional programming.
• Understand F#'s concise and elegant syntax.
• Access the huge range of libraries and components that run on the .NET Framework.
• Develop for real-world scenarios using functional programming and F#.
• Develop realistic applications through a comprehensive tutorial-based approach.
• Learn imperative and concurrent programming techniques within the functional programming paradigm.

Who is this book for?

F# is the future of programming (not just on .NET), and the future is now. If you are already familiar with functional programming, you'll find Beginning F# a great introduction to the language itself. If you are new to the FP arena, this book will also serve as a superb reference to FP in general and F# specifically.

About the Apress Beginning Series

The Beginning series from Apress is the right choice to get the information you need to land that crucial entry–level job. These books will teach you a standard and important technology from the ground up because they are explicitly designed to take you from “novice to professional.” You’ll start your journey by seeing what you need to know—but without needless theory and filler. You’ll build your skill set by learning how to put together real–world projects step by step. So whether your goal is your next career challenge or a new learning opportunity, the Beginning series from Apress will take you there—it is your trusted guide through unfamiliar territory!

Customer Reviews (3)

Good F# book
I found this F# book a useful resource while learning F#.

Incidentally, I gave just one star to Pickering's older F# book, but only for the reason that his older book is replaced by this newer one. Why Apress didn't leave the title the same and call this newer one the second edition is beyond me.

A gentle introduction to F# and functional programming.
All the F# books out there are puzzle pieces in the F# jigsaw puzzle; hence they all have a unique role to play in the milieu.

This book is the most tutorial, and it covers the topic pretty thoroughly (even monads and continuations are presented).

This book is also the most ecumenical (as of this writing).That is to say, it is not Microsoft-centric:it also caters to those coming from the Unix world and those using Mono.

Even if you don't consider yourself a beginner, you're likely to benefit from reading this book cover to cover (and for me that includes reading the legalese, the index, and the advertisements:everything!).

Sometimes Robert will draw attention to what might seem like a trivial point; but he's actually citing a representative point, and trying to instill in the reader an intuitive understanding of the design philosophy behind F#.

This book even covers quotations, compilation, interpreters, parsers, and the gestalt of language oriented programming (wherein domain specific languages are crafted as a way to control complexity).These important topics might seem pretty intense for a beginner's book, but they are presented in the same tutorial fashion that basic concepts are presented with.This is arguably the most accessible presentation of F#, and is based on one of the first books to come out.

Sometimes people try to do too much too fast, without having learned the basics first.That can be a recipe for frustration that might result in failing to stay the course.This book was often just what the (proverbial) doctor ordered for me, during such times of frustration.I'm very grateful for this book, and for Robert's helpfulness.

There are code samples in this book that are real gems of great value.It will take me years to fully digest all the great information this book has to offer.

Thanks Robert!

well written
I have yet to finish this book, as i've been too busy. but from the first quarter of the book that I have read; it was well written for people who have never been introduced to Functional programming. you still need some background in other programming types, as this does not feel like a intro language, like a VB or C# would be. ... Read more

Product Description
The aim of this study is to provide evidence of the relevance of functional programming for software engineering, both from a research and from a practical point of view. The software development process is studied and a brief introduction to functional programming and languages is provided. Functional programming tends to promote locality which makes it possible to reason about a component of a program, independent of the rest of the program. The significance of the functional approach for formal program manipulation is illustrated by two important techniques, abstract interpretation and program transformation. Abstract interpretation is applied to the compilation of memory management and program transformation is illustrated with many applications such as program correctness proofs, program analysis and compilation. A correct compiler is described entirely in terms of program transformations. Regarding program construction, it is shown that input/output and state-oriented problems can be described in a purely functional framework. ... Read more

Product Description
A common attraction to functional programming is the ease with which proofs can be given of program properties. A common disappointment with functional programming is the difficulty of expressing input/output (I/O) while at the same time being able to verify programs. Here, the author shows how a theory of functional programming can be smoothly extended to admit both an operational semantics for functional I/O and verification of programs engaged in I/O. He obtains, for the first time, operational semantics for the three most widely implemented I/O mechanisms for lazy languages, and proves that the three are equivalent in expressive power. He also develops semantics for a form of monadic I/O and verifies a simple programming example. These theories of functional I/O are based on an entirely operational theory of functional programming, developed using Abramsky's "applicative bisimulation." Graduate students and researchers will gain much from reading this book. ... Read more

Product Description
This book originates from the Third Summer School on Advanced Functional Programming, held in Barga, Portugal, in September 1998. The lectures presented are targeted at individual students and programming professionals as well as at small study groups and lecturers who wish to become acquainted with recent work in the rapidly developing area of functional programming. The book presents the following seven, carefully cross-reviewed chapters, written by leading authorities in the field: Sorting Morphisms; Generic Programming: An Introduction; Generic Program Transformation; Designing and Implementing Combinator Languages; Using MetaML: A Staged Programming Language; Cayenne: A Language with Dependent Types; Haskell as an Automation Controller. ... Read more

Product Description
"This work strikes a balance between the pure functional aspects of F# and the object-oriented and imperative features that make it so useful in practice, enable .NET integration, and make large-scale data processing possible."
—Thore Graepel, PhD, Researcher, Microsoft Research Ltd.

Over the next five years, F# is expected to become one of the world's most popular functional programming languages for scientists of all disciplines working on the Windows platform. F# is free and, unlike MATLAB® and other software with numerical/scientific origins, is a full-fledged programming language.

Developed in consultation with Don Syme of Microsoft Research Ltd.—who wrote the language—F# for Scientists explains and demonstrates the powerful features of this important new programming language. The book assumes no prior experience and guides the reader from the basics of computer programming to the implementation of state-of-the-art algorithms.

F# for Scientists begins with coverage of introductory material in the areas of functional programming, .NET, and scientific computing, and goes on to explore:

• Program structure

• Optimization

• Data structures

• Libraries

• Numerical analysis

• Databases

• Input and output

• Interoperability

• Visualization

Screenshots of development using Visual Studio are used to illustrate compilation, debugging, and interactive use, while complete examples of a few whole programs are included to give readers a complete view of F#'s capabilities.

Written in a clear and concise style, F# for Scientists is well suited for researchers, scientists, and developers who want to program under the Windows platform. It also serves as an ideal supplemental text for advanced undergraduate and graduate students with a background in science or engineering. ... Read more

Customer Reviews (8)

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

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.

a concise view of F# from a vantage point of technical computing
A hallmark of this book is conciseness.(The book itself is fairly small and thin; and nicely hardbound.)

This book is a gold mine of great information that could take years to fully digest!

While the book is titled as a scientific book, and it is that; it also has much more to offer.It should be of great interest to scientists, mathematicians, statisticians, computer scientists, financial programmers, and any programmers who want to write good code.It features a well balanced selection of topics including:algorithms, data structures, visualization, graphics, threading, performance, and optimization.The use of DirectX is demonstrated.Some compilation techniques are also shown.

A nice selection of recursive list algorithms are presented that showcase the kind of problem solving that can be done purely with recursion and list processing.These are classic idioms that are good to be exposed to; like power set, and substitution with replacement.

Many of the examples are very much in the spirit of the Scheme Revised^n Reports, wherein the most gutted possible examples are used to demonstrate a given primitive or concept.Nothing extraneous to cause distractions.

There is a complement to this book called "F# for Technical Computing" that can be purchased from the Flying Frog Consultancy here:[...].The complementary book adds nicely to the material in "F# for Scientists"; with discussions on such topics as parallel computing and WPF.In addition, the complementary book features longer page sizes, a stay flat (music book style) binding, and color; all of which I really like.(I wish more technical books made use of color because code is much easier to read when you see comments in one color, keywords in another, etc..)

Both books are gems.There are also counterparts to these books for OCaml programmers.

Relevant software can also be obtained from the Flying Frog Consultancy (which has, as part of its logo:"Putting the fun in functional since 2005").

Great content, well written
An excellent book that presents a broad set of examples of use of F#.
Excellent because the examples are presented just at the right level: they go to the core of the concept quickly and efficiently. This is a rare "software language" book that delivers the good of presenting the languages and its concepts while being educational and being a reference book of "how to" examples.
Although I am biased in having both functional and F# experience, I do feel that the author go it right and this book used by beginners in F# with experience in other languages.

Pretty good book
Misleading title. There is nothing "scientific" in this book. This is more or less standard collection of basic data structures and algorithms. However, you do these differently in F# than in Java. If you want to program nontrivial problems in F#, you need this book all the time. The best F# book among available

Beautiful.Succinct.Functional.
I am brand new to functional programming and this is my 3rd book having gone through both Foundations of F# and Expert F# which details the language very well. However, I was blown away with this book. While it does have some technical elements/examples to it, I found that it helped me bridge the gaps in some topics I did not fully grasp from the other two books.

This was written prior to the F# Sept 2008 CTP and due to changes in the language, one or two examples (again,let me stress just a few) needed to be modified in order to be compatible with the changes.

I enjoyed all the topics immensely but without a background in DirectX or 3D programming, while the chapter on visualization is beautiful, it is challenging. My readings in WPF3D helped a lot in parsing what was going on here. In addition, while there is information on using Windows Forms, I wished there was a section (or two!) on WPF. However, the F# Journal (by the same author) does have a few articles on WPF which are also very excellent.

The only thing is that, sometimes, the explanations for the examples are not very thorough, and it is a bit daunting as a beginner. One such example is the Powerset from 6.4.15 (p167) which took a while to work through. As such, I made a blog post just for this detailing how to get the solution for this.

This is not a book to, per say, 'learn F#', the previous two are for that. F# for Scientsts is great if you already have the basics at hand. All in all, I HIGHLY recommend this book. It is an excellent resource/reference and in my opinion, it is one of those books you have handy -> Just in case.

Overall A+. ... Read more

Product Description
Using a large number of running examples and case studies, this book encourages the design of well structured, reusable software together with proofs of correctness. The emphasis is on the process of crafting programs, solving problems and avoiding common errors. A tear-out card enables readers to acquire a Miranda compiler from Research Software Ltd. at a substantial discount. ... Read more

Product Description

This book constitutes the refereed proceedings of the 9th International Symposium on Functional and Logic Programming, FLOPS 2008, held in Ise, Japan, in April 2008.

The 20 revised full papers presented together with 3 invited contributions were carefully reviewed and selected from 59 submissions. The papers are organized in topical sections on constraints, constructive arithmetic, dependent types, rewriting, program transformation, logic and lambda-calculus, types, and debugging.