Tweag Blog

The Nix team (in particular grahamc with https://github.com/NixOS/ofborg) is working hard on making CI better . But it's true that the on-boarding experience and CLI could be much improved.

It's quite frustrating to me, because after I've been using Nix & NixOS for about 3 years now, there's no way I'd go back to the insanity out there. I never had the amount of stability, control, and predictability on any other platform, from configuring my OS, editors, WM, shell, random ricing, or building VMs, Servers, Docker containers, production deploys, development environments, there's really not much Nix can't handle.
But getting familiar with Nix took some serious effort I'm sure not many people can afford. I begin to understand how frustrated people in the Lisp and Smalltalk communities must feel while people slowly reinvent everything they've enjoyed for decades (and Nix is still in its teens).

Teaching people about the value of having just a single package manager, no matter what OS or language they're using, is mostly futile because there's so much value attributed to being "mainstream" that now we have hundreds of mainstream package managers with varying degrees of sophistication, security, predictability, and ability to _not_ try and take over your system.

I use it to build and develop Go, Ruby, JS, Crystal, Elm, Mint, Haskell, Perl, Bash, VimL, Elisp, Guile, and whatever else comes my way.
All I have to do to get a working and isolated dev env is go into that directory…

I don't follow it. This is the crux of the article:

> and there is nothing you can do in Haskell that is not data. No logic can be written in Haskell outside of data.

Is he talking about Lisp?

> the often dreaded Haskell monads are really just side effects represented as data.

Nah

> Typeclasses are data ...

Really?

> ... that define certain behaviour, yes, but this behaviour, like all behaviour in Haskell, is merely a rule, a declaration, a law, which states how one piece of data is transformed into another. This is also what functions are.

Yes. Functions. Not data.

Also some bad code in the example:

getNumOfReplacement :: String -> Maybe Char getNumOfReplacement word | first_char =='{' && third_char == '}' = Just second_char | otherwise = Nothing where first_char = head word second_char = word !! 1 third_char = word !! 2 Verbose and crashy (for inputs "", "{", "{x", ...). Here's better:

getNumOfReplacement' :: String -> Maybe Char getNumOfReplacement' ('{':x:'}':_) = Just x getNumOfReplacement' _ = Nothing > The above algorithm could also be written in a pretty similar way in many other languages, even some non-functional ones. What makes Haskell different however is that this is the only way in which you can do it.

Weird claim! There's loads of ways to do it.

> It forces you to yes, learn some mathematical concepts, but on a more fundamental level to…

Tweag.io | Paris, France | REMOTE + ONSITE | Software Engineer | Formal methods, PL design

http://tweag.io

We are a research and development laboratory at the heart of Europe, applying functional programming techniques to tame the complexity of distributed systems and scale predictably. Most of our existing folks have a PL research and/or formal methods background and enjoy demonstrating the correctness of their solutions with gusto: randomized test case generation, model checking in SPIN/Promela or interactive theorem proving using Coq. We're very active in the Haskell community - contributing new language extenions (linear types, static pointers) to GHC, publishing and maintaining HaskellR, inline-java, sparkle, rules_haskell and many others. We hit the HN front page just yesterday with our Haskell support in Bazel.

Tweag.io are organized as a distributed team of experts around three main areas of focus: distributed systems engineering, functional programming based devops (Nix, Haskell etc) and mathematical modelling / machine learning. We are looking for formal engineers and PL designers to join our distributed systems team, to help us apply interactive theorem proving techniques to industrial scale projects and work on tools to make this cost effective for the masses.

If you'd love the opportunity and the space to solve the hard problems of science's large dataset infrastructure, by systematically decomposing them into simple, orthogonal solutions that compose and…

> Besides, config languages never have the level of polish (re: tab completion and static analysis) that the main language does.

They don't have to!

> Why deny your users the niceties that you set up for yourself?

Don't do this, of course. :)

For instance, Nickel gained[1] an LSP implementation years before it hit version 1.0. When editing Nickel configs,byou get all the stuff you'd expect for a programming language: syntax highlighting, type hints, autocompletion, etc. But beyond static analysis, Nickel can also validate your configurations dynamically, according to arbitrary predicates-- and that too, integrates with your editor through the language server. Nickel ships with a command-line evaluator, REPL, pretty printer for data structures, code formatter, documentation generator, and CLI tab completions for Bash, zsh, Fish, PowerShell, and Elvish. Upstream distributes the tooling (which is, Go-style, a single executable with subcommands) as a Nix flake, a Docker image, and static executables for Linux aarch64 and x86_64 (< 30 MB, for now at least). Nickel doesn't yet have a package manager[3], but other than that it honestly has a better tooling story than many general-purpose programming languages currently in widespread use.

CUE, an older (but not old) configuration language (very cool in its own right), likewise has great tooling. It ships with a command-line evaluator, a pretty printer, a formatter, package management based on Go modules (i.e., it has both a…

For our last 2 clients (with both, offering a "data team as a service"): the reporting tools were written in Haskell, using Servant [1] which got started trying to do the same at Zalora to set up a customer service management tool. The motivation was that it made painful stuff much simpler and faster to write (performance was a bonus).

It's also used for a bunch of tricky data manipulation problems that were harder to solve using pure SQL. Example: identify a unique customer based on attributes (email, phone, address, etc.) one or more of which can change when a customer tries to create a "new" profile to grab the $10 new customer signup voucher. This ran recursively on the entire customer dataset (12 countries, some customers had created as many as 250 profiles) in about 4 seconds on a m3.medium instance.

We don't/didn't write blog posts or tweets about it though. I think the set of people who write blog posts (i.e. both have free time to do so, the talent, and the motivation) is relatively small, and the number of blog posts and other visible stuff being published is proportional to the size of the community, so you'll see many more Node.js/RoR posts than you will on using set theory to reduce a 5,000-table flawed data model systematically or the kind of everyday stuff Haskellers are doing everywhere. Also, personally at least, I don't feel like I know enough to have much to offer by writing a blog, so I stick to making these semi-anonymous HN comments.

Interviewing…

I’m a bit conflicted about your point here, because they seem cherry-picked to highlight disparate aspects of Haskell that don’t make it less interesting or important.

Haskell is more often than not sued as a general purpose language, not as a systems language. Its performance is actually outstanding, usually equal to Java and often close to C. This means that Haskell can be safely used in any domain were java would be fast enough.

I find also somewhat arrogant to claim that there are no complex systems built in it. Just take a look at the webpage publishing this article. They mention several projects of great complexity. Here’s an example: https://www.tweag.io/posts/2017-03-13-linear-types.html

They are using Haskell as a prototyping language that lets the refactor and radically change the direction of their solutions at a low development cost. Haskell clearly is helping solve complexity here.

Also, where did the claim that GHC is badly documented come from, and how is it relevant to Haskell being important?

Just looking at randomly selected file in the repo, it looks actually quite well documented: https://gitlab.haskell.org/ghc/ghc/blob/master/compiler/simplCore/FloatOut.hs