dandi8

Ah, yes, because if you do a modicum of prevention, like wearing a mask, you’re obviously missing life and there’s definitely no way to keep up with the world unless you just completely give up on safety. No in-between, snort covid or become a social shut-in.

/s

Over my dead body.

Not sure the son would see it the same way…

FYI there’s a fully playable unofficial port for Jak 1 and 2, and they’re working on the 3rd one: https://opengoal.dev/

deleted by creator

Pegasus?

I feel like I’d believe it if the headline was about John McAfee.

In my experience LLMs do absolutely terribly with writing unit tests.

IMO this perspective that we’re all just “reimplementing basic CRUD” applications is the reason why so many software projects fail.

Good abstractions are important for the code to be readable. An AbstractEventHandlerManager is probably not a good abstraction.

The original commenter said that their code was “generic with lot of interfaces and polymorphism” - it sounds like they chose abstractions which hindered maintainability and readability.

Is it possible that you just chose the wrong abstractions?

I do, and whether I have a good time depends on whether they have written their code well, of which the book’s suggestions are only one metric.

How do abstractions help with that? Can you tell, from the symptoms, which “level of abstraction” contains the bug? Or do you need to read through all six (or however many) “levels”, across multiple modules and functions, to find the error?

I usually start from the lowest abstraction, where the stack trace points me and don’t need to look at the rest, because my code is written well.

It’s only as incomprehensible as you make it.

If there are 6 subfunctions, that means there’s 6 levels of abstraction (assuming the method extraction was not done blindly), which further suggests that maybe they should actually be part of a different class (or classes). Why would you be interested in 6 levels of abstraction at once?

But we’re arguing hypotheticals here. Of course you can make the method implementations a complete mess, the book cannot guarantee that the person applying the principles used their brain, as well.

I never claimed it’s not important, I’m just saying it’s not relevant here, as there is no context to where this method was put in the code.

As I said, it might be top-level. You have to mutate state somewhere, because that’s what applications ultimately do. You just don’t want state mutations everywhere, because that makes bad code.

Clean code does not prevent writing bad code, it just makes it a bit easier to write good code.

OF COURSE you can follow the principles and still write bad code, because so much more goes into it, including skill.

A giant method with everything laid out, potentially mixing abstractions sounds like a nightmare to me. It leads to cognitive overload.

You’re nitpicking.

As it happens, it’s just an example to illustrate specifically the “extract to method” issues the author had.

Of course, in a real world scenario we want to limit mutating state, so it’s likely this method would return a Commission list, which would then be used by a Use Case class which persists it.

I’m fairly sure the advice about limiting mutating state is also in the book, though.

At the same time, you’re likely going to have a void somewhere, because some use cases are only about mutatimg something (e.g. changing something in the database).

And yet, outdated comments are far, far more common than outdated function names.

Also, if you’re changing a comment which explains the “what”, you should likely change the method name, as well.

It’s important for the client to know what the method does by looking at the name, so why would you duplicate your effort?

You’re talking about assembly in a thread about OOP…

Comments should never be about what is being done. They should only ever be about why it is being done.

If you write your code like suggested in the book, you won’t need to rely on possibly outdated comments to tell you what’s going on.

Any comment about “what is being done” can be replaced with extracting the code in question to a separate, well-named method.