Hacker News new | past | comments | ask | show | jobs | submit
At a level or two down from the abstraction of company size, crafting hobbies are also a reprieve from the tyranny of linters. So many programmers today believe that code is always better when it all looks identical. Consistency is a good thing, but not when it's expected to be absolute. Programming should actually allow for creativity, and where you decide to add spaces and newlines can actually add subtle but important communication as to the significance of a particular part of one's code. Most places I've worked in the last 6 or so years are obsessed with tooling and add so many lint rules that it's often impossible to merge your pull request if you decide to format your code in a way that violates the rules in some trivial way.

With woodworking, you can just do the thing. OK, I don't do woodworking myself, but both of my parents do, and I know that they don't spend their time bikeshedding or homogenizing their work. The tools they use are intended to help them accomplish something and aren't there to prevent you from doing anything.

It's possible to do personal software projects however one wants, but one will no doubt be faced with the modern compulsion to want to "do the right thing" and add a bunch of time wasting tooling. If you don't, and you share your code, inevitably someone is going to want to add a bunch of rules and bureaucracy to your software that was already working and free of serious problems in the first place.

loading story #40248548
loading story #40247151
loading story #40248241
loading story #40248323
loading story #40248792
loading story #40246159
loading story #40246811
loading story #40246471
loading story #40248525
loading story #40246808
> a reprieve from the tyranny of linters

Consistency is dramatically overrated. We all read through comment threads on HN where each is written in it's own style and nobody has a problem understanding it. I read through open source repos all the time, which all have their own styles and which are often not self-consistent; my comprehension is not impaired. I have worked with teams that enforce linting with a religious fervor and teams where anything goes. The anything goes team is probably more productive and with a comparable rate of bugs (but I don't have the metrics to prove it). Personally, I don't feel like my comprehension is better or worse in one setting or the other.

The difference I do notice is that when there are no linters, nobody wastes time trying to figure out how to work around it for a few lines. A great example is Eigen matrix initialization through the stream operator overload [1]. You really want to manually format that so each row is on it's own line. If you use clang-format in such code, it will be littered with

    MatrixXf mat(2, 2);
    // clang-format off
    mat << 1, 2, 
           3, 4;
    // clang-format on
which adds a ton of unnecessary noise which does impair reading.

[1] https://eigen.tuxfamily.org/dox/group__TutorialAdvancedIniti...

loading story #40258152
loading story #40250293
loading story #40247672
loading story #40248842
loading story #40252599
loading story #40252386
loading story #40250836
loading story #40247989
loading story #40246524