squaresinger @ squaresinger @lemmy.world

Posts

5

Comments

664

Joined

4 mo. ago

Thanks a lot for the summary! Hard to find information like that.

Is there a theme or something to the posts there?

Symbol names can be outdated as well, but what's worse is they can be flat-out wrong.

Real-life example that I had at my last job:

    
var isNotX = isX()

// somewhere else in the code:

var isX = isX()

fun isX() {
  // Code returns isNotX
}

  

That part of the code had a bug and it wasn't clear whether the function should return X or not X (the function was much more complex but returned a boolean).

A comment could have given context and/or be used as parity check for which implementation would have been correct.

This way I had to step through the whole flow just to figure out what it's doing and what it's supposed to do.

Harry Potter, especially in the first few books, is really not hard fiction at all. Rowling's worldbuilding is only there to make for a nice, somewhat magical backdrop for a children's story. Close to none of the in-universe rules she sets up really work if you look at them hard enough.

It starts with Wingardium Leviosa (and many other spells) blatantly breaking the laws of thermodynamics, thus allowing for infinite energy generation and thus infinite matter generation, but this continues not only throughout the magic system but also throughout every other system she sets up. Because most of it is nothing but a whimsical caricature of real things.

The money system is a caricature of the old British pre-decimal £sd money system.

Quidditch is a caricature of football (thousands of ways to perform a foul), rugby (brutal tackling and violence on the pitch) and cricket (a game can last for months) rolled into one.

The house system and house cup are only slightly embellished versions of what exists in real-life British boarding schools.

Just a few examples. The books are specifically not written in a rational-logical way. Attacking that is so easy that it's just boring. It's like proving that raindeer noses don't glow bright or that gingerbread lacks the static properties to be used to build life-sized houses for witches.

Was that Harry Potter and the methods of rationality?

I read the first dozen or so chapters maybe 10 years ago, until I realized that the total number of chapters approaches infinity and it got pretty boring after some time.

Not only are generally experienced developers really valuable, but developers experienced with the project they work on.

It takes a long time to actually understand everything in a large project, and if you do, you save a ton of time because you just know a lot of context already. No need to research or figure things out, you just know.

That's why the constant reorgs in larger corporations are incredibly hurtful to performance. If you want performance, let people stick to the few projects they know instead of switching stuff around all the time.

I know it was just an example, and examples are always contrived. It was just a good example to show how complexity can increase a lot if you use classes/types as glorified comments.

This total denial of the existence of comments, which is a common attitude right now, can easily do more harm than good, when you add code not for functionality but instead just to have more space for symbol names to put text into.

The project I worked on in my last job suffered a lot from this. It would lead to some really weird patterns, like e.g. this:

    
class BaseCommand {
    var commandType
}

class CreateCommand extends BaseCommand {
    public CreateCommand() {
        this.commandType = CREATE;
    }
}

  

We had dozens and dozens of classes that didn't actually contain any actual code, but were just flavour for "readability", which in turn just created garbage lines of code and all that trash would negate any potential benefits to readability. And since the code was spread out over so many classes it would mean that even simple changes would require touching tons of files.

I had, for example, a very simple 1 Story Point task to do. The whole task was "rename a variable", nothing more than that. I had to change 40 files. Not an exaggeration, it really was 40 files.

Code is for code, comments and external documentation are for documentation. Don't abuse one for the other.

I get headaches from caffeine. I prefer to go without headaches.

Btw, what does 196 stand for?

This.

Drinking is not a requirement. And if it is, you need better friends.

In some countries you can even lose your (car) driving license when cycling drunk.

TIL that I have been living dead for the last 30-odd years.

You can write comments, but you can’t make your colleagues read them. They don’t necessarily have to visit the originating file to read the docs.

When do you need documentation? When you are down in the code or when you are sitting on the toilet browsing Confluence? If your goal is to make people read the documentation, then the documentation needs to be immediately there where you need it, not in some external thing like Confluence.

Same goes with if your goal is to make people update the documentation. That's much more likely to happen if the documentation is in a comment in the code than when you first have to go hunting to find the correct page in that steaming pile of mess that is confluence.

Just be clear and explicit. Its not gaming; you dont have to care about losing a couple extra frames to type out a few extra characters. Most IDEs have sufficient autocompletes so it’s literally not even a problem in many cases.

You still only got so much screen real estate, and having huge names means that your lines get very long at times, which makes everything really hard to read.

Tbh, creating new code just to shorten variable names is pretty bad practice. Don't do that.

Each line of code needs to be maintained, each line of code can contain bugs and reusing such a class in locations it wasn't actually made for can cause more harm than good.

And if you are adding external information (e.g. via a class) why not just add that information as inline documentation (aka comments) instead? Most IDEs can handle that so that if you hover over the variable/function name it will display the documentation. And pretty much all IDEs allow you to navigate to declaration with just one click, and there you find the necessary information.

You example only gets worse if you keep nesting these things, so for example if I have:

    
int sleepIntervalSeconds = 0;

  

Then I immediately know:

• It's an int (not a double)
• It's an interval used for sleeping
• It's in seconds

(Putting all that in a comment instead of the variable name is almost equally as visible via IDE)

Instead consider your proposal, which would read like this:

    
Intervals var.sleep = 0;

  

I used var as the variable name since you abstracted the informations "sleep", "interval" and "seconds" into other definitions.

So now I still know it's an interval used for sleeping, but both the real variable type and the information that it's in seconds is gone. I have to navigate to the Intervals class/type to figure that out.

IRL this often gets even worse, because Intervals probably doesn't even contain the fields directly, but instead inherits from a Time class, which then inherits from some other class, and then you might get to the actual definition of the field.

This is only amplified by using Mixins and other obfuscation goodness.

If you have two options, and one option creates extra code, extra classes and extra code paths without reducing the complexity of the code significantly, than that's the worse option.

Congratulations, you figured out to do comments the wrong way.

You also figured out how to use a bad, unclear variable name, so should we also stop naming variables with sensible words since it can be done wrong?

External documentation can also be done badly, so let's stop doing that too.

Or what's your point?

I totally get your point.

I think the rule of "cleared its own orbit" tried to be less arbitrary and failed horribly.

A size threshold is clearly more consistent, but it's purely arbitrary, while the "cleared its own orbit" rule at least has the appearence of not being totally arbitrary, even though it introduces just the problem you are describing.

What kind of toes?

Pluto is a dog!

The main issue here is that everything from a speck of dust to the massive black hole at the centre of the galaxis is pretty much the same thing on a large spectrum.

You can clearly say that some grains of dust are something entirely different than a supermassive black hole, but it's really hard to find solid cut-off points to categorize anything in between.

So we started with a handful of arbitrary examples for each category, which was easy when we only had these examples, but with more and more discoveries the gaps between these examples are filled and it becomes a spectrum, and then it becomes iffy what exactly fits into which category.

Well, it is widely know.

Any time you cut off a spectrum you get weirdness around the edges.