A Robot Wrote this Article. I’m not worried about AGI coming for my job as an engineer just yet, but it’s still cool seeing software write an op-ed without any human input.
Nothing to see here, folks. The West Coast of the US is extremely on fire currently and it’s incredibly hard to ignore; as of writing this my city has some of the worst air quality of all the major west coast cities. This piece makes the case that major media outlets in the US are refusing to acknowledge systemic climate change as a cause for these fires. This type of negligence makes many folks (including yours truly) pretty outraged.
It was never enough. Fun long read from the Texas Monthly that profiles a prolific businessman / erstwhile scam artist who committed the wildest insurance fraud in the history of Texas.
A Deep Dive Into the ‘Gentrification Font’. If, like me, you live in a neighborhood where it seems like bougie construction is cropping up everywhere, you may sometimes feel that all new development looks the same. This story sheds some light on how some aspects of new development (such as the typefaces used) are exactly as isomorphic as you may think.
An intuition for optics. Tony Morris has written a bunch of intuitions on useful FP Algebraic Data Types over the last few weeks and I finally am getting around to reading them. I wish I’d read them earlier, honestly. If you’re keen on trying to understand some genuinely useful FP concepts and their associated algebraic jargon, start here.
Thoughts on Haskell in 2020. This week I read a lot about the “pragmatic” Haskell, which the concept of writing Haskell code that (while maybe not as powerful or fancily-typed as possible) is readable, maintainable, and takes advantages of Haskell’s static typing and ergonomics. There’s this whole movement called Boring Haskell that’s been espousing this concept for years, (see writings from Fommil, Snoyman, and Matt Parsons), but it’s still a hard habit to break, especially for people who are drawn to Haskell because of all the type-level abstractions you get to do with it. In my opinion, this post is best-targeted at (a) someone who wants to use Haskell at work and needs some data to help their manager or director sign off on a project or (b) someone who works on an existing Haskell team that’s struggling to hire developers with the necessary pre-requisite programming skills to write complex Haskell code.
Dependent and refinement types: why? LMAO so I know I just got off my soapbox talking about why simple Haskell is best, but that doesn’t mean it’s not worth understanding some of the strong types in Haskell so that you can take advantage of them when you code. In this post by my coworker Alejandro, he walks through the benefits of understanding rudimentary types in Haskell and how you can ultimately use dependent types to prove things to the compiler, which leads to writing code that is free of (software) bugs by definition
Safe, Expressive Code with Refinement Types On the heels of Alejandro’s post about the theoretical benefits of refinement types is this post from Gordon Rennie at OVO Energy that goes through an example of how to use refinement types to safely and elegantly handle input validation, which is a problem that is the scourge of many a web developer but, as Rennie argues in this post, is trivial to handle if you use a language that supports refinement types like Scala.