dandi8

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.

It makes me sad to see people upvote this.

Robert Martin’s “Clean Code” is an incredibly useful book which helps write code that Fits In Your Head, and, so far, is the closest to making your code look like instructions for an AI instead of random incantations directed at an elder being.

The principle that the author of this article argues against seems to be the very principle which helps abstract away the logic which is not necessary to understand the method.

public void calculateCommissions() {
  calculateDefaultCommissions();
  if(hasExtraCommissions()) {
    calculateExtraCommissions();
  } 
} 

Tells me all I need to know about what the method does - it calculates default commissions, and, if there are extra commissions, it calculates those, too. It doesn’t matter if there’s 30 private methods inside the class because I don’t read the whole class top to bottom.

Instead, I may be interested in how exactly the extra commissions are calculated, in which case I will go one level down, to the calculateExtraCommissions() method.

From a decade of experience I can say that applying clean code principles results in code which is easier to work with and more robust.

Edit:

To be clear, I am not condoning the use of global state that is present in some examples in the book, or even speaking of the objective quality of some of the examples. However, the author of the article is throwing a very valuable baby with the bathwater, as the actual advice given in the book is great.

I suppose that is par for the course, though, as the aforementioned author seems to disagree with the usefulness of TDD, claiming it’s not always possible…

You seem to think that “open source” is just about the license and that a project is open source if you’re allowed to reverse engineer it.

You have a gross misunderstanding of what OSS is, which contradicts even the Wikipedia definition, and are unwilling to educate yourself about it.

You suggest that Mistral would need to lend us their GPUs to fit the widely accepted definition of OSS, which is untrue.

You’re either not a software engineer, or you have an agenda.

Because of this, I will not be continuing this conversation with you, as at this point it is just a waste of my time.

You’re, hopefully not on purpose, misunderstanding the argument.

You can download a binary of Adobe Photoshop and run it. That doesn’t make it open source.

I cannot make Mistral Nemo from just the open-sourced tools, therefore Mistral Nemo is not open source.

But then it’s the tools to make the AI that are open source, not the model itself.

I think that we can’t have a useful discussion on this if we don’t distinguish between the source code of the training framework and the “source code” of the model itself, which is the training data set. E.g, Mistral Nemo can’t be considered open source, because there is no Mistral Nemo without the training data set.

It’s like with your Doom example - the Doom engine is open source, but Doom itself isn’t. Unfortunately, here the analogy falls apart a bit, because there is no logic in the art assets of doom, whereas there is plenty of logic in the dataset for Mistral - enough that the devs said they don’t want to disclose it for fear of competition.

This data set logic - incredibly valuable and important for the behavior of the AI, as confirmed by the devs - is why the model is not open source, even though the training framework might be.

Edit:

Another aspect is the spirit of open-source. One of the benefits of OSS is you can study the source code to determine whether the software is in compliance with various regulations - you can audit that software.

How can we audit Mistral Nemo? How can we confirm that it doesn’t utilize copyrighted material to provide its answers?

We’ll have to agree to disagree on pretty much everything, then.