• Sibbo@sopuli.xyz
    2·
    6 months ago

    The real joke here is that after causing millions of pointless refactorings and rewrites, now finally the source book is affected as well.

    • addie@feddit.uk
      1·
      6 months ago

      You can write an unmaintainable fucking mess in any language. Rust won’t save you from cryptic variable naming, copy-paste code, a complete absence of design patterns, dreadful algorithms, large classes of security issues, unfathomable UX, or a hundred other things. “Clean code” is (mostly) a separate issue from choice of language.

      Don’t get me wrong - I don’t like this book. It manages to be both long-winded and facile at the same time. A lot of people seem to read it and take the exact wrong lessons about maintainability from it. I think that it would mostly benefit from being written in pseudocode - concentrating on any particular language might distract from the message. But having a few examples of what a shitfest looks like in a few specific languages might help

    • BatmanAoD@programming.dev
      1·
      6 months ago

      Unlikely, unless his view has changed substantially in the last seven years: https://blog.cleancoder.com/uncle-bob/2017/01/11/TheDarkPath.html

      I think his views on how to achieve good quality software are nearly antithetical to the goals of Rust. As expressed in that blog post and in Clean Code, he thinks better discipline, particularly through writing lots and lots of explicit unit tests, is the only path to reliable software. Rust, on the other hand, is very much designed to make the compiler and other tooling bear as much of the burden of correctness as possible.

      (To be clear, I realize you’re kidding. But I do think it’s important to know just how at odds the TDD philosophy is from the “safe languages” philosophy.)

      • nous@programming.devEnglish
        0·
        6 months ago

        This is an absolute terrible post :/ I cannot believe he thinks that is a good argument at all. It basically boils down to:

        Here is a new feature modern languages are starting to adopt.

        You might thing that is a good thing. Lists various reasonable reasons it might be a good thing.

        The question is: Whose job is it to manage that risk? Is it the language’s job? Or is it the programmer’s job?

        And then moves on to the next thing in the same pattern. He lists loads of reasonable reasons you might want the feature gives no reasons you would not want it and but says everything in a way to lead you into thinking you are wrong to think you want these new features while his only true arguments are why you do want them…

        It makes no sense.

        • Sleepless One@lemmy.mlEnglish
          01·
          6 months ago

          Yeesh, I thought you were being hyperbolic, but it really is that bad! He even has this massive self report towards the end:

          And how do you avoid being punished? There are two ways. One that works; and one that doesn’t. The one that doesn’t work is to design everything up front before coding. The one that does avoid the punishment is to override all the safeties.

          And so you will declare all your classes and all your functions open. You will never use exceptions. And you will get used to using lots and lots of ! characters to override the null checks and allow NPEs to rampage through your systems.

          Uncle Bob must be the kind of guy who makes all of his types any when writing Typescript.

  • Prunebutt@slrpnk.net
    1·
    6 months ago

    I don’t really get the hate he gets in the other comments. Are you all joking, or can someone elaborate? I always liked what I’ve read/heard of Bob.

    • ByteOnBikes@slrpnk.net
      1·
      6 months ago

      I’m not as much vitriol as others about Clean Code, but I will argue that engineers who preach the book as some sort of scripture are really obnoxious.

      I love the Single Responsibility Principle, in theory.

      What I don’t like is when devs try to refactor everything to that idea to achieve “Clean Code”. I’ve seen devs over-architect a solution, turning one function into many, because they don’t want to break that rule. Then point to this book as to WHY their code is now 20x longer than it needs to be.

      It also doesn’t help that every recommendation about good programming books include this.

      It’s like recommending a Fitness book from the 70s - information made sense at the time, but new research has made a lot of the advice questionable.

      My main issue is the whole “Uncle Bob” persona. Robert C Martin is sexist and a racist, and has been uninvited by conferences. We don’t need that type of toxicity in the industry.