Python famously holds as a value “Explicit is better than implicit”. This is not something Rubyists (or many functional programmers) value, instead favoring compactness or “elegance”. I believe senior developers undervalue explicit code that uses fewer features than it could. Compact code that uses many language, library, and framework features excludes people from understanding and contributing to it, and I believe this is a serious consideration when writing code. What better judge of a codebase’s maintainability could there be than “fewest concepts needed to understand it”?
I’ve been traveling to San Francisco every two months (more or less) for the last five years as part of my job. The hardest part used to be the traveling and staying in hotels (now it’s that I pack so much activity into such a small amount of time, I barely see any of my San Francisco friends any more). This is about how to make the travel and hotels suck less, and if you are currently working remotely, or planning to, reducing travel anxiety and hassle should be something you actively address.
Engineers often deride anything that’s not writing code as being not “real” work. While this diminishes the contributions of others, and is generally an unhealthy bravado, it is critical to understand the difference between activities that directly solve a problem and those that organize said activities. The later, I call “meta-work” and engineers should be very conscious of spending too much time on it.
I’ve added another “problem” to “What problem does it solve?” about serverless architectures, which I think are the future of distributed systems (though that future isn’t here yet):
The less code you are responsible for running in production, the better. Running an actual server means it’s all on you. Using virtual servers delegates some to your hosting provider. Using a platform-as-a-service like Heroku delegates yet more. A serverless architecture reduces this to what might be the absolute minimum - you are responsible for your code, and everything else is handled by the provider.
There are three big challenges: deployment, vendor lock-in, and testing.
In this month’s issue of PragPub, I have an article about Rails, and how it’s still as relevant today as it was when it came out:
What Rails taught us about agility in 2005 is still applicable today. Rails has also kept up with the times, baking in more conventions around common problems, but also adding more technology to help solve them.
And there is testing support for all of it, from unit tests to browser-based system tests, so you can confidently ship your entire app, fully tested, whenever you need to make a change.
Read more about the entire issue here.
A few people on Twitter were talking about developers that run their entire test suite only on their continuous integration (CI) server. The idea was that this was a sign of low quality tests, low quality code, or an otherwise bad process. In the past, I felt this way, and “breaking the build” (by checking in code that had failing tests) was viewed as bad. I don’t believe this any longer, and now feel like it’s a critical ability for a high-functioning team to have. Not that it isn’t important to identify low quality tests or code, but what exactly is the value of having a fast test suite?
The last chapter is an attempt to describe this problem in detail and offer some solutions.
I was surprised at how counter-intuitive each step ended up being—I can totally see why there are so many blog posts describing how to set it up. From a test runner that can’t run tests, to a system that supports presets, but includes none of them, I was faced with many choices along the way, but also faced with completely opaque systems whose behavior and failure modes were unpredictable.
It focuses on Webpack and Karma, which I found very difficult to make work together:
Webpack and Karma’s interoperability is completely opaque to the user. This means that you have no way to know how the tools are working or even observe them working together without debugging into the source code.
If you didn’t make it all the way through the entire Webpack site, this last chapter is worth a read.
During your journey through this site, you’ll use Webpack, Karma, Jasmine, Babel, and many different plugins and extensions, all to get a very basic development environment working. There will be little handwaving. We’ll add tools and configuration only when needed to solve a specific problem.
I’m not obsessed with typography, but I have a healthy respect for it. I talked about typography and source code a while back and I’d like to revisit the subject, but focus on dreaded stack traces. Stack traces happen when your code hits a situation it can’t handle, and most programming languages give you a giant vomit of files and locations that are nigh unreadable. Can we apply typographic principals to them to help us better understand why our code fails?
Chris White and Jason Harrison of Zeal discussed my post on developer productivity this week on the Zeal Interestings Podcast. It’s just 26 minutes long, and hits some interesting points, particular around the use of the word “incompetent”. They bring up a fair point, but I couldn’t find a better to describe the notion of being given a task that you just don’t know how to complete.