131
I love programming but I hate the programming industry (www.deathbyabstraction.com)
submitted 2 years ago by to c/programming@programming.dev
44 comments fedilink hide all child comments
 

I don't entirely subscribe to the first paragraph – I've never worked at a place so dear to me that spurred me to spend time thinking about its architecture (beyond the usual rants). Other than that, spot on

you are viewing a single comment's thread
view the rest of the comments
[–] 14 points 2 years ago (5 children)

I believe refactoring never ends. Just because it works, doesn’t mean it can’t work better. The better it works, the easier it will be to add features… that can be refactored too.

  • permalink
  • fedilink
  • source
  • hideshow 5 child comments
    •
  • [–] 7 points 2 years ago (2 children)

    Bosses will never understand this and discourage refactoring until months later nothing works and everything has to be rewritten...

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 7 points 2 years ago

    Refactoring should not be a separate task that a boss can deny. You need to do feature X, feature X benefits from reworking some abstraction a bit, then you rework that abstraction before starting on feature X. And then maybe refactor a bit more after feature X now you know what it looks like. None of that should take substantially longer, and saves vast amounts of time later on if you don't include it as part of the feature work.

    You can occasionally squeeze in a feature without reworking things first if time for something is tight, but you will run into problems if you do this too often and start thinking refactoring is a separate task to feature work.

  • permalink
  • fedilink
  • source
  • parent
  • [–] 5 points 2 years ago

    So true! That's why I never use 'the R word'.

    Instead, I use synonyms:

    • performance tuning
    • proactive maintenance
    • fixed a subtle bug
    • fixed a failing test
    • corrected a CI/CD failure

    CI/CD failure is my favorite, because technically our CI/CD enforces a code review, so technically "we don't like how this is written" counts as a CI/CD failure.

  • permalink
  • fedilink
  • source
  • parent
  • [–] 5 points 2 years ago* (last edited 2 years ago)

    I agree; I prefer a "hammer and chisel" strategy, I tend to leave things a little less precisely organized/factored earlier in the project and then make a some incremental passes to clean things up as it becomes more clear that what I've done handles all the cases it needs to handle.

    It's the same vein as the "don't prematurely optimize."

    Minimizing responsibilities of individual functions/classes/components is the only thing that I take a pretty hard line on. Making sure that I can reason about the code later and objectively say simple sentences like "given X this does Y." I want all the complex pieces to be isolated into their own individual smaller pieces that can be reasoned about.

    All of the code bases I've been in where I go "oh my god why", the typical reason is been because that's not true; when I'm in the function I don't know what it does because it does a lot of things depending on different state flags.

  • permalink
  • fedilink
  • source
  • parent