Under_score

camelCase for general variables, CAPS for global/static variables, PascalCase for functions, under_score for very specific iterated variables/math context, like n_1, n_2, n_i if absolutely needed.

kebab-case if the language allows it, otherwise PascalCase

My current project in C is a mix of both. I use under_score for my own names and interface with libxml which is all camelCase. I still wonder if I should just go full camelCase though since I end up with things like:
xmlNodePtr some_element_name = xmlNewNode(NULL, BAD_CAST "someElementName");

>Only one survives after this thread
Why?
Both are ok, use whatever is consider good programming in your language.

anyone else is fucking triggered by the way python code is supposed to be formatted? I don't mind mixing pascal and camel case, but for the love of god, snake case and pascal case in one file? 200% heretical.

PascalCase for classes/modules
camelCase for functions
under_score for variables
ALL_CAPS for constants
kebab-space for filenames

>kebab-space

Attached: download (8).jpg (268x268, 27K)

DickCase8=====D~~

NuTcAsE

Whitespace cannot be used both to separate identifiers and as a component of identifiers. If you would propose to use whitespace in identifiers, what should be used as dividing characters?

PascalCase for types
SCREAMING_SNAKE_CASE for constants
snake_case for everything else.

Camel case I absolutely fucking hate this_is_a_variable
It's ugly and not as easy to read

The only right answer.

I do the same even going as far as to leave an opening comment explaining it so shit is easier to read.

Use tabs for the dividing characters you absolute simpleton

camelCase for Java, under_score for literally everything else, including Scala.

Attached: 1452434490602.png (256x312, 73K)

I agree with everything except for
>under_score for variables
What's wrong with using camelCase for variables too?

Fuck Pythonz it's stylistic norms are a piece of shit.

Concatenated lower case

Ever notice how ugly underscores look? Yeah, don't use them.

camelCase in ruby is just as bad as snake_scase in C#. Use the convention of the language. Which is snake_case in C btw :^)

variablesLikeThis
functions_like_this
ClassesLikeThis

They both look fine to me honestly, it's just the inconsistency that bugs me. I started out with under_score because it seemed more popular for C, but since libxml is such a prominent part now and the XML in question also uses camelCase I probably should just switch.

What-about-this?

kebab-case-for-minor-divisions_underscore-for-major-divisions

O hope the first captial was a mistake

>Cobol-case
Makes it a pain to search for. Double clicking the name in notepad++ only highlights the first bit

8=====D~Nut~Case~

I almost agree with this entirely but I personally use camelCase for variables, and PascalCase for public methods.

Attached: 1356657.png (400x400, 126K)

camelCase for functions is disgusting. under_score for variables is disgusting. You are a disgusting human being.

lmao if you dont use a language that enforces capitalization conventions

what's it like living in 1985, grandpa?

camelCase is for faggot Arabs. Underscores all the way.

>Language the enforces standards that aren't defined by the programmer
>Good
WRRRROOOOOOOONNNNNNGGGGGGGGG

foR Me, iT IS sTUdlycapS

I like underscore but some people make variable names way too descriptive and it looks retarded with all the underscores in the one variable. I understand it's silly to be upset over variables with too much description when the opposite is much worse but there's a balance here. You can stick to 2 words for most variables and if you're going over that then use any other case

i do morse code to brainfuck
++[------>++++....++[--->++.[-->+++--.++[--->++.[-->+++--.-.+..++[--->++.[-->+++--.-.+..++[--->++.--[-->+++...[--->++++.--[-->+++..+[->++++-..+[---->+-..[--->++++.....[-->+++--.-..[--->++++.--[-->+++...[--->++++.[-->+++--.-.+.++[--->++.[-->+++--.-.+..++[--->++.--[-->+++.+..++[--->++.--[-->+++.+[->++++-.+[---->+-.+[->++++-.+[---->+-..

camelCase for private shit
PascalCase for public shit
snake_case for Ruby, because of the conventions.
kebab-case for naming classes in SASS because it's already used in the current project and is somewhat convenient.