Some Upcoming Crazy Thoughts

July 16, 2017

I didn't mention it on my blog, but I put it on Twitter, so it's
probably not a surprise to most. About five months ago, we had a baby
boy (yay!). As you can imagine, new babies take a lot of energy,
especially when it's your first baby of four to have colic. Many
nights were spent walking Lavi around the block singing. I'm actually
pretty lucky none of the neighbors called the cops, my singing
definitely counts as disturbing the peace.

Pro tip to any new parents even a little bit superstitious: never say
“We've been through all of this before, this baby can't surprise us.”

Anyway, I'm not wont to share personal anecdotes on this blog, but I
mention this because I've obviously been pretty distracted with baby
things. Fortunately, the baby is just about done with colic (just in
time to start teething of course). Between that extra energy drain
evaporating, having had lots of time to let my mind wander while
walking a crying baby, and a few other things I'll detail at the end
of this post, I've gotten to mentally explore some crazier ideas.

I've already been blogging a bit on fpcomplete.com about monad
transformers. Expect some similar things on streaming data and
polymorphism (perhaps) in the next few weeks. Also, I'll probably talk
more about exceptions, though the thoughts there are less crazy and
more reaffirming previous things.

A good question is why am I bothering with this blog post at all. I
actually drafted most of it and then decided not to publish it for
about a week. My thinking here is I don't want anyone taking my crazy
thoughts too seriously. I like to explore ideas, and I explore ideas
best by actually writing libraries and blog posts about them. In other
words, I throw things at the wall and see what sticks. I usually buy
into the idea completely for a bit to avoid second-guessing derailing
an idea, and then take a step back afterwards to see if I like it.

Besides having reduced keyboard time for the past five months, here
are some of the other stimuli leading to some of the ideas I'll be
sharing:

I've spent considerably more effort on training. I've been doing
documentation and tutorial writing for a while, but I've had
multiple opportunities recently to train in a more direct
setting. This has helped remind me of some of the newcomer
experiences I've forgotten.

Similar to this, my time at LambdaConf earlier this year was
great. My conference experiences usually are either non-functional
programming conferences where I'm the Haskell anomaly, or advanced
functional crowds. The huge mixture of experience levels with FP and
Haskell at LambdaConf was wonderful and eye-opening (or perhaps
reopening).

I've been working on a few projects where my major focus is on
review and debugging, which forces me to focus less on making it
easy to write code the first time, and more on writing code for
maintainability and robustness (yeah, vague terms, don't beat me up
over it).

Most recently, I did a major 10-day-straight hacking fest on the
Stack code base, after not having seriously touched it for months
(and the parts in question for over a year). I got to play with
major refactorings and focuses on readability and future
extensibility.

And in addition to all of this Haskell stuff, I've finally forced
myself to start learning a new language for the first time in ten
years. I went through quite the journey through programming
languages before I hit on Haskell, and since then I've been so happy
with it that I haven't wanted to touch anything else. But in the
past half year, I've gotten into two languages to various extents:

PureScript This honestly wasn't much of a learning experience,
since it's close enough to Haskell. I think GHCJS is a great
project, and have enjoyed both Reflex and various React layers
in it. But the smaller output and strict nature of PureScript
make it something I wanted to experience for front end
development.

Rust As I said on Twitter: "Rust is the first language I've
learned in ten years (since Haskell) that both teaches new
concepts and does stuff Haskell can't." Rust is an interesting
language, promotes safety in a way that I like (the main reason
I love Haskell to be honest), and has a really well designed
community experience around it.