Safe: Robust programming in Haskell via types, testing, debugging

The uptake of FP in finance is interesting. I'd like to hear more about exactly how FP is being used in these contexts. Is it used in a narrow, specialized domain or broadly? To what extent are the advantages of FP in this domain realizable in others? Is FP only suitable for small, elite teams or can mainstream programmers pick it up with the right training? To what extent does the less mature or less conventional toolchain offset the advantages of the language itself?

Of course, most of the code that actually makes us money is Excel spreadsheets :)

Nope, and there never is. Haskell is just programming!

It's easy to agree that there's lots of software floating around, but that not a lot of it is good. That's particularly true about enterprise software (I used to work in the field). It doesn't have to be good. You could have an excessively complicated UI and do your numerics in Python (for the love of God, numerics and statistics in Python?) and people will still use it. The damn app can take 12 seconds to load, and people will still use it. How are you going to sell Haskell to the enterprise community when that's their bar?

If people want to write code in Haskell for a living, if they're serious about this freeing-software-from-the-von-Neumann-paradigm thing, they should seek out problem spaces where software quality matters. This is hardly the sole core competency of Haskell, IMO. When one of my friends was introduced to it, he noted that it was a very "scientific" language. Which is to say, he thought it was impractical for regular software. The flip side to this is that we can very easily do things like check for gene sequences in Haskell (Brian O'Sullivan was doing something like this).

The fact that things like sets and maps are treated like values means that they are very natural and easy to work with (albeit a little slower than their mutable counterparts in other languages), so why aren't we seeing Haskell used to analyze social networks? Haskell is a powerful language. We just need to see it for what we could do with it, rather than redoing the old things that have already been done.

  some comments
  \begin{code}
  foo :: Int -> Int
  \end{code}
  more comments
  \begin{code}
  foo = (+ 1)
  \end{code}

  some comments

  > foo :: Int -> Int

  more comments

  > foo = (+ 1)

  -- some comments
  foo :: Int -> Int
  -- more comments
  foo = (+ 1)

  some comments
  <<Foo.hs>>=
  <<type of foo>>
  <<definition of foo>>

  comments on definition of 'foo'
  <<definition of foo>>=
  foo = (+ 1)

  comments on type of 'foo'
  <<type of foo>>=
  foo :: Int -> Int