Underscores vs CamelCase

[Doodle77]

I have honestly never been sure which to pick. Many a time have i changed the names of functions i had written previously to conform to whatever inane rule my current code was following.
I need convincing.

[JayDee]

Look at my UserName and guess which I pick.

[crazyjimbo]

Look at my UserName and guess which I pick.

And look at mine and guess which I pick

I use CamelCase for classes and such like, and underscores for variables and methods. In a non OO language (i.e. C for me), I go with underscores for pretty much everything, but I haven't programmed in this for a while now.

[photosinensis]

I'm a fan of CamelCase myself, particularly for classes and functions. Objects and primitives usually get names in linguam latinam. This has caused amusement amongst profs that knew what I was doing and confusion amongst those that didn't.

I hate underscores with the fire of a thousand large, non-visible spectrum stars. HATE THEM.

[b.i.o]

I use CamelCase almost exclusively. Underscores annoy me.

[crazyjimbo]

i_find_it_is_much_easier_to_read_something_in_underscores_than_in_camel_case.

ButThenAgainThatMightJustBeMe,YouShouldAllLetMeKnowWhatYouThink.

[++$_]

Underscores require an extra keystroke to type. Therefore, they are inferior.

Why is there even any debate about this?

Anyway, you could write a perl script to convert between them in case your Current Project requires you to use the other convention.

Note: In Lisp, where dashes are allowed in variable names, that becomes the preferred option (at least for me). For example:
variable-with-long-complex-name instead of VariableWithLongComplexName. Far superior (same number of keystrokes, too!). Too bad that most languages overload - to mean "minus."

EDIT: It just occurred to me that this problem doesn't even exist if you write all your code in German (because you can just use compound words). Let's start a movement.

[JayDee]

Not really much of a difference. Even less of a difference in readability, I'd assume, if we are talking a couple of words rather than an entire sentence.

[zenten]

Camel Case is a tool of Microsoft.

[EvanED]

Me? I'm agnostic. I use UpperCamelCase for classes, and lowerCamelCase for functions and variables. UPPER_UNDERSCORE_CASE is for macros. (Constants that aren't macros follow the lowerCamelCase variant. I reserve UPPERCASE for macros.)

Underscores require an extra keystroke to type. Therefore, they are inferior.

Why is there even any debate about this?

Because, as crazyjimbo said, underscores are easier to read.

Anyway, you could write a perl script to convert between them in case your Current Project requires you to use the other convention.

Unless it's the convention crazyjimbo mentioned. Then your perl "script" is going to become fairly complicated.

(Probably still doable though... hmm, may not even be *that* hard now that I think about it a little more.)

Note: In Lisp, where dashes are allowed in variable names, that becomes the preferred option (at least for me). For example:
variable-with-long-complex-name instead of VariableWithLongComplexName. Far superior (same number of keystrokes, too!). Too bad that most languages overload - to mean "minus."

Agreed! Easier to type, better looking, and just as easy to read as underscores.

[Tuke]

Me? I'm agnostic. I use UpperCamelCase for classes, and lowerCamelCase for functions and variables. UPPER_UNDERSCORE_CASE is for macros. (Constants that aren't macros follow the lowerCamelCase variant. I reserve UPPERCASE for macros.)

ButwhatifI'manathiest? ThenwhatdoIdo?

[Korandder]

I use CamelCase, but this is mostly a side effect of learning Java first.

[davean]

I use CamelCase, but this is mostly a side effect of learning Java first.

Other side effects may include Nausea, migraines, constipation, loss of agility, and sudden death.

[b.i.o]

i_find_it_is_much_easier_to_read_something_in_underscores_than_in_camel_case.

ButThenAgainThatMightJustBeMe,YouShouldAllLetMeKnowWhatYouThink.

I agree when you type out whole sentences in it. But for 2-4 words I find it's just as readable and cleaner looking.

[photosinensis]

I use CamelCase, but this is mostly a side effect of learning Java first.

Other side effects may include Nausea, migraines, constipation, loss of agility, and sudden death.

Not to mention difficulties with handling I/O. You'd think that taking arguments from standard input would be easy. You would also be very, very wrong. Seriously, I'm thinking I might just create a class that handles inputs and does absolutely nothing else, then use it in all subsequent Java code of mine.

The guy with the messed up bit of mixing camel case and underscores has no clue what he's missing with compound words. As for macros, I'll have to think of something. I'll probably make those in another language, too. However, I've generally found preprocessor macros to be generally annoying. Just write the damn code.

[Dongorath]

I don't care, I stick to the convention of the code base I'm working on. At my work, it's CamelCase... So when I write personnal stuff, I tend to use CamelCase...

[Tei]

CamelCase seems superior. You don't need extra characters and looks clean to me.
I will use whatever is right on the code. if theres already code and use "_", I will use "_".

[enk]

Underscores require an extra keystroke to type. Therefore, they are inferior.

Well, once, yes. After that, there's something called word completion.

[evilbeanfiend]

generally i prefer underscores, mostly because i don't recognise capitals very easily, and the c++ std library and boost library use underscores. however the usually rules of following the conventions used in the code you edit prevail.

[Kizyr]

There are a few situations where I prefer underscores. If I'm renaming a whole bunch of files, and separating out words with spaces in the filenames, it's a lot easier to have a standard character to translate into spaces. If it's CamelCase then I may as well have to write an actual program to rename the files instead of just putting together a batch file in five seconds. KF

[pieaholicx]

Both in the same program. Yeah, I tend to not prefer a standard, which tends to make people mad. Unless I'm writing Java (which is what my job is using), then I use lowerCamelCase since that was always how I was taught Java, and it just stuck.

[Dingbats]

Underscores, mostly because it looks more professional to me.

[HappySmileMan]

I use lowerCamelCase for functions or variables, UpperCamelCase for classes and CAPITALS for constants or macros (thhough I don't really use macros)

[Webzter]

I use lowerCamelCase for variables and fields. UpperCamelCase for methods and classes. I'm debating switching to leading underscores for fields, even though I think they look ugly, because it disambiguates the following for some people:

Code: Select all

public class Person {
   private string _name;
 
   public Person(string name) {
      _name = name;
   }
}


[Karrion]

I'm debating switching to leading underscores for fields, even though I think they look ugly, because it disambiguates the following for some people

That's what this. is for.

[b.i.o]

Not to mention difficulties with handling I/O. You'd think that taking arguments from standard input would be easy. You would also be very, very wrong. Seriously, I'm thinking I might just create a class that handles inputs and does absolutely nothing else, then use it in all subsequent Java code of mine.

Please excuse me while I steal borrow your idea and regain my sanity.

[Number]

thingsNamedLikeThis for Java, where theDamnClassNamesGoOnForever.giveMeABreakPlease() happens all the time. While underscores would help readability, the Java brainwashers teachers made us name everything with lowerCamelCase. For a serious C++ project, ClassNames get CamelCase - STL makes this even more fun. But when it makes more sense (e.g. word_order) it gets an underscore, probably because it's a compound word/phrase thingy and putting nothing (wordorder/wordOrder) just looks wrong.
Oh, and constants and macros all get underscores and caps.

[evilbeanfiend]

Camel Case is a tool of Microsoft.

nonsense, its been around as PascalCase since the 70's at least

[Tei]

Camel Case is a tool of Microsoft.

Maybe you mean MicroSoft?

[BurntCornMuffin]

I use all lower for variables, upper CamelCase for classes, lower camelCase for functions, and all caps for constants.

Underscores only slow me down, especially since I tend to hit + instead.

[enk]

Underscores only slow me down, especially since I tend to hit + instead.

Again, I'd like to speak in favor of advanced editors that do word completion.

If you're willing to learn and actually invest time in getting faster at editing, I can recommend vim. A lot of others do word completion I guess, I just don't know which ones.

But then again, why use a couple weeks or months getting used to a new editor when you can keep using twice the amount of time editing a file for the rest of your life..?


(Edited to answer the OPs question)
I too

find_it_is_much_easier_to_read_something_in_underscores_than_in_camel_case.

[++$_]

Underscores require an extra keystroke to type. Therefore, they are inferior.

Well, once, yes. After that, there's something called word completion.

Afterwards, too, depending on how many of your variable names start with the same characters as the one you're trying to type. Since some people use prefixes for variable names, this is a serious issue. For example, if the variables in one part of your program are all named "tf_varname", where tf stands for whatever that module is, then you have to type in "tf_" every time, regardless of word completion. You might argue that it's the prefix causing the problem, not the underscore, and you would be correct. However, some people consider prefixes to be good style.

Also, even if you do have word completion, camelCase never takes MORE keystrokes. (In my own programs that no one else will have to read, ijuststringmultiplewordstogetherlikethis because I don't have any trouble reading it, it saves even more keystrokes, it gets rid of all case and underscore-related issues, and in my opinion it looks nicer in the code.)

BTW, emacs has word completion too.

[enk]

Underscores require an extra keystroke to type. Therefore, they are inferior.

Well, once, yes. After that, there's something called word completion.

Afterwards, too, depending on how many of your variable names start with the same characters as the one you're trying to type. Since some people use prefixes for variable names, this is a serious issue. For example, if the variables in one part of your program are all named "tf_varname", where tf stands for whatever that module is, then you have to type in "tf_" every time, regardless of word completion. You might argue that it's the prefix causing the problem, not the underscore, and you would be correct. However, some people consider prefixes to be good style.

In Vim, typing "t" or "tf", then C-p or C-n will suggest all words starting with "t" and "tf" respectively, including tf_var1, tf_var2 and so on.

(Btw. C-p and C-n are looking for previous or next word with the same beginning (it wraps, so it doesn't matter much in small files (and in normal mode C-p and C-n works like in readline (Emacs, Bash and so on)))).

An example:

Spoiler:

[Silverfish]

I use CamelCase, but this is mostly a side effect of learning Java first.

Same here. We learned CamelCasing in my first java course, now I use it for most anything other people will read. When writing programs for myself I tend to just do whatever.

[JamesCFraser]

I find CamelCase is much easier on the eyes. However, this is just down to my personal experience. I think on the plus side it does make you use case consistently, as opposed to a lot of people using inconsistent capitals.

Perosnally, if I read something with underscores, I mentally pause in between words, whereas I can read CamelCase like a normal sentence.

[shash]

FlexibleCase_is-whatIUse...

That is, underscores if I'm writing non-OO code (even in C++ or python), PascalCase for class names, camelCase for variables and functions.

In .Net, it becomes Pascal for methods (functions and properties), camel for variables because that's the standard in the framework.

Ultimately, depends on the toolkit and the team...

[EvanED]

Here's an interesting question: what do you do with acronyms?

For instance, would you create a class called XMLParser, or take the .Net standards and do it as XmlParser? What about when doing underscores? XML_parser, Xml_parser, or xml_parser?

(Personally, I like XmlParser and either XML_parser or xml_parser. XMLParser I think makes it harder to find the divisions between the "words".)

[_peterb]

Wrong wrong and wrong.

Follow the code conventions of the language you are using rather than imposing your deluded style on other people who have to read your code.

[zenten]

Wrong wrong and wrong.

Follow the code conventions of the language you are using rather than imposing your deluded style on other people who have to read your code.

I'm still allowed to cry if I really hate the coding conventions though, right?

[b.i.o]

Here's an interesting question: what do you do with acronyms?

For instance, would you create a class called XMLParser, or take the .Net standards and do it as XmlParser? What about when doing underscores? XML_parser, Xml_parser, or xml_parser?

(Personally, I like XmlParser and either XML_parser or xml_parser. XMLParser I think makes it harder to find the divisions between the "words".)

If you're using CamelCase it would be XMLParser, wouldn't it? Not capitalizing all the letters in an acronym is idiotic.