Serokell Blog

In recent years the Haskell ecosystem has drastically improved. With Haskell Language Server (HLS) there's now great autocompletion and inline error reporting for e.g. VSCode and other editors. We've recently got dot-notation, so you can type `myRecord.myField` instead of `myField myRecord`, which makes Haskell code feel more familiar when switching from other languages. With IHP we now even have a Haskell version of Rails/Laravel. It's really a superpower to have Haskell's type system combined with the rapid development approach of Rails :) Check it out here: https://ihp.digitallyinduced.com/ (I'm founder of IHP) Serokell also has a great blog section on people using Haskell in the industry, e.g. recently there was an interview with the CTO of Mercury. https://serokell.io/blog/haskell-in-production

I know you weren’t asking me, but you didn’t get an answer so I’ll chime in. At work we use Yesod, and it’s been working great for us. A more detailed explanation of what we use can be found here[0]. [0]: https://serokell.io/blog/haskell-in-industry-riskbook

There are a few notable projects that do use Haskell. Agda, Pandoc, wai, warp, servant, yesod, and [more](https://serokell.io/blog/best-haskell-open-source-projects). Some of these projects may not be things you happen across, unless you're looking for Haskell stuff (e.g., wai and the remainder of the list are networking tools written in Haskell, which you probably wouldn't use unless you're already using Haskell). I definitely think Haskell is at the very least worth learning. I personally find Haskell to be the best general purpose programming language. So, unless I really need a low-level language or a specific library, I will choose Haskell. But, of course, you need a certain level of proficiency for that choice to make sense. If you're looking to learn a programming language that helps you land a job, I don't know if there is anything definitive to be said. I was lucky enough to land a job as a Haskell programmer, but I can't really speak to how common such jobs are. It could be the case that having some Haskell projects on your resume is intersting to non-Haskell employers. Not sure.

> The compiler and the build system have gotten a lot more stable over the past several years. GHC2021 promises backwards compatibility, but it includes ill-specified extensions like ScopedTypeVariables. TypeAbstractions were just added, and they do the same thing, but differently.[0] It hasn't even been decided yet which extensions are stable[1], yet GHC2021 still promises compatibility in future compiler versions. So either, you'll have GHC retain inferior semantics because of backwards compatibility, or multiple ways of doing the same thing. GHC2024 goes even further and includes extensions that are even more unstable, like DataKinds. Another sign of instability is the fact that GHC 9.4 is still the recommended[2] release even though there are three newer 'stable' GHCs. I don't know of other languages where the recommendation is so far behind! GHC 9.4.1 is from Aug 2022. It was the same situation with Cabal, it took forever to move beyond Cabal 3.6 because the subsequent releases had bugs.[3] [0]: https://serokell.io/blog/ghc-dependent-types-in-haskell-3 [1]: https://github.com/ghc-proposals/ghc-proposals/pull/669 [2]: https://github.com/haskell/ghcup-metadata/issues/220 [3]: https://github.com/haskell/ghcup-metadata/issues/40

The best overall guide for flakes is likely the one from Serokell: https://serokell.io/blog/practical-nix-flakes. In the most basic, practical sense, flakes solve the standardization and pinpointing of two things: inputs, previously solved by things like niv, and outputs, making nix structures more standard and better able to coexist. Things like overlays, package outputs, nixos configurations, and even flake templates themselves all follow the same structure. The result of all this is that, when I look at a non-flake repository, I may have to spend some time looking around to see what it does at a high level, and it may have its own special method of installation that usually begins with this = import (builtins.fetchTarball "https://...") You can start by converting any of the things I listed to flakes, and there is a module called flake-compat designed to provide backward compatibility for non-flakes. The Serokell guide is very helpful for this as well.

What I did on my M1 was: 1. Grab a pre-release of Nix 2.4 from the `binaryTarball.aarch64-darwin` job on Hydra: https://hydra.nixos.org/jobset/nix/master#tabs-jobs 2. Run the installer with: ./install --daemon --no-channel-add 3. Edit `/etc/nix/nix.conf` to include the line: experimental-features = nix-command flakes ca-references 4. Restart the daemon with: sudo launchctl kickstart -k system/org.nixos.nix-daemon 5. Done! At this point you have a Nix installation, without any legacy channels, which uses aarch64-darwin by default. If you have Rosetta2 installed, Nix will automatically detect it and set `extra-platforms = x86_64-darwin` so you can seamlessly use / build software for other architectures. If you want to specifically get an Intel version of something in nixpkgs, you have to explicitly state it like: `nixpkgs#legacyPackages.x86_64-darwin.foo` I found Alexander Bantyev's blog post, "Practical Nix Flakes" (https://serokell.io/blog/practical-nix-flakes) especially helpful in figuring out how things are intended to work, followed by the unstable branch of the Nix documentation at https://nixos.org/manual/nix/unstable/command-ref/new-cli/nix.html, which covers the new CLI commands.

Thanks for your comments. There does seem to be three languages sure to engender disparate opinions: Lisp, Prolog, and Haskell. I suppose that their advocates can be forgiven for their enthusiasm. They are all quite remarkable languages. I am unqualified to assess the benefits of an advanced type system, after all, I've only worked through examples in a few Haskell books. I've never used Haskell professionally. Haskell is a lovely language. Its compiler is a remarkable achievement of computer science, mathematics, and engineering. Simon Payton Jones deserves the notable accolades and awards that he as received. In my opinion, Haskell's most important contribution is in pushing the state of the art of programming languages forward. Is it practical? Yes, that too, but after all these years, it hasn't really become popular because being "practical" wasn't the main goal for Haskell. Haskell was designed to explore the non-strict functional landscape. Haskell's designers made good choices and were able to expand our understanding of non-strict functional programming (e.g. see Miranda [1]). In the past I did years of research in program verification, so I'm naturally skeptical of the widely repeated claim that "Once your code compiles it usually works" (it's even on the haskell.org site). In what universe is this true? Verification that a program meets its specifications is quite difficult. In general, no compiler for Haskell can even verify that a program will terminate (the…

> read this: https://serokell.io/blog/dimensions-and-haskell-introduction , then look into the referenced libraries. Dude, I actually work with dependent type proof assistants (Lean), with a HOL proof assistants (Why3), and FOL/ZFC proof assistant (TLA+'s TLAPS), as well as with a model checker for TLA+ (TLC); I've also worked with a model checker for Java in the past. I have read several books on the subject, and have written two (both available online: https://pron.github.io/tlaplus, and https://pron.github.io/computation-logic-algebra). I've also trained engineers in formal methods. > Have fun arguing with objective reality. You've read a few blog posts on one aspect of one formal method, and seem to have not even heard of the majority of software correctness research. You certainly don't seem to have practiced formal methods in industry even using one method, let alone more than one. You don't even seem to know what first-order logic is, what higher-order logic is, and I'm sure that if I asked you the difference between HOL and Martin-Löf type theory, or between classical and constructive mathematics you won't even know what I'm talking about; ditto if I asked you what it means for a type theory to have a set-theoretical interpretation (as Lean's, and maybe Agda's -- I don't know -- type theories do). You've read a few blog posts about a small part of one of the most complex, refractory topics in all of computer science and software engineering. You don't know what…

>It doesn't, though. read this: https://serokell.io/blog/dimensions-and-haskell-introduction , then look into the referenced libraries. Have fun arguing with objective reality. As for resource safety, Haskell is yet to follow Rust and introduce linear types, but many cases are covered by bracket pattern https://wiki.haskell.org/Bracket_pattern which can be enforced on type level using some tricks with ST monad. BTW, it is very similar to RAI discipline suggested by many C++ guidelines, but here it can be enforced. Again, have fun arguing with objective reality. >This is true for all formal methods, but here, too, most of them beat deductive proofs. Sure, feel free to feel superior about that. The problem is, again, type system can be embedded into programming language and allow for quite a bit of guarantees even without full blown dependent types. Java has static typing for a reason. Sure, to enforce some properties using type system we need an uncomfortably deep delve into type theory or use awkwardly polymorphic code. However, a lot of properties can be enforced with relatively low cost, and Haskell is a long-running research project on what properties are practical to enforce this way. So, why I need to use proof assistants for properties that can be enforced via practical type system? I really don't see a reason.

https://serokell.io/blog/haskell-in-production-freckle https://github.com/freckle?q=&type=all&language=haskell&so… still haskelling 11 years later I see

You’re correct that Mercury uses Haskell for its backend: https://serokell.io/blog/haskell-in-production-mercury

Interestingly, Mercury [0] is VC-backed, and their backend is entirely Haskell. In an interview [1], their CTO mentions that it’s actually quite easy to hire for Haskell, as the demand is much lower than the supply, and, as he slyly puts it, “interest in Haskell acts as a decent proxy for baseline developer quality.” So while the pool is larger for JS/TS and Python, that may not always be beneficial. [0]: https://mercury.com [1]: https://serokell.io/blog/haskell-in-production-mercury

I'd give this article a read, as it can explain it more clearly than I can: https://serokell.io/blog/what-is-nix But to briefly answer your specific questions: Docker files are commonly not reproducible because they contain arbitary stateful commands like `apt-get update`, `curl`, etc. For a layer with these kinds of commands to be reproducible you would need a mechanism to version and verify the result. Nix provides such a mechanism, and a community package repository with versioned dependancies between packages. These are defined in a domain specific language called Nix (text files) and kept into a git repository. This should be familiar if you've used a package manager with lock files before. You can guarentee the package version will stay in the repository by pinning your build to an exact commit hash in the repository.

I've been meaning to learn more about this for a while, but haven't made time for it because I had assumed it would be more complicated than this. It's surprisingly accessible. As a haskell person, the implementation here brings to mind a free monad (https://serokell.io/blog/introduction-to-free-monads) with a fairly trivial interpreter.

One that is quite visible in Haskell circles is Standard Chartered Bank [1]. [1] https://serokell.io/blog/haskell-in-production-standard-chartered

Rust is good, but writing the experience writing Rust isn't like the experience writing Haskell. Here is a good post on it: https://serokell.io/blog/rust-vs-haskell

The author has a nice blog post series about companies using Haskell in production: https://serokell.io/blog/haskell-in-production

Here is one example: https://serokell.io/blog/rust-in-production-1password

Yes, you can do it that way! We also cover parser combinators on our blog for the interested: https://serokell.io/blog/parser-combinators-in-haskell And if you want to see what are the benefits of this approach over parser combinators, the second part of this series covers a little bit of that: https://serokell.io/blog/parsing-with-happy#happy-vs.-megaparsec

The real fix will happen when Data.Text moves from UTF-16 to UTF-8: https://discourse.haskell.org/t/hf-tech-proposal-1-utf-8-encoded-text/… Fortunately this proposal has been accepted, but I don't know the timeline for its implementation in GHC. Until then, working with UTF-8 is kind of convoluted https://serokell.io/blog/haskell-with-utf8 Also: libraries need to be fixed to accept Data.Text instead of String. IsString helps (it's a typeclass that contains all string types) but only if APIs take it instead of defaulting to String. Adding random string conversions to cope with legacy APIs is very annoying.

>Personally Ive been in the industry for roughly 20 years and I’ve yet to meet anyone IRL who has even dabbled in Haskell. See that's the bubble ;) If you work at a company who makes archival, language-detection and ocr you will see C/C++ Haskell and OCaml..well and perl in no time. http://wiki.haskell.org/Haskell_in_industry https://serokell.io/blog/top-software-written-in-haskell

https://serokell.io/blog/learn-elixir - I've made a guide to Elixir resources.

Yup! We talked about it a bit here: https://serokell.io/blog/elixir-in-production-papercups

Yes. Haskell is used by many companies, from small startups to hundred billion dollar corporations. Fighting spam with Haskell -- https://engineering.fb.com/2015/06/26/security/fighting-spam-with-hask… The Joy and Agony of Haskell in Production -- https://www.stephendiehl.com/posts/production.html Haskell in Production: Riskbook -- https://serokell.io/blog/haskell-in-industry-riskbook Haskell at Barclays (talk, not an article) -- https://www.infoq.com/presentations/haskell-barclays/

functional programming is a catch-all term for a way of writing code that is focused on composing pure functions, actually using the innovations in type systems made in the last few decades, and overall being awesome. This one also gives such advantages: the ability to manage complexity with abstractions, more safe, reliable, composable code, better maintainability I would advise you to read this article - https://serokell.io/blog/introduction-to-functional-programming, this article also has links to other useful topics that relate to this topic.

You might like to read https://serokell.io/blog/why-dependent-haskell , which describes a roadmap for making dependent types practical in Haskell. Useful steps on the road: singleton types (needed to make it easy to represent basic values as types), higher-kinded types (needed to implement functions at the type level), kind polymorphism (needed to be able to reuse the same functions at the type and the value level). Rust is I think getting the first, is gradually implementing little subsets of the second, and is nowhere near the third. The other thing you need to worry about is how dependent types interact with existing language features. In particular, if not implemented carefully then they may break type inference, and I imagine Rust's lifetime inference might have similar issues.

There are also some blog posts over at Serokell about tagless final in Haskell: https://serokell.io/blog/tagless-final.

This is actually a very good comment. Haskell has had these features since early ~2000s and it was a major competitive advantage in the language space, but today I would argue that if you're using a modern language then they don't stand out as much. Nevertheless, not all popular languages provide all the above mentioned features and in case they implement them it's usually in a compromised fashion. For example, nullable types are still an open issue in Java, while C# and Typescript provide easy ways to circumvent them, a lot of times by accident (the main issue is that they're mostly annotations, not runtime checks). On the other hand, you mention several features which Haskell provides, usually through libraries that can only be implemented due to the features provided by the base language: - Refinement types [1] allow to add runtime invariants to existing types in an ergonomic fashion, or you can go even further and use something like LiquidHaskell[2] to enforce properties at compile time. - For multithreaded programs, the existence of STM[3] allows to to write mutable variables which are safe to use across threads. Very few languages offer something like this. - For structural dependencies, you can apply the techniques of "ghost of departed proofs"[4]. Personally I don't like to go that route since programming becomes an act of "proving" rather than "doing" but I appreciate the fact that you can encode it if you want/need to. - Metaprogramming in Haskell is not as…

For us, there were a couple advantages. For context, I work at FOSSA (https://fossa.com/). Our core product solves software supply chain needs in enterprises (around licensing and security), and our core technology is around compiler, build, and source code analysis. Off the top of my head, 3 advantages stood out: 1. First, if you're not going that far off the beaten low-level path, Haskell has incredible productivity benefits. Effect tracking has enormous benefits for testability and understandability. If you've ever been down a debugging rabbit hole shaped like "there's no way this logging call is sending that API request", then you might be pleasantly surprised to discover that you can statically guarantee that this doesn't occur in Haskell programs! Pattern matching, algebraic data types (sum types!), and typeclass derivation make it much easier to make it impossible to construct invalid representations of data. Other languages are finally picking this up, but their versions of pattern matching often have caveats for backwards-idiom-compatibility. And monads are a very powerful abstraction. It's like being able to write your own semantics for async-await (I've talked more about this before at https://lobste.rs/s/7cllte/monads_part_six_really_what_is_monad#c_nbus… 2. Haskell was a good domain fit for us. One thing we build is the FOSSA CLI (https://github.com/fossas/fossa-cli/), which runs in customer CI pipelines to analyze their builds. It's a very compiler-shaped…

As sibling says, Jane Street has employed people who have worked on implementing unboxed types[1] and stack allocation[2] in the OCaml compiler. For Haskell, Well-Typed,[3] Tweag,[4] and Serokell[5] have employed people who have worked on GHC. For example, when Richard Eisenberg was at Tweag, he was working on implementing dependent types in Haskell which has led to new published research.[6] The work on dependent types is continued by other paid contributors. [1] https://www.janestreet.com/tech-talks/unboxed-types-for-ocaml/ [2] https://blog.janestreet.com/oxidizing-ocaml-locality/ [3] https://well-typed.com/blog/tags/ghc-activities-report/ [4] https://www.tweag.io/blog/tags/ghc [5] https://serokell.io/blog/ghc [6] https://www.youtube.com/watch?v=TXDivoj1v6w