Haskell, worst case scenario

This is my preemptive “why I switched back” blog entry on Haskell.

Next year, 2017, I’ll be taking on learning Haskell. For the past few years I’ve taken on a new language and the results have been mixed. Some years my efforts fall into the waste-bin of New Year’s resolutions, stillborn. But sometimes I’m delighted.

Learning Python was wonderful. It has replaced, much to my great pleasure, R as my daily language both for analytics, machine learning, and it became my go to for general purpose use.

My dive into node.js this year was a vast disappointment. I will not begrudge the tens of thousands of engineers who have made node a success for their career and the things they work on. But for me it was an endless gnarl and cause for constant obscenities. I burned out on it by March.

For context, I’m no software engineer. I hope to improve as a programmer and software developer but I’ve never had to maintain anyone else’s code so I think calling myself a true software engineer would be a bit of stretch and it seems like I would be doing a disservice to the hundreds of thousands of good folks who earn their living writing and maintaining richly built applications we all enjoy and depend on.

But I would like to create better and better services that make great applications smarter. To that end I decided I wanted to learn something that addressed most of the pain points I experience dealing with Python but t is unlikely I’ll ever abandon Python. Python addressed so many of my pain points with R but I still use R .

I would love it if Haskell ends up being my go to for certain daily tasks but I’m open to learning Haskell but never working in it. An important step in calling an effort successful requires that we know when we can call an effort a failure so if the following turn out to be true in a year, worst case scenario, I’ll be pleased with what I’ve learned.

Five things I loved about Haskell

1. Static types and algebraic data types makes data processing rock solid
2. Lack of side-effects makes concurrency and micro-services a joy to execute
3. Using an IDE finally helps me create better software instead of just helping me be lazy
4. If I weren’t already bald I wouldn’t loose any more hair refactoring
5. Haskell is brilliantly and consistently lazy

Five things that turned me back to Python

1. Community: The Python community is unparalleled and I can’t give it up
2. Ecosystem: Haskell is so far behind in scientific computing and it probably doesn’t make sense for anyone to help it catch up plus using Python I benefit from latest advances in CUDA, deep learning, machine learning, and great binding for other c-suite languages (e.g Lua/Torch, Julia, etc.)
3. Pragmatism: OOP & dynamic types are messy but not messy enough to get me off what works in Python
4. Momentum: Python (e.g. 3.2+) is addressing many of my immediate concerns and pains (i.e. advanced unpacking, better exceptions, lazy iterators, stricter type enforcement, annotations, etc.)
5. Cross-pollination: What I’ve learned in Haskell is making me a better user of Python