On a somewhat related note, Trees in Haskell:

—————————————————————————————
module Tree where

data Tree a = Node
{ rootLabel :: a
, subForest :: Forest a }

type Forest a = [Tree a]

flatten :: Tree a -> [a]
flatten t = squish t []
where squish (Node x ts) xs = x : foldr squish xs ts

levels :: Tree a -> [[a]]
levels t = map (map rootLabel) $
takeWhile (not . null) $
iterate (concatMap subForest) [t]
—————————————————————————————

They’re pushing it hard, and functional programming in general too.

They have LOTS of money for evangelisation.

Esperanto. I learned that too for some time, but forgot everything. Sigh.

“OO is embedded into our field it is what we all know it will take a long time to move onto a new paradigm.”

The comments too this post have made me think a lot. I suspect OO is successful because it makes modeling reality easier (but you can easily go wrong, see the DDD book). But I’m not sure yet. We’ll see.

I am a big fan of functional programmming I absolutely love the haskell language (especially its type system) unfortunately the Haskell platform (tools, libs, books, community support, etc) sucks.

Also as a software professional I would have no one else to talk too if I didn’t know C/C /Java. Building useful software is about people writting software in some esoteric language that no one knows is guaranteed to shorten its useful life considerably. Viaweb is the famous example of how to create a cool app that has to be re written to be maintained.

Who cares if you speak the best language in the world if there is no one else to talk too.

English(C/C /Java/C#) isn’t perfect but it is familar and in widespread use so there for it serves as a good medium of communication. You could learn a better language like Esperanto(Haskell) but you wouldn’t have many people to talk too.

I could never diss LISP its contributions to our field are massive but you don’t see tons of useful apps being cranked out in LISP.

Also LISP may permit a functional style but there is far more imperative lisp programs and that is the way most lispers code. The same goes for scheme(although probably more FP’ers in scheme than in LISP).

Functional programming has made very useful contributions to our field and will continue to do so but I doubt it will be the next big thing. OO is embedded into our field it is what we all know it will take a long time to move onto a new paradigm.

I will probably buy the Scala book when it comes out it looks realy cool but I doubt I will ever use it for anything real.

The reason esoteric languages never catch on is because the platform is more important then the language itself and people matter they don’t want to learn new things because getting things done is more important

Scala only addresses the first problem by running on and using the java platform the second problem is just as important. You can still find C developers who don’t want to make the jump to Java or C# despite all its obvious productivity advantages.

Troy

http://moscova.inria.fr/join/index.shtml

Fork/Join by Doug Lea is

http://gee.cs.oswego.edu/dl/papers/fj.pdf

Map/Reduce is another one.

It’s less general than 2.0 (Erlang style) and 1.0 (Thread style), but what you lose in generalism you gain in performance and easyness.

For a transparent solution in Java see Spin ( http://spin.sourceforge.net/solution.html ) which could be implemented with message inboxes and add Erlang style concurrency to Java.

Got cite for Domain Concurrency? I’m curious about it.

I totally agree about Erlang. Its message-passing is only part of the solution, mostly useful for solving the problem of distributed/interprocess synchronization: the best intraprocess solution I’ve found is the join calculus stuff that JoCaml implemented. I’m actually wondering if that can be implemented in Factor, since it seems to have a lot of the necessary plumbing…