Apparently monads were considered a kind of breakthrough for dealing with some ugly things (IO, exceptions, etc) in a purely functional programming language. I would highly recommend this paper for understanding why they were introduced into Haskell https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/mark.pdf I found the historical perspective especially interesting.

1. what all the singular monads practically have in common, in the case of Haskell for example: IO, State, Maybe, etc.

They have a common signature that follows the same laws. This means you can write code that works generically for any monad, and a lot of standard helper functions are already written for you, e.g. traverse or cataM. For a concrete example, in a previous codebase I had a bunch of per-client reports that had different requirements - one needed to accumulate some additional statistics over the report, and another needed a callback to their web API. So I wrote the general report logic generically in terms of any monad, and then for the client that needed the extra statistics I used Writer and for the client that needed the callbacks I used Future so that I could use a nonblocking HTTP library.

2. why monads are necessary (if they even are) for pure functional programming languages.

They’re never absolutely necessary, but it turns out that a lot of the time where you’d be tempted to use impure code to solve a problem, a monad lets you use the same code style but have your functions remain pure. E.g. rather than a global variable you can use Reader or State. Rather than a global logging facility you can use Writer. Rather than exceptions you can use Either. Rather than a thread-local transaction handle you can use a transaction monad. etc.

3. In what sense is this related to Monads from philosophy (simplest substance without parts)

Not at all, it’s an accident of terminology.

I haven’t yet ever had the experience of seeing a problem and saying “Why, I could express this as a Monad”.

Once you’re used to them you start seeing them everywhere.

YES! This advice completely applies to let variables in RSpec tests too. A let is a memoized method definition in my book. I am happy to recommend using more local variables over let variables in tests.

Not that I’m aware of. Hopefully it’s buildable. The main issue is the code base is older C++ so some warnings/errors in current compilers need to be disabled. It’s also 32-bit only. Mozart 2 is 64 bit but lacks the constraints and distribution libraries.

I’ve been using F# on Linux for a few years now using Mono. It’s a bit more manual than .NET Core, but it’s stable.

If you’re interested in trying again, I created a build system (yes, yet another one) specifically designed for getting going fast in most cases. I have a blog post here:

http://blog.appliedcompscilab.com/2016-Q4/index.html

Short version: all you need is a pds.conf which is in TOML so fairly straight forward, a specific directory structure (src/<project>) and GNU Make. Then you run pds && make -f pds.mk and you’re done. Supports tests as well as debug builds.

I agree, the different choices in tooling is sort of disorienting and it can lead to analysis-paralysis. For a toy compiler project I started working on, I tried to find the most basic tooling that would work: whatever ocaml compiler came with my distro, ocamlbuild, make, and then eventually, extlib, ocpindent, and then after some more time, opam, ocamlfind, utop. It may make sense to use the tooling outlined in this article if future maintainability is a big concern, but to get started and to learn ocaml, I don’t find it necessary (and definitely not appealing). Having done this, I don’t pine so much for standardization (;

There’s more than one standard library in a lot of languages, though. Why does that bother you?

Out of curiosity, have you tried OP’s project setup?

Also, there is only one OCaml standard library–the one that comes bundled with OCaml. The other ‘standard libraries’, Batteries Jane Street’s Core, are optional add-ons made for specific purposes.

The post has this weird, business-y subordinate tone to it, as if programming is mostly what you can get away with shipping to production. It is incredibly reductionistic and dull. If our lot in life as programmers is to write glue code to whatever the Internet deems as The Best Library, then I’m done with programming. There is room for a healthy appreciation for making things that work well when stressed and shipping regularly.

I take pride in my work, and that means doing things as best I can. At the end of every day, I at least have the satisfaction of knowing that.

Thank you for a detailed comment. All these tests are just synthetic tests. Of course, it is very different from how do we type in real life. Most of us type our thoughts in prose and code, thinking and editing as we type. I use those tests just to track my progress from time to time.

Your 130 wpm is very impressive. Could you share your learning story, please? When did you learn to type that fast? Do you practice deliberately on a regular basis? Thanks again.

You mean

# e.g. "col1\tcol2\n    ^ woah" => "Col1 Col2 ^ Woah"

Naming it hurts in this case, because the function does not do what you named it (e.g. in a string of tab-separated values, or a string where multiple spaces are used for formatting). If you had to name it, it would be better named as split_on_whitespace_then_upcase_first_letter_and_join or leave it unnamed and hope that everyone on your team knows that split in Ruby doesn’t work as expected.

The best solution is one that embodies exactly what you intend for it to do, i.e. substitute the first letter of each word with the upper case version of itself. In Ruby, that would be:

sentence.gsub(/(\b.)/) { |x| x.upcase }

Among other benefits, giving it a name means we can explode the code without worrying about a few extra lines in the middle of the caller.

words = sentence.split ' '
words.each { |w| w[0] = w[0].upcase }
sentence = words.join ' '

Introducing a variable called ‘words’ is a solid hint about the unit we’re working with. We may not want to pollute the caller with a new variable, but in a subroutine that’s not a problem.

Naming it does help in this case, but mostly because the reader no longer has to scrutinize over what it’s actually doing. Isn’t this sort of like polishing a turd?

That only masks the issue.

Any maintenance on that line will still have the same problems, whereas refactoring it to split it up into smaller segments AND giving it a name avoids that issue.

A kind of offtopic question based on this comment.

Would I use Coq to prove this function?

I found my way to functional and Scala by way of the checkers framework, initially triggered by http://www.joelonsoftware.com/articles/Wrong.html

I think there’s a convergence of languages. Scala looks like Python because both are trying to look like pseudocode. Even modern Java is moving towards that ideal. Moving towards a readable language is a good thing, and Scala is (or rather, well-written Scala can be) possibly the most readable mainstream-ish language with decent performance[1]. (Theoretically Haskell should be better, but I always find it unreadable - some combination of the terse variable (and type) name culture, the lack of syntax that looks like syntax, the overpowered $ operator/bracket, the lack of OO…)

I think if you take ordinary good programming practice - separation of concerns, encapsulation of state, composability - far enough, you end up with functional programming.

[1] I’m somewhat disturbed that Python and Ruby perform so much worse than Javascript - there’s no real reason this should be the case, and I see a lot of people leaving Python for performance reasons when it’s really the best language for what they need to do. I think it’s an artifact of there being much more moneyed competition in web browsers than in other language runtimes?

One of the MIT Lisp Machines used pairs (frame, index) when compiling variables. The binding stack was a list, with each entry being a De Brujin indexed list of variables so for any static context the (frame, index) pair uniquely identified a single variable.

Oh, very neat explanation.

Neat, never heard of De Brujin indices, but it sounds pretty close to lexical addressing. Anyone know if there’s a relation between the two?

Did the article say they have no code review? It looks possible to run into this problem even with that in place.

That’s curious. What are the benefits of string representation? I have only seen ints.

I’d answer “no”. They should be represented as strongly typed instances, though probably with the option of giving a custom one - possibly enums with the correct ints would be adequate. Look at spray.io (or its spiritual successor http4s) for a library that I think handles status codes really well.

I would use int only. Because range of the number also matters and int are easier to compare. Check these lines. For example, any code between 200 and 299, including those, is considered success.

none really, thought it would be a fun exercise, & easier to reason about what i’m doing than an awk script :)

5.5 snapshots ran fine on my x230 w/Intel HD gfx… though, I’m not sure if video acceleration was working. I was able to run Gnome3, so I think that counts?

Whoa, I installed 5.6 and it worked without a hitch. I also took the opportunity to switch over to cwm after using ratpoison for awhile… a reminder of how nice the defaults are.

I have run accelerated graphics on my x220 for a while now. Check the perms on your /dev/drm* As it turns out I have “Intel HD Graphics 3000”

Lots of luck, daily.

Only think that i had issues with is my realtek wireless but i use a usb dongle to connect wirelessly until someone takes care of it.