u/gosh

I am new to a team that have selected CSharpier and I do not like it at all. Not because it is a style that I do not use but that is tooooo rigid. You cant customise it.
And this makes developers stop caring about how they write code. It's too much trouble to format code differently when it is needed, and it's too easy to forget to add csharpier-ignore.

Writing code is art, you need to manage code like a painting and everything needs to fit together.

This is a lot harder with a rigid formater.

I don't even need to say that the code in this new team is... how do I put it? Not good.

"Single Responsibility" sounds easy until you try to define "One Thing". How do you actually draw the line?

The S in SOLID stands for the Single Responsibility Principle (SRP). Saw this explanaition: "A class or module should do one thing, and do it well."

But in the real world, what actually constitutes "one thing" in programming?

Depending on your abstraction level, "one thing" can mean completely different things

• Is saving a user to a database "one thing"?
• Is inserting a record to database "one thing"?
• Is handling an HTTP request "one thing"?

How do you personally define what "one thing" is? Is it purely a context-driven decision, meaning that "one thing" shifts depending on the scope of the project?

And if it depends on context, how do you define and communicate those rules to the rest of your team so everyone stays aligned and knows how to work with the code?

Also, why do you think this matters? There is always a underlying reason for trying to enforce this "one thing" concept in code. What are you actually trying to achieve with it, and why is it important to you?

Last one, for some this S in SOLID id easy, why so? Is it a something that is difficult to learn and understand

Back in the 80s when we coded on monochrome CRTs with maybe 40 characters of width and no syntax highlighting, putting a space between keywords and parentheses was useful. Then you were not able to switch between files as easy as modern editors today etc. And today there is color coding. Not only is it easy to find keywords today, code is also written differently because when you only have 40 characters to play with you start to think about "do I need indentation...".

There was several reasons to make these very important keywords to stand out in that environment.

But WHY are developers today still writing space between these keywords and the first ( ?

Sample code

// Old – space as a visual separator
if (x)    while (y)    for (i=0;i<n;i++)    switch (v)

// New – editor colors keywords already
if(x)     while(y)     for(i=0;i<n;i++)     switch(v)


// === OLD STYLE (1980s/early 90s) ===
// Monochrome screens, 40-char width. The space visually separates
// keywords from method calls when everything looks the same.

if (condition)
{
    while (running)
    {
        for (i = 0; i < 10; i++)
        {
            switch (value)
            {
                case 1:
                    return (result);
                default:
                    catch (exception)
                    {
                        // ...
                    }
            }
        }
    }
}

// === MODERN STYLE (2020s) ===
// Syntax highlighting makes the space redundant.
// Your editor already solved this problem.

if(condition)
{
    while(running)
    {
        for(i = 0; i < 10; i++)
        {
            switch(value)
            {
                case 1:
                    return(result);
                default:
                    catch(exception)
                    {
                        // ...
                    }
            }
        }
   }
}

I’m preparing a presentation on how automatic formatters can actually ruin code management over time. This relates heavily to the ongoing discussions about C++ memory safety and why some people see it as a critical issue while others don't get the fuss since basic memory allocation isn't that hard.

Memory issues are usually just a symptom of architectural failure, not a lack of developer skill in handling allocations. A messy architecture turns minor oversights into catastrophes. That's when hidden memory leaks or memory corruption become critical safety flaws and crashes.

I often think about the (nowadays) hated Hungarian Notation. Love it or hate it, it made developers extremely efficient because it provided immediate visual cues. Developers who actively care about the visual shape of text think completely differently about code structure. If you look at Charles Simonyi's other work, it’s clear how much focus he had on architecture.

Formatters can be an absolute disaster for architecture. It has become a religion in development teams that everything must be run through Prettier or Clang-Format to the letter. But the price we pay is that formatters erase all opportunities for visual cues regarding architecture and layers.

Architecture is WAY more important than formatting.

Code is text. By deliberately allowing flexibility in how to format, we can highlight major patterns and make code much easier to reason about. When a formatter forces all code through the same rigid, mechanical template, all code looks identical. The architecture becomes invisible. Ironically, this causes codebases to rot because developers in the team can no longer see where the architectural boundaries actually are.

Formatting in itself isn't bad, but it must be a formatting style that elevates the architecture and allows for human semantic grouping. The opposite is dangerous.

As far as I know, there is no formatter out there today that is anywhere near capable of handling the flexibility required to actually make architecture visible in code.

What are your thoughts on this? Have formatters made us blind to the actual structure and layer belonging of our code?

EDIT

To those of you who only see problems with this approach: what is your actual alternative for managing cognitive load at scale?

The common stance seems to be "just write code however you want, as long as the automatic formatter makes the layout look consistent."

But formatting only fixes cosmetic consistency, it doesn't fix structure, architectural boundaries, or intent. If you believe that naming conventions, prefixes, and semantic text layouts are useless, you are essentially advocating for visual anarchy disguised as "clean text". How does a mechanical linter help a new developer navigate architectural layers in a large codebase if the code itself provides zero visual cues about where the boundaries go?

Gamer Nexus have done a lot of good videos about AI and the insane prices and overvalued companies that do not earn money.

It's a monopoly that do not want to sell personal computers, they want us to rent it. We should use terminals connected to data centers.