7 ms·
As a guy who casually (definitely not in-depth) reviewed working with Haskell about 2 years ago I'd say the most relatable part of the article to me is: complex
by pdimitar 6y ago
As a guy who casually (definitely not in-depth) reviewed working with Haskell about 2 years ago I'd say the most relatable part of the article to me is: complexity in tooling and unnecessary tension when working with libraries. Also the String situation (several types of them).
A lot of the other points could be addressed but the community's seeming unwillingness to tackle everyday productivity sends to me the message: "Keep out!". :(
As a comparison, Elixir's Mix and Rust's Cargo are amazingly ergonomic build systems and provide all the tooling you need to work with the languages and your projects.
And hey, don't kill me. As I said, I reviewed it casually for several days while comparing it with Rust and OCaml. They aren't the easiest to start with either but Rust's tooling is excellent, OCaml's is also excellent but not immediately obvious (their docs have improved a lot), and Haskell's is... kind of there, as the article points out.
- bjz_ 6y ago> OCaml's is also excellent but not immediately obvious (their docs have improved a lot) Interesting! The last time I tried OPAM, it actually seemed more frustrating than Cabal! Maybe it's improved? Last time I tried OPAM it would install packages globally by default, and avoiding that was a confusing process, when that should be the default behavior. Cargo (while not perfect) has really nice defaults out of the box - ie. it generates a lockfile by default, scopes packages locally to individual projects, and lets you use more than one package of the same version in the same project. Really hoping OCaml and Haskell can improve their package management story - they are getting there, but it still holds me back from really using them on a daily basis.
- pdimitar 6y agoI got told some months ago to look for these docs: https://news.ycombinator.com/item?id=22395595 https://news.ycombinator.com/item?id=22395595 It seems all we want can be made to work but it does require some tinkering and being aware of the tools' options.
- ghostwriter 6y ago> Really hoping OCaml and Haskell can improve their package management story - they are getting there, but it still holds me back from really using them on a daily basis. Cabal 3.x with Nix-style buildscovers all packaging needs that I ever had with Haskell ecosystem[1]. And there's a new wave of tooling based on incremental Nix builds, that you can begin using today [2] [1] https://cabal.readthedocs.io/en/latest/nix-local-build-overview.html https://cabal.readthedocs.io/en/latest/nix-local-build-overv... [2] https://github.com/nmattia/snack https://github.com/nmattia/snack
- bjz_ 6y agoYeah, it's really great to see the progress there. However, afaik, it still doesn't freeze packages by default, or let you have multiple packages of the same version in a dependency tree[1]. The former can be worked around, but it's annoying that it's not the default. The latter is more frustrating however! [1] https://news.ycombinator.com/item?id=23454711 https://news.ycombinator.com/item?id=23454711
- lallysingh 6y agoStack does this, if I understand what you're saying. Stack+nix has worked quite well for me for a few projects.
- marcosdumay 6y agoYep. Cabal 3.x is great, better than anything else I've seen for any other language. As the article says, it just needs to correct the default behavior (deprecating the old behavior is on the roadmap, interestingly, the documentation doesn't even say what is the standard right now) and some improvements on usability (just better docs goes a long way).
- nextos 6y agoA bit off topic, but is Haskell viable for production? Or is it just really intended as an experiment? Is it worthwhile to jump into Haskell now, or perhaps one should look into Idris or Agda? Any companies using Haskell where it has proven a distinct advantage? Ocaml and SML (the former being sadly quite unpopular these days) are an order of magnitude simpler than Haskell. They are easy to master. I have been quite productive with Scala which, while being a member of the ML family, is much more intricate due to OO + FP on top of great Java interop and many Haskell-like features (laziness, monads, lenses...). Haskell doesn't feel the same. I have learned some Haskell over the years. Since I come from a pure FP education (started with SML) and I have lots of type theory background, everything feels familiar, yet I've found it really hard to be productive or to justify the mental overhead of laziness. I have developed some small projects in Haskell, but I haven't found it a productive alternative to the languages above.
- the_af 6y ago> A bit off topic, but is Haskell viable for production? Or is it just really intended as an experiment? It's viable for production and there are businesses which use it, notably fintechs. Also Facebook for some things (Facebook employs Simon Marlow [1]). And I know this is an irrelevant anecdote, but I have a friend who has been working in several startups which use Haskell for the last few years. Like Paul Graham has argued of Lisp, Haskell really is a "secret weapon" and people who use it for production tend to love it. EDIT: a prior version of this post claimed Facebook employed Philip Wadler, which is incorrect. Sorry! I got my wires crossed and confused Philip Wadler with Simon Marlow! [1] https://www.linkedin.com/in/simonmarlow/ https://www.linkedin.com/in/simonmarlow/
- auggierose 6y agoFacebook employs Wadler? Since when?
- the_af 6y agoGah! I meant to say Simon Marlow [1], co-developer of the Glasgow Haskell Compiler (GHC) [2]. Sorry for the confusion, I'll edit my other post now. [1] https://www.linkedin.com/in/simonmarlow [2] https://en.wikipedia.org/wiki/Simon_Marlow
- Erlangen 6y agoPackages are not installed globally in opam by default nowadays. `opam switch` "enables the user to have several installations on disk, each with their own prefix, set of installed packages, compiler version, etc". https://opam.ocaml.org/doc/Usage.html#opam-switch https://opam.ocaml.org/doc/Usage.html#opam-switch
- bjz_ 6y agoOh that's nice to hear! Some questions: Do you have to run this command manually, and does it mutate the shell state? That's one thing that frustrated me with opam in the past as well. I couldn't just jump into a directory and build a thing, then switch to another project directory - there was a lot of manual switching and unswitching of packages if I recall correct? Is it possible to install multiple tools globally using opam that use disjoint library versions? Like, I might want to install Abella and Coq side-by-side, but they might have conflicting version requirements. I think I was super excited about opam 2, then tried installing one thing, only to have it break again when I installed something else. Is it possible to have multiple versions of the same libray in the same project, or does the constraint solver need to find a single solution for each library? [1] [1] https://news.ycombinator.com/item?id=23454917 https://news.ycombinator.com/item?id=23454917
- Erlangen 6y agoSorry I miss your reply. I create opam switches to have different versions of compiler, or allow libraries that conflict to live at different branches. 1. Dune is a relative new build system for Ocaml. You just write a configuration file, and dune will handle switches automatically. "It also supports multi-context builds, such as building against several opam roots/switches simultaneously. This helps maintaining packages across several versions of OCaml and gives cross-compilation for free." See https://opam.ocaml.org/packages/dune/ https://opam.ocaml.org/packages/dune/ 2. Yes. You can can multiple versions library at different switch. 3. I am not sure.
- talex5 6y agoBy default, opam installs everything into the current "switch". Typically you have switch one per compiler, but you can create one per project. You can also create a "local" switch directly inside your project directory: https://opam.ocaml.org/blog/opam-local-switches/ https://opam.ocaml.org/blog/opam-local-switches/ Another option is to use the duniverse tool (https://github.com/ocamllabs/duniverse https://github.com/ocamllabs/duniverse). That downloads all dependencies to the project directory, and then builds them all together as one giant project. That makes it very easy to make changes across multiple libraries at once, while keeping fast incremental builds. And a final option is to build projects with Docker, which allows you to have separate versions of non-OCaml packages too.
- bjz_ 6y agoAhh cool - had some similar questions here: https://news.ycombinator.com/item?id=23460980 https://news.ycombinator.com/item?id=23460980 - mainly, how much manual switching do you have to do? Or is it seamless, depending on what project directory your in? I think I tried the local switches in the past and got really confused when switching projects and everything broke, thinking 'wasn't all this meant to prevent this?'.
- andrepd 6y agoMaybe you tried it before v2? Imho opam now is very usable, lets you be productive for 95% tasks after reading a 5min introduction, and generally gets out of your way.
- ghostwriter 6y agoIt is in your interest to have multiple string-like datatypes in a lazy language, especially when some of them are not real strings, but rather streams of binary data. https://mmhaskell.com/blog/2017/5/15/untangling-haskells-strings https://mmhaskell.com/blog/2017/5/15/untangling-haskells-str...
- pdimitar 6y agoSure, same as Erlang has "binaries" (which can be C strings or literally any binary data as you said) and Elixir built on top of that to give us UTF-8 strings. But, you know, only these two. No more. I quite dislike when languages start choking me with analysis paralysis. There have to exist sensible defaults!
- ghostwriter 6y agoErlang is not lazy by default. If it were you'd like to have at least two more types being generally available in its standard library.
- chriswarbo 6y agoI agree, although the arguments in that article aren't the strongest. In particular: The main reason given for 'String' being slow is that it's immutable and hence leads to many duplicate Strings being created. In fact, the main reason Strings are slow is that their linked-list structure has a lot of overhead, and may be scattered around in memory. For example, the String "abc" will be represented something like this: +---+---+ +---+---+ +---+---+ | * | *---->| * | *---->| * | *---->[] +-|-+---+ +-|-+---+ +-|-+---+ | | | V V V 'a' 'b' 'c' Those arrows are pointers, which can point to locations arbitrarily far away. From this we can see that just storing a (fully evaluated) String is expensive, since each character requires a pair of pointers (in addition to the unique characters themselves). Processing the contents of this String is also slow, since we need to dereference two pointers for each character (one to get the character, one to get the tail of the String). Since the data may not be contiguous in memory, this can make poor use of the CPU caches, which might otherwise speed up these dereferences. Compare this to a C-style string, which would look like this in memory: +---+---+---+---+ | a | b | c | 0 | +---+---+---+---+ This "packed" representation requires no long-distance dereferencing, the memory is contiguous so it will make good use of the cache, and we can process the characters directly without having to chase pointers. That article describes the ByteString type as a "list of Word8 objects", but that's a bit misleading. Firstly we often say "list" to mean a chain-of-pointers like the first diagram above, e.g. that's exactly what Haskell's built-in list type is, and Haskell's String is such a list. ByteStrings store their Word8 objects more like the second diagram, so it would be better to call them an "array of Word8 objects". Secondly, ByteStrings use a clever three-layered structure to speed up common operations: - The raw Word8 characters are stored in arrays, like the C-style string above (but without the NUL byte at the end) - These arrays are pointed to by values called "chunks". These are "fat pointers", i.e. they also store a length and offset value. - A ByteString itself is a list of chunks (like the first String diagram, but instead of values like 'a', 'b' and 'c' the values are chunks). This makes ByteString really fast, for three reasons: - Some operations can be performed by just fiddling at the list-of-chunks level. For example, to append X and Y, the result is just a list of X's chunks followed by Y's chunks; no need to touch the underlying chunks or arrays. - Some operations can be performed by just fiddling the length and/or offset of a chunk. For example, incrementing a chunk's offset will chop characters off the start (they're still stored in memory, but they will be ignored); decrementing a chunk's length will chop characters off the end. - The same underlying Word8 arrays can be pointed to by many different chunks in many different ByteStrings; i.e. we rarely need to copy the actual characters around. As an example, let's say we read the ByteString "[\"foo\", \"bar\"]" (without the backslashes), we parse it as JSON to get a list of ByteStrings ["foo", "bar"], then we concatenate that list to get the single ByteString "foobar", here's how it might look in memory: BS--+---+ BS--+---+ "foobar": | * | *---->| * | *---->[] +-|-+---+ +-|-+---+ | | +----+ +----------------+ | | | List+---+ List+---+ | ["foo", "bar"]: | | * | *------->| * | *---->[] | | +-|-+---+ +-|-+---+ | | | | | | | | | | | | | | V V | | BS--+---+ BS--+---+ | "foo" and "bar": | | * | *---->[] | * | *---->[] | | +-|-+---+ +-|-+---+ | | | | | | | +---+ | | | | | V V V V Chunk---+---+ Chunk---+---+ (chunks) | 3 | 2 | * | | 3 | 9 | * | +---+---+-|-+ +---+---+-|-+ | | BS--+---+ | | Input: | * | *---->[] | | +-|-+---+ | | | | | V | | Chunk+---+---+ | | (chunk) | 14 | 0 | * | | | +----+---+-|-+ | | | | | | | | | | | V V V Array---+---+---+---+---+---+---+---+---+---+---+---+---+ (array) | [ | " | f | o | o | " | , | | " | b | a | r | " | ] | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+ (Note that the exact position where arrows "land" doesn't matter; they're pointing to the entire datastructure they "hit") Here we can see that there's only one copy of the underlying text; that the substrings 'foo' and 'bar' are simply chunks with length 3, offset by appropriate amounts; and that the resulting 'foobar' ByteString is just a list of these two chunks. This approach of "store things once, then do all processing with indices" can be very fast (even faster than C in some cases https://chrisdone.com/posts/fast-haskell-c-parsing-xml https://chrisdone.com/posts/fast-haskell-c-parsing-xml ). Whilst we can obviously write this sort of algorithm in any language, re-using arrays and chunks like this relies on them being immutable, which is more idiomatic in Haskell. In particular: - Languages which tend to use mutation aren't well suited to this, since mutating one value can have unforseen consequences to those which are re-using the same components. Copying is safer and more predictable in the face of mutation. - Languages which favour some built-in interface rather than high-level functions may need to copy values in order to comply with these interfaces. In particular, C's array syntax will work for arrays and chunks, but not for the overall ByteString structure (a list of chunks). - If we want NUL-terminated arrays, we'll need to make copies when truncating strings, to avoid the NUL byte overwriting the truncated part. - Re-using values can make it hard to keep track of which parts can be freed. Garbage collection (and other approaches, like linear types, borrow checking, etc.) can make this easier. The difference between lazy and strict ByteStrings is just whether the overall list-of-chunks is lazy (chunks generated on-demand, useful for streaming) or strict (chunks are generated up-front, closer to using one big array, hence potentially faster and more predictable). The Text type is just a ByteString paired with a particular encoding method, e.g. 'UTF-8'. The article you link also talks about fusion, claiming that's why Text (and hence ByteString) is faster, or avoids intermediate allocations. Fusion is great, but care must be taken if we're going to rely on it; e.g. very minor changes to an expression (say, to make debugging easier) can stop things from fusing, greatly changing the compiled code's speed and memory usage. On the subject of fusion, it's worth noting that Haskell's built-in list type is also subject to fusion, often resulting in zero allocation (e.g. generating a list of characters, then counting them, might compile down to a single loop with a single counter variable, and no Chars/Lists/Strings in sight!). Again, it can be tricky to ensure that this happens. One approach is to test for it with something like https://hackage.haskell.org/package/inspection-testing https://hackage.haskell.org/package/inspection-testing
- 2mol 6y agoThe tooling situation has rapidly improved in my opinion, nowadays ghcide [0] (a language server implementation) is really great and easy to set up. I really do hope that not too many people feel like the message is "keep out". In recent years the community has generally strived to be welcoming to beginners and share the excitment of learning Haskell, without the arrogance. The aforementioned tooling improvements were only possible because a bunch of excellent people did exactly what you mention: tackle everyday productivity and pleasantness by improving IDE integration deep into the stack, all the way to the information the compiler makes available to the tooling. If you want to get a fresh impression, ZuriHac [1] is happening (remotely) this weekend, and there is an online class for absolute beginners held by the excellent Julie Moronuki (of haskellbook.com fame). Disclaimer: I'm very biased, because I'm a co-organizer, but I think it will be great fun! [0]: https://github.com/digital-asset/ghcide https://github.com/digital-asset/ghcide [1]: https://zurihac.com https://zurihac.com
- misja111 6y ago>> ghcide .. is really great and easy to set up Honestly, I tried to set up ghcide because I would love to have a good ide for Haskell but stopped because the setup procedure is not easy at all. Or maybe I'm getting something completely wrong? On the link you are giving, there are the following steps: - clone a git repo - run cabal install - test that ghcide is able to load your code (!) Quote: "If it doesn't work, see the hie-bios manual to get it working." - finally integrate it in the ide that you are currently using. I am using IntelliJ IDE with the Haskell plugin and apparently I am out of luck because it is not listed.
- tome 6y ago> finally integrate it in the ide that you are currently using. I am using IntelliJ IDE with the Haskell plugin and apparently I am out of luck because it is not listed. Well, is it an IDE that supports LSP? If so, it should just work. If not, then ghcide won't work with it. Providing a language server is the whole point of what it does!
- 6y ago
- tathougies 6y ago> (several types of them). I find this criticism very bizarre. C++ and C have several different string types, as does python. This comes down to the fact that what programmers think are strings are often not really and vice versa. To be clear, a 'string' is a sequence of characters or glyphs meant for human consumption or that are produced by a human as input. A string is not a sequence of bytes. C++ and C get this really wrong, and we pretend char* or std::string is actually a string, but they're not -- they're sequences of bytes. The best string in C is wchar* and the best string in C++ is std::wstring or even better a string from the ICU library. std::string completely glosses over the various encodings of real strings. Python gets the string situation much better. str is for strings, and bytes is for bytes. str can contain actual human characters, and bytes can't (unless you encode a str to bytes properly). From this perspective, Haskell really has only one string type: Text. ByteString is actually just a sequence of bytes, and it's an accident of history that Roman characters fit into bytes. String is an iterator over human readable characters, akin to str in python or std::wstring::iterator in C++.
- tome 6y agoAnother great comment on this thread which could be a blog post of its own :)
- pdimitar 6y agoYou might find this a bizarre criticism but In Java, Ruby, Elixir, Rust strings are all Unicode with escape hatches for manually handling byte arrays (that could be C strings). In that regard I still find it extremely puzzling that some languages / runtimes still struggle with only giving you two choices: byte arrays and UTF-8 strings. I really don't know what's so hard about it. As mentioned in another comment in this [now pretty big] sub-thread, this is one of the things I found off-putting in OCaml which is otherwise an excellent language. As for Haskell, it has been about 2 years since I last looked at it. I might be spoiled by the languages I enumerated but I just found the docs [at the time] lacked proper nuance to give you a way to immediately make a choice. Dunno. It's not only the strings though; Haskell's community focuses so much on certain aspects that basic ergonomics get neglected. I am willing to retry getting into it one day. Just shared my general impressions which are very likely outdated.
- morty_s 6y ago> complexity in tooling and unnecessary tension when working with libraries Yep. I’m currently feeling this. I’m thankful I’m not a complete beginner and thankful for the Haskellers that blog their opinionated experiences. But this is such a roundabout way of learning. It’s also almost unfair to compare things to Rust’s Cargo (and Elixir’s Mix). They set the bar pretty high IMO. Haskell would be more widely used if the ecosystem was more cohesive (perhaps a bit more centralized). I’ve been enjoying Haskell enough that I’d like to help improve things.
- tome 6y ago> Haskell would be more widely used if the ecosystem was more cohesive (perhaps a bit more centralized). > I’ve been enjoying Haskell enough that I’d like to help improve things. I am hatching an idea along these lines. How do I get in touch with you? Alternatively can email me at the address here if you like: http://web.jaguarpaw.co.uk/~tom/contact/ http://web.jaguarpaw.co.uk/~tom/contact/
- hopia 6y agoGonna write anything publicly about whatever you're working on? If I'm correct, you've already made Opaleye which is really great, I'd be interested to hear if you got a new Haskell project coming up.
- tome 6y agoThanks, glad you like Opaleye! I would like to start a project to improve programmer experience in Haskell. It's not ready to go public yet but if you want to know more then feel free to email me: http://web.jaguarpaw.co.uk/~tom/contact http://web.jaguarpaw.co.uk/~tom/contact