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.
Just to add, I’d argue dotnet has one of the best sets of guidance on style. It goes beyond just naming and towards how to structure code for easier consumption and consistency. People love to dump on MSFT, but the dotnet platform is superb.
https://learn.microsoft.com/en-us/dotnet/standard/design-guidelines/
Highly agree. I’ve been writing code since I was in the single digits and while these days I write mostly Python, Haskell, and C++, I was blown away by the quality of C# and dotNET’s documentation (used it for a few Unity projects) to the point I actually miss it and am considering C# for a Godot project.
I’m not at all a fan of Windows, Office, Azure etc but Microsoft truly got C# right.
I'd be surprised if there is a serious language that doesn't come with at least some semi-official style guide.
Does JavaScript have one?
Edit: Except google's style guide
Google's, Mozilla's and Apple's style guides are pretty much as official as you're gonna get here.
The 'prettier' formatter is also rather popular and as such its stylistic choices, although that is of course moreso a hammer than a guide.
Is JavaScript a serious language? /s
Joking aside: One of Brendan Eich's books probably contains something resembling a style guide.
Eslint rules and prettier. I use the AirBnB ruleset as a base close to my personal preferences and then customize to my liking.
I don't really have to do any manual formatting. I just save to apply the formatting.
edit: javascript
Java walks in, whose stdlib uses different styles in the same file.
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.
Rust, like the majority of modern languages, has an official formatter which everyone should be using. Formatters are good enough nowadays that everyone should be using them.
What other languages have formatter programs?
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
Permanently Deleted
If you're using visual studio (2022 is current) the idiomatic styling will be mostly correct by default (Ctrl k,e will reformat).
I've found it to be less strict than I'd prefer. Things like whether parameters are aligned or indented, whether or not the first one is on its own line, what statements are indented in fluent calls that have blocks, etc.
A lot of other formatters (prettier, anything for python, etc) force something consistent in those cases, whereas it seems like the dotnet formatter prefers to leave things as they were.
I'd love for it to be more opinionated and heavy handed if anyone has suggestions
I've never looked into it very deeply, but it uses a styling spec called EditorConfig. Check it out, https://editorconfig.org/
There's
dotnet formatwhich will format your code. You can configure it with editorconfigFor practical advice, I recommend starting a project with
dotnet new editorconfigwhich 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#:
lots of languages have linters to enforce style. Examples are jslint/eslint phplint, etc..
ESLint will hurt your feelings.
Anyway, I didn’t setup the tooling, and it can be configured to enforce code styles, as it does with each commit. It also enforces rules, but can enforce code style as well.
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.
The last part is why you use an IDE.
Several of them will ingest prettier files to build code formatting rules
- https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode
- https://www.jetbrains.com/help/webstorm/prettier.html
- https://marketplace.eclipse.org/content/prettier-formatter
IDE support is normally a good way to work out what the wider community is using.
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
You say this, but C# does have official code style conventions. It's not about the compiler at all but about ensuring a relatively homogeneous coding style across the ecosystem, so a .NET dev can work on different projects without needing to refamiliarize.
If indentation and newline policies prevent developers from migrating from one project to another then either your developer suck or your language does.
That said, C# is somewhat special in that it is both a language and a corporate flag by Microsoft. Similar to how Google pushes to have their style guides made public so that other projects will adopt them. Which has less to do about making it so that one developer can bounce between projects (because they should be able to anyway) but to instead push Google as the goal everyone aspires to and emulates.
Someone else already mentioned Rust, but to add to it,
rustupinstallsrustfmt(opinionated formatter) andclippy(linter) by default, but you can choose not to run them or even install them.rustfmthas 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 namedid, etc. Still, since the language doesn't strictly enforce this, you can easily adjust these rules to meet your project's needs.I believe
gorequires you to run the bundled formatter to even compile the code, but I could be misremembering.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
PHP has PSR-1, PSR-2 and now the updated PSR-12: https://www.php-fig.org/psr/psr-12/
I refuse to believe that people use a php style guide. I have yet to open a php file in the course of any job that doesn't mix tabs and spaces arbitrarily on top of numerous other horrors.
Luckily it's not often that I have to, so sample size may play in a bit...
For Java, I guess this as official as you can get.
https://www.oracle.com/technetwork/java/codeconventions-150003.pdf
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.
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.
In my experience, they're rarely as strictly enforced as e.g.
flake8does 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.
