Programming

Since you specifically mentioned C# : https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions

I'd be surprised if there is a serious language that doesn't come with at least some semi-official style guide. But usually they are not universally followed and everybody just does their own thing.

Rust has a style guide and comes with a linter. But I don't think you need to follow it if you don't want.

I'm fond of Go, which comes with its own auto formatter. It eliminates all arguments over style and format.

go fmt has been a thing for almost 11 years

If you're using visual studio (2022 is current) the idiomatic styling will be mostly correct by default (Ctrl k,e will reformat).

There's dotnet format which will format your code. You can configure it with editorconfig

For practical advice, I recommend starting a project with dotnet new editorconfig which covers many of the .NET coding conventions. If you want more strict standards you can use StyleCop, but you will need to configure it a bit to be consistent with the .NET conventions.

There are a few coding conventions and style guides for C#:

• .NET C# Coding Style
• .NET Framework design guidelines
• C# at Google Style Guide

lots of languages have linters to enforce style. Examples are jslint/eslint phplint, etc..

Most languages with "official" formatting guidelines are due to limitations of the compiler/interpreter. Mixing whitespace in Python (or older Fortran) is a great way to error out massively.

For the more modern compiled languages, there is no need. But there still tend to be popular formats from companies like Google

JavaScript / TypeScript are famously free-form, but a number of styles (and style-enforcing tools) have emerged.

“Prettier” is the most recent. It actually parses your code into an AST and then re-prints it according to its style.

“ESLint” is the most widespread; it is more of a framework into which rules can be plugged.

I use “XO”, which is essentially a custom eslint ruleset with a few other nice things tacked on.

The best part of eslint/xo is the “—fix” command, which can auto-fix most mistakes.

Python is unique in formatting forms part of the syntax, every language has linters but its far more common for orgs to tweak the default rules .

For example Java has Checkstyle. The default rules 'sun checks' give a line length of 80, tabs are 4 spaces and everything is placed on a new line.

Junior devs inevitably want to trash the line length (honestly on 1080p monitors, 120 makes sense,).

There is always a new line/same line discussion (everyone perfers same line but there is always one die hard new line person).

The tab width discussion always has one junior dev complain that "tabs are better", as someone who started development on Visual Studio 6 where half the team double spaced, the other half used tabs. Those people get a lecture from me on how we can convert tabs to spaces but not the inverse so it will always be spaces if I am near.

With Checkstyle you upload the rule file as an artifact into your M2 repository. Then you can pull it down as a dependency when the checkstyle plugin runs.

Sort of. Python is a lot more ceremonious about its PEPs or whatever, but there are official naming guidelines for .NET in general at least. The rest of it falls more under the general "this and that is considered 'good' code, this and that is not". You could prefer ancient-style C# or heavily functional C#, there's the SOLID stuff that applies both generally and specifically to OOP, etc

Javascript has airbnb style guide, enforceable through eslint. There's also react related eslint extensions to give you a lot of best practices to follow.

There's also prettier, which is just about formatting.

For Java, I guess this as official as you can get.

https://www.oracle.com/technetwork/java/codeconventions-150003.pdf

PHP has PSR-1, PSR-2 and now the updated PSR-12: https://www.php-fig.org/psr/psr-12/

Someone else already mentioned Rust, but to add to it, rustup installs rustfmt (opinionated formatter) and clippy (linter) by default, but you can choose not to run them or even install them. rustfmt has a few configuration options, but is for the most part strict in how it formats code.

PEP8 is nice since it sets some common rules across Python projects, but I'm not a fan of some of the decisions they made. The biggest one for me was discouraging defining variables/attributes/etc that use the same name as built-ins. That means no variable named input, no attr on your data model named id, etc. Still, since the language doesn't strictly enforce this, you can easily adjust these rules to meet your project's needs.

I believe go requires you to run the bundled formatter to even compile the code, but I could be misremembering.

In my experience, they're rarely as strictly enforced as e.g. flake8 does it for Python, but yeah, there is usually some resource suggesting a code style. If all else fails, you can look at some of the code the language authors have written. They'll usually have developed a rather consistent style...

C# has the Microsoft coding standards that are most accepted. PHP has the PSR standards. JavaScript has pretty much nothing and is the Wild West.

Those are the only ones I know about.