all 19 comments

sorted by: hot top controversial new old
[–] 33 points 1 year ago (2 children)

The logic is fine. If you rename the variable to isAdmin, it makes perfect sense. Either they are an admin, or they are not an admin, or the state is unknown (here expressed as null). If you want to throw another JS-ism at this, undefined could be assigned before the check has been made.

I regularly use variables like this. If users is undefined, I haven’t fetched them yet. If they’re a list, then fetching is complete. If they’re null, then there was an error while fetching.

  • source
  • hideshow 2 child comments
  • [–] 28 points 1 year ago* (1 child)

    The only flaw is that the console.log states that null means user is not logged in.

    If there are three or more explicit states, you should not use a nullable bool, but some more explicit data structure, like enum.

    For example, if the state comes from a db, the user could be successfully logged in, but somehow for a range of possible reasons this variable ends up as null and you'll have a hell of a time debugging, because the log will give you nonsense.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 24 points 1 year ago

    Today i have seen:

    if (var === true || var === 'true' || var === "true")

    I'm just fortunate enough to not work with the frontend at our very backend service, but I always hear things that shouldn't be even allowed in this planet.

  • source
  • [–] 16 points 1 year ago

    Yes JS is the crime in itself.

  • source
  • [–] 13 points 1 year ago

    Not yes or no, but a secret third thing

  • source
  • [–] 9 points 1 year ago

    Like any good Boolean:

    True / False / File not found

  • source
  • [–] 11 points 1 year ago (2 children)

    How many "equal" symbols do we need to be absolutely sure?

  • source
  • hideshow 2 child comments
  • [–] 4 points 1 year ago

    Just use an enum lol

  • source
  • [–] 4 points 1 year ago

    True, false, and magic.

  • source
  • [–] 3 points 1 year ago

    Obviously this should be a Result that the gets compiled to a nullable bool.

  • source
  • [–] 2 points 1 year ago*

    Aren't the first two if branches completely useless? The variable was just defined without a value, so it should always be null

  • source
  • [–] 3 points 1 year ago (2 children)

    the real crime in this photo is the ===

  • source
  • hideshow 2 child comments
  • [–] 2 points 1 year ago (1 child)

    I'm so confused. I understand the reasoning behind two equal signs but three?

  • source
  • hideshow 1 child comment
  • 67 comments in c/programmer_humor@programming.dev view that post
    [–] 80 points 1 year ago (25 children)

    I mean aside of the variable name, this is not entirely unreasonable.

  • source
  • hideshow 25 child comments
  • [–] 33 points 1 year ago (4 children)

    I would certainly rather see this than {isAdmin: bool; isLoggedIn: bool}. With boolean | null, at least illegal states are unrepresentable... even if the legal states are represented in an... interesting way.

  • source
  • parent
  • hideshow 4 child comments
  • [–] 3 points 1 year ago (3 children)

    Admin false LoggedIn false doesn't feel illegal to me, more redundant if anything

  • source
  • parent
  • hideshow 3 child comments
  • [–] 8 points 1 year ago* (2 children)

    I was thinking of the three legal states as:

    • not logged in (null or {isAdmin: false, isLoggedIn: false})
    • logged in as non-admin (false or {isAdmin: false, isLoggedIn: true})
    • logged in as admin (true or {isAdmin: true, isLoggedIn: true})

    which leaves {isAdmin: true, isLoggedIn: false} as an invalid, nonsensical state. (How would you know the user's an admin if they're not logged in?) Of course, in a different context, all four states could potentially be distinctly meaningful.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 8 points 1 year ago* (1 child)

    E: omg forget my whole comment. I agree with you that the name sucks.


    I mostly don't like that role is typically an intuitive name, and now suddenly it means something I wouldn't expect. Why add confusion to your code? I don't always remember what I meant week to week, much less if someone else wrote it.

  • source
  • parent
  • hideshow 1 child comment
  • [–] -1 points 1 year ago* (14 children)

    Yeah let’s use a union of a boolean and null to represent role, something that inherently represents more than two (…or three, I guess) different values, as opposed to something like an integer.

    Even if the name is clearly misleading in this specific case, the entire choice of using a bool here is just bad because it’s almost guaranteed you’re going to expand on that in future and then you’ll just have to entirely rewrite the logic because it simply can’t accommodate more than two values (or three with the null union… 🙈), while it gives absolute zero benefits over using something more reasonable like an integer to represent the roles, or in this case, admin, not-admin and guest. Even if you’ll end up with just admin, non-admin and guest, the integer would still work great with no disadvantages in terms of amount of code or whatever. Just increased legibility and semantical accuracy.

    Not to mention that there’s zero reason to combine the state of being logged in and the role in which you’re logged in in one variable… those are two different things. They will remain two different things in future too…

    I mean they’re already chaining elseifs (basically matching/switching, while doing it in an inefficient way to boot 🥴) as though there were an n amount of possible states. Why not just make it make sense from the start instead of whatever the hell this is?

  • source
  • parent
  • hideshow 14 child comments
  • [–] 6 points 1 year ago (13 children)

    This is quite reasonable, aside from the variable name which should be isAdmin. A user either is an admin, or isn't. Unless we don't know, then it's null. You are correct this is bad if the point was to represent roles, but it's not supposed to.

  • source
  • parent
  • hideshow 13 child comments
  • [–] 1 point 1 year ago (12 children)

    Admin is a role though, was my point. And besides, if you check for three different states, and you decide to go with a boolean to represent that, I really find it hard to believe anyone would think it reasonable. It’s valid and it’s practical, but can you really say it’s reasonable?

    I don’t do typescript, but wouldn’t a union of a null and a bool be just more resource intensive than simply using an unsigned byte-sized integer? I struggle to find reasons to ever go for that over something more reasonable and appropriate for what it attempts to represent (3 distinct states as it stands, and likely in future more than just 3 when they have a need for more granularity, as you’d often do with anything you’d need an admin role distinction in the first place), but likely I’m just not familiar with ts conventions. Happy to hear the reasoning for this though.

  • source
  • parent
  • hideshow 12 child comments
  • [–] 1 point 1 year ago (1 child)

    My preferred way of modelling this would probably be something like
    role: "admin" | "regular" | "logged-out"
    or
    type Role = "admin" | "regular";
    role: Role | null
    depending on whether being logged out is a state on the same level as being a logged-in (non-)admin. In a language like Rust,
    enum Role {Admin, Regular}
    instead of just using strings.

    I wouldn't consider performance here unless it clearly mattered, certainly not enough to use
    role: number,
    which is just about the least type-safe solution possible. Perhaps
    role: typeof ADMIN | typeof REGULAR | typeof LOGGED_OUT
    with appropriately defined constants might be okay, though.

    Disclaimer: neither a professional programmer nor someone who regularly writes TypeScript as of now.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 1 point 1 year ago* (last edited 1 year ago)

    Yeah obviously with constants for the set roles per value. Some languages call them enums, but the point is that what we pass and use is always still the smallest integer type possible. With the extra bonus that if the roles ever become composable, the same value type would likely suffice for a bitflag and only thing needing refactoring would be bitshifting the constants.

    But anyway, this turns out to be the weirdest hill I find myself willing to die on.

  • source
  • parent
  • [–] 1 point 1 year ago* (last edited 1 year ago) (9 children)

    So in a language with nullable types, are you against a boolean ever being nullable? Null means "empty, missing info". Let's say we have role variable with a enum type of possible roles. It could still reasonably be nullable, because in some scenarios you don't know the role yet, like before log in.

    In any use case where we need to store some boolean, it's a common occurrence that we don't have the data and it's null. It would be overkill to use an enum with True, False, NoData for these cases, where there is already a language feature made just for that, nullable values.

    I've never used TypeScript, just writing from experience in other languages.

  • source
  • parent
  • hideshow 9 child comments
  • [–] 2 points 1 year ago* (8 children)

    Yeah, but if it is about being an admin or not, hence the bool, it’d be idiomatic and reasonable to assume it to be false if we have no data. Unless we want to try and allow admin access based on no data. Having three states for a simple binary state is weird. And if it is not about just being an admin or not, the bool is inherently a too limited choice for representation.

  • source
  • parent
  • hideshow 8 child comments
  • [–] 1 point 1 year ago* (7 children)

    Depends on your requirements.

    If the admin status needs to be checked in a database, but most actions don't require authentication at all, it's pointless to waste resources checking and it would be left null until the first action that needs the information checks it and fills it in as true or false.

  • source
  • parent
  • hideshow 7 child comments
  • [–] 1 point 1 year ago (6 children)

    I don’t really follow you there, wouldn’t it be exactly the opposite and wouldn’t checking for nulls be, as a premise, more wasteful? But doesn’t really matter, time to digress. I’m conventionally educated as an engineer so what I know and find reasonable today might be outdated and too strict for most contemporary stuff.

  • source
  • parent
  • hideshow 6 child comments
  • [–] 1 point 1 year ago (5 children)

    Let's say you have a website receiving 1 million requests per day. 0.01% of those are admin requests that need to know if your are an admin to execute them. It would be wasteful to check with the database if you are an admin for every request, when only a tiny minority of then needs to know that. So for 999.900 of the requests isAdmin will be null. We don't know if the user is an admin and we don't need to know.

  • source
  • parent
  • hideshow 5 child comments
  • [–] 1 point 1 year ago* (4 children)

    That all is besides the point. There’s no real advantage to use null instead of defaulting to false there… it’s semantically more accurate and also less wasteful in that other code does not have to worry about nulls which always leads to unnecessary overhead when false is already equivalent in your proposed example.

  • source
  • parent
  • hideshow 4 child comments
  • [–] 1 point 1 year ago* (last edited 1 year ago) (3 children)

    It is not more accurate nor less wasteful. If you default it to false and you have 100 admin requests in the session where that variable is stored, you would have to check with the database 100 times. Because you are conflating false to mean two things: "the user is not an admin" and "we don't know if the user is an admin". Where if you set it to true or false the first time we need the information, then subsequent requests don't need to check anymore.

    does not have to worry about nulls

    I am used to null safe languages where there is no such thing as worrying about nulls, because not checking for null on a nullable type is a compile error, and so it's impossible to forget about the null case. Maybe it's why I don't see any issue with using them.

  • source
  • parent
  • hideshow 3 child comments
  • [–] 1 point 1 year ago (2 children)

    That is all just external implementation details. Not sure if it was you or someone else, but the main argument in defense of the OP as in it reasonable, was that the name is wrong. That it ought to be idAdmin. None of what you just described should have anything to do with user being or not being an admin. In place of checking “isAdmin” for null, the semantical and resourcewise equivalent would be a third variable for “admin rights having been validated” or whatever. Conflating it in this one variable while renaming it to isAdmin or similar, would be even less sensical.. what if somewhere else in the code you have to check whether the initial validations have been made (while the actual role or whether is admin or not is irrelevant), you’d have to check if isAdmin equals null, which in that context would be confusing, ambiguous (i.e someone reading that bit will not know this is what is being checked without additional documentation) and just a code smell in general. You do want to make the important things unambiguous and self-documenting. Even more so the bigger the codebase is and the more contributors there are across its lifetime and in parallel at any given time.

    But if we go with the original meaning of roles overall, then the union type is just a code smell that warrants a proper role thing around it.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 1 point 1 year ago* (last edited 1 year ago) (1 child)

    what if somewhere else in the code

    Then you'd need to do something else.

    the semantical and resourcewise equivalent would be a third variable

    So you are advocating for:

    data class Filters(
        val isAdmin: Boolean = false,
        val filterByAdmin: Boolean = false,
        val isConfirmed: Boolean = false,
        val filterByConfirmed: Boolean = false,
    )
    
    fun filterUsers(users: List<User>, filters: Filters): List<User> {
        return users
            .filter { !filters.filterByAdmin || it.isAdmin == filters.isAdmin }
            .filter { !filters.filterByConfirmed || it.isConfirmed == filters.isConfirmed }
    }
    
    fun getAdmins() {
        val users = getUsers()
        val filters = Filters(isAdmin = true, filterByAdmin = true)
        val admins = filterUsers(users, filters)
        println("Admins: $admins")
    }
    

    Over:

    data class Filters(
        val isAdmin: Boolean? = null,
        val isConfirmed: Boolean? = null,
    )
    
    fun filterUsers(users: List<User>, filters: Filters): List<User> {
        return users
            .filter { filters.isAdmin == null || it.isAdmin == filters.isAdmin }
            .filter { filters.isConfirmed == null || it.isConfirmed == filters.isConfirmed }
    }
    
    fun getAdmins() {
        val users = getUsers()
        val filters = Filters(isAdmin = true)
        val admins = filterUsers(users, filters)
        println("Admins: $admins")
    }
    

    To me, Filters(isAdmin = true) is a very easy to use API, where Filters(isAdmin = true, filterByAdmin = true), with the additional variable to avoid nullable booleans, is more verbose, for not much benefit and brings ambiguity. What if someone writes Filters(isAdmin = true), but forgets they need to set filterByAdmin = true for it to actually work? Easy mistake to make. We can prevent these mistakes by removing default values so they have to be specified on the call site, but then you need Filters(isAdmin = true, filterByAdmin = true, isConfirmed = false, filterByConfirmed = false), which is very verbose. Having two variables also allows your systems to get into invalid states:

    isAdmin = true, adminRightsHaveBeenValidated = false isAdmin = true, filterByAdmin = false

    What do these mean? It's better for invalid states to be unrepresentable. Since these states are mutually exclusive, we should have only 3 states, not 4 which you get with 2 booleans. Which you could achieve with an enum True, False, None, but then you are just reinventing the wheel of nulls. You also get the issue that now you have to remember to always update both variables together.

    It all comes back to your point:

    it’d be idiomatic and reasonable to assume it to be false if we have no data

    You want to have ambiguous states, where a single value represents both "we have no data" and "we have the data, the answer is no".

  • source
  • parent
  • hideshow 1 child comment
  • [–] 1 point 1 year ago

    Then you’d need to do something else.

    Precisely my point.

    And I’m not advocating for any of that. That’s just weird design, both of them, and as such a good example of something that warrants a bigger redesign in general.

    Just advocating for clear, sensible, self-documenting and most importantly, expandable and maintainable code.

    What’s idiomatic varies between languages and the conventions aren’t the same even then, when arguing across disciplines. This discussion seems to be more about different educations. I can get your point but from my personal experience in academia and working in the field it sounds undesired. But that’s just it. My, as in extremely limited, perspective. From your pov what you argue here is probably equally correct to what I think from mine is from my pov, it’s just a difference in the segment of the field we work in I suppose. Or plain old cultural differences.

    Whichever it is, I bet we both can find better use for our time. I’m thankful for the time and effort though, even if I wasn’t persuaded. Sorry to have prolonged it so.

  • source
  • parent
  • [–] 56 points 1 year ago (5 children)

    Ah, the ol' tristate boolean switcheroo

  • source
  • hideshow 5 child comments
  • [–] 4 points 1 year ago* (last edited 1 year ago) (2 children)

    tristate as in three states or tristate as in five states?

  • source
  • parent
  • hideshow 2 child comments
  • [–] 26 points 1 year ago (4 children)

    This is pretty clearly just rage bait. Nothing is actually setting the value so it's undef. Moreover there isn't any context here to suggest if the state definitions are determined by some weird api or are actually just made up

  • source
  • hideshow 4 child comments
  • [–] 8 points 1 year ago (3 children)

    Troof

    I mean facts. Facts is what the kids say. Facts.

  • source
  • parent
  • hideshow 3 child comments
  • [–] 13 points 1 year ago (1 child)

    Sadly this is (or used to be) valid in PHP and it made for some debugging “fun”.

  • source
  • hideshow 1 child comment
  • [–] 12 points 1 year ago

    I see this every sprint.

  • source
  • [–] 10 points 1 year ago (2 children)

    What if role is FILE_NOT_FOUND?!

  • source
  • hideshow 2 child comments
  • [–] 15 points 1 year ago (1 child)

    if it's 'FILE_NOT_FOUND' then the string will be read as truthy and you will get 'User is admin' logged.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 29 points 1 year ago (15 children)

    i would say why would you just not to isAdmin = true but i also worked with someone who did just this so i'll instead just sigh.

    also the real crime is the use of javascript tbh

  • source
  • hideshow 15 child comments
  • [–] 23 points 1 year ago (14 children)

    That's TypeScript. I can tell by the pixels defining a type above.

  • source
  • parent
  • hideshow 14 child comments
  • [–] 6 points 1 year ago (13 children)

    Was looking at it and could not figure out why their weren't any semicolon's.

  • source
  • parent
  • hideshow 13 child comments
  • [–] 13 points 1 year ago (12 children)

    Neither Javascript nor Typescript require semicolon, it is entirely a stylistic choice except in very rare circumstances that do not come up in normal code.

  • source
  • parent
  • hideshow 12 child comments
  • [–] 13 points 1 year ago* (3 children)

    Explanation for nerdsThe reason is the JS compiler removes whitespace and introduces semicolons only "where necessary".

    So writing

    function myFn() {
      return true;
    }
    

    Is not the same as

    function myFn() {
      return 
        true;
    }
    

    Because the compiler will see that and make it:

    function myFn() { return; true; }
    

    You big ol' nerd. Tee-hee.

  • source
  • parent
  • hideshow 3 child comments
  • [–] 5 points 1 year ago (1 child)
  • [–] 1 point 1 year ago

    Not wrong, but funnily enough, it's a linting rule win. I'd go nuts if I didn't have my type checks and my linters. My current L, though, is setting up the projects initially and dealing with the configuration files if I raw dog it, but that's a problem with ESLint configs and the ecosystem as a whole having to deal with those headaches. So in the end, the JS devs got clever and shifted the blame to the tooling. 😅

  • source
  • parent
  • [–] 4 points 1 year ago (4 children)

    That's good to know. Don't know how I didn't know this. Been writing JS since 2000. Always just used them I guess. Ecmascripts look funny to me without them

  • source
  • parent
  • hideshow 4 child comments
  • [–] 2 points 1 year ago* (2 children)

    Fair enough, I like it better without but I don't have a strong preference and have no issue adapting to whatever the style of the repo is.

    I learned about it researching tools to automatically enforce formatting style and came across StandardJS, which eliminates them by default.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 1 point 1 year ago (1 child)

    I can see the benefit of matching style when working with others. I only code for myself and never had to worry about conformity for project consistency.

    It is good to learn new things.

    I'm sure I have some coding habitats that would annoy others.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 2 points 1 year ago (2 children)

    Hmm, a webdev colleague said he'd normally prefer without semicolons, but used them anyways for better compile errors.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 1 point 1 year ago (1 child)

    Interesting, I'm not aware of any way they would affect compile errors. I'd be curious to know more.

  • source
  • parent
  • hideshow 1 child comment
  • [–] 2 points 1 year ago

    I don't have experience with how it affects JavaScript specifically, but independent of programming language, it usually removes the guesswork where the error might be.

    The thing is that compilers use fairly static rules for their grammar. So, even if you just typo a comma where there should've been a dot, then its grammar rules don't match anymore and it doesn't really know what to do with your code.
    To some degree, it's possible to say certain symbols just cannot appear in a specific place, but especially with a comma, it could be the start of the next element in a list, for example.

    Without semicolons, it's likely going to tell you that something's wrong between somewhere before your typo and the next closing brace (}). With semicolons, it can generally pinpoint the specific statement where the comma is wrong.
    This should also make analysis quicker while you're editing the code, as it only has to check one statement (or two, if you're inserting a new line and haven't typed the semicolon yet).

  • source
  • parent
  • [–] 7 points 1 year ago* (last edited 1 year ago)

    role is never instantiated, so the... privileged....logs.... will never be called

    Edit: Actually no logs at all, I read the null as undefined on first skim

  • source
  • [–] 4 points 1 year ago (1 child)

    And what if it's undefined?

  • source
  • hideshow 1 child comment
  • [–] 3 points 1 year ago

    You could make it even dumber by using weak comparisons.

  • source
  • What the fuck

  • source
  • [–] 1 point 1 year ago (2 children)

    Same as ?

    std::optional<bool> role;
    
    if (role.value())
    { std::cerr ("User is admin");}
    else if (!role.value())
    { std::cerr ("User is not admin");}
    else if (!role.has_value())
    { std::cerr ("User is not logged in");}
    

    Here has_value() should have been checked first, but the JS seems kinda fine.
    Which is it?

  • source
  • hideshow 2 child comments