12 ms·

A Taste of Haskell

157 points by def- 10y ago

androidfox 10y ago
Nice link. One related question : where have you used Haskell in real life. Do some top companies use Haskell to solve problems
- wuschel 10y ago
  I second this question and would like to add another one: Where is it that Haskell shines?
  - sa1 10y ago
    This State of the Haskell Ecosystem doc[1] is very informative. If you're looking at application domains, Haskell(and OCaml etc) is usually well suited for writing compilers, but its not bad for your usual server-side application either. The only domain its fundamentally unsuited for is systems/embedded programming. [1]: https://github.com/Gabriel439/post-rfc/blob/master/sotu.md https://github.com/Gabriel439/post-rfc/blob/master/sotu.md
    - initram 10y ago
      My impression from having tried it briefly is that it's not great at real-time stuff because of its lazy evaluation. Do you find that to be true, or is that not an issue in real life?
      - sa1 10y ago
        Lazy evaluation does make understanding performance/memory behavior hard, but usually you'll be using pipes/conduit/machines instead of lazy lists in production code, so its not much of an obstacle for real-time behavior. However GHC's garbage collector can be an issue for real-time code, having high 99th percentile latencies.
  - jfoutz 10y ago
    There are a bunch of fussy little problems that Haskell solves nicely. One example is looking up a value in a map map.get("foo") // returns null is the value of the key null, or was there no key? Different languages have different approaches. Haskell let's you build up deep structures, a list of maps of list of maps ... and you'll have an indication of what path you took down the data structure to get a result. You can do this in any language, but it relies on programmer discipline, and everybody doing it the same way every time. In Haskell, it's the easy thing to do, and often the only way to do it. You'll wind up with something like [Just ["foo"], Just ["bar"], Nothing] The first two maps had once answer each, the final map had nothing. Laziness means you have control of the order of evaluation. in practice you can make your own control structures without macros. bracket is a good example, bracket open_socket do_stuff close_socket the socket always gets cleaned up, with an ordinary function. No try/catch. One of the biggest hassles in programing is leaky abstractions. The type system means you can steal abstractions from mathematicians that just don't leak. There's some good stuff here [1] about the kinds of things you can say. Purity means values can't change behind your back. there's no function to call that'll change the state of some object you're working with. All together, it's nice for languages. You can build up parse trees any way you wish, and traverse those trees to execute the semantics. So if you can think of a dsl for your problem, you can whip up an interpreter pretty quick. If you change your mind, and want to turn it into a compiler, it's relatively painless. It's a fun language. [1] https://wiki.haskell.org/Typeclassopedia https://wiki.haskell.org/Typeclassopedia
    - z1mm32m4n 10y ago
      I'm writing a compiler in Haskell for a university class this semester. I don't think "painless" is the word I would use to describe it. Would you care to elaborate on your thoughts here?
      - bbcbasic 10y ago
        You're writing a compiler! It won't be painless in any language.
      - Athas 10y ago
  - harpocrates 10y ago
    For me, I think the answer to this is really that Haskell is pure and immutable. Equational reasoning[1] is immensely useful when debugging. It isn't unusual to debug pieces of Java code that look like this. MyClass c = new MyClass(..); c.method1(..); c.method2(..); c.method3(..); assert(c.someField == ..) // fails! To figure what went wrong, you have to read through all three methods and depending on whether you have dynamic dispatch coming into play, you might need to read through _multiple_ versions of all three methods. [1]: http://www.haskellforall.com/2013/12/equational-reasoning.html http://www.haskellforall.com/2013/12/equational-reasoning.ht...
  - marcosdumay 10y ago
    Haskell shines at large codebases. It shines in a lot of other domains, but there's no mainstream competitor on dealing with messy, badly defined, big, changing problems. Haskell shines on refactoring, API designing, and constrain setting (want to enforce safety? atomicity? thread ordering?). As a bonus, it'll also reduce your codebase an order of magnitude or two. I mean, yes, if you never wrote a complex parser on Haskell, you should try. But that won't change your life too much.
    - bertiewhykovich 10y ago
      Haskell and its advocates talk a big, big game about its supposed strengths in these areas, but there are suspiciously few examples of these strengths actually manifesting in anything but toy or academic projects. I've been hearing about Haskell's supposed miracles for years and years, and I've never, never seen them.
      - chongli 10y ago
        Then you haven't been paying much attention to Haskell which can be forgiven because it's still pretty niche compared to Python or JS. The best example I can give you is the Haxl project at Facebook [0]. [0] https://github.com/facebook/Haxl https://github.com/facebook/Haxl
        bertiewhykovich 10y ago
        Haxl is one of the standard two or three examples. I want to see a non-Haxl example.
      - iLemming 10y ago
        Many things that emerged at Facebook during recent years can be attributed to the influence of Haskell. React, Immutable.js, GraphQL, etc. Haskell is extremely powerful but allow me to rephrase Euclid "There's no royal road to functional programming". If you want something more pragmatic, yet still quite expressive and powerful - try Clojure and Clojurescript. Especially Clojurescript - it's probably one of the best languages out there to use for front-end and mobile app development.
  - imh 10y ago
    Haskell is very strict in what the compiler allows you to do where. It's a really great alternative to just requiring developer discipline. It means that you can do some things (like refactoring) with much greater confidence because the compiler rules out some big classes of bugs. Same with using other people's libraries. You can only use them certain ways and they are explicit. A side effect of being so strict (in the sense of picky) about what is allowed where is that it needs some really powerful abstractions to keep that from slowing you down. Its type system shines here. Often, these abstractions have a nice syntax in haskell and it makes for some really clean code, relative to a direct translation in other languages.
  - FullyFunctional 10y ago
    I've loved Haskell for decades, but not yet had a chance to use it to pay bills. IMO, Haskell, more than any of the 1e3+ other PLs I know, shines in enabling 1) elegant and 2) robust ("better bugs") solutions. Elegance comes from the non-strict functional part, enabling succent and modular implementations. Robustness comes from the static typing which forces you to be explicit about the range and domain of functions. What's unique about Haskell is that the type system is _very_ expressive, making this a practical approach. IMO, the type system is absolutely key to Haskell. Where Haskell disappoints: Int. For reasons that I still cannot phantom, someone chose to infest a beautiful language that is almost free of pitfalls with the atrocity of a "C-like" Int type. Indeed, in Haskell, this isn't always true: a < a + 1 where a :: Int which is a real shame IMO. It fails the largest value of Int (which BTW is implementation dependent). The correct answer would either to have (my preference) Int == Integer, that is arbitrary sized integers always, or at the _very_ least, have (+) fail on overflow, that is, return bottom like head [].
  - startling 10y ago
    Writing parsers is really nice in Haskell: http://www.cs.nott.ac.uk/~pszgmh/pearl.pdf http://www.cs.nott.ac.uk/~pszgmh/pearl.pdf Trifecta is a nice modern parsing library: https://hackage.haskell.org/package/trifecta https://hackage.haskell.org/package/trifecta
- ianleeclark 10y ago
  https://code.facebook.com/posts/745068642270222/fighting-spam-with-haskell/ https://code.facebook.com/posts/745068642270222/fighting-spa... This goes into detail about how Facebook uses haskell to fight spam. There's a talk that goes alongside it and the talk was one of the motivating factors for me to start learning Haskell.
- samcal 10y ago
  Yes, but only recently. The most notable example in a top company is Facebook's spam detection service, powered by their library called Haxl[0]. The language allows some very skilled programmers to build this library that makes it very easy to write spam rules. Lower-level engineers can then write very simple and elegant code that looks sequential but is automatically parallelized by the library. The service is a big deal, because every action or request that anyone makes on Facebook touches this service. [0]: https://code.facebook.com/posts/302060973291128/open-sourcing-haxl-a-library-for-haskell/ https://code.facebook.com/posts/302060973291128/open-sourcin...
  - dorfsmay 10y ago
    Facebook is the new FedEx. Name a technology, Facebook's probably using it!
  - ppcsf 10y ago
    It's interesting that you said the Haskell allows programmers to build Haxl, with the implication being that other languages would disallow it. I wrote a port of Haxl to C#[0]. At this point one might expect me to recite the whole Turing-completeness-means-all-languages-are-the-same banality, but my experience porting Haxl has actually led me to the opposite opinion. Haxl probably wouldn't have been written in any other language other than Haskell. Because Haxl leans so heavily on concepts that other languages have no words for, I think it's inexpressible in C#, or most other mainstream languages. Obviously not literally inexpressible (there's an existence proof of a C# Haxl) but in an Orwellian, "these concepts are unthinkable in other languages" sort of way. [0]: https://github.com/joashc/HaxlSharp https://github.com/joashc/HaxlSharp
- sa1 10y ago
  Standard Chartered has some 3 million lines of Haskell, but they don't use GHC, they have their own internal compiler.
  - tome 10y ago
    About one million of those lines are actually compiled with GHC and about two million with Mu (or at least that was roughly accurate last time I checked).
- bbcbasic 10y ago
  Yes http://ambiata.com/ http://ambiata.com/
- bertiewhykovich 10y ago
  This question gets asked regularly, and every time Facebook's spam detection service, Standard Chartered's (never-seen) codebase, and maybe one or two other firms that no one's ever heard of get invoked. These are seemingly the only examples.
  - spraak 10y ago
    Facebook references all over this thread and literally the comment below yours is in regard to Standard Chartered :D
  - tome 10y ago
    Barclays Capital: http://neilmitchell.blogspot.co.uk/2016/09/full-time-haskell-jobs-in-london-at.html http://neilmitchell.blogspot.co.uk/2016/09/full-time-haskell...
  - sa1 10y ago
    Since when is visibility expected from corporate codebases?
- tikhonj 10y ago
  I'm currently using Haskell to do supply chain optimization at Target. It's pretty awesome! The language lets us express our models in ways that feel natural. We're both solving some specific problems (ie inventory control, network/transport optimization) and building a pretty general framework for expressing, analyzing and solving large stochastic optimization problems. Haskell is a great fit because it's extremely expressive and lets us write and reason about our problems in a natural, expressive way. It helps that we have a very mathy team in a mathy field :). Our team also has a bunch of people with programming language research backgrounds, and our long-term remit is to apply programming language ideas to operations research. Turns out that—for a whole class of PL problems and PL people—Haskell is the perfect language :). I also know people use Haskell at Facebook (already mentioned), Google (Ganeti and some unnamed X project), a few banks (JP Morgan, Barclays and Standard Chartered) as well as a whole bunch of startups and small companies.
- pea 10y ago
  We're a startup in London (shameless plug: www.nstack.com) using Haskell to develop a containerised microservices platform, bringing in lots of low-level Linux coding along with high-level concepts such as typed DSLs. So far it's working extremely well for us and has been a great decision - letting us build complex/reliable systems really quickly and effectively. It is also very good for attracting amazing people, and we have found a small Haskell team can deliver truly spectacular product. This does on how you architect a Haskell codebase: e.g. you could spend a ton of time focusing on the most pure approach vs. pragmatism, so it's a balancing act.
- cx1000 10y ago
  kittyhawk has an opening for a full time Haskell software engineer https://kittyhawk.aero/ https://kittyhawk.aero/
- deleted 10y ago
  [deleted]
- eli_gottlieb 10y ago
  Well, someone seems to show up to Boston Haskell every month having used it in industry, and I've used it for a paper on probabilistic modelling in my copious free time.
sa1 10y ago
That's not really the Sieve of Eratosthenes. The list data structure is not well suited for the algorithm. See [1] for a proper discussion. As someone who wants to write Haskell(and loves it) for code with mathematically well defined guarantees, the propagation of such examples, where the guarantees or behavior is not clear to the author, is not helpful. [1]: https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf
- harpocrates 10y ago
  Cannot agree more. I think the usual example of quicksort also falls under this category. [1]: http://stackoverflow.com/questions/7717691/why-is-the-minimalist-example-haskell-quicksort-not-a-true-quicksort http://stackoverflow.com/questions/7717691/why-is-the-minima...
- pera 10y ago
  It's the same example displayed in haskell.org though.
  - seagreen 10y ago
    Totally fair point. haskell.org has a very . . . casual approach to presenting the language. It's been such an issue some people made an alternate homepage at haskell-lang.org.
- kmill 10y ago
  Or if Python's your thing: http://www.kylem.net/stuff/sieve_eratosthenes.html http://www.kylem.net/stuff/sieve_eratosthenes.html
kinkdr 10y ago
Started learning Haskell just a couple of weeks ago. My only complaint with the language so far is that I cannot have the same name for a field in two records in the same module. Other than that it is amazing the confidence it gives me; if it compiles it works (r).
- sdegutis 10y ago
  This may help you: https://www.reddit.com/r/haskell/comments/2z248l/language_extensions/ https://www.reddit.com/r/haskell/comments/2z248l/language_ex...
  - kinkdr 10y ago
    Thanks!
- harpocrates 10y ago
  If you are using GHC, the newest version (8.0.1) actually supports duplicate record fields with the [DuplicateRecordFields](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#duplicate-record-fields https://downloads.haskell.org/~ghc/latest/docs/html/users_gu...) extension. Check it out!
  - kinkdr 10y ago
    Ahh awesome! Thanks!
  - pyrale 10y ago
    Nice ! Does it work well with lenses ?
    - rfergie 10y ago
      So you can do something like this: data Foo = Foo { _bar :: String } data Buzz = Buzz {_bar :: String} And derive lenses? I think it doesn't - this is more than just a duplicate record name, you also end up with a duplicate `bar` lens
jjawssd 10y ago
How difficult is it in your experience for developers to learn Haskell while on the job?
- chadaustin 10y ago
  In my experience at IMVU, surprisingly not very difficult. It's easier to learn Haskell in a team environment than on your own because your peers can help you connect the dots and accomplish your task at hand. It did seem like less experienced people picked it up faster, perhaps because they had less to unlearn. The hardest things were learning to parse GHC's error messages and learning all of the names of the functions to transform between various data types.
- evincarofautumn 10y ago
  I basically learned Haskell at my first job (writing a compiler), and it was pretty easy to productively contribute starting on day 1, especially because there seems to be less risk of breakage than in many other languages. I also helped teach it at the next job, and developers found it pretty easy to pick up, just different from what they were used to. Prior to this, I had some experience using it for hobby projects, but there was a lot more to learn for real-world use. My colleagues and I helped each other learn new concepts and write better code, as best we could, but we did end up making some questionable design decisions. I think you still need an experienced Haskeller to advise on good program architecture.
  - andrewchambers 10y ago
    Compilers are a bit easier to start with because you can just deal with pure functions for the majority of the time
    - evincarofautumn 10y ago
      You can, but that’s not to say we did, haha. One of the aforementioned questionable design decisions.
Dzugaru 10y ago
Don't know about Haskell, but what really got me (a long time CSharp programmer) into functional programming was this awesome site [1] (and a man behind it with his awesome talks) - which is focused on core aspects of FP (applicable in most languages nowadays) in real-world applications. [1] https://fsharpforfunandprofit.com/ https://fsharpforfunandprofit.com/
- shados 10y ago
  I love that site. The best part about it is that it gives you all of the common names for stuff like category theory concepts. Eg: the various ways map, flatMap, bind, etc are called across languages. Because its a pain in the ass to learn those concepts from scratch when you're looking at code in one language but reading a tutorial in another...the concepts are language agnostic, the naming conventions however are not.
KennyCason 10y ago
I love Haskell, but if you hate Java, but still want to leverage the nice Java ecosystem, (libs, IntelliJ, JVM, tooling, etc) try Kotlin! :) https://kotlinlang.org/ https://kotlinlang.org/
- mahyarm 10y ago
  Does kotlin have the same compile time, binary size and IDE indexer choking issues as Swift? I've heard that it has similar problems. I would not use Kotlin for a large project if that is the case.
  - KennyCason 10y ago
    I used Kotlin for basically all of our machine learning/classifier code in a pretty large map/reduce + storm pipeline and have had no problems. IntelliJ also does not seem to have any problem with it either. (The IntelliJ authors being the the creator of Kotlin) In terms of code size, Kotlin is definitely smaller and easier to maintain. In terms of raw/clean compile speed, I would expect it to be a bit slower, but there are ways to improve it. One of the bigger ways is via incremental builds. I.e. Only build changed chunks of code, which Kotlin supports, and is comparable to, and in some cases faster than Java: https://medium.com/keepsafe-engineering/kotlin-vs-java-compilation-speed-e6c174b39b5d https://medium.com/keepsafe-engineering/kotlin-vs-java-compi... In terms of executable size, I don't have good data, but will investigate, but I'd say likely not a major deterrent given all the other value adds. :)
    - mahyarm 10y ago
      So how long would a generic heavy 100 kloc project take to compile? Full compile and changing one 200 line library file used by 1/4th of the project?
      - KennyCason 10y ago
        I don't know. The experiments in the post only shows a limit set of examples. My hunch is that if you are using a modern compiler/IDE, you will not be coding -> compiling -> running that frequently. I typically code a lot before I actually actually run anything, so I'm not usually waiting around on a compiler. I don't even notice, at all, Java's incremental compilation when coding in IntelliJ. I refactor like a madman. Also, Kotlin is not very ambiguous, and the type inference that it does enable does not escape the scope of a function so the compiler doesn't have to do that much work. (functions require strict typing). I would guess much of that lambda work gives it a small headache, but probably not that much worse than Java's. If Kotlin grows mainstream, it's already pretty good compiler, will only get better. Of course, that is all a hunch. :)
NotThe1Pct 10y ago
I tried haskell queues a while ago - under the advice of a friend and compared with a straightforward C++ queue - it was about 100x slower. Abandoned the idea.
- bbcbasic 10y ago
  Let me guess ... you used [a]
  - sammoth 10y ago
    What are you implying? What should they have used?
    - tome 10y ago
      The list datatype is horrendously unsuited for being used a queue. They should have used a datatype designed for use as a queue.
    - bbcbasic 10y ago
      There are better pure queue types and STM channels and suchlike that are designed for the job, so if bench-marking then you want to be fair to Haskell and use the right type.
- 59nadir 10y ago
  You should do a write-up on it and show your tests. As it stands, this post has almost no real value for anyone else and no one knows anything about what you used and how.
TheAceOfHearts 10y ago
I got started with Haskell recently, and I'm really regretting not having picked it up earlier. Most of what I knew about types came from C, C++, or Java; so it's a big leap. I've been using Haskell for Mac IDE [0] while experimenting, and it's been great fun. The thing that prompted me to give Haskell a a try was this video [1] of a guy using Haskell to generate Elm types, in order to maintain consistent types across the stack. This idea captivated my interests. I'm confident that GraphQL and Relay, or something along those lines, is gonna be the future. My experience so far has been that Elixir feels more welcoming and beginner friendly. There's nothing wrong with the Haskell community (or my limited interactions with it so far), but so far it's just felt a bit drier. [0] http://haskellformac.com/ http://haskellformac.com/ [1] https://www.youtube.com/watch?v=sh4H8yzXnvw https://www.youtube.com/watch?v=sh4H8yzXnvw
- Matachines 10y ago
  Of course Elixir is more welcoming—the language is "practically" functional, easy, and made for building stuff. Haskell's purity and academic background is definitely a big impact on its culture.
  - not-much-io 10y ago
    I wish there was a haskell-without-the-warts language with the same culture as Elixir - developer friendliness, practicality etc. As it stands I can't help but feel discouraged when learning Haskell. Haskell feels like a research tool for furthering other programming languages... I'm still going to learn Haskell, promised myself I would! But I do look to the Elixir folk with a bit of jealousy..
- acchow 10y ago
  If you delve deep enough into C++ TMP, it's just as expressive (more expressive in some ways) as Haskell. You can actually do dependent types in C++.
  - yyhhsj0521 10y ago
    You can, but would you?
mahyarm 10y ago
I really want to warn people from using long-to-compile languages in big projects. And by long, I mean longer than C++. From what I heard Haskell has compile time issues. You will regret it once your in that position and it is hard to get out of once your there.
- dkubb 10y ago
  It's a common misconception that Haskell is slow to compile but not really true, see for example: http://www.shimweasel.com/2016/10/24/fast-tests-and-static-languages http://www.shimweasel.com/2016/10/24/fast-tests-and-static-l...
  - mahyarm 10y ago
    That feels like a limited optimization in the context of practical development.
  - Athas 10y ago
    I guess it depends on your expectations. I'm working on a ~38000 SLOC Haskell program (an optimising compiler: http://futhark-lang.org http://futhark-lang.org), and with GHC 8.0.1, a full build takes about 7 minutes. I can cut off a minute or two by passing `--fast` to Stack. However, even small incremental builds take a significant amount of time due to linking, which is what annoys me the most. It's still far from making me disavow Haskell, but it's definitely not among the fastest-compilable languages. This program is also too big to load in GHCi, at least on my laptop with 8GiB of memory.
    - mahyarm 10y ago
      That's pretty uncanny, swift has a fairly sloc to time ratio too. The memory usage although is significantly less.
  - mbrock 10y ago
    No, it's a very common issue brought up within the community that GHC takes a lot of time and memory. That blog post just says that interpreting Haskell can be faster than compiling. I worked with Haskell professionally on a pretty large codebase. It was split up into many separate libraries and binaries. There were a lot of coffee breaks when recompiling. https://www.reddit.com/r/haskell/comments/45q90s/is_anything_being_done_to_remedy_the_soul/ https://www.reddit.com/r/haskell/comments/45q90s/is_anything...
agentgt 10y ago
As for the Java bashing in the beginning I'm not saying Java is anywhere near the expressive power of Haskell but many people think different things based on Java because of features they either don't know about, outdated libraries used, or experiences with older versions and codebases. For example most don't know that Java actually does have macro like capabilities through APT (annotation processor that will work automagically I might add). Some might say ewww its not macros but then again annotation processing might just be 80/20 good enough (aka what OCaml learned with ppx vs camlp) and that Java now sort of has traits and that its code swapping is actually fairly good (jrebel). There are even sadly people that don't know Java has lambdas, and even some (usually C++ dudes) that don't know it has generics. Most don't even know that you can combine interfaces with generic types as in: `<T extends Comparable & Serializable> void someFunc(T t)`. Yes Java is not Rust, Haskell or even OCaml in expressiveness but it certainly is more powerful than Golang and definitely compiles fast (albeit starts up slow). That being said OCaml is still my favorite. Compiles fast and easier for me to understand. Super mature and lots of companies use it.
- iLemming 10y ago
  It's not Java what makes Java platform one of the most popular but rather JVM. That's why Clojure grows in popularity. Because it brings the expressiveness.
  - oweiler 10y ago
    Please show me how Clojure is growing in popularity. Clojure has never been more than a niche language.
    - ardacinar 10y ago
      A language can grow in popularity while still remaining a niche language. Haskell is a very good example of that, but I really can't say the same thing about Clojure.
      - adrianN 10y ago
xamuel 10y ago
I taught myself Haskell because people say it improves you as a programmer. I didn't see that, but I have a math PhD so maybe I'm just too familiar with abstract types to gain new insight from Haskell. As a language, it's sterile. You can tell it was designed by committee.
- dorfsmay 10y ago
  Are you still using it? If not, what did you switch to for expressive, "fast" (faster than python) language?
  - xamuel 10y ago
    No not still using it. I use C or q (as in kdb+) when I want speed and expressiveness. Python if I want quick easy prototypes. If you think Haskell is a weird language that challenges what you think about programming, it's nothing compared to q! :)
    - dorfsmay 10y ago
      Not looking for a challenge, it's more like python is often too slow, and it spoiled me, I find every other language too verbose and missing expressiveness. I've started looking at Haskel as the possible solution here.
- the_af 10y ago
  > As a language, it's sterile. You can tell it was designed by committee. This remark is puzzling. How do you tell if a language is sterile?
  - xamuel 10y ago
    Hard to put a finger on it but it lacks a certain "playfulness" which real-world languages have. It's like the difference between Lojban/Esperanto (artificially constructed spoken languages) and English/Spanish. English/Spanish are "imperfect" but their warts are the results of thousands of years of culture (and may not be imperfections after all, they may be a case of some kind of coding theory emerging organically)
joobus 10y ago
I've spent quite a bit of time with Haskell, and all the beginner text like this link are easy to grok, but where I've constantly come up short is trying to write an app with, for example, a configuration and a database connection. Having multiple levels of Monad transformers just confuses me and I never get anywhere useful. Something like: App MaybeT IO (StateT IO (EitherT IO Text SomeRecord)) Or something. I haven't figured this out.
- spion 10y ago
  Use IO for everything at the beginning. Use wai/warp to run an app directly and setup handlers. Use postgresql-simple to send queries. Read the settings object once, then pass it everywhere. You can slowly start writing generic types for your pure code after a while. For example, replace types such as `[t]` with `Functor f => f t` if the only list-related operation done in that function is `map` (fmap). Try to take advantage of the stuff here: https://wiki.haskell.org/Typeclassopedia https://wiki.haskell.org/Typeclassopedia After a while of doing this, you can start looking into how you can write your code in a way to have more generic types, then specialise it for the concrete problems you're solving Finally at this point transformers should become easier and more obvious. Perhaps the first one would be to replace passing the config everywhere with ReaderT. Implementing a few transformers by yourself should help. Start with MaybeT and continue with ReaderT. Tip: `liftIO` magically works but you don't have to always understand how. Maybe also try free monads if transformers seem too annoying!
  - atc 10y ago
    This is a recommendation I would back for people learning Haskell and don't want to get snagged in the weeds like this. I have been programming in Haskell on and off for a year and eventually got the opportunity to write some REST services in it. It required Servant & PostgreSQL and I didn't generify it too much, just used straight IO. I am now "mature" enough with the language to start generify the API a bit more and depend on things like `MonadIO` instead of direct IO usage, which would also enable better unit testing like those described here: https://lexi-lambda.github.io/blog/2016/10/03/using-types-to-unit-test-in-haskell/ https://lexi-lambda.github.io/blog/2016/10/03/using-types-to... Good luck to GP!
lifeisstillgood 10y ago
How bad is it looking at the examples and thinking "I love that lambda symbol as a prompt. I want" I have to revisit my base setup soon. The 1990s wants its bash_profile back
seochang 10y ago
http://sanbatdongsanvinhomes.net/vinhomes-cao-xa-la-smart-city/ http://sanbatdongsanvinhomes.net/vinhomes-cao-xa-la-smart-ci...
cies 10y ago
There are some book recommendations at the bottom of the article, which are missing the (IMHO) latest-and-greatest introductory resource to Haskell: the book Haskell from First Principles. http://haskellbook.com http://haskellbook.com
krautsourced 10y ago
This may sound (and probably is) quite superficial, but I am immediately put off by any language that uses syntax like this: foldr' (+) :: Num t1 => t1 -> [t1] -> t1 Why? Because of things like => and -> are just a pain to write all the time and make you chase all over the keyboard, even more so on non-english keyboards. Just my very personal preference of course, but still...
- dancek 10y ago
  It is quite superficial. Code being easy to read is much more important than code being easy to write. I'm not saying it's a bad idea to have both, but look at Java or C# that are a pain to write without a very smart IDE (just because of the amount of boilerplate). Even they have been saved by tooling. Also, modern popular languages tend to use arrows (Java, C#, ES6). Not to say that popularity matters, but people are used to it nowadays.

157 points by def- 10y ago

Nice link. One related question : where have you used Haskell in real life. Do some top companies use Haskell to solve problems

wuschel 10y ago
I second this question and would like to add another one: Where is it that Haskell shines?
- sa1 10y ago
  This State of the Haskell Ecosystem doc[1] is very informative. If you're looking at application domains, Haskell(and OCaml etc) is usually well suited for writing compilers, but its not bad for your usual server-side application either. The only domain its fundamentally unsuited for is systems/embedded programming. [1]: https://github.com/Gabriel439/post-rfc/blob/master/sotu.md https://github.com/Gabriel439/post-rfc/blob/master/sotu.md
  - initram 10y ago
    My impression from having tried it briefly is that it's not great at real-time stuff because of its lazy evaluation. Do you find that to be true, or is that not an issue in real life?
    - sa1 10y ago
      Lazy evaluation does make understanding performance/memory behavior hard, but usually you'll be using pipes/conduit/machines instead of lazy lists in production code, so its not much of an obstacle for real-time behavior. However GHC's garbage collector can be an issue for real-time code, having high 99th percentile latencies.
- jfoutz 10y ago
  There are a bunch of fussy little problems that Haskell solves nicely. One example is looking up a value in a map map.get("foo") // returns null is the value of the key null, or was there no key? Different languages have different approaches. Haskell let's you build up deep structures, a list of maps of list of maps ... and you'll have an indication of what path you took down the data structure to get a result. You can do this in any language, but it relies on programmer discipline, and everybody doing it the same way every time. In Haskell, it's the easy thing to do, and often the only way to do it. You'll wind up with something like [Just ["foo"], Just ["bar"], Nothing] The first two maps had once answer each, the final map had nothing. Laziness means you have control of the order of evaluation. in practice you can make your own control structures without macros. bracket is a good example, bracket open_socket do_stuff close_socket the socket always gets cleaned up, with an ordinary function. No try/catch. One of the biggest hassles in programing is leaky abstractions. The type system means you can steal abstractions from mathematicians that just don't leak. There's some good stuff here [1] about the kinds of things you can say. Purity means values can't change behind your back. there's no function to call that'll change the state of some object you're working with. All together, it's nice for languages. You can build up parse trees any way you wish, and traverse those trees to execute the semantics. So if you can think of a dsl for your problem, you can whip up an interpreter pretty quick. If you change your mind, and want to turn it into a compiler, it's relatively painless. It's a fun language. [1] https://wiki.haskell.org/Typeclassopedia https://wiki.haskell.org/Typeclassopedia
  - z1mm32m4n 10y ago
    I'm writing a compiler in Haskell for a university class this semester. I don't think "painless" is the word I would use to describe it. Would you care to elaborate on your thoughts here?
    - bbcbasic 10y ago
      You're writing a compiler! It won't be painless in any language.
    - Athas 10y ago
- harpocrates 10y ago
  For me, I think the answer to this is really that Haskell is pure and immutable. Equational reasoning[1] is immensely useful when debugging. It isn't unusual to debug pieces of Java code that look like this. MyClass c = new MyClass(..); c.method1(..); c.method2(..); c.method3(..); assert(c.someField == ..) // fails! To figure what went wrong, you have to read through all three methods and depending on whether you have dynamic dispatch coming into play, you might need to read through _multiple_ versions of all three methods. [1]: http://www.haskellforall.com/2013/12/equational-reasoning.html http://www.haskellforall.com/2013/12/equational-reasoning.ht...
- marcosdumay 10y ago
  Haskell shines at large codebases. It shines in a lot of other domains, but there's no mainstream competitor on dealing with messy, badly defined, big, changing problems. Haskell shines on refactoring, API designing, and constrain setting (want to enforce safety? atomicity? thread ordering?). As a bonus, it'll also reduce your codebase an order of magnitude or two. I mean, yes, if you never wrote a complex parser on Haskell, you should try. But that won't change your life too much.
  - bertiewhykovich 10y ago
    Haskell and its advocates talk a big, big game about its supposed strengths in these areas, but there are suspiciously few examples of these strengths actually manifesting in anything but toy or academic projects. I've been hearing about Haskell's supposed miracles for years and years, and I've never, never seen them.
    - chongli 10y ago
      Then you haven't been paying much attention to Haskell which can be forgiven because it's still pretty niche compared to Python or JS. The best example I can give you is the Haxl project at Facebook [0]. [0] https://github.com/facebook/Haxl https://github.com/facebook/Haxl
      - bertiewhykovich 10y ago
        Haxl is one of the standard two or three examples. I want to see a non-Haxl example.
    - iLemming 10y ago
      Many things that emerged at Facebook during recent years can be attributed to the influence of Haskell. React, Immutable.js, GraphQL, etc. Haskell is extremely powerful but allow me to rephrase Euclid "There's no royal road to functional programming". If you want something more pragmatic, yet still quite expressive and powerful - try Clojure and Clojurescript. Especially Clojurescript - it's probably one of the best languages out there to use for front-end and mobile app development.
- imh 10y ago
  Haskell is very strict in what the compiler allows you to do where. It's a really great alternative to just requiring developer discipline. It means that you can do some things (like refactoring) with much greater confidence because the compiler rules out some big classes of bugs. Same with using other people's libraries. You can only use them certain ways and they are explicit. A side effect of being so strict (in the sense of picky) about what is allowed where is that it needs some really powerful abstractions to keep that from slowing you down. Its type system shines here. Often, these abstractions have a nice syntax in haskell and it makes for some really clean code, relative to a direct translation in other languages.
- FullyFunctional 10y ago
  I've loved Haskell for decades, but not yet had a chance to use it to pay bills. IMO, Haskell, more than any of the 1e3+ other PLs I know, shines in enabling 1) elegant and 2) robust ("better bugs") solutions. Elegance comes from the non-strict functional part, enabling succent and modular implementations. Robustness comes from the static typing which forces you to be explicit about the range and domain of functions. What's unique about Haskell is that the type system is _very_ expressive, making this a practical approach. IMO, the type system is absolutely key to Haskell. Where Haskell disappoints: Int. For reasons that I still cannot phantom, someone chose to infest a beautiful language that is almost free of pitfalls with the atrocity of a "C-like" Int type. Indeed, in Haskell, this isn't always true: a < a + 1 where a :: Int which is a real shame IMO. It fails the largest value of Int (which BTW is implementation dependent). The correct answer would either to have (my preference) Int == Integer, that is arbitrary sized integers always, or at the _very_ least, have (+) fail on overflow, that is, return bottom like head [].
- startling 10y ago
  Writing parsers is really nice in Haskell: http://www.cs.nott.ac.uk/~pszgmh/pearl.pdf http://www.cs.nott.ac.uk/~pszgmh/pearl.pdf Trifecta is a nice modern parsing library: https://hackage.haskell.org/package/trifecta https://hackage.haskell.org/package/trifecta
ianleeclark 10y ago
https://code.facebook.com/posts/745068642270222/fighting-spam-with-haskell/ https://code.facebook.com/posts/745068642270222/fighting-spa... This goes into detail about how Facebook uses haskell to fight spam. There's a talk that goes alongside it and the talk was one of the motivating factors for me to start learning Haskell.
samcal 10y ago
Yes, but only recently. The most notable example in a top company is Facebook's spam detection service, powered by their library called Haxl[0]. The language allows some very skilled programmers to build this library that makes it very easy to write spam rules. Lower-level engineers can then write very simple and elegant code that looks sequential but is automatically parallelized by the library. The service is a big deal, because every action or request that anyone makes on Facebook touches this service. [0]: https://code.facebook.com/posts/302060973291128/open-sourcing-haxl-a-library-for-haskell/ https://code.facebook.com/posts/302060973291128/open-sourcin...
- dorfsmay 10y ago
  Facebook is the new FedEx. Name a technology, Facebook's probably using it!
- ppcsf 10y ago
  It's interesting that you said the Haskell allows programmers to build Haxl, with the implication being that other languages would disallow it. I wrote a port of Haxl to C#[0]. At this point one might expect me to recite the whole Turing-completeness-means-all-languages-are-the-same banality, but my experience porting Haxl has actually led me to the opposite opinion. Haxl probably wouldn't have been written in any other language other than Haskell. Because Haxl leans so heavily on concepts that other languages have no words for, I think it's inexpressible in C#, or most other mainstream languages. Obviously not literally inexpressible (there's an existence proof of a C# Haxl) but in an Orwellian, "these concepts are unthinkable in other languages" sort of way. [0]: https://github.com/joashc/HaxlSharp https://github.com/joashc/HaxlSharp
sa1 10y ago
Standard Chartered has some 3 million lines of Haskell, but they don't use GHC, they have their own internal compiler.
- tome 10y ago
  About one million of those lines are actually compiled with GHC and about two million with Mu (or at least that was roughly accurate last time I checked).
bbcbasic 10y ago
Yes http://ambiata.com/ http://ambiata.com/
bertiewhykovich 10y ago
This question gets asked regularly, and every time Facebook's spam detection service, Standard Chartered's (never-seen) codebase, and maybe one or two other firms that no one's ever heard of get invoked. These are seemingly the only examples.
- spraak 10y ago
  Facebook references all over this thread and literally the comment below yours is in regard to Standard Chartered :D
- tome 10y ago
  Barclays Capital: http://neilmitchell.blogspot.co.uk/2016/09/full-time-haskell-jobs-in-london-at.html http://neilmitchell.blogspot.co.uk/2016/09/full-time-haskell...
- sa1 10y ago
  Since when is visibility expected from corporate codebases?
tikhonj 10y ago
I'm currently using Haskell to do supply chain optimization at Target. It's pretty awesome! The language lets us express our models in ways that feel natural. We're both solving some specific problems (ie inventory control, network/transport optimization) and building a pretty general framework for expressing, analyzing and solving large stochastic optimization problems. Haskell is a great fit because it's extremely expressive and lets us write and reason about our problems in a natural, expressive way. It helps that we have a very mathy team in a mathy field :). Our team also has a bunch of people with programming language research backgrounds, and our long-term remit is to apply programming language ideas to operations research. Turns out that—for a whole class of PL problems and PL people—Haskell is the perfect language :). I also know people use Haskell at Facebook (already mentioned), Google (Ganeti and some unnamed X project), a few banks (JP Morgan, Barclays and Standard Chartered) as well as a whole bunch of startups and small companies.
pea 10y ago
We're a startup in London (shameless plug: www.nstack.com) using Haskell to develop a containerised microservices platform, bringing in lots of low-level Linux coding along with high-level concepts such as typed DSLs. So far it's working extremely well for us and has been a great decision - letting us build complex/reliable systems really quickly and effectively. It is also very good for attracting amazing people, and we have found a small Haskell team can deliver truly spectacular product. This does on how you architect a Haskell codebase: e.g. you could spend a ton of time focusing on the most pure approach vs. pragmatism, so it's a balancing act.
cx1000 10y ago
kittyhawk has an opening for a full time Haskell software engineer https://kittyhawk.aero/ https://kittyhawk.aero/
deleted 10y ago
[deleted]
eli_gottlieb 10y ago
Well, someone seems to show up to Boston Haskell every month having used it in industry, and I've used it for a paper on probabilistic modelling in my copious free time.

sa1 10y ago

That's not really the Sieve of Eratosthenes. The list data structure is not well suited for the algorithm. See [1] for a proper discussion. As someone who wants to write Haskell(and loves it) for code with mathematically well defined guarantees, the propagation of such examples, where the guarantees or behavior is not clear to the author, is not helpful. [1]: https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf https://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf

harpocrates 10y ago
Cannot agree more. I think the usual example of quicksort also falls under this category. [1]: http://stackoverflow.com/questions/7717691/why-is-the-minimalist-example-haskell-quicksort-not-a-true-quicksort http://stackoverflow.com/questions/7717691/why-is-the-minima...
pera 10y ago
It's the same example displayed in haskell.org though.
- seagreen 10y ago
  Totally fair point. haskell.org has a very . . . casual approach to presenting the language. It's been such an issue some people made an alternate homepage at haskell-lang.org.
kmill 10y ago
Or if Python's your thing: http://www.kylem.net/stuff/sieve_eratosthenes.html http://www.kylem.net/stuff/sieve_eratosthenes.html

kinkdr 10y ago

Started learning Haskell just a couple of weeks ago. My only complaint with the language so far is that I cannot have the same name for a field in two records in the same module. Other than that it is amazing the confidence it gives me; if it compiles it works (r).

sdegutis 10y ago
This may help you: https://www.reddit.com/r/haskell/comments/2z248l/language_extensions/ https://www.reddit.com/r/haskell/comments/2z248l/language_ex...
- kinkdr 10y ago
  Thanks!
harpocrates 10y ago
If you are using GHC, the newest version (8.0.1) actually supports duplicate record fields with the [DuplicateRecordFields](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#duplicate-record-fields https://downloads.haskell.org/~ghc/latest/docs/html/users_gu...) extension. Check it out!
- kinkdr 10y ago
  Ahh awesome! Thanks!
- pyrale 10y ago
  Nice ! Does it work well with lenses ?
  - rfergie 10y ago
    So you can do something like this: data Foo = Foo { _bar :: String } data Buzz = Buzz {_bar :: String} And derive lenses? I think it doesn't - this is more than just a duplicate record name, you also end up with a duplicate `bar` lens

jjawssd 10y ago

How difficult is it in your experience for developers to learn Haskell while on the job?

chadaustin 10y ago
In my experience at IMVU, surprisingly not very difficult. It's easier to learn Haskell in a team environment than on your own because your peers can help you connect the dots and accomplish your task at hand. It did seem like less experienced people picked it up faster, perhaps because they had less to unlearn. The hardest things were learning to parse GHC's error messages and learning all of the names of the functions to transform between various data types.
evincarofautumn 10y ago
I basically learned Haskell at my first job (writing a compiler), and it was pretty easy to productively contribute starting on day 1, especially because there seems to be less risk of breakage than in many other languages. I also helped teach it at the next job, and developers found it pretty easy to pick up, just different from what they were used to. Prior to this, I had some experience using it for hobby projects, but there was a lot more to learn for real-world use. My colleagues and I helped each other learn new concepts and write better code, as best we could, but we did end up making some questionable design decisions. I think you still need an experienced Haskeller to advise on good program architecture.
- andrewchambers 10y ago
  Compilers are a bit easier to start with because you can just deal with pure functions for the majority of the time
  - evincarofautumn 10y ago
    You can, but that’s not to say we did, haha. One of the aforementioned questionable design decisions.

Dzugaru 10y ago

Don't know about Haskell, but what really got me (a long time CSharp programmer) into functional programming was this awesome site [1] (and a man behind it with his awesome talks) - which is focused on core aspects of FP (applicable in most languages nowadays) in real-world applications. [1] https://fsharpforfunandprofit.com/ https://fsharpforfunandprofit.com/

shados 10y ago
I love that site. The best part about it is that it gives you all of the common names for stuff like category theory concepts. Eg: the various ways map, flatMap, bind, etc are called across languages. Because its a pain in the ass to learn those concepts from scratch when you're looking at code in one language but reading a tutorial in another...the concepts are language agnostic, the naming conventions however are not.

KennyCason 10y ago

I love Haskell, but if you hate Java, but still want to leverage the nice Java ecosystem, (libs, IntelliJ, JVM, tooling, etc) try Kotlin! :) https://kotlinlang.org/ https://kotlinlang.org/

mahyarm 10y ago
Does kotlin have the same compile time, binary size and IDE indexer choking issues as Swift? I've heard that it has similar problems. I would not use Kotlin for a large project if that is the case.
- KennyCason 10y ago
  I used Kotlin for basically all of our machine learning/classifier code in a pretty large map/reduce + storm pipeline and have had no problems. IntelliJ also does not seem to have any problem with it either. (The IntelliJ authors being the the creator of Kotlin) In terms of code size, Kotlin is definitely smaller and easier to maintain. In terms of raw/clean compile speed, I would expect it to be a bit slower, but there are ways to improve it. One of the bigger ways is via incremental builds. I.e. Only build changed chunks of code, which Kotlin supports, and is comparable to, and in some cases faster than Java: https://medium.com/keepsafe-engineering/kotlin-vs-java-compilation-speed-e6c174b39b5d https://medium.com/keepsafe-engineering/kotlin-vs-java-compi... In terms of executable size, I don't have good data, but will investigate, but I'd say likely not a major deterrent given all the other value adds. :)
  - mahyarm 10y ago
    So how long would a generic heavy 100 kloc project take to compile? Full compile and changing one 200 line library file used by 1/4th of the project?
    - KennyCason 10y ago
      I don't know. The experiments in the post only shows a limit set of examples. My hunch is that if you are using a modern compiler/IDE, you will not be coding -> compiling -> running that frequently. I typically code a lot before I actually actually run anything, so I'm not usually waiting around on a compiler. I don't even notice, at all, Java's incremental compilation when coding in IntelliJ. I refactor like a madman. Also, Kotlin is not very ambiguous, and the type inference that it does enable does not escape the scope of a function so the compiler doesn't have to do that much work. (functions require strict typing). I would guess much of that lambda work gives it a small headache, but probably not that much worse than Java's. If Kotlin grows mainstream, it's already pretty good compiler, will only get better. Of course, that is all a hunch. :)

NotThe1Pct 10y ago

I tried haskell queues a while ago - under the advice of a friend and compared with a straightforward C++ queue - it was about 100x slower. Abandoned the idea.

bbcbasic 10y ago
Let me guess ... you used [a]
- sammoth 10y ago
  What are you implying? What should they have used?
  - tome 10y ago
    The list datatype is horrendously unsuited for being used a queue. They should have used a datatype designed for use as a queue.
  - bbcbasic 10y ago
    There are better pure queue types and STM channels and suchlike that are designed for the job, so if bench-marking then you want to be fair to Haskell and use the right type.
59nadir 10y ago
You should do a write-up on it and show your tests. As it stands, this post has almost no real value for anyone else and no one knows anything about what you used and how.

TheAceOfHearts 10y ago

I got started with Haskell recently, and I'm really regretting not having picked it up earlier. Most of what I knew about types came from C, C++, or Java; so it's a big leap. I've been using Haskell for Mac IDE [0] while experimenting, and it's been great fun. The thing that prompted me to give Haskell a a try was this video [1] of a guy using Haskell to generate Elm types, in order to maintain consistent types across the stack. This idea captivated my interests. I'm confident that GraphQL and Relay, or something along those lines, is gonna be the future. My experience so far has been that Elixir feels more welcoming and beginner friendly. There's nothing wrong with the Haskell community (or my limited interactions with it so far), but so far it's just felt a bit drier. [0] http://haskellformac.com/ http://haskellformac.com/ [1] https://www.youtube.com/watch?v=sh4H8yzXnvw https://www.youtube.com/watch?v=sh4H8yzXnvw

Matachines 10y ago
Of course Elixir is more welcoming—the language is "practically" functional, easy, and made for building stuff. Haskell's purity and academic background is definitely a big impact on its culture.
- not-much-io 10y ago
  I wish there was a haskell-without-the-warts language with the same culture as Elixir - developer friendliness, practicality etc. As it stands I can't help but feel discouraged when learning Haskell. Haskell feels like a research tool for furthering other programming languages... I'm still going to learn Haskell, promised myself I would! But I do look to the Elixir folk with a bit of jealousy..
acchow 10y ago
If you delve deep enough into C++ TMP, it's just as expressive (more expressive in some ways) as Haskell. You can actually do dependent types in C++.
- yyhhsj0521 10y ago
  You can, but would you?

mahyarm 10y ago

I really want to warn people from using long-to-compile languages in big projects. And by long, I mean longer than C++. From what I heard Haskell has compile time issues. You will regret it once your in that position and it is hard to get out of once your there.

dkubb 10y ago
It's a common misconception that Haskell is slow to compile but not really true, see for example: http://www.shimweasel.com/2016/10/24/fast-tests-and-static-languages http://www.shimweasel.com/2016/10/24/fast-tests-and-static-l...
- mahyarm 10y ago
  That feels like a limited optimization in the context of practical development.
- Athas 10y ago
  I guess it depends on your expectations. I'm working on a ~38000 SLOC Haskell program (an optimising compiler: http://futhark-lang.org http://futhark-lang.org), and with GHC 8.0.1, a full build takes about 7 minutes. I can cut off a minute or two by passing `--fast` to Stack. However, even small incremental builds take a significant amount of time due to linking, which is what annoys me the most. It's still far from making me disavow Haskell, but it's definitely not among the fastest-compilable languages. This program is also too big to load in GHCi, at least on my laptop with 8GiB of memory.
  - mahyarm 10y ago
    That's pretty uncanny, swift has a fairly sloc to time ratio too. The memory usage although is significantly less.
- mbrock 10y ago
  No, it's a very common issue brought up within the community that GHC takes a lot of time and memory. That blog post just says that interpreting Haskell can be faster than compiling. I worked with Haskell professionally on a pretty large codebase. It was split up into many separate libraries and binaries. There were a lot of coffee breaks when recompiling. https://www.reddit.com/r/haskell/comments/45q90s/is_anything_being_done_to_remedy_the_soul/ https://www.reddit.com/r/haskell/comments/45q90s/is_anything...

agentgt 10y ago

As for the Java bashing in the beginning I'm not saying Java is anywhere near the expressive power of Haskell but many people think different things based on Java because of features they either don't know about, outdated libraries used, or experiences with older versions and codebases. For example most don't know that Java actually does have macro like capabilities through APT (annotation processor that will work automagically I might add). Some might say ewww its not macros but then again annotation processing might just be 80/20 good enough (aka what OCaml learned with ppx vs camlp) and that Java now sort of has traits and that its code swapping is actually fairly good (jrebel). There are even sadly people that don't know Java has lambdas, and even some (usually C++ dudes) that don't know it has generics. Most don't even know that you can combine interfaces with generic types as in: `<T extends Comparable & Serializable> void someFunc(T t)`. Yes Java is not Rust, Haskell or even OCaml in expressiveness but it certainly is more powerful than Golang and definitely compiles fast (albeit starts up slow). That being said OCaml is still my favorite. Compiles fast and easier for me to understand. Super mature and lots of companies use it.

iLemming 10y ago
It's not Java what makes Java platform one of the most popular but rather JVM. That's why Clojure grows in popularity. Because it brings the expressiveness.
- oweiler 10y ago
  Please show me how Clojure is growing in popularity. Clojure has never been more than a niche language.
  - ardacinar 10y ago
    A language can grow in popularity while still remaining a niche language. Haskell is a very good example of that, but I really can't say the same thing about Clojure.
    - adrianN 10y ago

xamuel 10y ago

I taught myself Haskell because people say it improves you as a programmer. I didn't see that, but I have a math PhD so maybe I'm just too familiar with abstract types to gain new insight from Haskell. As a language, it's sterile. You can tell it was designed by committee.

dorfsmay 10y ago
Are you still using it? If not, what did you switch to for expressive, "fast" (faster than python) language?
- xamuel 10y ago
  No not still using it. I use C or q (as in kdb+) when I want speed and expressiveness. Python if I want quick easy prototypes. If you think Haskell is a weird language that challenges what you think about programming, it's nothing compared to q! :)
  - dorfsmay 10y ago
    Not looking for a challenge, it's more like python is often too slow, and it spoiled me, I find every other language too verbose and missing expressiveness. I've started looking at Haskel as the possible solution here.
the_af 10y ago
> As a language, it's sterile. You can tell it was designed by committee. This remark is puzzling. How do you tell if a language is sterile?
- xamuel 10y ago
  Hard to put a finger on it but it lacks a certain "playfulness" which real-world languages have. It's like the difference between Lojban/Esperanto (artificially constructed spoken languages) and English/Spanish. English/Spanish are "imperfect" but their warts are the results of thousands of years of culture (and may not be imperfections after all, they may be a case of some kind of coding theory emerging organically)

joobus 10y ago

I've spent quite a bit of time with Haskell, and all the beginner text like this link are easy to grok, but where I've constantly come up short is trying to write an app with, for example, a configuration and a database connection. Having multiple levels of Monad transformers just confuses me and I never get anywhere useful. Something like: App MaybeT IO (StateT IO (EitherT IO Text SomeRecord)) Or something. I haven't figured this out.

spion 10y ago
Use IO for everything at the beginning. Use wai/warp to run an app directly and setup handlers. Use postgresql-simple to send queries. Read the settings object once, then pass it everywhere. You can slowly start writing generic types for your pure code after a while. For example, replace types such as `[t]` with `Functor f => f t` if the only list-related operation done in that function is `map` (fmap). Try to take advantage of the stuff here: https://wiki.haskell.org/Typeclassopedia https://wiki.haskell.org/Typeclassopedia After a while of doing this, you can start looking into how you can write your code in a way to have more generic types, then specialise it for the concrete problems you're solving Finally at this point transformers should become easier and more obvious. Perhaps the first one would be to replace passing the config everywhere with ReaderT. Implementing a few transformers by yourself should help. Start with MaybeT and continue with ReaderT. Tip: `liftIO` magically works but you don't have to always understand how. Maybe also try free monads if transformers seem too annoying!
- atc 10y ago
  This is a recommendation I would back for people learning Haskell and don't want to get snagged in the weeds like this. I have been programming in Haskell on and off for a year and eventually got the opportunity to write some REST services in it. It required Servant & PostgreSQL and I didn't generify it too much, just used straight IO. I am now "mature" enough with the language to start generify the API a bit more and depend on things like `MonadIO` instead of direct IO usage, which would also enable better unit testing like those described here: https://lexi-lambda.github.io/blog/2016/10/03/using-types-to-unit-test-in-haskell/ https://lexi-lambda.github.io/blog/2016/10/03/using-types-to... Good luck to GP!

lifeisstillgood 10y ago

How bad is it looking at the examples and thinking "I love that lambda symbol as a prompt. I want" I have to revisit my base setup soon. The 1990s wants its bash_profile back

seochang 10y ago

http://sanbatdongsanvinhomes.net/vinhomes-cao-xa-la-smart-city/ http://sanbatdongsanvinhomes.net/vinhomes-cao-xa-la-smart-ci...

cies 10y ago

There are some book recommendations at the bottom of the article, which are missing the (IMHO) latest-and-greatest introductory resource to Haskell: the book Haskell from First Principles. http://haskellbook.com http://haskellbook.com

krautsourced 10y ago

This may sound (and probably is) quite superficial, but I am immediately put off by any language that uses syntax like this: foldr' (+) :: Num t1 => t1 -> [t1] -> t1 Why? Because of things like => and -> are just a pain to write all the time and make you chase all over the keyboard, even more so on non-english keyboards. Just my very personal preference of course, but still...

dancek 10y ago
It is quite superficial. Code being easy to read is much more important than code being easy to write. I'm not saying it's a bad idea to have both, but look at Java or C# that are a pain to write without a very smart IDE (just because of the amount of boilerplate). Even they have been saved by tooling. Also, modern popular languages tend to use arrows (Java, C#, ES6). Not to say that popularity matters, but people are used to it nowadays.