A parameter is the variable which is part of the method’s signature (method declaration).  An argument is an expression used when calling the method.

Consider the following code:

&lt;!-- language: lang-cs --&gt;

    void Foo(int i, float f)
    {
        // Do things
    }

    void Bar()
    {
        int anInt = 1;
        Foo(anInt, 2.0);
    }

Here `i` and `f` are the parameters, and `anInt` and `2.0` are the arguments.

I have been heavily relying on CSS for a website that I am working on. Right now, all the CSS styles are being applied on a per tag basis, and so now I am trying to move it to more of an external styling to help with any future changes.

But now the problem is that I have noticed I am getting a &quot;CSS Explosion&quot;.  It is becoming difficult for me to decide how to best organize and abstract data within the CSS file.

I am using a large number of `div` tags within the website, moving from a heavily table-based website.  So I&#39;m getting a lot of CSS selectors that look like this:

&lt;!-- language: lang-css --&gt;

    div.title {
      background-color: blue;
      color: white;
      text-align: center;
    }
    
    div.footer {
      /* Styles Here */
    }
    
    div.body {
      /* Styles Here */
    }

    /* And many more */

It&#39;s not too bad yet, but as I am a beginner, I was wondering if recommendations could be made on how best to organize the various parts of a CSS file.  I don&#39;t want to have a separate CSS attribute for every element on my website, and I always want the CSS file to be fairly intuitive and easy to read.

My ultimate goal is to make it easy to use the CSS files and demonstrate their power to increase the speed of web development. This way, other individuals that may work on this site in the future will also get into the practice of using good coding practices, rather than having to pick it up the way I did.

Managing CSS Explosion

I have a data frame `df` and I use several columns from it to `groupby`:

    df[&#39;col1&#39;,&#39;col2&#39;,&#39;col3&#39;,&#39;col4&#39;].groupby([&#39;col1&#39;,&#39;col2&#39;]).mean()

In the above way I almost get the table (data frame) that I need. What is missing is an additional column that contains number of rows in each group. In other words, I have mean but I also would like to know how many number were used to get these means. For example in the first group there are 8 values and in the second one 10 and so on.

In short: How do I get **group-wise** statistics for a dataframe?




Get statistics for each group (such as count, mean, etc) using pandas GroupBy?

I got _parameter_ and _argument_ kind of mixed up and did not really pay attention to when to use one and when to use the other.  

Can you please tell me? 


&quot;Parameter&quot; vs &quot;Argument&quot;

I got parameter and argument kind of mixed up and did not really pay attention to when to use one and when to use the other.
Can you please tell me?

I have a bash function that produces some output:

    function scan {
      echo &quot;output&quot;
    }

**How can I assign this output to a variable?**

ie. VAR=scan (of course this doesn&#39;t work - it makes VAR equal the string &quot;scan&quot;)

How can I assign the output of a function to a variable using bash?

What is a fastest way to clone a function in JavaScript (with or without its properties)?

Two options coming to mind are `eval(func.toString())` and `function() { return func.apply(..) }`. But I am worried about performance of eval and wrapping will make stack worse and will probably degrade performance if applied a lot or applied to already wrapped.

`new Function(args, body)` looks nice, but how exactly can I reliable split existing function to args and body without a JS parser in JS?

Thanks in advance.

**Update:**
What I mean is being able to do

    var funcB = funcA.clone(); // where clone() is my extension
    funcB.newField = {...};    // without affecting funcA

JavaScript: clone a function

If I have a Bash script like:

    #!/bin/bash
    
    f() {
      # echo function name, &quot;f&quot; in this case
    }

Is there any way to do this? This could be used in help messages such as

    printf &quot;Usage: %s: blah blah blah \n&quot; $(basename $0) &gt;&amp;2; 

Only in this case what I wanted is not `$0`, which is the file name of the script.

How to determine function name from inside a function

Lets say I have two functions:

    def foo():
      return &#39;foo&#39;

    def bar():
      yield &#39;bar&#39;

The first one is a normal function, and the second is a generator function. Now I want to write something like this:

    def run(func):
      if is_generator_function(func):
         gen = func()
         gen.next()
         #... run the generator ...
      else:
         func()
         
What will a straightforward implementation of `is_generator_function()` look like? Using the `types` package I can test if  `gen` is a generator, but I wish to do so before invoking `func()`. 

Now consider the following case:

    def goo():
      if False:
         yield
      else:
         return

An invocation of `goo()` will return a generator. I presume that the python parser knows that the `goo()` function has a yield statement, and I wonder if it possible to get that information easily.

Thanks!

In python is there a way to check if a function is a &quot;generator function&quot; before calling it?

Is it possible to use previous arguments in a functions parameter list as the default value for later arguments in the parameter list?  For instance,

    void f( int a, int b = a, int c = b );

If this is possible, are there any rules of use?

Can I set a default argument from a previous argument?

In C# you can put a constraint on a generic method like:

    public class A {
        
        public static void Method&lt;T&gt; (T a) where T : new() {
            //...do something...
        }
        
    }

Where you specify that `T` should have a constructor that requires no parameters. I&#39;m wondering whether there is a way to add a constraint like &quot;*there exists a constructor with a `float[,]` parameter?*&quot;

The following code doesn&#39;t compile:

    public class A {
        
        public static void Method&lt;T&gt; (T a) where T : new(float[,] u) {
            //...do something...
        }
        
    }

A workaround is also useful?

Is there a generic constructor with parameter constraint in C#?

I have this line of code:

    &lt;%= link_to &quot;Add to cart&quot;, :controller =&gt; &quot;car&quot;, :action =&gt; &quot;add_to_cart&quot;, :car =&gt; car %&gt;


when im in the add_to_cart method...how can i call the :car please?


    @car = Car.new(params[:car])

That doesn&#39;t work because it says that I&#39;m trying to stringify it.

I don&#39;t understand what&#39;s wrong; because I used this to create new users and it worked fine.

By the way, car is my car object.


 

pass parameter by link_to ruby on rails

Is there a way to set up a C# function to accept any number of parameters? For example, could you set up a function such that the following all work - 

    x = AddUp(2, 3)
    
    x = AddUp(5, 7, 8, 2)
    
    x = AddUp(43, 545, 23, 656, 23, 64, 234, 44)

Pass multiple optional parameters to a C# function

I&#39;m wondering whether to use matrix or query parameters in my URLs. I found an older [discussion][1] to that topic not satisfying.

Examples

- URL with query params: http://some.where/thing?paramA=1&amp;paramB=6542
- URL with matrix params: http://some.where/thing;paramA=1;paramB=6542

At first sight matrix params seem to have only advantages:

 - more readable
 - no encoding and decoding of &quot;&amp;&quot; in XML documents is required
 - URLs with &quot;?&quot; are not cached in many cases; URLs with matrix params are cached
 - matrix parameters can appear everywhere in the path and are not limited to its end
 - matrix parameters can have more than one value: `paramA=val1,val2`
 
But there are also disadvantages:

 - only a few frameworks like [JAX-RS][2] support matrix parameters
 - When a browser submits a form via GET, the params become query params. So it ends up in two kinds of parameters for the same task. To not confuse users of the REST services and limit the effort for the developers of the services, it would be easier to use always query params - in this area.

Since the developer of the service can choose a framework with matrix param support, the only remaining disadvantage would be that browsers create by default query parameters.

Are there any other disadvantages? What would you do?


  [1]: https://stackoverflow.com/questions/401981/when-to-use-query-parameters-versus-matrix-parameters
  [2]: https://jsr311.dev.java.net/

URL matrix parameters vs. query parameters

I&#39;ve got a R script for which I&#39;d like to be able to supply several command-line parameters (rather than hardcode parameter values in the code itself).  The script runs on Windows.

I can&#39;t find info on how to read parameters supplied on the command-line into my R script.  I&#39;d be surprised if it can&#39;t be done, so maybe I&#39;m just not using the best keywords in my Google search...

Any pointers or recommendations?

How can I read command line parameters from an R script?

Not strictly a question, more of a puzzle...

Over the years, I&#39;ve been involved in a few technical interviews of new employees. Other than asking the standard &quot;do you know X technology&quot; questions, I&#39;ve also tried to get a feel for how they approach problems. Typically, I&#39;d send them the question by email the day before the interview, and expect them to come up with a solution by the following day.

Often the results would be quite interesting - wrong, but interesting - and the person would still get my recommendation if they could explain why they took a particular approach.

So I thought I&#39;d throw one of my questions out there for the Stack Overflow audience. 

Question: **What is the most space-efficient way you can think of to encode the state of a chess game (or subset thereof)? That is, given a chess board with the pieces arranged legally, encode both this initial state and all subsequent legal moves taken by the players in the game.**

No code required for the answer, just a description of the algorithm you would use.

EDIT: As one of the posters has pointed out, I didn&#39;t consider the time interval between moves. Feel free to account for that too as an optional extra :)

EDIT2: Just for additional clarification... Remember, the encoder/decoder is rule-aware. The only things that really need to be stored are the player&#39;s choices - anything else can be assumed to be known by the encoder/decoder.

EDIT3: It&#39;s going to be difficult to pick a winner here :) Lots of great answers!



Programmer Puzzle: Encoding a chess board state throughout a game

Given a system (a website for instance) that lets a user customize the background color for some section but not the font color (to keep number of options to a minimum), is there a way to programmatically determine if a &quot;light&quot; or &quot;dark&quot; font color is necessary?

I&#39;m sure there is some algorithm, but I don&#39;t know enough about colors, luminosity, etc to figure it out on my own.

Determine font color based on background color

Given 2 angles in the range -PI -&gt; PI around a coordinate, what is the value of the smallest of the 2 angles between them?

Taking into account that the difference between PI and -PI is not 2 PI but zero.

**Example:**

Imagine a circle, with 2 lines coming out from the center, there are 2 angles between those lines, the angle they make on the inside aka **the smaller angle**, and the angle they make on the outside, aka the bigger angle. Both angles when added up make a full circle. Given that each angle can fit within a certain range, **what is the smaller angles value, taking into account the rollover**

How can I find the difference between two angles?

What is the difference between concurrent programming and parallel programing? I asked google but didn&#39;t find anything that helped me to understand that difference. Could you give me an example for both?

For now I found this explanation: http://www.linux-mag.com/id/7411 - but &quot;concurrency is a property of the program&quot; vs &quot;parallel execution is a property of the machine&quot; isn&#39;t enough for me - still I can&#39;t say what is what.

What is the difference between concurrent programming and parallel programming?

The year 2009 is coming to an end, and with the economy and all, we&#39;ll save our money and instead of buying expensive fireworks, we&#39;ll celebrate in ASCII art this year.

## The challenge

Given a set of fireworks and a time, take a picture of the firework at that very time and draw it to the console.

The best solution entered before midnight on New Year&#39;s Eve (UTC) will receive a bounty of 500 rep. This is code golf, so the number of characters counts heavily; however so do community votes, and I reserve the ultimate decision as to what is best/coolest/most creative/etc.

## Input Data

Note that our coordinate system is left-to-right, bottom-to-top, so all fireworks are launched at a `y`-coordinate of 0 (zero).

The input data consists of fireworks of the form

    (x, speed_x, speed_y, launch_time, detonation_time)
    
where 

* `x` is the position (column) where the firework is launched,
* `speed_x` and `speed_y` are the horizontal and vertical velocity of the firework at launch time,
* `launch_time` is the point in time that this firework is launched,
* `detonation_time` is the point in time that this firework will detonate.

The firework data may be hardcoded in your program as a list of 5-tuples (or the equivalent in your language), not counting towards your character count. It must, however, be easy to change this data.

You may make the following assumptions:

* there is a reasonable amount of fireworks (say, fewer then a hundred)
* for each firework, all five numbers are integers within a reasonable range (say, 16 bits would suffice for each),
* `-20 &lt;= x &lt;= 820`
* `-20 &lt;= speed_x &lt;= 20`
* `0 &lt; speed_y &lt;= 20`
* `launch_time &gt;= 0`
* `launch_time &lt; detonation_time &lt; launch_time + 50`

The single additional piece of input data is the point of time which is supposed to be rendered. This is a non-negative integer that is given to you via standard input or command line argument (whichever you choose).

The idea is that (assuming your program is a python script called `firework.py`) this bash script gives you a nice firework animation:

    #!/bin/bash
    I=0
    while (( 1 )) ; do
        python firework.py $I
        I=$(( $I + 1 ))
    done

(feel free to put the equivalent .BAT file here).

## Life of a firework

The life of a firework is as follows:

* Before the launch time, it can be ignored.
* At launch time, the rocket has the position `(x, 0)` and the speed vector `(speed_x, speed_y)`.
* For each time step, the speed vector is added to the position. With a little stretch applied to Newton&#39;s laws, we assume that the speed stays constant.
* At detonation time, the rocket explodes into nine sparks. All nine sparks have the same position at this point in time (which is the position that the rocket would have, hadn&#39;t it exploded),
but their speeds differ. Each speed is based on the rocket&#39;s speed, with -20, 0, or 20 added to `speed_x` and -10, 0, or 10 added to `speed_y`. That&#39;s nine possible combinations.
* After detonation time, gravity starts to pull: With each time step, the gravitational constant, which happens to be 2 (two), is subtracted from every spark&#39;s `speed_y`.
The horizontal `speed_x` stays constant.
* For each time step after the detonation time, you **first** add the speed vector to the position, **then** subtract 2 from `speed_y`.
* When a spark&#39;s `y` position drops below zero, you may forget about it.

## Output

What we want is a picture of the firework the way it looks at the given point in time. We only look at the frame `0 &lt;= x &lt;= 789` and `0 &lt;= y &lt;= 239`, mapping it to a 79x24 character output.

So if a rocket or spark has the position (247, 130), we draw a character in column 24 (zero-based, so it&#39;s the 25th column), row 13 (zero-based and counting from the bottom, so it&#39;s line 23 - 13 = 10, the 11th line
of the output).

Which character gets drawn depends on the current speed of the rocket / spark:

* If the movement is horizontal*, i.e. `speed_y == 0 or abs(speed_x) / abs(speed_y) &gt; 2`, the character is &quot;`-`&quot;.
* If the movement is vertical*, i.e. `speed_x == 0 or abs(speed_y) / abs(speed_x) &gt; 2`, the character is &quot;`|`&quot;.
* Otherwise the movement is diagonal, and the character is &quot;`\`&quot; or &quot;`/`&quot; (you&#39;ll guess the right one).
* If the same position gets drawn to more than once (even if it&#39;s the same character), we put &quot;`X`&quot; instead. So assuming you have a spark at `(536, 119)` and one at `(531, 115)`, you draw an &quot;`X`&quot;, regardless of their speeds.

&lt;sup&gt;* update: these are integer divisions, so the slope has to be at least 3, or at most 1/3, respectively&lt;/sup&gt;

The output (written to standard output) is 24 lines, each terminated by a newline character. Trailing spaces are ignored, so you may, but don&#39;t need to, pad to a width of 79. The lines may not be longer than 79 characters (excluding the newline). All interior spacing must be space characters (ASCII 32).

## Sample Data

Fireworks:

    fireworks = [(628, 6, 6, 3, 33),
                 (586, 7, 11, 11, 23),
                 (185, -1, 17, 24, 28),
                 (189, 14, 10, 50, 83),
                 (180, 7, 5, 70, 77),
                 (538, -7, 7, 70, 105),
                 (510, -11, 19, 71, 106),
                 (220, -9, 7, 77, 100),
                 (136, 4, 14, 80, 91),
                 (337, -13, 20, 106, 128)]

Output at time 33:

&lt;pre&gt;
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
       \         |         /                                                   
                                                                               
                                                                               
                                                      /                   \    
                                                                               
       -         |         /                                                   
                                                                               
                                                                               
                                                                               
                                                                               
       -         |         -                                                   
                                                                               
                                                                               
                                                      /                   \    
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
&lt;/pre&gt;

Output at time 77:

&lt;pre&gt;
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                            \                                  
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                \                              
                      X                                                        
                                                                               
                                                                               
                      \                                                        
&lt;/pre&gt;

Output at time 93:

&lt;pre&gt;
                                                                               
                                                                               
                                                                               
              \   |   /                                                        
                                                                               
              \   /   /                                                        
                                                                               
              -   -   -              \                                         
                                                                               
                                                                               
                                                                               
                                                                               
       \                                                                       
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
                                                                               
  /                               \                               \            
                                                                               
                                                                               
                                                                               
&lt;/pre&gt;

**Update:** I have uploaded the expected output at the times 0 thru 99 to [firework.&#252;-wie-geek.de/NUMBER.html][1], where NUMBER is the time. It includes debug information; click on a particle to see its current position, speed, etc. And yes, it&#39;s an umlaut domain. If your browser can&#39;t handle that (as obviously neither can Stack Overflow), try [firework.xn---wie-geek-p9a.de][2].

**Another update:** As hinted at in the comments below, a longer firework is now available on [YouTube][3]. It was created with a modified version of [MizardX&#39; entry][4], with a total fireworks count of 170 (yes, that&#39;s more than the spec asked for, but the program handled it gracefully). Except for the color, the music, and the end screen, the animation can be recreated by any entry to this code golf. So, if you&#39;re geeky enough to enjoy an ASCII art firework (you know you are): Have fun, and a happy new year to all!


  [1]: http://firework.&#252;-wie-geek.de/0.html
  [2]: http://firework.xn---wie-geek-p9a.de/0.html
  [3]: http://www.youtube.com/watch?v=HRYg6ixAnPg
  [4]: https://stackoverflow.com/questions/1947031/code-golf-new-years-fireworks/1953608#1953608

Code Golf: New Year&#39;s Fireworks

`$1` is the first argument.  
`$@` is all of them.

How can I find the last argument passed to a shell
script?

Getting the last argument passed to a shell script

I usually input command line arguments in Eclipse via run configuration. But I don&#39;t know how do achieve the same task in IntelliJ IDEA.

How do you input command line arguments in IntelliJ IDEA?

Is there a way to allow &quot;unlimited&quot; vars for a function in JavaScript?

Example:

    load(var1, var2, var3, var4, var5, etc...)
    load(var1)


JavaScript variable number of arguments to function

Is it possible to declare a method that will allow a variable number of parameters ?

What is the symbolism used in the definition that indicate that the method should allow a variable number of parameters?

**Answer:** varargs


Java variable number of arguments for a method

I wonder not only what is Facet but also what is Facet &#39;in physical level&#39; (as I understand it&#39;s not a separate jar, but what?)?

I also wonder how can it affect my application after deploying. I&#39;ll explain on real example:

I had 2 facets (which were created by IDE): Spring Facet and Web Facet (for jsf). I deployed it to Tomcat and my application worked fine.

Then I added (by means of IDE) one more facet - JPA Facet. I redeployed application and.. it still worked fine :) 

So, I&#39;m just curious what is that and why do we need it?

What is &#39;Facet&#39; in JavaEE?

I&#39;ve been reading a bit about how interpreters/compilers work, and one area where I&#39;m getting confused is the difference between an AST and a CST.  My understanding is that the parser makes a CST, hands it to the semantic analyzer which turns it into an AST.  However, my understanding is that the semantic analyzer simply ensures that rules are followed.  I don&#39;t really understand why it would actually make any changes to make it abstract rather than concrete.

Is there something that I&#39;m missing about the semantic analyzer, or is the difference between an AST and  CST somewhat artificial?

What is the difference between an Abstract Syntax Tree and a Concrete Syntax Tree?

I understand JSON, but not JSONP. [Wikipedia&#39;s document on JSON][1] is (was) the top search result for JSONP. It says this:

&gt; JSONP or &quot;JSON with padding&quot; is a JSON extension wherein a prefix is specified as an input argument of the call itself.

Huh? What call? That doesn&#39;t make any sense to me. JSON is a data format. There&#39;s no call.

The [2nd search result][2] is from some guy named [Remy](https://stackoverflow.com/users/22617/remy-sharp), who writes this about JSONP:

&gt; JSONP is script tag injection, passing the response from the server in to a user specified function.

I can sort of understand that, but it&#39;s still not making any sense.

----

So what is JSONP? Why was it created (what problem does it solve)? And why would I use it? 

----

**Addendum**: I&#39;ve just created [a new page for JSONP][3] on Wikipedia; it now has a clear and thorough description of JSONP, based on [jvenema][4]&#39;s answer.


  [1]: http://en.wikipedia.org/wiki/JSON
  [2]: http://remysharp.com/2007/10/08/what-is-jsonp/
  [3]: http://en.wikipedia.org/wiki/JSONP
  [4]: https://stackoverflow.com/users/25330/jvenema

What is JSONP, and why was it created?

If I have a URL like:

    http://www.example.com:9090/test.html

Then I know that `www.example.com` is the host name, but what do you call `http://www.example.com:9090`? Is there some kind of established name for that?

Content Type	Original Author	Original Content on Stackoverflow
Question	dummy	View Question on Stackoverflow
Solution 1 - Function	tranmq	View Answer on Stackoverflow

"Parameter" vs "Argument"

Function Problem Overview

Function Solutions

Solution 1 - Function

Get statistics for each group (such as count, mean, etc) using pandas GroupBy?

Managing CSS Explosion

Attributions