5 ms·
This seems nice for prototyping, since it'd allow a Lisp-style approach to changes and refactoring, where you can incrementally refactor, and run the intermedia
by _delirium 15y ago
This seems nice for prototyping, since it'd allow a Lisp-style approach to changes and refactoring, where you can incrementally refactor, and run the intermediate results. Traditionally that's been difficult in Haskell, because if you e.g. change the type of a function, you have to change or comment out all the code that calls that function before it'll compile. That's particularly annoying when doing sketchy speculative prototyping, during which it's common to frequently change your mind about how things should be put together.
- cageface 15y agoI have found it ironic that Haskell packages seem a lot more brittle than packages in a language like Ruby. It's possible to get into "dll hell" with gems of course, but my limited experience fiddling around with Cabal suggests it can be much more difficult to get exactly the right set of versions in Haskell. Maybe this means that there are a lot of undetected bugs lurking in the typical gemset but at least you can get something off the ground.
- fusiongyro 15y agocabal-install leaves something to be desired in the dependency management area. There are active projects under way to improve the situation, largely borrowing from Ruby along the lines of rvm and bundler.
- Uchikoma 15y agoI don't think this has anything to do with Ruby (dynamic) or Haskell (static). Scala is a dll hell b/c of binary incompatibility and a community that wants all frameworks on bleeding edge Scala (RC even) versions. Compared to Java, where many frameworks still work with Java 1.5 and dependency management is a joy.
- cageface 15y agoThe difference seems to be that languages with dynamic type systems or very simple static type systems aren't as difficult as languages that encode a lot more information into their types. Maybe it's not fair to generalize from just those few examples though.
- fusiongyro 15y ago> ...if you e.g. change the type of a function, you have to change or comment out all the code that calls that function before it'll compile. I thought so for a long time too, but then I discovered `undefined`. You can replace any expression with undefined and if there's a type, it will compile, and explode at runtime when it tries to evaluate it.