I always thought that it was in order to differentiate them from function calls.

It&#39;s very subjective question, but there are code conventions. Example in Java: 
https://www.oracle.com/java/technologies/javase/codeconventions-whitespace.html

&quot;Blank spaces should be used in the following circumstances: ...A keyword followed by a parenthesis...&quot;

`while (`

or

`for (`

But with modern IDEs it&#39;s not a critical question anymore, in my opinion.

I prefer NOT to add a space in these cases (after keywords like `for`, but in function/method calls `function()` as well. 
I think, `function ()` is less readable.


I&#39;m POSTing a file to a WCF REST service through a HTML form, with `enctype` set to `multipart/form-data` and a single component: `&lt;input type=&quot;file&quot; name=&quot;data&quot;&gt;`. The resulting stream being read by the server contains the following:

    ------WebKitFormBoundary
    Content-Disposition: form-data; name=&quot;data&quot;; filename=&quot;DSCF0001.JPG&quot;
    Content-Type: image/jpeg

    &lt;file bytes&gt;
    ------WebKitFormBoundary--

The problem is that I&#39;m not sure how do extract the file bytes from the stream. I need to do this in order to write the file to the disk.

Reading file input from a multipart/form-data POST

I&#39;m writing a simple Python application that uses matplotlib to display a few figures on screen. The number of figures generated is based on user input and changes throughout the application&#39;s life. The user has the ability to issue a &quot;plot&quot; command to generate a new figure window with the selected data series. In order to improve the user experience, I would like to provide another command that would programmatically arrange all open figure windows in some convenient arrangement (e.g. tile them across the available screen space).

I believe to have found APIs that allow me to adjust the size of the figure window (in pixels), but haven&#39;t had any success in finding a way to set their absolute position on screen. Is there a way to do this without delving into the details of whatever backend is in use? I would like to do this in a backend-agnostic way so I can avoid relying upon implementation details that might change in the future.

How do you set the absolute position of figure windows with matplotlib?

Most coding conventions prefer putting a space after `if`, `while`, etc (`if (` vs `if(`). Is there a particular reason for this, or is that something that is a personal quirk?

Space after if, while, etc (and before the paren)

<p>Most coding conventions prefer putting a space after <code>if</code>, <code>while</code>, etc (<code>if (</code> vs <code>if(</code>). Is there a particular reason for this, or is that something that is a personal quirk?</p>


I find myself preferring `if not` rather than `unless`. Is there a proper way to write that sort of condition? How do people generally feel about `unless`?

Ruby: unless vs if not

I am (probably) NOT referring to the &quot;all other variables&quot; meaning like `var1~.` here. 
I was pointed to `plyr` once again and looked into `mlply`and wondered why parameters are defined with leading dot like this: 

    function (.data, .fun = NULL, ..., .expand = TRUE, .progress = &quot;none&quot;, 
    .parallel = FALSE) 
    {
    if (is.matrix(.data) &amp; !is.list(.data)) 
        .data &lt;- .matrix_to_df(.data)
    f &lt;- splat(.fun)
    alply(.data = .data, .margins = 1, .fun = f, ..., .expand = .expand, 
        .progress = .progress, .parallel = .parallel)
    }
    &lt;environment: namespace:plyr&gt;

What&#39;s the use of that? Is it just personal preference, naming convention or more? Often R is so functional that I miss a trick that&#39;s long been done before.  

What does the dot mean in R – personal preference, naming convention or more?

In the past I&#39;ve always used underscores for defining _class_ and _id_ attributes in HTML. Over the last few years I changed over to dashes, mostly to align myself with the [trend in the community][1], not necessarily because it made sense to me.

I&#39;ve always thought dashes have more drawbacks, and I don&#39;t see the benefits:

### Code completion &amp; Editing

Most editors treat dashes as word separators, so I can&#39;t tab through to the symbol I want. Say the class is &quot;`featured-product`&quot;, I have to auto-complete &quot;`featured`&quot;, enter a hyphen, and complete &quot;`product`&quot;.

With underscores &quot;`featured_product`&quot; is treated as one word, so it can be filled in one step.

The same applies to navigating through the document. Jumping by words or double-clicking on class names is broken by hyphens.

(More generally, I think of classes and ids as _tokens_, so it doesn&#39;t make sense to me that a token should be so easily splittable on hyphens.)

### Ambiguity with arithmetic operator

Using dashes breaks object-property [access to form elements][2] in JavaScript. This is only possible with underscores:

    form.first_name.value=&#39;Stormageddon&#39;;

(Admittedly I don&#39;t access form elements this way myself, but when deciding on dashes vs underscores as a universal rule, consider that someone might.)

Languages like [Sass][3] (especially throughout the [Compass][4] framework) have settled on dashes as a standard, even for variable names. They originally used underscores in the beginning too. The fact that this is parsed differently strikes me as odd:

    $list-item-10
    $list-item - 10

### Inconsistency with variable naming across languages

Back in the day, I used to write `underscored_names` for variables in PHP, ruby, HTML/CSS, and JavaScript. This was convenient and consistent, but again in order to &quot;fit in&quot; I now use:

* `dash-case` in HTML/CSS
* `camelCase` in JavaScript
* `underscore_case` in PHP and ruby

This doesn&#39;t really bother me too much, but I wonder why these became so misaligned, seemingly on purpose. At least with underscores it was possible to maintain consistency:

    var featured_product = $(&#39;#featured_product&#39;); // instead of
    var featuredProduct = $(&#39;#featured-product&#39;);

The differences create situations where we have to [translate strings][5] unnecessarily, along with the potential for bugs.

So I ask: Why did the community almost universally settle on dashes, and are there any reasons that outweigh underscores?

There is a [related question][6] from back around the time this started, but I&#39;m of the opinion that it&#39;s not (or _shouldn&#39;t_ have been) just a matter of taste. I&#39;d like to understand why we all settled on this convention if it really was just a matter of taste.


  [1]: http://css-tricks.com/5016-new-poll-hyphens-or-dashes/
  [2]: https://stackoverflow.com/questions/2119629/javascript-and-css-using-dashes/2119668#2119668
  [3]: http://sass-lang.com/
  [4]: http://compass-style.org/
  [5]: https://stackoverflow.com/questions/7286607/jquery-camel-case-mapping-from-data-attribute-names-to-data-keys
  [6]: https://stackoverflow.com/questions/1686337/hyphens-or-underscores-in-css-and-html-identifiers

Why are dashes preferred for CSS selectors / HTML attributes?

In traditional C++, passing by value into functions and methods is slow for large objects, and is generally frowned upon. Instead, C++ programmers tend to pass references around, which is faster, but which introduces all sorts of complicated questions around ownership and especially around memory management (in the event that the object is heap-allocated)

Now, in C++11, we have Rvalue references and move constructors, which mean that it&#39;s possible to implement a large object (like an `std::vector`) that&#39;s cheap to pass by value into and out of a function.

So, does this mean that the default should be to pass by value for instances of types such as `std::vector` and `std::string`? What about for custom objects? What&#39;s the new best practice?

Is pass-by-value a reasonable default in C++11?

I was wondering what was the best practice for initializing object attributes in Python, in the body of the class or inside the `__init__` function?

i.e.

    class A(object):
        foo = None

vs

    class A(object):
       def __init__(self):
           self.foo = None


Content Type	Original Author	Original Content on Stackoverflow
Question	Yuvi	View Question on Stackoverflow
Solution 1 - Coding Style	K-ballo	View Answer on Stackoverflow
Solution 2 - Coding Style	Hermann Schwarz	View Answer on Stackoverflow

Space after if, while, etc (and before the paren)

Coding Style Problem Overview

Coding Style Solutions

Solution 1 - Coding Style

Solution 2 - Coding Style

How do you set the absolute position of figure windows with matplotlib?

Reading file input from a multipart/form-data POST

Attributions