Removing ableist language in code is important; it helps to create and maintain an environment that welcomes all developers of all backgrounds, while emphasizing that we as developers select the most articulate, precise, descriptive language we can rather than relying on metaphors. Quite simply, avoiding ableist language lets us make sure we are inclusive of all developers, while moving toward language that is simultaneously more acccessible to developers whose first language might not be our own.
The phrase sanity check is ableist, and unnecessarily references mental health in our code bases. It denotes that people with mental illnesses are inferior, wrong, or incorrect, and the phrase sanity continues to be used by employers and other individuals to discriminate against these people.
There are a ton of alternatives, and one of the best ways to select one is to ask yourself: What am I actually checking? and select something more descriptive. In everyday conversation, we can simply drop the idiom completely and say something akin to Let's check to ensure everything is working.
If this doesn't help, consider one of these many alternatives. I'm prone to using the first two in my own code, though these are gleaned from many developers:
- Quick check
- Initial check
- Confidence check
- Coherence check
- Soundness check
- Calibration check
- Rationality check
One to avoid? Health check. Along with again tieing in discussions of health and disability, this phrase already carries a lot of previous implications from other products that may obfuscate what you're actually trying to say.
It seems to me that most of the examples where things fall into potentially ableist or discriminatory language are also examples where a word has been used that isn't actually accurately describing what we're testing.
Many describe when we're testing (e.g. initial, preliminary), or the category of testing (e.g. essential), or how the tests sit in relation to other groups of tests (base, foundation, core, primary), or or how the tests make us feel (e.g. confidence, reliability), or uses some other metaphor (smoke).
(In my opinion, metaphors are the riskiest ground - not only do they drag a lot of unrelated, potentially discriminatory contextual baggage into the fray, but they're also often culture-specific. Non-native speakers of the language can easily be confused and alienated by them.)
To quote @seanmhanson 's original gist, "What am I actually checking?"
What are we considering to be "good" or "bad"?
Unfortunately, very few suggestions actually address this question - they're just vaguely defined taxonomies, or worse. There's logic there, yes, but they're all opaque in terms of the "what", and some really need to be explained, which would definitely have a negative impact on adoption.
@lychaxo suggests bounds check, which is a great example. We're checking that the result falls within some specified bounds. There's little ambiguity here.
More general thoughts...
It's interesting to see in these posts that some words which, on face value, appear to be less ableist (e.g. coherence) have been pointed out by others as in fact being potentially more problematic.
@pelevesque mentioned "sanitize", which actually (I assume) derives most recently from "sanitation", not "sanity", but nevertheless, both words derive from "sanus", the Latin for "healthy" (or so Google tells me - I'm no linguist). So maybe the word "sanitation" (as in, taking waste away from people for the purposes of avoiding disease, something I think we can all agree is a good thing) is out? How do we decide?
@lychaxo also mentions "valid"/"invalid" terminology, which seems to have come the Latin words for "strong", the word "invalidus" meaning "not strong", so I would guess this is the root of the ableist/discriminatory sense of the word. At some point at least several hundred years ago it seems it also began being applied legal/academic arguments.
Ultimately I find myself wondering how easy it is to steer clear of words that could be construed as ableist or discriminatory, given that so many words in modern language are derived from much older languages, the users/makers of which apparently had far fewer qualms about being discriminatory. Many of the things we want to describe, particularly in terms of testing, necessarily fall into the general categories of either "good" or "bad", and so very quickly we start down this slippery lingual slope towards discrimination. Even the word "discriminate", in another sense, can describe what happens in a test. We want to discriminate between wanted and unwanted outcomes.
I don't know where the line can be drawn. How long ago can a word change its meaning before it's okay to use it without having to consider the implications of a previous meaning? What about reclaimed words?
This probably seems like an unnecessary exercise in derailing the original conversation, presenting more difficult questions than answers (which is why I added a subheading before these thoughts, to separate them from more actionable suggestions above). But the point I'm making is that if we want to be successful at replacing pervasive discriminatory language in the tech world, and not be accused by people on all sides of being misguided/white knighting/babying others, etc, there's little point in randomly presenting ideas that are arguably "just as bad". We need to present better ideas. And for that we need some rubric to measure what "better" means. I don't know if that's possible, but I'd be interested if anyone more qualified than me has any thoughts to offer on this, or who can perhaps point us to some resources that aren't just more "instead of word X, use word Y".