Test Double, a software consultancy, writes about testing, TDD, Ruby, developer tooling, and engineering practice.
Commenters link it for "The Failures of Intro to TDD", posts on favorite tools and privacy-minded analytics, and a moving post about a colleague.
Seems like Nix is having a bit of a moment. After devbox[1] was released I started looking into Nix, and there's a lot happening.
I'm staying away from these Nix wrappers and learning how to do some basic nix-shell work, myself. Until it's proven the wrappers are adding real value, not just trying to hide scary scary Nix from devs who only feel safe in YAML files.
For the curious, this post[2] describes mixing Nix and Docker. And this[3] is a pretty decent tutorial on using Nix itself for this use case (consistent developer environments). Without going full NixOS, setting up a shell.nix with some OS-level environmental dependencies is a great way to dabble.
It seems there may be a sensible reaction away from "Dockerise all the things" for development at least, e.g. this blog post[4]. There are real downsides to containers for development, even though using things like `rvm`, `nvm` and `venv` were also a pain.
We've run into issues ourselves with developers starting to use the new M1 Macs - we've still not figured out how to make filesystem mounting fast yet. There seem to be other advantages to running more things locally, like simpler configuration of debuggers etc. (EDIT for clarity: the issues were with Docker, not Nix, hence the reference to filesystem mounting. Nix == "running more things locally".)
But taking a broader view, while containerising apps with complicated dependencies is a win, we really don't need to pretend that production and dev are actually…
I work mainly with front-end JavaScript developers, who generally speaking got into programming through HTML and CSS and see testing as something someone else does after they've built the thing. (Which also perfectly describes me up until a year ago.)
I don't have a reference for start-to-finish automated testing, but I like the way in which Justin Searles explains the difficulty of such a thing here: http://blog.testdouble.com/posts/2014-01-25-the-failures-of-intro-to-tdd.html
I gave a brief presentation about testing a few months ago and felt like it didn't really connect. I think it's genuinely hard to break the preconceptions about testing, and also there's a fair amount of incidental framework and library minutia that can be hard to isolate from the big picture ideas.
Subjective experience is a huge factor. Trying to rationally explain the advantages or conceptual underpinnings of testing doesn't always work. (In hindsight it didn't work for me either.) It really takes sitting down next to somebody and walking them through a process. I've had success in showing a test I wrote from some unit that I wanted to exist, deleting the implementation, walking them through a re-implementation, and then passing them the keyboard to implement another deleted implementation.
Make sure that the developers actually experience a cycle of red-green-refactor.
I have adopted the same philosophy. A few resources on this, part of the so-called London school TDD:
- https://github.com/testdouble/contributing-tests/wiki/London-school-TDD (and the rest of the Wiki)
- http://blog.testdouble.com/posts/2015-09-10-how-i-use-test-doubles
- Most of the screencasts and articles at https://www.destroyallsoftware.com/screencasts (especially this brilliant talk https://www.destroyallsoftware.com/talks/boundaries)
- Integration Tests Are A Scam: https://www.youtube.com/watch?v=VDfX44fZoMc
All of these basically go the opposite way of the article's philosophy:
Not too many integration tests, mostly unit tests. Clearly define a contract between the boundaries of the code, and stub/mock on the contract. You'll be left with mostly pure functions at the leaves, which you'll unit test.
Justin Searls' recent talk "The Social Coding Contract" has a nice take on why expectations get so out-of-sync: http://blog.testdouble.com/posts/2014-12-02-the-social-coding-contract.html
Nobody is "the bad guy", but creators and late adopters have very different understandings of what OSS is for, why it exists, and what to expect.
You might like http://blog.testdouble.com/posts/2014-01-25-the-failures-of-intro-to-tdd.html
It's a tad long, but worth it. tl;dr: the first half agrees with you, and the second half describes a process that does help you test useful stuff (and design your software decently along with it)
I wrote a blog post about this:
http://blog.testdouble.com/posts/2020-04-07-favorite-things/
Outside of that, I'd say linters and code formatters have a huge impact on my productivity and code quality. ShellCheck in particular has taught me oodles about shell scripting.