For a file containing the given class, SomeCoolClass, what would be the proper or standard filename?

&lt;pre&gt;
 1. somecoolclass.rb
 2. some_cool_class.rb
 3. some-cool-class.rb
 4. SomeCoolClass.rb
&lt;/pre&gt;

or some other variation?

I noticed in the Ruby stdlib, versions 1, 2 and 3 are used.

Standard File Naming Conventions in Ruby

I&#39;m wondering if there is a *standard* or &quot;normal&quot; means of interpreting time interval data end points with respect to inclusiveness/exclusiveness of the value defining the end point. Note however that I am asking what the standard (or most common) ***convention*** is (if there is one), not for a dissertation on your personal preference. If you really want to provide a dissertation, please attach it to a reference to someone&#39;s published standard or a standard text on the matter. Open standards (that I don&#39;t have to pay to read) are greatly preferred unless they are fundamentally flawed :).

Of course there are 4 possibilities for a time interval from A to B:

 1. (A, B) - Both ends are exclusive.
 2. [A, B] - Both ends are inclusive.
 3. [A, B) - Start is inclusive and end is exclusive
 4. (A, B] - Start is exclusive and end is inclusive

Each of these has different characteristics (as I see it, feel free to point out more)

The [A, B] convention would have the seemingly inconvenient property that B is contained withing the inteval [A, B] and also [B, C]. This is particularly inconvenient if B is meant to represent the midnight boundary and you are trying to determine which day it falls on for example. Also, this means the duration of the interval is slightly irritatig to calculate since [A, B] where A = B should have a length of 1 and therefore the duration of [A, B] is (B - A) **+ 1** 

Similarly the (A, B) convention would have the difficulty that B falls within neither (A,B) nor (B,C)... continuing the analogy with day boundaries, midnight would be part of neither day. This is also logically inconvenient because [A, B] where A = B is a non-sense interval with duration less than zero, **but reversing A and B does not make it a valid interval**.

So I think I want either [A, B), or (A, B] and I can&#39;t figure out how to decide between them. 

So if someone has a link to a standards document, reference to a standard text or similar  that clarify the convention that would be great. Alternately, if you can link a variety of standards documents and/or references that more or less completely fail to agree, then I can just pick one that seems to have sufficient authority to CMA and be done with it :). 

Finally, I will be working in Java, so I am particularly susceptible to answers that work well in Java.


Is there a standard for inclusive/exclusive ends of time intervals?

In node.js, it seems I run into the same 3 filenames to describe the main entry point to an app:

 - When using the `express-generator` package, an **`app.js`** file is created as the main entry point for the resulting app.
 - When creating a new `package.json` file via `npm init`, one is prompted for the main entry point file. The default is given as **`index.js`**.
 - In some programs I have seen, **`server.js`** serves as the main entry point as well.

Other times, still, it seems as though there are subtle differences in their usage. For example, this node app directory structure uses `index.js` and `server.js` in different contexts:

    app
      |- modules
      |    |- moduleA
      |    |    |- controllers
      |    |    |    |- controllerA.js
      |    |    |    +- controllerB.js
      |    |    |- services
      |    |    |    +- someService.js
      |    |    +- index.js &lt;--------------
      |    +- index.js &lt;-------------------
      |- middleware.js
      +- index.js &lt;------------------------
    config
      +- index.js &lt;------------------------
    web
      |- css
      |- js
    server.js &lt;----------------------------

What are the differences, if any, between these three names?

Conventions for app.js, index.js, and server.js in node.js?

At work, we place braces on the next line, but at home, I do the opposite. Which one do you prefer? (K&amp;R vs OTBS)

    function something() {
        // ...
    }
    
    function something()
    {
        // ...
    }

A lot of JavaScript libraries seem to use the OTBS (one true brace style). I&#39;d like to follow them for consistence among other JavaScript projects, but doesn&#39;t K&amp;R style look more readable?

Note: We know the problem with return and braces in JavaScript, that will always be an exception. However, that is only a single case.

JavaScript braces on new line or not?

I&#39;m having trouble finding good advice and common practices for the use of namespaces in Clojure.  I realize that namespaces are not the same as Java packages so I&#39;m trying to tease out the conventions in Clojure, which seem surprisingly hard to determine.  

I think I have a pretty good idea how to split functions into clj files and even roughly how I&#39;d want to organize those files into directories.  But beyond that I&#39;m having trouble finding the mechanics for my dev environment.  Some inter-related questions: 

 1. Do I use the same uniqueness conventions for Clojure namespaces as I would normally use for Java packages?  [ie backwards-company-domain.project.subsystem] 
 2. Should I save my files in a directory structure that matches my namespaces?  [ala Java]
 3. If I have multiple namespaces, do I need to compile all of my code into a jar and add it to my classpath to make it accessible?  
 4. Should each namespace compile to one jar?  Or should I create a single jar that contains clj code from many namespaces?  

Thanks...



What are common conventions for using namespaces in Clojure?

I&#39;ve seen this a couple of times recently in *high profile* code, where constant values are defined as variables, named after the value, then used only once. I wondered why it gets done?

E.g. Linux Source (resize.c)

    unsigned five = 5;
    unsigned seven = 7;

E.g. C#.NET Source (Quaternion.cs)

    double zero = 0;
    double one = 1;



Named numbers as variables

What is the naming convention in python community to set names for project folders and subfolders? 

    my-great-python-project
    my_great_python_project 
    myGreatPythonProject 
    MyGreatPythonProject

I find mixed up in the github. 
Appreciate your expert opinion. 

Folder naming convention for python projects

&gt; **Possible Duplicate:**  
&gt; [What do &amp;ldquo;branch&amp;rdquo;, &amp;ldquo;tag&amp;rdquo; and &amp;ldquo;trunk&amp;rdquo; really mean?](https://stackoverflow.com/questions/16142/what-do-branch-tag-and-trunk-really-mean)  

&lt;!-- End of automatically inserted text --&gt;

What is a trunk, branch and tag in Subversion and what are the best practices to use them?

What tools can I use for Subversion in [Visual Studio 2008][1]?

  [1]: http://en.wikipedia.org/wiki/Microsoft_Visual_Studio#Visual_Studio_2008


What is trunk, branch and tag in Subversion?

Is there a python convention for when you should implement `__str__()` versus `__unicode__()`.  I&#39;ve seen classes override `__unicode__()` more frequently than `__str__()` but it doesn&#39;t appear to be consistent.  Are there specific rules when it is better to implement one versus the other?  Is it necessary/good practice to implement both?


Python __str__ versus __unicode__

Is there some one-liner bridge method to dump a given *Enumeration* to `java.util.List` or `java.util.Set`?

Something built-in like `Arrays.asList()` or `Collection.toArray()` should exist somewhere, but I&#39;m unable to find that in my IntelliJ debugger&#39;s evaluator window (and Google/SO results, too).

Convert Enumeration to a Set/List

What is the [&quot;one [...] obvious way&quot;][1] to add all items of an iterable to an existing `set`?

  [1]: http://www.python.org/dev/peps/pep-0020/

How do I add the contents of an iterable to a set?

I&#39;ve got a large-ish class (40 or so methods) that is part of a package I will be submitting as course-work. Currently, the methods are pretty jumbled up in terms of utility public/private etc. and I want to order them in a sensible way. Is there a standard way of doing this? E.g. normally fields are listed before methods, the constructor(s) are listed before other methods, and getters/setters last; what about the remaining methods?

Are there any Java method ordering conventions?

I have been reading about Optionals in Swift, and I have seen examples where `if let` is used to check if an Optional holds a value, and in case it does – do something with the unwrapped value.

However, I have seen that in Swift 2.0 the keyword `guard let` is used mostly. I wonder whether `if let` has been removed from Swift 2.0 or if it still possible to be used.

Should I change my programs that contain `if let` to `guard let`?

Swift: guard let vs if let

When I undertake an R project of any complexity, my scripts quickly get long and confusing. 

What are some practices I can adopt so that my code will always be a pleasure to work with? I&#39;m thinking about things like

 - Placement of functions in source files
 - When to break something out to another source file
 - What should be in the master file
 - Using functions as organizational units (whether this is worthwhile given that R makes it hard to access global state)
 - Indentation / line break practices. 
    - Treat ( like {? 
    - Put things like )} on 1 or 2 lines?

Basically, what are your rules of thumb for organizing large R scripts?

How to organize large R programs?

Is there a best practice for defining custom error types in a Ruby library (gem) or Ruby on Rails application? Specifically:

 1. Where do they belong structurally in the project? A separate file, inlined with the relevant module/class definition, somewhere else?
 2. Are there any conventions that establish when *to* and when *not to* create a new error type?

Different libraries have different ways of doing things, and I haven&#39;t noticed any real patterns. Some libraries always use custom error types while others don&#39;t use them at all; some have all errors extending StandardError while others have nested hierarchies; some are just empty class definitions, others have all sorts of clever tricks.

Oh, and just because I feel like calling these &quot;error types&quot; is sort of ambiguous, what I mean is this: 

    class AuthenticationError &lt; StandardError; end
    class InvalidUsername &lt; AuthenticationError; end

Where to define custom error types in Ruby and/or Rails?

I very rarely meet any other programmers!

My thought when I first saw the token was &quot;implies that&quot; since that&#39;s what it would read it as in a mathematical proof but that clearly isn&#39;t its sense.

So how do I say or read &quot;=&gt;&quot; as in:-

    IEnumerable&lt;Person&gt; Adults = people.Where(p =&gt; p.Age &gt; 16)

Or is there even an agreed way of saying it?

How do I pronounce &quot;=&gt;&quot; as used in lambda expressions in .Net

There are different ways to log messages, in order of fatality:

1. `FATAL`

2. `ERROR`

3. `WARN`

4. `INFO`

5. `DEBUG`

6. `TRACE`

How do I decide when to use which?

What&#39;s a good heuristic to use?


When to use the different log levels

[PEP 8](http://www.python.org/dev/peps/pep-0008/) says:

&gt;- Imports are always put at the top of the file, just after any module
comments and docstrings, and before module globals and constants.

On occation, I violate PEP 8. Some times I import stuff inside functions. As a general rule, I do this if there is an import that is only used within a single function.

Any opinions?

**EDIT (the reason I feel importing in functions can be a good idea):**

Main reason: It can make the code clearer.

* When looking at the code of a function I might ask myself: &quot;What is function/class xxx?&quot; (xxx being used inside the function). If I have all my imports at the top of the module, I have to go look there to determine what xxx is. This is more of an issue when using ``from m import xxx``. Seeing ``m.xxx`` in the function probably tells me more. Depending on what ``m`` is: Is it a well-known top-level module/package (``import m``)? Or is it a sub-module/package (``from a.b.c import m``)?
* In some cases having that extra information (&quot;What is xxx?&quot;) close to where xxx is used can make the function easier to understand.

Is it pythonic to import inside functions?

I [read once](https://web.archive.org/web/20100827225248/http://progit.org/book/ch5-2.html) that git commit messages should be in the imperative present tense, e.g. &quot;Add tests for x&quot;. I always find myself using the past tense, e.g. &quot;Added tests for x&quot; though, which feels a lot more natural to me.

[Here&#39;s a recent John Resig commit](http://github.com/jquery/jquery/commit/c5382ad7c118ca54dde630b6c7146f1c3b6afb80) showing the two in one message:

&gt; Tweak some more jQuery set results in the manipulation tests. Also fixed the order of the expected test results. 

Does it matter? Which should I use?

Should I use past or present tense in git commit messages?

If you had to iterate through a loop 7 times, would you use:

    for (int i = 0; i &lt; 7; i++)

or:

    for (int i = 0; i &lt;= 6; i++)

There are two considerations:

  - performance
  - readability 

For performance I&#39;m assuming Java or C#.  Does it matter if &quot;less than&quot; or &quot;less than or equal to&quot; is used?  If you have insight for a different language, please indicate which.

For readability I&#39;m assuming 0-based arrays.

**UPD:** My mention of 0-based arrays may have confused things. I&#39;m not talking about iterating through array elements.  Just a general loop. 


There is a good point below about using a constant to which would explain what this magic number is. So if I had &quot;`int NUMBER_OF_THINGS = 7`&quot; then &quot;`i &lt;= NUMBER_OF_THINGS - 1`&quot; would look weird, wouldn&#39;t it. 

Should one use &lt; or &lt;= in a for loop

I am designing a new YAML file, and I want to use the most standard style of naming.  Which is it?

Hyphenated?

    - job-name:
        ...

lower_case_with_underscores?

    - job_name:
        ...

CamelCase?

    - jobName:
        ...



What is the canonical YAML naming style

`console.log(&quot;double&quot;);` vs. `console.log(&#39;single&#39;);`

I see more and more JavaScript libraries out there using single quotes when handling strings. What are the reasons to use one over the other?

I thought they&#39;re pretty much interchangeable.



When should I use double or single quotes in JavaScript?

Most of the blogs or tutorials or books have private methods at the bottom of any class/module. Is this the best practice?

I find having private methods as and when necessary more convenient. For example:

    public
    def my_method
      # do something
      minion_method
    end

    private
    def minion_method
      # do something
    end

    public
    def next_method
    end

This way I find the code more readable instead of scrolling up and down continuously which is very irritating.

Is there something terribly wrong in this approach? Is having private methods at the bottom not just a best practice and something else?

Where to place private methods in Ruby?

Since `std::list` and `std::vector` exist, is there a reason to use traditional C arrays in C++, or should they be avoided, just like `malloc`?

Should arrays be used in C++?

When writing a python module and functions in it, I have some &quot;public&quot; functions that are supposed to be exposed to outsiders, but some other &quot;private&quot; functions that are only supposed to be seen and used locally and internally.

I understand in python there is no absolute private functions. But what is the best, most neat, or most used style to distinguish &quot;public&quot; functions and &quot;private&quot; functions?

I list some of the styles I know:

1. use `__all__` in module file to indicate its &quot;public&quot; functions (https://stackoverflow.com/questions/2187583/whats-the-python-all-module-level-variable-for)
2. use underscore at the beginning of name of &quot;private&quot; functions

Is there any other idea or convention that people use?

Thank you very much!


Python &quot;private&quot; function coding convention

I looked through some code and noticed that the convention was to turn pointer types like

    SomeStruct* 

into

    typedef SomeStruct* pSomeStruct;


Is there any merit to this?

Is it a good idea to typedef pointers?

While coding python I&#39;m using only 2 spaces to indent, sure [PEP-8][1] really recommend to have 4 spaces, but historically for me it&#39;s unusual.

So, can anyone convince me to use 4 spaces instead of 2? What pros and cons?

P.S. And finally, what&#39;s easy way to convert all existing codebase from 2 spaces to 4 spaces?

_____

P.P.S. PEP-8 Also srictly recommend not using tabs for indention. [read here][2]
____
So, to summarize:

   Pros:

  - Have more space to arrange when wraping string more than 80 lines long.
  - Can copy code from snippets and it just works.

Cons: 

  - With deeper level of nested statements you have less space for actual code.



Thanks.

  [1]: http://www.python.org/dev/peps/pep-0008/
  [2]: https://stackoverflow.com/questions/120926/why-does-python-pep-8-strongly-recommend-spaces-over-tabs-for-indentation

Python: using 4 spaces for indentation. Why?

NetBeans 7.4 **beta** is currently available for public download, and it introduces a weird warning rule by default:

&gt; Method length is 16 lines (10 allowed)

My question is: Is this an accepted code convention rule, that can be proven somehow, somewhere ? NetBeans support/devs say it&#39;s not a bug, but don&#39;t give a statement why they only allow 10 lines, and where exactly this rule has its origin.

Netbeans 7.4 introduces &quot;10 lines max&quot; per method rule. Where does this rule come from?

I&#39;m reading McConell&#39;s *Code Complete*, and he discusses using boolean variables to document your code. For example, instead of:

    if((elementIndex &lt; 0) || (MAX_ELEMENTS &lt; elementIndex) || 
       (elementIndex == lastElementIndex)){
           ...
    }

He suggests:

    finished = ((elementIndex &lt; 0) || (MAX_ELEMENTS &lt; elementIndex));
    repeatedEntry = (elementIndex == lastElementIndex);
    if(finished || repeatedEntry){
       ...
    }

This strikes me as logical, good practice, and very self-documenting. However, I&#39;m hesitant to start using this technique regularly as I&#39;ve almost never come across it; and perhaps it would be confusing just by virtue of being rare. However, my experience is not very vast yet, so I&#39;m interested in hearing programmers&#39; opinion of this technique, and I&#39;d be curious to know if anyone uses this technique regularly or has seen it often when reading code. Is this a worthwhile convention/style/technique to adopt? Will other programmers understand and appreciate it, or consider it strange?

Should programmers use boolean variables to &quot;document&quot; their code?

In Cocoa, when should I use NSAssert, NSException, NSError?

Here&#39;s what I&#39;ve been thinking:

**NSAssert** - When creating any client program used for the programmers own benefit to double check rules, conventions, assumptions, or pre-conditions and post-conditions?

**NSException** - When creating a third-party library for the benefit of other programmers that use the library, so that they immediately know when an input is invalid?

**NSError** - When interfacing with an external system to get data like a file, database, or web service that isn&#39;t guaranteed to give me a result?

Objective-C: Assertion vs. Exception vs. Error

In Python, I&#39;ve seen two variable values swapped using this syntax:

    left, right = right, left

Is this considered the standard way to swap two variable values or is there some other means by which two variables are by convention most usually swapped?

Is there a standardized method to swap two variables in Python?

Could someone provide a link to a good coding standard for Haskell? I&#39;ve found [this][1] and [this][2], but they are far from comprehensive. Not to mention that the HaskellWiki one includes such &quot;gems&quot; as &quot;use classes with care&quot; and &quot;defining symbolic infix identifiers should be left to library writers only.&quot;

  [1]: http://urchin.earth.li/~ian/style/haskell.html
  [2]: http://www.haskell.org/haskellwiki/Programming_guidelines

Good Haskell coding standards

What is the Lisp convention about how many semicolons to use for different kinds of comments (and what the level of indentation for various numbers of semicolons should be)?  

Also, is there any convention about when to use semicolon comments and when to use `#|multiline comments|#` (assuming they exist and exist on multiple implementations)?

Lisp commenting convention

As far as I know, one needs to use double or single quotes for fonts if they contain spaces, like:

    font-family: &quot;Times New Roman&quot;, Times; 
    font-family: &#39;Times New Roman&#39;, Times;

But on Google Fonts ([http://www.google.com/webfont][1]), I also see 

    font-family: &#39;Margarine&#39;, cursive;

Some even use it like so:

    font-family: &#39;Margarine&#39;, &#39;Helvetica&#39;, arial;

I find this weird, as the following works as well:

    font-family: Arial, Helvetica, sans-serif;
    font-family: Cambria, serif;

So what is the correct usage of quotes around font names in CSS?


  [1]: http://www.google.com/webfont

Why would font names need quotes?

In the initial drafting of a new gem I need to leave some method implementations empty ( to be implemented in the next )

Therefore, I would like to signal a &quot;not implemented yet&quot; exception

I&#39;m wondering if there is a *best practice* or *standard conventions* specific to the Ruby language to code this kind of placeholder / exception. 

i.e: something like: 

 - [UnsupportedOperationException](http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/UnsupportedOperationException.html) in Java
 - [NotImplementedException](http://msdn.microsoft.com/en-us/library/system.notimplementedexception.aspx) in .Net Framework (C#)

How to signal &quot;not implemented yet&quot;?

I&#39;ve noticed that a lot of projects have the following structure:

* Project-A
  * bin
  * lib
  * src
     * main
         * java
             * RootLevelPackageClass.java

I currently use the following convention (as my projects are 100% java):

* Project-A
  * bin
  * lib
  * src
     * RootLevelPackageClass.java

I&#39;m not currently using Maven but am wondering if this is a Maven convention or not or if there is another reason. Can someone explain why the first version is so popular these days and if I should adopt this new convention or not?

Chris

What is the advantage of the &#39;src/main/java&#39;&#39; convention?

Does JavaScript support substitution/interpolation?

# Overview

----------

I&#39;m working on a JS project, and as it&#39;s getting bigger, keeping strings in good shape is getting a lot harder. I&#39;m wondering what&#39;s the easiest and most conventional way to construct or build strings in JavaScript.

My experience so far:

&gt; String concatenation starts looking ugly and becomes harder to maintain as the project becomes more complex.

The most important this at this point is succinctness and readability, think a bunch of moving parts, not just 2-3 variables.

It&#39;s also important that it&#39;s supported by major browsers as of today (i.e at least ES5 supported).

I&#39;m aware of the JS concatenation shorthand:

    var x = &#39;Hello&#39;;
    var y = &#39;world&#39;;
    console.log(x + &#39;, &#39; + y);

And of the [String.concat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat) function.

I&#39;m looking for something a bit neater.

Ruby and Swift do it in an interesting way.

**Ruby**

    var x = &#39;Hello&#39;
    var y = &#39;world&#39;
    print &quot;#{x}, #{y}&quot;

**Swift**

    var x = &quot;Hello&quot;
    var y = &quot;world&quot;
    println(&quot;\(x), \(y)&quot;)

I was thinking that there might be something like that in JavaScript maybe something similar to [sprintf.js](https://github.com/alexei/sprintf.js).


# Question

----------

Can this be done without any third party library? If not, what can I use?

What&#39;s the best way to do string building/concatenation in JavaScript?

I have always thought of header files as a sort of &#39;public interface&#39; describing a class, in which case it would be better to keep private fields and functions in the cpp file.

I understand that private fields need to be in the header so that other classes can tell how much memory an instance of a class will consume, but it occurred to me as I was about to write a private helper function, that this function could be made static, in which case there was no need for it to be &#39;part of the class&#39; at all, it could just as easily be a regular function in the class definition&#39;s .cpp file.

It then occurred to me that ***all*** private functions could potentially be re-written to be static by accepting pointers/references to class fields instead of expecting to be defined in the class.

This would eliminate the need to declare any private functions in the header file.

I do like to follow conventions so now I want to ask, is it considered an established convention in C++, that non-static private functions ***should*** be in the header file? What about static functions or static constants?


EDIT: I&#39;m going to put in some code to explain what I&#39;m getting at:

**.h file:**

    #ifndef SOME_CLASS_H
    #define SOME_CLASS_H
    
    class SomeClass
    {
    private:
    	int x;
    public:
    	void combineWithX(int y);
    };
    
    #endif


**.cpp file**

    #include &quot;SomeClass.h&quot;
    
    void someHelper(int* x)
    {
    	*x = (*x) + 1;
    }
    
    void SomeClass::combineWithX(int y)
    {
    	someHelper(&amp;x);
    	x += y;
    }


Note that `someHelper(int* x)` in the cpp file references the private member x in spirit, but not directly, and therefore does not need to appear in the header. I&#39;m wondering if this sort of thing is considered &#39;bad style&#39;


C++, do private functions really need to be in the header file?

In pretty much all applications that have a menu bar, some of the items have an ellipsis (...) after them, and some don&#39;t. Is there a well known convention on when to put that ellipsis there and when not to? When do you do it? Do you do it?

I have looked at various windows applications, and this is what I have come to:

- **Ellipsis**
 - Menu items which opens a form that require user input to do something (Replace, Go to, Font)

- **No ellipsis**
 - Menu items which just does something (Cut, Paste, Exit, Save)
 - Menu items which opens a form that does not require user input (About, Check for Updates)

But then there always seems to be menu items that doesn&#39;t follow this rule. For example the Help items (How do I, Search, Index) and the Find and Replace (Quick Find, Find in Files, Find Symbol) in Visual Studio.

So after thinking about it a bit more I now think this might be the thing:

- **Ellipsis**
 - Menu items that will definitely open a modal window.

- **No Ellipsis**
 - Menu items that opens a non-modal window.
 - Menu items that doesn&#39;t open any window.
 - Menu items that most likely won&#39;t open a modal window (Like Save, which does open a modal window if you haven&#39;t saved before or something like that, but otherwise don&#39;t)

What do you guys think?

All Conventions Solutions on Gang of Coders

Total of 39 Conventions Solutions