Do you have examples of using Haskell as a DSL in an environment NOT
targeted at people who know it already?
I'm thinking of using Haskell to build my Mac trading app but I'm
very concerned about dumping Haskell on the trading systems
developers. It seems that using, say, Ruby as the trading systems DSL
would give me a leg up since it's simple and syntax and generally
warm and fuzzy.
What do you think?
P.S. Yes, I'm a big fan of "Composing Financial Contracts"
"Lava is a hardware description language based upon the functional
programming language Haskell. Its main aim is to show that modern
programming language features such as type inference, polymorphism,
higher-order functions, type classes, and laziness are very useful
even in hardware description."
The target audience is primarily hardware designers, not haskellers.
Joel Reymont skrev:
> On Jul 5, 2006, at 3:07 PM, Niklas Broberg wrote:
>> Lava: http://www.cs.chalmers.se/~koen/Lava/ >
> Excellent example, thank you Niklas!
> Are you using QuickCheck for verification?
I assume you're asking if Lava (rather than Niklas) uses QuickCheck.
In Lava, you write properties in a style similar to QuickCheck props., but the
actual verification is done by external tools. You still get the nice benefit of
having description and verification within the same language.
About teaching Lava (and probably other Haskell DSLs) to non Haskellers, I think
that higher-order functions (and the type errors you get when using them
incorrectly) is what causes most confusion among our students. A minority of
them also finds it hard to use recursion instead of loops. Luckily, they don't
have to use monads...
I've been talking to a person at Intel who has been trying to teach their
hardware designers to use a functional language (somewhat like Lava). This
turned out to be much harder than expected, since the designers were so used to
the imperative style. I'm not sure what the current status is, but they really
have to make a trade-off between the time it takes to "convert" the designers
and the quality (correctness/maintainability/performance/coding time/etc.) of
the resulting code. It is important to show that functional programming has an
advantage on the latter aspect (if that is the case).