naming-conventions

I've been a good JavaScript programmer and adhered to the coding conventions enlisted by Douglas Crockford . However JavaScript has evolved since then and I believe the naming conventions are now outdated. For example Crockford said: Do not use _ (underbar) as the first character of a name. It is sometimes used to indicate privacy, but it does not actually provide privacy. If privacy is important, use the forms that provide private members . Avoid conventions that demonstrate a lack of competence. However JavaScript now allows you to create non-enumerable properties. Hence it makes sense (at

Traditionally, the names of template types are just a single upper-case letter: template<class A, class B, class C> class Foo {}; But I hesitate to do this because it's non-descriptive and hard therefore to read. So, wouldn't something like this be better: template<class AtomT, class BioT, class ChemT> class Foo {}; I also tend to think the following would not be a bad idea: template<class ATOM, class BIO, class CHEM> class Foo {}; It makes them stand out (and also, it's upper-case letters again). What's your opinion? For C++ templates I have a couple of patterns If there is just a single

In Ruby, a standard convention is to use a question mark at the end of a method name to indicate the method returns a boolean result: [].empty? #=> true Another standard convention is to end a method name with an exclamation point if the method is destructive (that is, it modifies the original data): mylist.sort! # sort mylist in-place Recently I have seen these same conventions used in Scheme. Which makes me wonder, what other languages use/support this convention? Are there any other special characters that are commonly used for naming by these or other languages? The answer is, of course,

Typically, when I use lambdas, I just use "a, b, c, d..." as variable names as the types are easily inferred, and I find short names to be easier to read. Here is an example: var someEnumerable = GetSomeEnumerable(); var somethingElseList = someEnumerable.Select(a => a.SomeProperty) .OrderBy(a => a.SomePropertyField); var someDictionary = somethingElseList.ToDictionary(a => new SomeClass(a.Prop1), a => a); Some question this naming, and would prefer to see long typed out names, like this: var someEnumerable = GetSomeEnumerable(); var somethingElseList = someEnumerable.Select(importantObj =>

What is the naming convention for a variable referencing a class in Python? class MyClass(object): pass # which one is correct? reference_to_class = MyClass # or ReferenceToClass = MyClass Here is another example that resembles my situation: # cars.py class Car(object): pass class Sedan(Car): pass class Coupe(Car): pass class StatonWagon(Car): pass class Van(Car): pass def get_car_class(slug, config): return config.get(slug) # config.py CONFIG = { 'ford-mustang': Coupe, 'buick-riviera': Coupe, 'chevrolet-caprice': Sedan, 'chevy-wan' Van: 'ford-econoline': Van } # main.py from config.py import