The file open modes are not really specific to ruby - they are part of IEEE Std 1003.1 ([Single UNIX Specification][1]). You can read more about it here:


[http://pubs.opengroup.org/onlinepubs/009695399/functions/fopen.html][2]

    r or rb
        Open file for reading.

    w or wb
        Truncate to zero length or create file for writing.

    a or ab
        Append; open or create file for writing at end-of-file.

    r+ or rb+ or r+b
        Open file for update (reading and writing).

    w+ or wb+ or w+b
        Truncate to zero length or create file for update.

    a+ or ab+ or a+b
        Append; open or create file for update, writing at end-of-file.

Any mode that contains the letter &#39;b&#39; stands for binary file. If the &#39;b&#39; is not present is a &#39;plain text&#39; file.

The difference between &#39;open&#39; and &#39;open for update&#39; is indicated as:

&gt; When a file is opened with update mode ( &#39;+&#39; as the second or third character in the mode argument), both input and output may be performed on the associated stream. However, the application shall ensure that output is not directly followed by input without an intervening call to fflush() or to a file positioning function ( fseek(), fsetpos(), or rewind()), and input is not directly followed by output without an intervening call to a file positioning function, unless the input operation encounters end-of-file.

  [1]: http://en.wikipedia.org/wiki/Single_UNIX_Specification
  [2]: http://pubs.opengroup.org/onlinepubs/009695399/functions/fopen.html

I have setup xdebug and webgrind and I have generated a profile so I can start improving the speed of my code execution. I have displayed the profile in webgrind but I haven&#39;t got a clue what any of it means. All the googling I have done doesn&#39;t really explain any of it either.

Could someone please explain the basics of reading a webgrind report:

Invocation Count

Total Self Cost


Total Inclusive Cost

What the different colours mean

What the coloured bar means

Calls

Total Call Cost

Count

How do a read a xdebug profile in webgrind?

I sense that the Scala community has a little big obsession with writing &quot;concise&quot;, &quot;cool&quot;, **&quot;scala idiomatic&quot;**, &quot;one-liner&quot; -if possible- code. This is immediately followed by a comparison to Java/imperative/ugly code.

While this (sometimes) leads to easy to understand code, it also leads to inefficient code for 99% of developers. And this is where Java/C++ is not easy to beat.

Consider this simple problem: **Given a list of integers, remove the greatest element.** Ordering does not need to be preserved.

Here is my version of the solution (It may not be the greatest, but it&#39;s what the average non-rockstar developer would do).

    def removeMaxCool(xs: List[Int]) = {
	  val maxIndex = xs.indexOf(xs.max);
	  xs.take(maxIndex) ::: xs.drop(maxIndex+1)
    }

It&#39;s Scala idiomatic, concise, and uses a few nice list functions. It&#39;s also very inefficient. It traverses the list at least 3 or 4 times.

Here is my totally uncool, Java-like solution. It&#39;s also what a reasonable Java developer (or Scala novice) would write.

	def removeMaxFast(xs: List[Int]) = {
		var res = ArrayBuffer[Int]()
		var max = xs.head
		var first = true;	
		for (x &lt;- xs) {
			if (first) {
				first = false;
			} else {
				if (x &gt; max) {
					res.append(max)
					max = x
				} else {
					res.append(x)
				}
			}
		}
		res.toList
	}

Totally non-Scala idiomatic, non-functional, non-concise, but it&#39;s very efficient. It traverses the list only once!

So, if 99% of Java developers write more efficient code than 99% of Scala developers, this is a huge 
obstacle to cross for greater Scala adoption. Is there a way out of this trap?

I am looking for practical advice to avoid such &quot;inefficiency traps&quot; while keeping implementation clear ans concise.

**Clarification:** This question comes from a real-life scenario: I had to write a complex algorithm. First I wrote it in Scala, then I &quot;had to&quot; rewrite it in Java. The Java implementation was twice as long, and not that clear, but at the same time it was twice as fast. Rewriting the Scala code to be efficient would probably take some time and a somewhat deeper understanding of scala internal efficiencies (for vs. map vs. fold, etc)


Is Scala idiomatic coding style just a cool trap for writing inefficient code?

I am new programmar in Ruby. Can someone take an example about opening file with r+,w+,a+ mode in Ruby? What is difference between them and r,w,a?

Please explain, and provide an example.

File opening mode in Ruby

<p>I am new programmar in Ruby. Can someone take an example about opening file with r+,w+,a+ mode in Ruby? What is difference between them and r,w,a?</p>
<p>Please explain, and provide an example.</p>


How do I add a default value to a column that already exists through a migration? 

All the documentation I can find shows you how to do it if the column doesn&#39;t already exist but in this case it does. 

Add a default value to a column through a migration

    rails g model Rating user_id:integer message:string value:integer


How can I completely remove this model? Thanks

Removing a model in rails (reverse of &quot;rails g model Title...&quot;)

Suppose we have string like this:

    Hello, my\n       name is Michael.

How can I remove that new line and strip those spaces after that into one inside of string to get this?

    Hello, my name is Michael.

Remove multiple spaces and new lines inside of String

I am using an after_commit in my application. 

I would like it to trigger only when a particular field is updated in my model. Anyone know how to do that?

after_commit for an attribute

&gt; **Possible Duplicate:**  
&gt; [diff a ruby string or array](https://stackoverflow.com/questions/80091/diff-a-ruby-string-or-array)  

&lt;!-- End of automatically inserted text --&gt;

I have an old array: `[1, 2, 3, 4, 5]`, and new: `[1, 2, 4, 6]`

How to get difference with Ruby: that `5, 3` was removed and `6` was added?

Get difference of arrays in Ruby

I want to redirect **all** console text to a file. Here is what I tried:

    &gt; sink(&quot;test.log&quot;, type=c(&quot;output&quot;, &quot;message&quot;))
    &gt; a &lt;- &quot;a&quot;
    &gt; a
    &gt; How come I do not see this in log
    Error: unexpected symbol in &quot;How come&quot;

 

Here is what I got in test.log:

    [1] &quot;a&quot;

Here is what I want in test.log:

    &gt; a &lt;- &quot;a&quot;
    &gt; a
    [1] &quot;a&quot;
    &gt; How come I do not see this in log
    Error: unexpected symbol in &quot;How come&quot;

What am I doing wrong? Thanks!



How to save all console output to file in R?

How can I download only a specific folder or directory from a remote Git repo hosted on GitHub?

Say the example GitHub repo lives here:

    git@github.com:foobar/Test.git

Its directory structure:

```
Test/
├── foo/ 
│   ├── a.py
│   └── b.py   
└── bar/
    ├── c.py
    └── d.py
```

I want to download only the **foo** folder and not clone the whole Test project.

Download a single folder or directory from a GitHub repo

I have a problem getting the size of a file. I have the following code:

    File file = new File(&quot;/sdcard/lala.txt&quot;);
    long length = file.length();

And always length is zero, yes zero.

I am using Android SDK (not sure what version), the code is running inside an Activity, I have created an sdcard.  

Perhaps it is a permission issue? Is there anything I am missing?


Get the file size in android sdk?

I have been given this interview question:

&gt; Given an input file with four billion integers, provide an algorithm to generate an integer which is not contained in the file. Assume you have 1&amp;nbsp;GB memory. Follow up with what you would do if you have only 10&amp;nbsp;MB of memory.

### My analysis:

The size of the file is 4&#215;10&lt;sup&gt;9&lt;/sup&gt;&#215;4 bytes = 16&amp;nbsp;GB.

We can do external sorting, thus letting us know the range of the integers.

My question is what is the best way to detect the missing integer in the sorted big integer sets?

### My understanding (after reading all the answers):

Assuming we are talking about 32-bit integers, there are 2&lt;sup&gt;32&lt;/sup&gt; = 4*10&lt;sup&gt;9&lt;/sup&gt; distinct integers.

# Case 1: we have 1&amp;nbsp;GB = 1 * 10&lt;sup&gt;9&lt;/sup&gt; * 8 bits = 8 billion bits memory.

### Solution:
If we use one bit representing one distinct integer, it is enough. we don&#39;t need sort.

### Implementation:

&lt;!-- language: lang-cs --&gt;

    int radix = 8;
    byte[] bitfield = new byte[0xffffffff/radix];
    void F() throws FileNotFoundException{
        Scanner in = new Scanner(new FileReader(&quot;a.txt&quot;));
        while(in.hasNextInt()){
            int n = in.nextInt();
            bitfield[n/radix] |= (1 &lt;&lt; (n%radix));
        }

        for(int i = 0; i&lt; bitfield.lenght; i++){
            for(int j =0; j&lt;radix; j++){
                if( (bitfield[i] &amp; (1&lt;&lt;j)) == 0) System.out.print(i*radix+j);
            }
        }
    }

# Case 2: 10&amp;nbsp;MB memory = 10 * 10&lt;sup&gt;6&lt;/sup&gt; * 8 bits = 80 million bits


&gt; ### Solution:
For all possible 16-bit prefixes, there are 2&lt;sup&gt;16&lt;/sup&gt; number of
integers = 65536, we need 2&lt;sup&gt;16&lt;/sup&gt; * 4 * 8 = 2 million bits. We need build 65536 buckets. For each bucket, we need 4 bytes holding all possibilities because the worst case is all the 4 billion integers belong to the same bucket.
&gt;
&gt; 1. Build the counter of each bucket through the first pass through the file.
&gt; 2. Scan the buckets, find the first one who has less than 65536 hit.
&gt; 3. Build new buckets whose high 16-bit prefixes are we found in step2
through second pass of the file
&gt; 4. Scan the buckets built in step3, find the first bucket which doesnt
have a hit.
&gt;
&gt; The code is very similar to above one.

  Conclusion:
    We decrease memory through increasing file pass.

----
&lt;sup&gt;
A clarification for those arriving late: The question, as asked, does not say that there is exactly one integer that is not contained in the file&amp;mdash;at least that&#39;s not how most people interpret it. Many comments in the comment thread **are** about that variation of the task, though. Unfortunately the comment that **introduced** it to the comment thread was later deleted by its author, so now it looks like the orphaned replies to it just misunderstood everything. It&#39;s very confusing, sorry.
&lt;/sup&gt;

Generate an integer that is not among four billion given ones

Suppose my python code is executed a directory called `main` and the application needs to access `main/2091/data.txt`.

how should I use `open(location)`? what should the parameter `location` be?

I found that below simple code will work.. does it have any disadvantages?


    file = &quot;\2091\sample.txt&quot;
    path = os.getcwd()+file
    fp = open(path, &#39;r+&#39;);



Open file in a relative location in Python

What is the use of `tim.tv_sec` and `tim.tv_nsec` in the following?

How can I sleep execution for `500000` microseconds?

    #include &lt;stdio.h&gt;
    #include &lt;time.h&gt;
 
    int main()
    {
       struct timespec tim, tim2;
       tim.tv_sec = 1;
       tim.tv_nsec = 500;
 
       if(nanosleep(&amp;tim , &amp;tim2) &lt; 0 )   
       {
          printf(&quot;Nano sleep system call failed \n&quot;);
          return -1;
       }
 
       printf(&quot;Nano sleep successfull \n&quot;);
 
       return 0;
    }

How to use nanosleep() in C? What are `tim.tv_sec` and `tim.tv_nsec`?

I am using a scientific software including a Python script that is calling `os.system()` which is used to run another scientific program. While the subprocess is running, Python at some point prints the following:

    close failed in file object destructor:
    IOError: [Errno 9] Bad file descriptor

I believe that this message is printed at the same time as `os.system()` returns.

My questions now are:

Which conditions can lead to this type of IOError? What does it exactly mean? What does it mean for the subprocess that has been invoked by `os.system()`?





What can lead to &quot;IOError: [Errno 9] Bad file descriptor&quot; during os.system()?

Is snprintf always null terminating the destination buffer?

In other words, is this sufficient:

    char dst[10];

    snprintf(dst, sizeof (dst), &quot;blah %s&quot;, somestr);

or do you have to do like this, if somestr is long enough?

    char dst[10];

    somestr[sizeof (dst) - 1] = &#39;\0&#39;;
    snprintf(dst, sizeof (dst) - 1, &quot;blah %s&quot;, somestr);


I am interested both in what the standard says and what some popular libc might do which is not standard behavior.



Is snprintf() ALWAYS null terminating?

From my understanding, `SIGPIPE` can only occur as the result of a `write()`, which can (and does) return -1 and set `errno` to `EPIPE`... So why do we have the extra overhead of a signal? Every time I work with pipes I ignore `SIGPIPE` and have never felt any pain as a result, am I missing something?

Why does SIGPIPE exist?

The C standard (ISO/IEC 9899:2011 or 9899:1999) defines a type `ptrdiff_t` in `&lt;stddef.h&gt;`.

The POSIX standard (ISO/IEC 9945; IEEE Std 1003.1-2008) defines a type `ssize_t` in `&lt;sys/types.h&gt;`.

* What is the difference between these types (or why were both deemed necessary)?
* Is there an implementation where the underlying base type for `ssize_t` is not the same as for `ptrdiff_t`?

Content Type	Original Author	Original Content on Stackoverflow
Question	amir amir	View Question on Stackoverflow
Solution 1 - Ruby	miku	View Answer on Stackoverflow

File opening mode in Ruby

Ruby Problem Overview

Ruby Solutions

Solution 1 - Ruby

Is Scala idiomatic coding style just a cool trap for writing inefficient code?

How do a read a xdebug profile in webgrind?

Attributions