• Tackling software complexity with the CELP stack

    The last couple of months I’ve been deeply immersed in the combination of Elixir with Phoenix LiveView for the Web UI, Commanded as a CQRS/ES implementation, and PostgreSQL for persistence - I think I heard someone call it the CELP stack, so let’s call it the CELP stack. I think this stack is a great way to tackle software complexity.

  • A heretic's guide to testing

    Our industry is largely driven by fads: someone comes up with a great idea, and people then lift that idea out of context, run with it, and declare it “the true and only way.” In this post, I want to talk about testing and especially about the dogma that tests should be written first and they always should be there. In other words, about Test Driven Development (TDD) being the true and only way.

  • Less handoffs: reviewer merges

    When developing software in teams, there are always seemingly conflicting forces at work. You want to move as quickly as possible, but to do that in the long term, you need to make sure that the full team knows what is going on. A lot of people accept that this tiny slow down in the short term has a huge payoff in the long term, and one of the practices that seems to have become entrenched is the practice of code reviews.

  • Back to the '70s with Serverless

    I’ve now worked with “The Cloud” for long enough to see that there’s still a long way to go before it becomes materially better than, say, the oldschool method of renting a couple of servers with a co-location company and running your software there. The latest fad is Serverless, which makes me feel a lot like we’ve arrived in 1970.

  • Building a chicken coop dusk timer with NodeMCU and Lua

    One of the more fun bits of hardware I have acquired in the last couple of years is the NodeMCU development board.

  • Fun with macros: anaphoric lambda

    In “On Lisp”, Paul Graham introduced the concept of “anaphoric macros”, a term he borrowed from linguistics. We can have them in Elixir as well, and while they’re dangerous because code written in them might confuse people, they are fun to play with.

  • Erlang stuff that Elixir developers should know

    A lot of people are learning Elixir these days. Just at my employer, more than 150 people have taken Dave Thomas’ excellent video course. Learning Elixir is simple, but you’ll also be embracing a new ecosystem, the Erlang/OTP ecosystem; treating it as a black-box is just going to make life harder, so let’s open it.

  • The Programming Language Conundrum

    A lot has been written about “hyperproductive teams”, and a lot has been written how programming languages help here.

  • Love thy product owner...

    People regularly find me quoting a Goethe poem called “Art and Nature”. It is the only Goethe poem I’ve read and remembered (except probably during German classes in highschool, but that’s repressed memory), and the bit I quote is at the far end; I like to quote it because it contains such a cardinal truth in such a succinct statement that I’m jealous at the power of poetry.

  • Integration testing considered harmful

    I just watched J.B. Rainsberger’s talk “Integrated Tests Are a Scam” and I urge you to do so as well (I’m gonna refer to him as JBR down below in line with the good old “name people by their TLA” tradition).

  • Uderzo vs Scenic

    At ElixirConf 2018, Boyd Multerer finally announced Scenic, his Elixir-native UI. Since I’ve been dabbling in the same space, I thought it’d be interesting to write up a quick post.

  • Programming Études

    It’s been a while since I last learned a language I was going to use full-time at work, and usually that means hard work to master the thing; the drawback of being considered a senior is that people expect you to be an expert at everything, so you need to work really hard in order to not disappoint them ;-). Really studying a language (not like Seven Languages in Seven Weeks) made me think about how we’re learning in our profession versus other areas of skill I happen to know a bit about, like performing classical music.

  • Don't use libraries

    If there is one thing that changed in writing software since I started, it is how easily accessible other people’s code is. Open Source code repositories (started by SourceForge, enhanced by Github), package managers (I guess Perl’s CPAN gets the credits there), it is currently way easier to just borrow code than write it. But that doesn’t mean you should do it. On the contrary, most of the time you shouldn’t.

  • Pair Programming

    One of the mantras of agile is that Pair Programming is universally good; some teams even extended this into “mob programming” where the whole team shares a keyboard. After practicing this on and off for two decades, I’m not too convinced of its general applicability or advantageousness. Note that this will be a longread ;-)

  • Engineering

    Following up on my post on “Design”, I’d like to take a bit deeper dive on this whole “engineering” business, because I think the topic is worth an article.

  • Design

    There’s something I need to get out of my system, and it’s how we tend to handle design when writing code. Much has been said on this and I’m not sure I will actually contribute to the discussion, but I feel better when I have it written down. This is going to be a lengthy and probably quite meandering post, but it’s been quite a while since I last wrote about the subject so I think it’s my turn again to further pollute the internet.

  • Scala, part II

    Eight years ago, I wrote a very enthusiastic post about Scala on Artima. It is 2017 now, and I’m a little bit less happy with the language, to say the least. Consider this a retraction :-)

  • Packaging Elixir

    You’re all down and now you want to deploy your awesome new Elixir project. Question one is - how to package it up so you can ship it off? There are tons of solutions and there’s little guidance out there. Here’s my (quick) take on it.

  • Mocking in Elixir

    Elixir is a pretty new language and as such is still developing patterns and adapting existing patterns to its sometimes idiosyncratic ways. One of these concerns mocking.

  • Why I'm skipping my commute

    I work for a great company. We have awesome offices with all amenities, and public transport brings me there and back for CA$6 in a reasonable time. Still, I’m mostly working from home these days.

  • CUPS on Raspberry Pi for HBPL1

    The Raspberry Pi 3 is a wonderful little device. I have two, one to toy with and one as a media box attached to the living room TV. Then my SO wanted to do AirPrint, so I installed CUPS and Avahi and then discovered that there are no standard HBPL1 drivers, which my Dell C1660w needs.

  • Elixir

    New languages have been popping up with predictable regularity ever since I wrote my first line of code. Elixir is one of the exceptions that gets me out of jaded-old-guy mode.

  • Transitive dependencies

    Transitive dependencies look to me a lot like multiple inheritance, and with the same pitfalls.

  • Rantware: Hardcoded

    More rantware. Bloated configuration libraries that let you store configs all over the place, fetch them from URLs or S3 or whatever, while the smart people behind the twelve-factor app are quite right in simply insisting that configs go through the environment.

  • Rantware: Unclever

    New stuff: rantware. Sometimes, enough is enough, and you go off on a rant. Lately, I had that a couple of times and in order to channel the energy into something productive, I’ve invented “rantware”. Rants that result in code.

  • How to skin a snake using docker

    The snake being Python, of course.

subscribe via RSS