Slashdot Log In
Purely Functional Data Structures
from the raw-function-baby dept.
| Purely Functional Data Structures | |
| author | Chris Okasaki |
| pages | 220 |
| publisher | Cambridge University Press |
| rating | 8/10 |
| reviewer | Andrew Cooke |
| ISBN | 0521663504 |
| summary | Functional programming for grown-ups. |
In Okasaki's introduction he says that the "[...] benefits of functional languages are well known, but still the vast majority of programs are written in imperative languages such as C. This apparent contradiction is easily explained by the fact that functional languages have historically been slower than their more traditional cousins, but this gap is narrowing."
Indeed, OCaml has a reputation for being "as fast as C," yet it contains automatic memory management and supports object-oriented, as well as functional, programming. It's also probably the most widely used functional language outside academia (except perhaps Lisp/Scheme).
I mention OCaml not just because it's fast, free and popular, but because Okasaki uses a related language - ML - in his book. The ML family of languages are the standard strict, functional languages (Standard ML of New Jersey is perhaps the reference implementation but see also standardml.org). Okasaki also includes an appendix with examples in Haskell, which is the standard lazy functional language.
The difference between lazy and strict languages is the order in which code is evaluated. Most languages are strict. Unlike most languages, Haskell only evaluates something when it is absolutely necessary. Each parameter to a function, for example, is passed as a "thunk" of code, not a value. If the value is not required inside the function, the parameter is left unused; if it is required (say as part of a result that needs to be displayed) then the thunk is evaluated. This evaluation may trigger a whole slew of evaluations of functions that "should" have been called earlier (from a Java programmer's point of view).
Laziness is both good and bad. The bad side is obvious: the order in which code is executed my be very different from the order in which the program was written and some serious book-keeping is necessary in the compiler to juggle the thunks of code and their final values. The reordering of code could cause mayhem for IO operations, for example (in practice, of course, Haskell includes a solution to this problem).
The good side is that laziness can help make programs more efficient and, while the definition of ML doesn't include laziness, individual ML implementations -- including OCaml and SML/NJ -- include it as an extra.
Much of Purely Functional Data Structures (the second of three parts) focuses on how to use laziness to make data structures efficient. Lazy evaluation allows book-keeping actions to be postponed, for example, so that the cost of maintaining the data structure in an efficient form can be averaged across several read/write operations (improving worst case limits - avoiding a very slow response if the data happen to be in a "bad" order).
An understanding of how the efficiency of algorithms is rated (the big-O notation) is one piece of knowledge that this book does assume, along with a basic grasp of what Stacks, Queues, Trees, etc, are.
This lazy boost in efficiency is needed because, even though functional languages may be getting faster, it's not always possible for them to implement the efficient algorithms used in imperative (non-functional) programming.
But I'm getting ahead of myself, because I haven't described what a functional language is, or why it is useful. These are the topics of the first part of the book, which explains how functional languages, which make it impossible to change variable values by direct assignment, support persistent data structures. This section is fairly brief, and while it's a good refresher course for someone who's not had to worry about such things since studying at university, it's not sufficient as an initial introduction to functional programming in general.
There's a good explanation of functional programming in the Wikipedia, but, in all honesty, I don't see how anyone can really "get it" without writing functional code (just as I, at least, couldn't understand how OOP worked until I wrote code that used objects).
So forgive me for not telling you why functional programming is good (This paper is one famous attempt), but perhaps a better question to focus on is "Why should you spend the time to investigate this?" The best answer I can give is that it leads to a whole new way of thinking about programming. Describing functional programming as "excluding assignment to variables" doesn't do justice to the consequences of such a profound change (one I found almost unimaginable - how can you program without loop counters, for example?).
There's a practical side to all this too - learning new ways of thinking about programs makes you a better programmer. This ties in closely with the final part of Okasaki's book, which explores a few fairly esoteric approaches to data structures. Who would have thought that you can design data structures that parallel the way in which you represent numbers? Some of this is pretty heavy going - I can't say I understood it all, but I'm taking this book with me on holiday (it's slim - just over 200 pages) and I'll be bending my brain around some of the points in the last few chapters as I lie in the sun (here in the southern hemisphere it's late summer).
So just who would benefit from this book? It seems to me that it's most valuable as a second book on functional programming. There are a bunch of texts (and online guides) that can get you started in functional programming. This one goes further. It shows how to exploit the features of functional languages to solve real problems in applied computing. Admittedly, they are problems that have already been solved in imperative languages, but you might find that you, too, come to enjoy those famous benefits of functional languages. The algorithms in this book let you enjoy those benefits without paying the price of inefficiency.
Andrew Cooke last reviewed for Slashdot The Aardvark is Ready for War . You can purchase Purely Functional Data Structures from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.
Purely *Functional* Data Structures (Score:4, Funny)
(http://www.geocities.com/polysillycon)
Re:Purely *Functional* Data Structures (Score:5, Funny)
"As opposed to what, Data Structures that don't work? Yeah, we need more books on those..."
Fear not, MFC is extensively documented.
(Complains I, recently bit by yet another lame long-acknowledged-yet-unfixed bug in M$'s class libraries.)
Re:Purely *Functional* Data Structures (Score:5, Insightful)
(Last Journal: Saturday March 06 2004, @01:00AM)
Then how the heck do you know what the teachers are teaching? Maybe you have only talked to the morons who go through comp-sci thinking it is a programming degree. I know that there was a large percentage of people I went through school with who chose to ignore things like functional programming simply because they had the mind set that they were there to get a software development job after school. It was taught, but it mostly fell on deaf ears. If it wasn't c++/MFC they thought they wouldn't need it (and hence spent no time trying to learn it). They were the same crop of students who thought it was stupid that they had to take differential equations and physics, because they would never use that in "the field." They just wasted their education.
I personally thought it was really interesting, and as such I am now a graduate student. I love comp-sci for what it actually is, which is not programming.
Why am I replying to a troll??? Oh well, I feel better now.
Re:Purely *Functional* Data Structures (Score:5, Interesting)
(http://www.intelligentblogger.com/ | Last Journal: Monday August 27, @11:47AM)
I didn't get a degree, but I did take the hard way of learning comp-sci. I spent years of my time studying the various texts and papers that students *should* be studying. Some people complain that, "well you can't be a *true* comp-sci professional because you didn't pay for this piece of paper." I just shake my head at their insecurity and offer to help them solve whatever their current problem is.
There are my credentials. Take them or leave them. My only recommendation is that you don't underestimate what I can do, or what I have done.
Re:Purely *Functional* Data Structures (Score:4, Insightful)
Knowing what the term means, and knowing how to actually prove that an algorithm is O(x), are two different things. Can you prove that general sorting cannot be less than O(n log n)? This is fundamental. If you can't do it, you do not know computer science. (Flip side of coin: if you can, then you are at least heading the right direction).
"game programming is not real comp-sci!" (tell that to my collision algorithms or research into better timing methods)
A hobbyist tinkering in the garage does not a scientist make. Put out a publication comparing your methods with other known methods. Give theoretical upper and lower bounds on run time, memory usage, jitter, etc. Criticize yourself and explain the defects in your methods. Submit it to peer scrutiny. That's science.
Re:Purely *Functional* Data Structures (Score:5, Interesting)
(http://www.intelligentblogger.com/ | Last Journal: Monday August 27, @11:47AM)
Yes, I can. And that's my point. I learned how when I was given my first book on data structures. It was a little weird at first, but if you're going to do things right, you have to know the math behind them. In fact, modern computers long ago made me give up the desktop calculator. Trying to develop for the processing power of today requires numbers far beyond what my old desktop calculators could do. It's too bad, because it was so convenient to not have to switch windows. And yes, I'm too cheap to get a decent scientific calculator.
Put out a publication comparing your methods with other known methods.
You mean like this one [javagaming.org]? Looking back at it, I should have taken the time to clean up the english. I was so excited about my algo, that I just pushed it out.
Keep an eye on Java Developers Journal for an article on logging. They wouldn't let me publish a pure research paper, but I was able to squeeze in a dissertation on using ThreadLocals for multiplexing a stream.
Does anyone know any *good* comp-sci journals? Dr. Dobbs looks promising, but I had already promised an article to JDJ.
Over where I work (Score:5, Funny)
I don't even see the code.. (Score:5, Funny)
(http://www.webfire.ca/)
Nice Review! (Score:5, Informative)
(http://www.cubiclemuses.com/)
By the way, this reminds me of the recent article on Domain Specific Languages over on Martin Foweler's website [martinfowler.com]. Another aspect of programming worth investigating.
Re:Nice Review! (Score:5, Informative)
(Last Journal: Monday July 29 2002, @08:12PM)
I would recommend this book to programmers that have a couple years experience with imperative or OO languages, who have also taken an introductory course in algorithms. A motivated reader does not need experience with ML, but having taken some sort of "Programming Languages" class that spends a day or two on ML is very helpful. I found it the most rewarding to learn ML and start programming in ML while reading this book, then attempting to implement the data structures in the book myself to use in small projects.
If you don't know any functional languages and don't want to learn them, this book will not be helpful and you probably won't get enough motivation from the book itself to understand what it's talking about. If you don't really know functional languages but are willing to give them a try, this book is ideal. If you already know one or more functional languages well, you should try to read Okasaki's papers on functional data structures before getting the book. Of course you might want the book too.
O'Camel (Score:4, Interesting)
(http://www.robertwebb.com/)
Misread Headline (Score:2, Funny)
I was really confused for a minute thinking, "What do ficticious data structures have to do with ML or Lisp?"
Not a typewriter (Score:5, Funny)
(http://staff.washington.edu/joshuadf/)
You know, your computer is not a typewriter [princeton.edu], so you really could have rewritten that part of your review...
Re:Not a typewriter (Score:5, Funny)
I like any language (Score:5, Funny)
(http://www.donnyspi.com/)
Functionals (Score:3, Interesting)
Re:Functionals (Score:4, Interesting)
I agree that functional programming languages are quite useful, but speaking as a coder who learned functional programming just last year in class, I can say that functional languages are a lot more complicated than procedural languages.
Sure, once you get good at it you can bang out a functional program easily, and maintenance can be a breeze once you know how to write the code. However, reading and understanding code that ISN'T yours can be damn near impossible sometimes, especially when you're a newbie.
I'm not discounting the use of functional languages, I'm just saying they are harder to learn than procedural languages.
Re:Functionals (Score:4, Informative)
But then again, I majored in math, not programming, so maybe I'm biased.
Re:Functionals (Score:5, Insightful)
I don't know how you can say that the languages are more complicated. Scheme, for example, is the simplest language I know of, in terms of syntax and semantics.
I think you're confusing this with how difficult it is to think functionaly when you've been raised to think imperatively. Functional programming is a different paradigm than imperative programming, and as such, you have to think differently. If you've been programming imperatively for a while, learning another imperative langauge is often straight forward; you learn the basics of the syntax, what the language provides natively, and how you can construct what it does not provide. You already know how to solve problems with that style of language.
Learning a functional language, however, is more than just having to learn a different syntax and set of rules (assuming you've been raised imperatively). You have to learn a different way of solving problems. And until you've done that for quite some time (I, for example, have not), I don't think you're qualified to make the judgement calls you did.
Re:Functionals (Score:5, Insightful)
(Last Journal: Friday July 04 2003, @03:37PM)
You know how they say, once you know one programming language, learning another is easy? Yes, once you know C++, picking up Java is a sinch, and you can probably even read someone's Python code without even learning the language first. But, this is because all of these languages are imperative. If someone tells you to write something in LISP, you may be able to figure out the syntax pretty easily, but no doubt you'll find yourself using imperative constructs like "progn". And, when you do that, the language seems very difficult to use indeed, because it was never supposed to be used that way. I made this mistake once myself.
Anyway, point is, it's not really fair for you to be judging functional languages until you've practiced them as much as the imperative ones. Personally, my imperative experience still dwarfs my functional experience by a factor of thousands... but I've now convinced myself that, for most purposes, functional languages are superior.
Re:Functionals (Score:5, Insightful)
but speaking as a coder who learned functional programming just last year in class, I can say that functional languages are a lot more complicated than procedural languages.
Wouldn't you be a little bit more qualified to comment if you had several years of experience with both functional and imperative languages, first?
Re:Functionals (Score:5, Informative)
(http://gangien.com/)
What?? More complicated? No no no.. They are certainly not more complicated. For instance the funcitonal languages:
(display "Hello World") -Scheme
main =
do
putStr "Hello World" - Haskell
vs
#include
main () {
printf("hello world"); }- C
#!/usr/bin/perl
print "hello world"; - perl
Now those differences are subtle, but A. The functional languages are easier to read(and I think most any none biases person would aggree with me) B. No whacky syntax, hell scheme syntax is only () C. The data types are simple, Pointers? please. Ect ect. The thing that makes functional programming difficult is the lack of an imperative control flow. Which is how people tend to solve problems. For instance if you want to sum up the numbers 1 through 8, in an imperative language it'd be
tol = 0
for i = 1 to 8
tol += i
end for
in scheme it'd be
(define (sum a b)
(if (equal? a b)
b
(+ a (sum (+ 1 a) b)))
which is confusing. And not obvious. But as for other people's code, that is always the case. Well I've never seen a language that oculd get around that anyhow, the closest I think is java.
What is the world coming to? (Score:3, Funny)
(http://www.twistedsquare.com/)
Next thing we know, people will start reading the books as well!
This was a great review (Score:5, Interesting)
(http://www.example.com/)
I guess what I'm saying is that I've used languages like Perl and Python considerably and ignored the functional aspects of the language, probably much to my disadvantage. I think a good study of a purely functional language could really improve my perl, python, or ruby.
Re:This was a great review (Score:5, Insightful)
For example, where I work, I have to write in ColdFusion sometimes. ColdFusion has 2 syntaxes: a tag-based one that looks like HTML and is four times redudant and impossible to deal with, but is easier for people, and a second syntax with first-order functions. Writing in the first-order function syntax is easier, more efficient, clearer, and easier to debug in everyway, except all my co-workers write in the tag syntax, which forces me to, as well. It sucks.
The point is that programs tend to be written to the lower-common-demoninator of the language, which makes the difference between functional, procedural, and oo languages so huge when there is really no difference.
Re:This was a great review (Score:5, Interesting)
(http://tomcopeland.blogs.com/)
> language could really improve my perl,
> python, or ruby.
Right on. Here's a quote from Yukihiro Matsumoto, creator of Ruby [ruby-lang.org]:
There's an Artima article [artima.com] where he gives some of his reasons for this idea. That whole series of interviews with him is pretty good.
eek! (Score:2, Funny)
article... triggering... college... flashbacks.
..must.. resist...
..cannot.. fight.. functional
..language.. tempatation...
*head explodes*
The memories... (Score:5, Insightful)
Translation of Okasaki's sources from SML to OCAML (Score:2, Informative)
(http://www.redstream.org/)
It's all in the constructors (Score:4, Informative)
(http://slesinsky.org/brian/)
You can do this in any language, but to be efficient, you need an good garbage collector and a compiler that can optimize out most of the temporary objects.
Just got this book (Score:5, Informative)
(https://customer.lylix.net/aff.php?aff=006)
I just got this book and it's clear the author has really done his research. His writing style is also very clear, concise and well thought out. Not overly chatty or pandering, yet not dryly accademic either. Precisely the kind of computer book I'd want to write!
I'm glad the reviewer didn't try to talk a lot about why people should be interested in functional programs, however I must say that the ability to write large complex algorithms in very few lines, and prove mathematically that it works is simply a miracle in some situations. If you need to write a compiler (or do any other set of complex alogirthms on large recursive data structures, especially those that could take advantage of tagged unions, like Abstract Syntax Trees do) you should check out OCaml. And it doesn't hurt that it can figure out the type of all your functions and variables for you
Oh, and if you happen to get this book, and want to play with OCaml, you can get the OCaml translation of the data structures in this book here [univie.ac.at].
I dont' know if very many programmers will ever program in a purely functional language, however it seems that languages of the future will have to include things like first class functions and closures, as they are incredibly useful. I know Ruby and Python already support a lot of it.
Oh and in case anyone's wondering, it *IS* possible to encapsulate things like notion of state, error handling, and I/O in a purely functional language ("side effect free" language) using something called monads [ed.ac.uk]. Now there's a fun concept to wrap your brain around!
Hope some people here are brave enough to dig into a book like this that requires a bit of math, and more than a little faith at some points
Cheers,
Justin Wick
Re:Just got this book (Score:4, Interesting)
(https://customer.lylix.net/aff.php?aff=006)
No no no... I just got the book a few days ago and have been reading it. I've forced myself to play around with OCaml and various functional languages for the last month or so to try out the paradigm, and I must say I'm impressed by the compact expressivity, and the safety of these languages.
I love the idea of writing programs that can't crash (well, they can hang but they can't segfault), and being able to so elegantly describe an algorithm that I might as well just be writing the math.
I'm also not exactly upset by the type-inference (I never have to specify the type of almost *ANYTHING* despite the fact that there's no implicit casting). Also being able to make functions that are polymorphic in extremely complex ways allows me to keep algorithms much more general. Functors, for those that havne't used them, are simply awesome. Think templates but done right.
We need more good book reviews like this. Slashdot should hire the guy
Cheers,
Justin Wick
Re:Just got this book (Score:5, Informative)
So the design pattern consists of using functions that pass a state value in and out of each function, in addition to possibly other values. The pattern enforces some restrictions, one of which is: each state value can only be used once.
So executing one command and then another involves each command being defined as a function that takes the world's state and returns the world's state after modification. Sequencing the two commands then consists of composing the functions such that the state is passed from one function to the next.
There are additional properties required for something to be considered a Monad... and it turns out that this "design pattern" is a mathematical construct known from a branch of mathematics known as Category Theory, and that category theory construct is called a "Monad".
A side note: category theory is basically the study of mathematical design patterns. Its more than that, but thats a good intuition for computer scientists to take when they study category theory.
Re:Just got this book (Score:5, Informative)
(https://customer.lylix.net/aff.php?aff=006)
What makes them special is the mathematical rigor that *ensures* the properties you need from the monads, and greatly aids in proving properties of your algorithms. Things like associativty, and the left/right unit properties really help trivialize a lot of programming proofs.
It's more than just a "fancy name", and I'd say the most exciting thing about it is that it allows the use of composition of monads to compose functionalities described inside them. It makes functional programs much more modular because of this, and allows one to add all kinds of features to something like an interpreter without hardly changing the signatures of any functions! Quite impressive compared to the normal craziness associated with refactoring a functional program.
It's interesting to see how monads are used in Glassgow's Haskell compiler... much more useful than I ever though "some weird triple thing" from category theory could be.
A side note: category theory is basically the study of mathematical design patterns. Its more than that, but thats a good intuition for computer scientists to take when they study category theory.
I always thought Category Theory was best though of by CS students as a replacement for Set Theory that has a function-centric view... a more pure theory of functions (with applications to the lamda calculus no less) that can usefully find common structure in many disparate fields of mathematics, especially discrete math.
Cheers,
Justin Wick
functional algorithms (Score:2)
(Last Journal: Friday February 28 2003, @03:28PM)
So, functional programmers, how to improve such a program without simply mimicking the imperative version?
Slashdot ate my spaces.I bought this book (Score:5, Informative)
(http://www.bartlettpublishing.com/)
Anyway, the book was a great read. I was really surprised to learn how efficient some of the functional data structures could be.
Good discussion as well on the use of suspensions (lazy evaluation for specific blocks of code) in programming.
I heard this mentioned on some previous article (Score:1)
(http://zenith.homelinux.net/)
Online version available (Score:5, Informative)
(http://www.bartlettpublishing.com/)
See http://www-2.cs.cmu.edu/~rwh/theses/okasaki.pdf [cmu.edu].
I suggest you get the book, however, as it's a great read.
Another Book ... (Score:2, Informative)
Well he why not try "Comparative Programming Languages" it covers most of them.
Here is an excerpt:
"This book considers the principal programming language concepts and how they are dealt with in object-oriented languages such as Java and Delphi, in traditional procedural languages such as Pascal, C and Fortran, in hybrid object-oriented or object-based languages such as C++ and Ada 95, in functional languages such as ML and in logic languages like Prolog. "
There is also a link to it:
http://www.cs.stir.ac.uk/~rgc/cpl/
which I post as plain text because I'm lazy right now and also because I hope this prevents compulsive clickers (are there such people?) from going there without getting too much wisdom out of it. There is after all this much feared slashdot effect.
Have fun
Cool languages, but why... (Score:2, Interesting)
(http://freenode.blogspot.com/ | Last Journal: Wednesday March 21 2007, @08:42PM)
I enjoy learning new programming languages but because of stuff like this, I wonder why I should. I still will because I have done non-trivial stuff in them very easily but it is a big downer. At least they let authors write neat books for us geeks to take on vacation.
Scala (Score:3, Informative)
(http://www.stateofflow.com/)
From their site:
Scala is a pure object-oriented language in the sense that every value is an object. Types and behavior of objects are described by classes and traits. Class abstractions are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance.
Scala is also a functional language in the sense that every function is a value. Scala provides a lightweight syntax for defining anonymous functions, it supports higher-order functions, it allows functions to be nested, and supports currying. Scala's case classes and its built-in support for pattern matching model algebraic types used in many functional programming languages.
Laziness Bad (Score:1)
My understanding was that, in general, the "efficency" of laziness is outweighed by the cost of the bookkeeping for it. After all, a function uses the parameters it is passed most of the time.
I'm a fan of functional programming, but lazy evaluation complicates the code and slows it down. That's one advantage of scheme's function-calling semantics over lisp's, IIRC (can anyone confirm?).
Lisp (Score:1)
(http://www.magog.nu/)
But what data structures? (Score:5, Informative)
(https://customer.lylix.net/aff.php?aff=006)
Heaps:
Trees:
Queues:
There's also a lot of other things, such as some interesting ways of doing numerical representation in functional languages (lazy numbers!) Even talks about trinary/quaternary numbers, as discussed before on slashdot.
Also if you'd like to see the source code without buying the book (you cheap bastard!) you can find it here [wu-wien.ac.at].
But I hope you buy the book
Cheers,
Justin
A coder's hobby (Score:3, Insightful)
So this is what computer programmers do in their spare time - program computers! WooHoo!
Who would have thought... (Score:2)
(Last Journal: Monday January 06 2003, @10:36PM)
Functional Programming missed the boat (Score:5, Interesting)
Network effects are what rules the programming tools industry. Network effects are whim to fashion. Fashion is ruled by those with the legitimacy to glamorize.
Re:Functional Programming missed the boat (Score:5, Insightful)
Also, it's not exactly true that functional programming lacks a big-name sponsor. Haskell research and implementation is largely driven by Microsoft Research. This is not the same as promoting (something like) Haskell to working programmers, but it suggests that Microsoft has its eye on doing so someday.
Now what I'd like to see (Score:2, Funny)
(http://www.edkearns.com/)
Just think of the Zen Koan Binary Tree.
Great Book (Score:2)
(http://foo.ewu.edu/ | Last Journal: Monday June 18, @12:43PM)
Yup, I'm an academic - but I've also done real programming. Learning the functional programming mindset took some time, and learning to really program in functional languages (I like Haskell as it makes it hard to program non-functionally) took some serious work. I can pick up most algol family/imperative languages in a couple of days, at least enough to feel comfortable and be able to code real problems. Haskell took more than a month to master (maybe about a week to get the basics) but then it finally really clicked (and I suspect the click was probably audible, it was so sudden and revelatory). And my program analysis skills and my programming skills have been all the stronger since.
Okasaki's book not only helped me understand the functional programming model, it helped convince me that there was more to it than just fun languages.
I recommend this book highly for those who are interested in functional programming, or who are interested in learning more about data structures and algorithms on many levels.
Hard to use in the "real world". (Score:5, Informative)
1. Few commercial tools: Functional languages are under represented in the commercial space. With the exception of Franz Lisp and a few other lisp dialects, there is little commercial support. That may not be a killer for everyone, but I would like an environment with a good form designer and a large library to back me up. One I could give to another coder and expect them to be productive with it. Emacs works as an IDE for me, but I can't force that on others...
2. Fewer programmers: The vast majority of programmers seem unable/unwilling/whatever to grasp the concepts and work with functional code. If you need to build a team of programmers, it is much harder to find those who can do functional programming (and when you do, they rock, but are expensive and in high demand).
In the end, I use commonly used commercial tools so I can work with other people. Internally I use a lot of non commercial tools (LAMP model) and so I can sometimes indulge in my functional side there, but rarely can I do functional programming for my business clients.
Took Okasaki's data structures course (Score:5, Interesting)
(http://philgross.com/)
The course was pretty mind-blowing. He knows his stuff. It was a bit freaky to watch him grading programming assignments by just reading them, not running them, and yet never missing a mistake.
I would recommend the book not just as an introduction to advanced data structures in functional languages, but as a guide to some of the more interesting data structures of the last fifteen years, regardless of implementation language.
-- Phil Gross
The tyranny of momentum: why Ocaml is not popular (Score:5, Informative)
Take a language like Ocaml.
It is a functional language with imperative features (loops, mutable data structures), modular organization, has object orientation, compiles to portable byte code (like Java and the JVM) as well as compiling to native code that runs as fast as C, has garbage collection, and a good standard library.
I'm thinking the reason why there are such few people picking up functional programming is the same reason the US still uses the imperial system for measurement.
While the rest of the world is on the metric system, the U.S. still uses the strange imperial system, that uses things like 12 inches to a foot, 3 feet to a yard, 16 ounces to a pound. That's because the US is entrenched in a mindset and there's no driving reason to change. This is the same reason why people have been stuck on imperative languages. Imperative languages have been the overriding paradigm because in the past, processing time and memory were expensive and imperative languages. This is no longer the case but there is a huge momentum of imperative language that that rolls on like a giant snowball, reinforced by industry and entrenched upon the next generation of computer programmers.
How did I discover Ocaml?
I was investigating rapid prototyping languages to add to my toolbelt and ran across Ocaml. I was drawn to it because it has done extremely well in the ICFP contests, especially in the lightning division (24 hour submission).
Also it ranks impressively in the great language shootout by Doug Bagley, in terms of Lines of Code, Execution Speed, and memory consumption.
http://www.bagley.org/~doug/shootout/
Functional JPEG (Score:2)
(http://www.doxpara.com/)
A good example of how terse yet powerful functional code can be: JPEG decoding in a few pages of code. Damn.
--Dan
Letting you in on a little secret (Score:4, Interesting)
Encapsulation is a restriction not a benefit.
Just as non-open source software allows your data to be held hostage by the class producer authors.
Reusability is poor because while both Accounting and Genealogy software might use a person object neither is interested in holding the other's baggage.
An object hierarchy becomes a house of cards, built on excruciating desicions of what to include and exclude at each level, and how much baggage to bring along.
Really the only good that ever came out of OOP was a straightforward way of passing around references to the same data, and easily creating and destroying records from classes.
<a href="http://www.lua.org/home.html">Lua</a&g t; is probably the best syntactically designed language out there in terms of both expressive power and readability.
It has an easy to read vb/pascal like syntax without semicolons.
It has full functional powers
No silly restrictions such as immutable variables.
Tables as a replacement to both lists, and classes,
essentially fully associative keyed lists
and since any value can be a function a Table can act as a "method" container.
Powerful extention mechanisms to define class inheritance/relationships within the language itself (rather than the compiler).
great calling convention with multiple assignment/return values.
Lua is a great introductory language, in that it is exceptionally readable. While you will immidiately gravitate to using functional paradigms, you're not forced to using them exclusively. It has elegant OOP and imperative paradigms as well.
Good book? Yes. Useful? Not really. (Score:3, Interesting)
I'm speaking from experience as both a functional and imperative programmer. While I have enjoyed the book, I didn't find it to be something that I keep returning to over the years.
Prefer databases (Score:3, Interesting)
(http://www.geocities.com/tablizer | Last Journal: Saturday March 15 2003, @01:22PM)
Relational tables are more stable as requirements change. Relational tables are mostly designed around the quantity of relationships between things, such as one-to-many, many-to-many, etc. They are NOT dictated by how they are actually used in a given application for the most part. This at first sounds bad, but it is good because normalized tables transcend specific uses, and are thus more flexible and change-friendly. Relational tables are to describe nouns and facts about nouns, not reflect specific tasks or usages. Thus, you don't end up with "pointer messes".
For example, if you want to represent a graph with dedicated data structures, you might be tempted to make a list of lists, where one list is the ID's (or pointers) to other nodes (links). But if one is later required to put weights on these links, then a list is no longer appropriate, and you have to overhaul your structures and code that references them. However, a (properly normalized) relational database would use a many-to-many table to represent the links. Adding a weight factor is a trivial column addition. Existing code still works without change (as long as it does not reference or need weight info of course).
However, SQL and tradition has "bulked up" databases beyond what they need to be for many applications. A light-duty "local" relational engine to complement or replace "big-iron" RDBMS would be nice. I used to use "nimble table engines", and they were easy-to-use and relatively quick. SQL is not the ideal relational language, especially for smaller DB engines. I would like to see the industry explore alternative relational languages. Then we could get away from the pressure to use dedicated data structures. I find them archaic, to be frank. Let's move on.
I have implemented some of these in Ocaml (Score:4, Interesting)
(Last Journal: Wednesday June 11 2003, @11:43AM)
Red-black binary tree
Skew-binomial heap
Real-time catenable deque
They're buried in a library containing a lot of other goodies that I haven't ported to all the platforms where Ocaml runs. The data structure modules are pure Ocaml, though- so, you can just lift them. The library is BSD licensed (two-clause), so take all the liberties you want as long as you give me props in your distribution and you can cope with the fact that you get NO WARRANTY from me. (It would be nice if you told me you were using it too-- that would help motivate me to care about timely release of updates.)
* The real-time deque is not technically a pure functional data structure since it uses lazy evaluation for handling concatenation, but- to be fair, a lot of the algorithms in Okasaki's book have a similar property. He is, of course, careful to distinguish the difference between pure and non-pure functional data structures.
The heap algorithms in Scheme (Score:2, Informative)
(http://www.jensaxel.dk/)
in data structures owe themselves read his book.
I became so inspired that I implemented all the heap
algorithms in Scheme:
http://www.scheme.dk/heaps-galore/heap.scm
The code contains implementations of the following heaps:
- leftist heaps
- binomial heaps
- pairing-heaps
- splay heaps
- lazy binomial heaps
- lazy pairing heaps
- skew binomial heaps
The documentation is here:
http://www.scheme.dk/heaps-galore/doc-heap.txt
thanks (Score:1)
(http://cybertiggyr.com/gene/)
gene
Mathematica? (Score:2, Informative)
It seems to me that Mathematica is extremely powerful in this respect: one can choose which paradigm to program in, and successfully mix paradigms, almost to the heart's content, and get useful information out. Of course, the execution speed may not be so hot, but for ease of use, it can't be beaten. What other programs out there allow such mixing?
OCaml software (Score:2)
(http://www.annexia.org/)
http://www.merjis.com/developers/ [merjis.com]
Rich.
Anyone Know A Good Tutorial or Introduction? (Score:1)
(http://abuzar.com/)
I did something like this before, there was a 2 page tutorial on the net that showed functional programming for perl. It showed you various techniques like passing functions into functions and making compound functions. Stuff like that has come in handy.
So, at the moment I've written stuff to generate user interfaces and databases given a description of how they should look like (using XML). I'm wondering how I can move beyond using arrays, hashes, and objects in Perl. The article sounds like there might be something that the Functional people have figured out about writing application logic and user interface Models (as in the M of MVC) that I can steal from. Is this true?
Let me also try to explain why FP is good (Score:4, Informative)
(http://www.cs.cmu.edu/~tom7/ | Last Journal: Monday January 07 2002, @01:07AM)
That (along with all of the other features that functional languages typically have that languages like Java and C don't, like higher order nested lexically-scoped functions, polymorphism, algebraic data types and pattern matching, parameterized modules, tuple and sum types, etc.) is the reason to do functional programming. Of course, SML and O'Caml allow you to program imperatively too, since some activities are more naturally expressed that way.
I used to be a total C cowboy, and now I love functional programming. You can just do so much more great stuff with it.
IMO, mlton [mlton.org] is a great compiler with which to start functional (SML) programming. The performance is incredibly good, it behaves like a real compiler from the command line, and it's free (GPL) software.
Oh for god's sakes.. (Score:1)
correctness (Score:1)
(http://javierisassi.googlepages.com/cabazorro | Last Journal: Tuesday August 10 2004, @04:22PM)
so here it goes:
In the white paper I read about functional
languages there is a strong emphasis on coding
an algorighm and showing it's correctness or
proof. In today's arena we programmers gauge
ourselves by our abilities debugging code. Bugs
are a given. We like to believe that debugging
thousand lines of code is a small price to pay
for the wonders of procedural language.
Hard to quantify I must admit but for those who
compare Haskell or other functional language against
any procedural language please remember the
issue of correctness.
Because even if is cheaper and faster to count
cows by counting the legs and dividing them
by four...still wrong.
As a functional programming fan (Score:1)
(Last Journal: Monday March 17 2003, @01:21PM)
Anyone who wants to learn ML and the principles of functional programming could do a lot worse than getting a copy of Larry Paulson's "ML For The Working Programmer"
Re:Functional use (Score:2)
You carry on searching Monster.com for your coding drone jobs, that just leaves more of those six-figure salary jobs, using advanced programming languages, for those who actually have skills and knowledge.
But when your boss ships your job off to the lowest offshore bidder, you might try picking up a copy of something like PAIP or SICP (google for them), and learn some of the stuff you've missed in your education and/or career so far.
Re:A REQUEST FOR INFORMATION (Score:1)
(Last Journal: Wednesday June 11 2003, @11:43AM)
Seriously. It's easy to learn. You don't have to immerse yourself in it for hundreds of hours just to learn how the syntax and semantics of the language work. You can pick up the whole enchilada in a couple hours of fooling around with it.
Other functional languages might be preferable for specific applications, but Scheme is the one that I would recommend learning first. It has all the basic features you need for functional programming. Learn how Scheme coders write algorithms on sequences of values and you'll cover the most useful ground in the shortest time.
--
Re:A REQUEST FOR INFORMATION (Score:2)
(http://www.groklaw.net/)
I will have to agree with the above poster that Scheme is probably the best language to learn functional programming.
A good introduction to Scheme is Scheme in fixnum days (google for it) it is quite simple to start with but also involves more esoteric example near the end which, while they are a bit harder to comprehend than most imperative algorithms at first give you a small epiphany when you finally grok them.