What I mean is: some boolean flags are perfect for the real world phenomenon they are representing e.g. is_light_on makes you understand perfectly that when it is true the light is on and when it is false the light is off.
There are other cases in which if you didn’t write the code and you don’t read any additional documentation, everything is not clear just by looking at the variable name e.g. is_person_standing, when true it’s clear what that means but when false, is the person sitting? Lying? Kneeling?
I’m obviously not talking about cases in which there are more states, boolean would of course not be a good solution in those cases. I’m talking about programs in which there are only two states but it’s not obvious, without external knowledge, which ones they are.
if the states aren’t obvious, use an enum with two values, and name them both. Thats what enums are for.
a boolean named
is_person_standingseems fine when person states other than standing don’t matter to the program, except for the fact they are not standing.which leads to: name the boolean based on the thing relevant to what you’re building (this applies to other variable types, as well).
isOccupied is a good enough boolean for the state of the washroom stall. If you need more information, maybe another data type would be better (such as an Enumerated type).
Other states are irrelevant only the true condition implied matters, it is or isn’t that one state.
is_person_standing, is_standing, bStanding all tell you if someone is standing or NOT standing. Nothing else period. It does not matter if there could be other states as the test is one specific case.
is_person_standing is a good use case for enumeration, not a bool, if you care about whether they’re sitting or lying prone or hovering &c.
It shouldn’t matter if the user is leaning or jumping or whatever. If the variable says “is_person_standing” then the only information I get out of it is whether the person is standing or not. It would be much simpler to use enums to represent the state if there are such other options. If you don’t have enums in your language, then use constants.
One should not use boolean just because variable has only two states.
I believe when you use boolean when enum should be used is called “boolean blindness”.
Eg: isFemale instead of enum Sex {MALE;FEMALE} It also gives you an option to simply extend code if requirements change and there are more than two options.
My favorite when debugging some code for a memory manager, written in the days of DOS extended memory, was shit_cookie_corrupt.
The original author called blocks of memory “cookies”. If too many cookies were corrupted then eventually the function ohShitOhShitOhShit was called, which shut everything down.
I would use an Enum if available in the language:
- More meaningful
- Extendable
- Lower chance of misuse
- No naming problem
Moreover, once you’re accustomed to thinking in these terms, it becomes safer to start with a boolean, because the refactoring path is clear: replace boolean with 2-value enumeration, then expand from there.
PolicyCancelledByCarrier
If canx notice has been received, processed, blah blah, eventually it’s set to true.
If/when a reinstatement is received, set to false.
Zero ambiguity, something along that line saved my tail when working with devs in different countries with different insurance customs.
Carrier sent letter telling policy holder to get bent because “fuck you, pay me?” Field is true.
Otherwise, or with reinstatement letter, field true.
Our IT often use a Boolean as a shortcut for figuring out things in code. For example, if there’s a charge we don’t apply to some customers, instead of setting it to zero, they’ll have a Boolean on the customer to decide whether they skip that part of the calculation. On top of this, they then name it in a way that limits how many records they have to update, this leads to many settings phrased in the negative, such as “Don’t apply extra leg charges”. As an extra layer on this, more recently they were made aware of the confusion this causes for staff and their solution was to change how end users are the question, which causes the “yes/no” in the interface to read the opposite of the “true/false” in the database
In your example, it’s implied that any pose other than standing is irrelevant in that context. Why do you need to care if you don’t need to care?
Maybe I explained myself poorly, what I was asking is about cases in which there are only two states e.g. standing and sitting and they are equally important so is_person_standing would not be a good name
Couldn’t you just add a comment that says that if the variable is false, then the person is sitting?
Or if the programming language supports it, you could add a getter called is_person_sitting that returns !is_person_standing.
If that sort of distinction is important, it’s best practice to eschew the boolean type and instead define an enumerated type in order to remove such ambiguity.
Yup. If a boolean were to be used in this case, it’d be an additional variable that you need to update in addition to Enum stance.
No need to deal with the bool, if you can instead just check if (stance == 'standing ')
Probably better to use enums instead of strings
Makes sense, forget booleans my new best friends are enums
I name it
flag, it makes reader assume it’s binary valueBut if I have two states like standing and sitting, and call the boolean standing_sitting_flag how do you know what false and true mean?
Maybe name it
standing_negated_sitting_flag? I really have no idea though.
Not sure I understand your second example, if is_person_standing is false I’d assume the person is not standing and that’s all the information is needed. As you said it yourself, if more information is needed maybe a boolean is not the best choice, or a second variable could be used.
Maybe I explained myself poorly, what I was asking is about cases in which there are only two states e.g. standing and sitting and they are equally important so is_person_standing would not be a good name
I think I see what you mean, you have two states and kind of opposite but you usually name the variable after one of them, so you have to “guess” the other one. For instance you could have isRightHand, the opposite state being left hand, but from the variable name you can’t be sure if it could be “not right hand” as in right foot or something like that. Man it’s kind of difficult to come up with examples.
I sometimes name booleans after the action that will be taken rather than the condition they represent For example, I might have booleans called “doQuickInit” or “invertResult”. I find this very useful when the value of a boolean is determined by a complex series of conditions that are not actually true or false.
