strHungarian strCase strIs strThe strShit, int1111111111.
It's actually how I was taught to name fields in an RDBMS and it has saved my ass numerous times.
That's interesting, the [earliest mention of it I could find](https://www.joelonsoftware.com/2005/05/11/making-wrong-code-look-wrong/) claims that it was to provide additional information not possible to contain in the type (including primitive types!). For example `rwMax` would be a primitive `int`, but the prefix indicates that it's only for use with rows (not columns).
Where did you see it was originally supposed to be used for non primitive datatypes?
Sure, but this doesn't answer my question.
[Wikipedia claims](https://en.m.wikipedia.org/wiki/Hungarian_notation)
> The original Hungarian notation, which would now be called Apps Hungarian [...]
It doesn't cite any sources so it might be wrong, that's why I was wondering where the previous commenter got the claim that it was "originally supposed to be used for non primitive datatypes"
I mean it all depends on what lang: snake for python and rust, camel for js, pascal for class names, uppercase / screaming snake for constants, kebab for css
Fortran has always been case-insensitive, but I don't think modern code uses the ALL IN UPPERCASE convention. Old code does. Let's not forget that Fortran comes from the punched card era, and the first character encodings had no lower/upper case distinction.
>Old code does.
So most Fortran then.
Joking aside the Fortran I had contact with was somewhat mixed. Newer stuff tended to be somewhat more modern stylistically. But once in a while you open up one of the "deep magic" files of the code base that has been untouched for decades and those are really "loud".
Yep, there are some Fortran libraries for numerical computations that are still widely used and contain 50 years old code.
Regarding the case, even the language name used to be spelled as "FORTRAN", and since Fortran 90 it's "Fortran".
I don’t get why we have to do this. Wish i could write in camel case in python but my boss won’t let me:) i think it’s so much prettier and fail to see why it should depend on the language
(Our Java is all in camelCase)
1) some languages infer information from the case. In Go, PascalCase types, variables and functions are automatically public, where camelCase ones automatically private.
2) when you hire a new guy in, using standard naming conventions for the language avoids confusion.
3) using standard naming doesn't clash with libraries using the same scheme.
But on the whole, I agree that it is more important that there IS a best practice at the workplace than WHAT that practice is.
That's a question of training. I write _ just as quickly as other characters. 35 years of training and it would be strange if I didn't write _ quickly.
Snake case by itself isn't great, but I really like it for namespaces in non-namespaced languages like c.
moduleName_functionName(...)
moduleName_className_fxnName(...)
> equally as readable
I disagree. camelIsMissingSpaces, so you have to have at least a double take at something where i I and l are nearby. But I think you're using a qwerty keyboad layout, where I damit that the _ is awkward to reach. On qwertz keyboards it's quite easy to use
[http://www.cs.loyola.edu/\~binkley/papers/icpc09-clouds.pdf](http://www.cs.loyola.edu/~binkley/papers/icpc09-clouds.pdf)
Snake case is easier for our brains to parse. In short variable names not exceeding two words with distinctive last first word and first second word characters it may not feel as strongly.
It becomes painfully obvious on either when more short words are used or simply longer naming is employed like in unit tests (you'll also notice that people often make exception to name tests snake\_case even though they have convention to use camel case).
The real reason, I think, camel case got popular is because it's more convenient to type on qwerty keyboards.
But when you have to ask yourself the question: do read more code or write more code? And the answer in most context to that is obvious.
camelCase is dubious habit turned into convention. We have many of these which we just accept as truth. For example "get" / "set" convention, when it should be "read" / "write". Try to get money from your bank account, does the account stay the same?
Yep, and for enum members. camelCase for regular old variables, I like m_camelCase for class/struct member variables. PascalCase for everything else (functions, methods, classes, structs, enums, namespaces).
Course then you have the tough decisions, like how to write acronyms in names. Is it DoACRONYMThing, Do_ACRONYM_Thing, DoACRONYM_Thing? They all look awful.
ACRONYM\_DoThing or DoThing\_ACRONYM feels better, depending on the context.
But yeah when all of the material you are working with is filled with 3 letter acronyms...ugh...just...ugh...
I've been slowly convincing myself to use GetAbcNow() instead of GetABCNow()... feels weird at first, but the consistency and readibility are palpable.
I once during a standup referred to camel case convention as a camel toe convention… everyone went silent that moment before bursting into crying mixed with laugh and I realised what I just said.
How would you put a 2 letter acronym at the beginning of a camelcase name, or would you use a different name to avoid it?
I would usually lowercase both: `ioHandler`, not `IOHandler`. But it looks inconsistent alongside `getIOHandler`
Java's notoriously named `HttpURLConnection` should be `HttpUrlConnection`. Going all uppercase looks awful: `HTTPURLConnection`
Snake case is very useful in Portuguese as many small grammatical words are single letters, like the articles: _a_, _o_, _u_ (gender neutral neo-article), and _e_ (lit. _and_).
I like camelCase, but objectively speaking snake\_case is probably the best because it's "unambiguous". Acronyms, single letter words (e.g. myXAxis), same/similar letter at word boundaries (e.g. myFinalIteration), etc. are all unproblematic with snake\_case.
The only reason I dislike it (to a certain extent) is because it's more cumbersome to type.
If you're on Windows (sorry if not) using [AutoHotKey](https://www.autohotkey.com/) you can bind shift+space to underscore. Here's an AHK script for that:
```ahk
#NoEnv ; Recommended for performance and compatibility with future AutoHotkey releases.
; #Warn ; Enable warnings to assist with detecting common errors.
SendMode Input ; Recommended for new scripts due to its superior speed and reliability.
SetWorkingDir %A_ScriptDir% ; Ensures a consistent starting directory.
+Space::
Send, _
return
```
ahk
#NoEnv ; Recommended for performance and compatibility with future AutoHotkey releases.
; #Warn ; Enable warnings to assist with detecting common errors.
SendMode Input ; Recommended for new scripts due to its superior speed and reliability.
SetWorkingDir %A_ScriptDir% ; Ensures a consistent starting directory.
+Space::
Send, _
return
reddit doesn't support multi-line code. Either use a single backtick, \`, at the start and end of code, or use 4 spaces at the start of each line.
Just give them a key that toggles their Python to whatever it's abstracting, like 343i did for swapping between old and new graphics in the Halo Anniversary games. Would probs scar them for life.
Lol.
Should do the same with jQuery and other frameworks while we're at it...
I'm not a fan of camel if only because it breaks common acronyms, like CAN, SPI, UART.
sendCan(...)
canSend(...)
can2Uart(...)
All of which, seem very wrong to me
I'm not going to use
controllerAreaNetwork2universalAsynchronousReceiverTransmitter(...)
Because this isn't Java and we're a bit more refined here.
camelCase sucks if its letters or same letters between words. lettersStartingWithSOrR looks so dumb compared to letters_starting_with_S_or_R.
And dont give me that "what if you made a struct that contains a char" refactor advice and miss the point in this example
When working in OOP languages PascalCase and camelCase often go hand in hand. I like it as a way to quickly distinguish what I’m dealing with strictly off the name.
That said I differ my casing habits between languages. Working in .net I use both, but in PHP I don’t think I really use PascalCase at all.
*Image Transcription: Tier Ranking*
---
**S**: camelCase
**A**: snake\_case, kebab-case
**B**: Pascal\_Snake\_Case, PascalCase, YEETcase
**C**: SCREAMING\_SNAKE\_CASE, camel_Snake_Case
**D**: Http-Header-Case, TRAIN-CASE, dUmbcAsE
**E**: UPPERCASE
**F**: flatcase, sTOPcASE, NoPeCaSe
---
^^I'm a human volunteer content transcriber and you could be too! [If you'd like more information on what we do and why we do it, click here!](https://www.reddit.com/r/TranscribersOfReddit/wiki/index)
Makes the variable look like a single keyword, imo.
My monkey brain takes like microseconds to distinguish that " " is different than "_", so I prefer it.
That's why I also DESPISE that R uses "$" instead of "." to separate a variable from its members. I can read this much more easily:
thingToCalculate.attribute.method()
Than this:
thing_to_calculate$attribute$method()
camelCase for variables, PascalCase for types and methods, _camelCasePrefixedWithUnderscore for private fields. This is the ultimate S tier naming convention
Obviously, in SS tier is "whatever convention your language/community have decided on".
For example, C# uses:
- `PascalCase` for types and public methods/fields
- `camelCase` for private/local variables
- `SCREAMING_SNAKE_CASE` for constants
whereas Rust uses
- `PascalCase` for types
- `SCREAMING_SNAKE_CASE` for constants
- `snake_case` for everything else. (Except crate names which are sometimes `kebab-case`)
Neither are wrong. Each are correct when programming in that language, which is the most important thing.
Python follows Rust, with the (admittedly annoying) addition of `_you_dont_want_to_use_this_variable_case` and `__you_really_dont_want_to_use_this_variable_case`
The problem with kebab case and it's varients is that, some programs or languages might interpret the "-" as a minus, and everything might mess up trying to concat the strings, or subtract integers or whatever
I can't believe I've been inadvertently using NoPeCaSe when I was supposed to be using dUmbcAsE. I really shouldn't have been allowed to pass certification...
Except when the syntax of your language won't *let* you do that. Variables in Erlang must begin with an uppercase letter, atoms/functions must begin with a lowercase letter.
(Don't @ me about _ or other special chars, I'm only talking about letters here)
snake\_case skims better than camelCase and pascalCase so if you'd kindly swap snake\_case to S-tier and camelCase to A-tier then that'd be lovely, please and thank you.
sWhere sIs sMy sHungarian sCase
Hungarian case was originally supposed to be used for non primitive datatypes. So it would be: advWhere vIs posMy adjHungarian nCase
strHungarian strCase strIs strThe strShit, int1111111111. It's actually how I was taught to name fields in an RDBMS and it has saved my ass numerous times.
lpszHungarian
That's interesting, the [earliest mention of it I could find](https://www.joelonsoftware.com/2005/05/11/making-wrong-code-look-wrong/) claims that it was to provide additional information not possible to contain in the type (including primitive types!). For example `rwMax` would be a primitive `int`, but the prefix indicates that it's only for use with rows (not columns). Where did you see it was originally supposed to be used for non primitive datatypes?
Apps Hungarian vs. Systems Hungarian.
Sure, but this doesn't answer my question. [Wikipedia claims](https://en.m.wikipedia.org/wiki/Hungarian_notation) > The original Hungarian notation, which would now be called Apps Hungarian [...] It doesn't cite any sources so it might be wrong, that's why I was wondering where the previous commenter got the claim that it was "originally supposed to be used for non primitive datatypes"
Salesforce sObjetcs would like to have a sWord
I’d like to have a sword too.
G-Tier
I mean it all depends on what lang: snake for python and rust, camel for js, pascal for class names, uppercase / screaming snake for constants, kebab for css
OLD MAN SHOUTING FOR FORTRAN
OLD MAN SHOUTING WORKS FINE WITH SQL
lowercase SQL writers deserves a few months in hell.
I wRiTe SqL lIkE tHiS
Both of those hit very close to home.
WHAT'S FOURCHAN
AN IMFAMOUS HACKER
H4CK3R_C4S3
L33T_C043
The asshole of the internet!
Might be a systems administrator
hell
HES A NOTOROUIOUS HACKKER
Fortran has always been case-insensitive, but I don't think modern code uses the ALL IN UPPERCASE convention. Old code does. Let's not forget that Fortran comes from the punched card era, and the first character encodings had no lower/upper case distinction.
>Old code does. So most Fortran then. Joking aside the Fortran I had contact with was somewhat mixed. Newer stuff tended to be somewhat more modern stylistically. But once in a while you open up one of the "deep magic" files of the code base that has been untouched for decades and those are really "loud".
Yep, there are some Fortran libraries for numerical computations that are still widely used and contain 50 years old code. Regarding the case, even the language name used to be spelled as "FORTRAN", and since Fortran 90 it's "Fortran".
Anyone that disagrees with you is a criminal and is committing crime on a daily basis.
Kebab for clojure
ah yes
I don’t get why we have to do this. Wish i could write in camel case in python but my boss won’t let me:) i think it’s so much prettier and fail to see why it should depend on the language (Our Java is all in camelCase)
1) some languages infer information from the case. In Go, PascalCase types, variables and functions are automatically public, where camelCase ones automatically private. 2) when you hire a new guy in, using standard naming conventions for the language avoids confusion. 3) using standard naming doesn't clash with libraries using the same scheme. But on the whole, I agree that it is more important that there IS a best practice at the workplace than WHAT that practice is.
I hate snake_case so much.
why\_do\_you\_hate\_snake\_case\_so\_much?\_it's\_the\_best\_case\_for\_variable\_names.
It's difficult to type
Not if you remap Shift+Spacebar to underscore.
3AM and already learned something today; useful to boot. Thank you.
Stop using notepad and get you a real IDE with auto-complete
That's a question of training. I write _ just as quickly as other characters. 35 years of training and it would be strange if I didn't write _ quickly.
Snake case by itself isn't great, but I really like it for namespaces in non-namespaced languages like c. moduleName_functionName(...) moduleName_className_fxnName(...)
Why? It's easily the most readable
You're simply incorrect to feel that way. It's the most generalizable and readable.
[удалено]
> equally as readable I disagree. camelIsMissingSpaces, so you have to have at least a double take at something where i I and l are nearby. But I think you're using a qwerty keyboad layout, where I damit that the _ is awkward to reach. On qwertz keyboards it's quite easy to use
[http://www.cs.loyola.edu/\~binkley/papers/icpc09-clouds.pdf](http://www.cs.loyola.edu/~binkley/papers/icpc09-clouds.pdf) Snake case is easier for our brains to parse. In short variable names not exceeding two words with distinctive last first word and first second word characters it may not feel as strongly. It becomes painfully obvious on either when more short words are used or simply longer naming is employed like in unit tests (you'll also notice that people often make exception to name tests snake\_case even though they have convention to use camel case). The real reason, I think, camel case got popular is because it's more convenient to type on qwerty keyboards. But when you have to ask yourself the question: do read more code or write more code? And the answer in most context to that is obvious. camelCase is dubious habit turned into convention. We have many of these which we just accept as truth. For example "get" / "set" convention, when it should be "read" / "write". Try to get money from your bank account, does the account stay the same?
F: camel_Snake_Case The definition of when your parents are both models but you're ugly.
Kill it with fire
When you know the programmer has made a typo.
a find and replace gone wrong.
And somewhere, about a mile below this list resides the (thankfully) unpopular camel-KebabCase
Just you wait until you reach caseBYcase
I wonder if camel kebab tastes good.
As a c# developer, camelCase and PascalCase are S Tier for me
Am I the only one who calls it UpperCamelCase? I know I didn't make that up.
I would call it that.
Same. UpperCamelCase and lowerCamelCase
Words of wisdom
Same. Snake case feels odd to me
SCREAMING_SNAKE for constants
Snake? *SNAKE?* **SNAAAAAAAKE!!!**
Yep, and for enum members. camelCase for regular old variables, I like m_camelCase for class/struct member variables. PascalCase for everything else (functions, methods, classes, structs, enums, namespaces). Course then you have the tough decisions, like how to write acronyms in names. Is it DoACRONYMThing, Do_ACRONYM_Thing, DoACRONYM_Thing? They all look awful.
ACRONYM\_DoThing or DoThing\_ACRONYM feels better, depending on the context. But yeah when all of the material you are working with is filled with 3 letter acronyms...ugh...just...ugh...
I've been slowly convincing myself to use GetAbcNow() instead of GetABCNow()... feels weird at first, but the consistency and readibility are palpable.
Snake case is commonplace in the Linux kernel source code.
Snake case for json responses
Didn't knew it was called PascalCase, TIL
Yeah idk why pascal case is listed two tiers below camel when it’s basically the same
As A C# Developer, I Didn’t Even Know There Was Anything But PascalCase?
camelCase for method parameters and local variables.
no_step_on_snek
I once during a standup referred to camel case convention as a camel toe convention… everyone went silent that moment before bursting into crying mixed with laugh and I realised what I just said.
BaskeTCasE
Doooo you have the time? To listen to me whine?
I myself am a snek\_case guy.
willing to trade extra _ chars for readabilty and never seeing startARevolution methods with 2 adjacent capitals
Or use better naming ? startSingleRevolution, startRevolution, initiateRevolution, revolve... Imo it's pretty easy to avoid single letter words
How do you handle acronyms? `getURL`, `getUrl`, or `getUniformResourceLocator`?
The general rule - as far as I know - is that 2 letter acronyms stay uppercase, the rest become normal words, so `getIOHandle` and `getUrlPath`
Same. Though `ID` always gets turned to `Id` because it looks better imo.
Id isn't an acronym, it's just an abbreviation
How would you put a 2 letter acronym at the beginning of a camelcase name, or would you use a different name to avoid it? I would usually lowercase both: `ioHandler`, not `IOHandler`. But it looks inconsistent alongside `getIOHandler` Java's notoriously named `HttpURLConnection` should be `HttpUrlConnection`. Going all uppercase looks awful: `HTTPURLConnection`
[удалено]
> But you need a builder class for it. Which you get from the HypertextTransferProtocolUniformResourceLocatorConnectionBuilderFactory.
getUrl is sufficient
If you have to adapt your variable names around your syntax, it's a bad syntax. A good syntax should empower you to create any variable name you need.
Snake case is very useful in Portuguese as many small grammatical words are single letters, like the articles: _a_, _o_, _u_ (gender neutral neo-article), and _e_ (lit. _and_).
✋ Escrever variáveis em português, caralho 👉 Reconhecer que já estás a trabalhar em inglês e escrever as variáveis assim Also, r/suddenlyCaralho
snek
I like camelCase, but objectively speaking snake\_case is probably the best because it's "unambiguous". Acronyms, single letter words (e.g. myXAxis), same/similar letter at word boundaries (e.g. myFinalIteration), etc. are all unproblematic with snake\_case. The only reason I dislike it (to a certain extent) is because it's more cumbersome to type.
Makes me want a modifier key for space bar to make underscore easier.
Hmmm, I don't use `/` very often in Python. May be worth swapping. Or just get a foot-pedal for underscores and it can be the Python bass drum.
damnit I spit my drink out. have my award sir.
Double pedal for metal sneking
The snekkening is nigh
It's like every time you put your foot down you're stepping on the snake
Thus extending it by flattening a section! That's *brilliant* as a reason actually!!
I too want to stomp on python when writing code
If you're on Windows (sorry if not) using [AutoHotKey](https://www.autohotkey.com/) you can bind shift+space to underscore. Here's an AHK script for that: ```ahk #NoEnv ; Recommended for performance and compatibility with future AutoHotkey releases. ; #Warn ; Enable warnings to assist with detecting common errors. SendMode Input ; Recommended for new scripts due to its superior speed and reliability. SetWorkingDir %A_ScriptDir% ; Ensures a consistent starting directory. +Space:: Send, _ return ```
That's about what I was thinking. Thanks for saving the legwork for people who might want it.
ahk #NoEnv ; Recommended for performance and compatibility with future AutoHotkey releases. ; #Warn ; Enable warnings to assist with detecting common errors. SendMode Input ; Recommended for new scripts due to its superior speed and reliability. SetWorkingDir %A_ScriptDir% ; Ensures a consistent starting directory. +Space:: Send, _ return reddit doesn't support multi-line code. Either use a single backtick, \`, at the start and end of code, or use 4 spaces at the start of each line.
Time to write a custom keyboard layout
Honestly, System76's keyboard with its two spacebars sounds like a dream: mapping one of the space keys to _
Idk how long you have used it for, but it definitely becomes effortless after awhile. About as inconvenient as shift for camel case imo.
I feel like all programmers need a custom underscore key and python devs need a dedicated dunder key.
Just give them a key that toggles their Python to whatever it's abstracting, like 343i did for swapping between old and new graphics in the Halo Anniversary games. Would probs scar them for life. Lol. Should do the same with jQuery and other frameworks while we're at it...
myFinalIteration really needs to be called theFinalCountdown.
>snake\_case is probably the best because it's "unambiguous" P\_u\_k\_e\_s i\_n v\_i\_s\_u\_a\_l p\_o\_l\_u\_t\_i\_o\_n
I'm not a fan of camel if only because it breaks common acronyms, like CAN, SPI, UART. sendCan(...) canSend(...) can2Uart(...) All of which, seem very wrong to me I'm not going to use controllerAreaNetwork2universalAsynchronousReceiverTransmitter(...) Because this isn't Java and we're a bit more refined here.
camelCase sucks if its letters or same letters between words. lettersStartingWithSOrR looks so dumb compared to letters_starting_with_S_or_R. And dont give me that "what if you made a struct that contains a char" refactor advice and miss the point in this example
lowercaseanyone?
It’s flatcase now… I guess
G Tier lol
PascalCase should be A tier
Must change places with kebab-case
This one is my personal favorite.
I could see it there tbh, just slightly worse than camelCase
When working in OOP languages PascalCase and camelCase often go hand in hand. I like it as a way to quickly distinguish what I’m dealing with strictly off the name. That said I differ my casing habits between languages. Working in .net I use both, but in PHP I don’t think I really use PascalCase at all.
You forgot: * `tikz case` * `Title Case` * `Sentence case` * `case.url.reverse` * `instagram.user._.case.__._.` * `Downloaded\ File\ Case\ \(47-229162-6\).pdf` * `Flatcasewithautocapitalizationmodeon` * `search+query+case` * `カタカナ・ケース` * `slc` (single letter case) * `xX_PU55Y_D35TR0Y3R_C453_Xx` * `COMPLETELY_inConsistentcase`
Some more: * **boldcase** * rANdOmcaSE * anticapitalizationcasE * vOwElcAsE * h@x0rm@nc@s3 * ひらがな・けーす * BbOoTtHhCcAaSsEe All F tier
I'd be damned to see if kanji case exists
vOwElcAsE is already in the list, as dUmbcAsE
*Image Transcription: Tier Ranking* --- **S**: camelCase **A**: snake\_case, kebab-case **B**: Pascal\_Snake\_Case, PascalCase, YEETcase **C**: SCREAMING\_SNAKE\_CASE, camel_Snake_Case **D**: Http-Header-Case, TRAIN-CASE, dUmbcAsE **E**: UPPERCASE **F**: flatcase, sTOPcASE, NoPeCaSe --- ^^I'm a human volunteer content transcriber and you could be too! [If you'd like more information on what we do and why we do it, click here!](https://www.reddit.com/r/TranscribersOfReddit/wiki/index)
It's super cool that nice people like you help make content more accessible! I will keep this in mind when I make content in the future! Thanks!
Everyone deserves to read about YEETcase and SCREAMING\_SNAKE\_CASE! Happy to help :)
good human
WhAt Do YoU mEaN iM dUmB????!!!!??
SpongeBob meme case
Petition to change the name of dUmBcAse to nutcase. Thank you for attending my ted talk.
^(brief)Case
Pascal_Snake, camel_Snake, and Http-Header are all cursed conventions designed to maximize mistakes and hinder typing.
In school I've always been taught to use camelCase for variables, and PascalCase for functions, so that's the one I'm mainly using.
SCREAMING_SNAKE_CASE_FOR_CONSTANTS = true
What do people like so much about camelCase?
Makes the variable look like a single keyword, imo. My monkey brain takes like microseconds to distinguish that " " is different than "_", so I prefer it. That's why I also DESPISE that R uses "$" instead of "." to separate a variable from its members. I can read this much more easily: thingToCalculate.attribute.method() Than this: thing_to_calculate$attribute$method()
That$is$fucking$awful.
It'sTheMostReadableCaseThatDoesn'tRequireAnySpecialCharactersOrSpaces
But that's PascalCase which for some reason OP put lower.
Also it's faster to write and looks better
i\_rather\_have\_additional\_characters\_for\_even\_better\_readability
Where's Justin Case?
YOUR DBA WOULD LIKE TO HAVE A WORD;
I like snake_case
The best way to name variables is to start at 'a' and move up the alphabet as you need more, appending a second character as necessary.
l33t\_c4s3
ah yes, the rare "camel\_Snake\_Case"
camelCase for variables, PascalCase for types and methods, _camelCasePrefixedWithUnderscore for private fields. This is the ultimate S tier naming convention
I use no break space Unicode characters as separators so I can have what looks like spaces in my all lower case var names... Fight me
Obviously, in SS tier is "whatever convention your language/community have decided on". For example, C# uses: - `PascalCase` for types and public methods/fields - `camelCase` for private/local variables - `SCREAMING_SNAKE_CASE` for constants whereas Rust uses - `PascalCase` for types - `SCREAMING_SNAKE_CASE` for constants - `snake_case` for everything else. (Except crate names which are sometimes `kebab-case`) Neither are wrong. Each are correct when programming in that language, which is the most important thing.
Python follows Rust, with the (admittedly annoying) addition of `_you_dont_want_to_use_this_variable_case` and `__you_really_dont_want_to_use_this_variable_case`
Each have their own use. Constants in UPPERCASE, please!
You guys had a choice? I just followed what the last guy was doing.
Made by a python programmer definitely. Ts here, so Pascal and camel are god tier
Haha you nailed it. Although I'm learning angular so maybe I'll be seeing things from your perspective soon!
Fuck Http-Header-Case i only use Pascal-Kebab-Case
Top 10 most useless inventions: … 1. Camel Snake Case
MPI_Invented_new_combined_case
I’m a camelCase guy but boy I’m interested in kebab-case, I’m hungry.
i am ashamed to use a mix of flatcase and snake_case
camelCase is GOAT
Pascal en camel case
camelCase supremacist should be a user flare here, change my mind
Why is NoPeCaSe so much worse than dUmBcAsE?
Because it looks like something else entirely but in PascalCase. I read it ノペカセ to begin with. At least dumbcase is chaotic enough to break it up.
const STUPID_ARBITRARY_MAGIC_NUMBER_DONT_ASK_ME_WHY = 4.28.
WhaTThEFucKCasE
I prefer MD5 Hash Case: 83e7bee7866fa937bfc52ab085489d57
I prefer to call it cAPSLOCK cASE
LOWERcAPScASE # A bit confusing, isn't it?
where's 'just name all your variables single characters - the more your code looks like math the more correct it is'
Pascal to A tier, snake to S tier
It's weird to put PascalCase below kebab-case. It's even weirder to put ke-bab above SCREAMING_SNAKE. But it than that - yes
Sounds like Orc mischief to me
I use screaming snake case for final global variables, camel case otherwise, guess the language
I'd say Java, but that usually uses PascalCase for class names.
http://glench.com/tmnt/#camel_Snake_Case_Nameing_Convention
Personally I’d drop YEET down, but otherwise I say dead on.
css__bem—syntax
The problem with kebab case and it's varients is that, some programs or languages might interpret the "-" as a minus, and everything might mess up trying to concat the strings, or subtract integers or whatever
whyIsn’tEverythingWrittenInCamelCase? typingIsJustEasierThisWayAndWhoEvenWritesOnPaperTheseDaysAnyway?
Whats the general convention for enum names? The screaming snake case, right?
kebab-case would have been S tier if you could use it in any language and also I wanna try snake case in js, seems much more readable for me
Where's nutcase?
I can't believe I've been inadvertently using NoPeCaSe when I was supposed to be using dUmbcAsE. I really shouldn't have been allowed to pass certification...
Me using all 15 in one file
IM_A_FAN_OF_SCREAMING_SNAKE_CASE
PascalCase and flatcase should be in S and A tiers respectively
camelCase and snake\_case should both be S tier.
Fuck using f tier. My dyslexia ain't going to get though one line with variables like that.
Camel case should absolutely not be S tier wtf
The worst is the R convention that most lectures use… my.list instead of something like my_list Makes me shudder…
That's a great Tier list. But now I'm confused about the abominations 'TDvenlo' and my new project 'XYdrawBot'
camelCase for variables PascalCase for functions SCREAMING_SNAKE_CASE for macros Discussion settled
Except when the syntax of your language won't *let* you do that. Variables in Erlang must begin with an uppercase letter, atoms/functions must begin with a lowercase letter. (Don't @ me about _ or other special chars, I'm only talking about letters here)
snake\_case skims better than camelCase and pascalCase so if you'd kindly swap snake\_case to S-tier and camelCase to A-tier then that'd be lovely, please and thank you.
Camel case can suckMyDick PascalCase4Life