News for hackers. Stuff that matters.
Re:When are enums not a code smell? by cle on Monday November 22, 2021 @08:59AM (#29306332)
Can you elaborate on your shallow dismissal?
Re:When are enums not a code smell? by flaviu1 on Monday November 22, 2021 @09:10AM (#29306426)
I'd expect it to go something like this:

- There are many many languages without classes that make good use of enums

- Doing this refactoring is excessively verbose

- Someone making bold claims like this about a language feature that's never been considered error prone and been around since the beginning ought to provide some really good evidence to back things up.

There's cases where enums are good, and there's cases where polymorphic classes are good. Dismissing one of them by default is wrong, since both are useful at different times.

edit: and the citation there to Martin Fowler et al., Refactoring: Improving the Design of Existing Code doesn't even match the claim being made. That book mentions

- "The first part of this problem is that switch statement. It is a bad idea to do a switch based on an attribute of another object. If you must use a switch statement, it should be on your own data, not on someone else's." -- sure, I agree

- "Often you find the same switch statement scattered about a program in different places. If you add a new clause to the switch, you have to find all these switch, statements and change them. The object-oriented notion of polymorphism gives you an elegant way to deal with this problem." -- fair enough

This is a long way from "enums are a code smell," and honestly feels like padding the citation count. Another thing to note is that the second edition of Refactoring: Improving the Design of Existing Code says:

> Even in our more wild-eyed youth, we were never unconditionally opposed to the conditional. Indeed, the first edition of this book had a smell entitled “switch statements.” The smell was there because in the late 90’s we found polymorphism sadly underappreciated, and saw benefit in getting people to switch over.

> These days there is more polymorphism about, and it isn’t the simple red flag that it often was fifteen years ago.

Re:When are enums not a code smell? by oflannabhra on Monday November 22, 2021 @10:03AM (#29306989)
In Swift specifically, switch statements are exhaustive, so adding a new case to an enumeration that is switched on will automatically give you compilation errors at every point in the code base where that enum is matched against.

Which, in my experience is a huge advantage rather than the supposed disadvantage Fowler is saying it is (although I could see that being the case in many other languages).

Re:When are enums not a code smell? by bryanrasmussen on Monday November 22, 2021 @10:04AM (#29307007)
>This is a long way from "enums are a code smell,"

originally the meaning of code smell was not that code that had the smell was bad, but there was a chance it was and should be examined. For this reason of course it is useful to get rid of code smells so that people don't feel the need to investigate hey is this smelly code actually bad code.

But all that said not sure if an enum is a code smell.

on edit: this at any rate was the rationale behind the phrase code smell I was first introduced to.

Re:When are enums not a code smell? by masklinn on Monday November 22, 2021 @09:52AM (#29306855)
> - "Often you find the same switch statement scattered about a program in different places. If you add a new clause to the switch, you have to find all these switch, statements and change them. The object-oriented notion of polymorphism gives you an elegant way to deal with this problem." -- fair enough

Even that seems like it could easily be way overkill e.g. if you have multiple switches which, say, generate a label from an enum, the first step is probably to add a utility function / method, not to migrate the whole thing over to polymorphism.

Although there is one thing to be said about context:

* OP works in C#, whose enums are literally useless (they’re like C’s)

* apparently even in Java (which at least has type-safe enums even if not sum types), `switch` is unable to check for completeness

Re:When are enums not a code smell? by couchand on Monday November 22, 2021 @10:05AM (#29307023)
Generally the issue with the switches scattered about (or more generally, and concern about conditions scattered about the codebase) is that the body of each case is different. Of course if all the bodies are the same the easier option is a utility method.
Re:When are enums not a code smell? by aardvark179 on Monday November 22, 2021 @11:45AM (#29308428)
Switch statements are not required to be exhaustive, but switch expressions are. I’d have to check but I think it was found that changing the exhaustiveness requirement would break too much source code. The compiler will still insert some some sort of default case because somebody might add to the enumerator, and it might be in a separate compilation unit.
Re:When are enums not a code smell? by jaywalk on Monday November 22, 2021 @10:47AM (#29307637)
As someone who works in C# and finds enums useful, I'd be curious to know why you describe them as literally useless.
Re:When are enums not a code smell? by masklinn on Monday November 22, 2021 @11:09AM (#29307925)
A C# enum is, like a C enum (as they were explicitly introduced to be compatible with those), just a bunch of constants for integers.

So when you have an enum-typed value, odds are good that it’s one of the named ones but there’s no mechanism anywhere preventing it to be any other integer of the underlying type.

Re:When are enums not a code smell? by Semaphor on Monday November 22, 2021 @11:44AM (#29308423)
But how is that an issue? I guess when you are casting random integer to the enum-type without any checks?
Re:When are enums not a code smell? by masklinn on Monday November 22, 2021 @12:00PM (#29308616)
> But how is that an issue? I guess when you are casting random integer to the enum-type without any checks?

Any caller can send any garbage (if you're publishing a package / API), likewise a dependency can return any garbage, etc... C#'s enums are entirely indicative.

Re:When are enums not a code smell? by Semaphor on Tuesday November 23, 2021 @02:30AM (#29315444)
Then you have the default path, throwing an exception. I don’t see how that is different from accessing an array with an OOB index.
Re:When are enums not a code smell? by dtech on Monday November 22, 2021 @09:35AM (#29306679)
This might have been valid in 00's Java/C#. However, most modern languages and even Java 16+ have good Enum support and exhaustiveness checks, making them very convenient and safe to express a limited set of possible values.

In contrast, an alternative like polymorphism + a visitor is safe, but excruciatingly verbose and hard to follow and modify.

Re:When are enums not a code smell? by strulovich on Monday November 22, 2021 @09:14AM (#29306464)
For me it’s the following: - going for polymorphic classes instead of a few switches can cause bad coupling of knowledge. ( For example, instead of a switch on what to log in module A and the same for module B, now you’re mixing code from these two modules due to a shared constant.

Sometimes these polymorphic classes make sense, but my experience is that it’s a minority, and it’s better to err on the side of some simple enums.

Also note that Uncle Bob in Clean Code pretty much directly opposes in one of the chapters about logic and data separation (can’t find the chapter right now since I don’t have the book anymore)

Re:When are enums not a code smell? by mannykannot on Monday November 22, 2021 @10:39AM (#29307530)
Fivelessminutes's dismissal is indeed shallow, but then again, the rule being dismissed looks like shallow dogma (though we are not seeing it in context.)

Enums are essentially categorical variables, and there is nothing wrong with that: they are widely used in statistics and other real-world applications (arguably, even, booleans are a case of such.)

As a junior programmer, I was once assigned to work on an example of what could happen as a result of following this advice: an explosion of subclasses for the sake of avoiding a few conditional clauses. Algorithms had been broken up so that the common parts could be put in base classes, and you had to jump all around the code to see what was going on. Worse, objects could change their categorization during their lifetime, which required the substitution of a new object for the previous one. This complexity was contagious; once this one type was implemented in this manner, a lot of other things had to follow suit.

This was one of the experiences that turned me into a skeptic with regard to the proposition that there's no problem that cannot be simply solved by being more object-oriented.

Re:When are enums not a code smell? by kaetemi on Monday November 22, 2021 @10:04AM (#29307010)
The OO story generally falls apart once you go outside of the module/library, and want to actually treat objects like generic objects, and have new custom behaviour for some types of objects.

Either you end up with 'scary' enums, or with dynamic_cast and 'scary' null pointers.

Re:When are enums not a code smell? by coldacid on Monday November 22, 2021 @09:47AM (#29306797)
Mark Seemann started it first.