Advantages of using React:

- easy to know how a component is rendered, you just look at the render function. 
- JSX makes it easy to read the code of your components. It is also really easy to see the layout, or how components are plugged/combined with each other.
- you can render React on the server-side.
- it is easy to test, and you can also integrate some tools like jest.
- it ensures readability and makes maintainability easier.
- you can use React with any framework (Backbone.js, Angular.js) as it is only a view layer.

What is not so good about React?

- it is only a view layer, you have still to plug your code for Ajax requests, events and so on. Some people get surprised by that.
- the library itself is pretty large.
- the learning curve can be steep.



If react-native is really how it was described, react is going to become even bigger.

Performance wise, it is really good as it relies on a virtual-dom to know what is really changing in your UI and will re-render only what has really changed.  It does have trouble with very large, slightly changing, lists of children (2000 `&lt;li&gt;` test), but can be optimized simply.

If you are not sure, just think about the big projects using React:
instagram, hipchat, facebook chat and so on.

Some resources:

- [React for the stupid people][1]
- [Rebuilding Hipchat with React][2]
- [Why React?][3]


And probably one of my favorite blog post [Why React is awesome?][4]


  [1]: http://blog.andrewray.me/reactjs-for-stupid-people/
  [2]: https://developer.atlassian.com/blog/2015/02/rebuilding-hipchat-with-react/
  [3]: http://facebook.github.io/react/docs/why-react.html
  [4]: http://jlongster.com/Removing-User-Interface-Complexity,-or-Why-React-is-Awesome

I need to check if a double-defined variable is convertible to Int without losing its value. This doesn&#39;t work because they are of different types:
   
    if self.value == Int(self.value)
where `self.value` is a double.

Checking if a double value is an integer - Swift

I want to download a vagrant box file from Atlas for using it later locally with my vagrant file. How can I do this, and how can I configure it?

Download vagrant box file locally from atlas and configuring it

I am new to using React for development.

Can someone list the advantages and disadvantages in using ReactJS.
Are there any performance issues with using this library for large projects.

Advantages and Disadvantages of using ReactJS

<p>I am new to using React for development.</p>
<p>Can someone list the advantages and disadvantages in using ReactJS.
Are there any performance issues with using this library for large projects.</p>


I recently came across the android `RecyclerView` which was released with Android 5.0 and it seems that `RecyclerView` is just an encapsulated traditional `ListView` with the ViewHolder pattern incorporated into it, which promotes the reuse of the view, rather than creating it every single time.

What are the other benefits of using `RecyclerView` ?
If both have the same effect in terms of performance, why would one prefer RecyclerView` ?

**Edit**

I found that people have asked similar question and the answers are not conclusive, adding them here for record keeping.

[Recyclerview vs Listview][3]

[Should we use RecyclerView to replace ListView?][1]

[Why doesn&#39;t RecyclerView have onItemClickListener()? and How RecyclerView is different from Listview?][2]

  [1]: https://stackoverflow.com/questions/28392554/should-we-use-recyclerview-to-replace-listview?rq=1
  [2]: https://stackoverflow.com/questions/24885223/why-doesnt-recyclerview-have-onitemclicklistener-and-how-recyclerview-is-dif/24933117#24933117
  [3]: https://stackoverflow.com/questions/26728651/recyclerview-vs-listview

Android Recyclerview vs ListView with Viewholder

I am investigating performance hotspots in an application which spends 50% of
its time in memmove(3). The application inserts millions of 4-byte integers
into sorted arrays, and uses memmove to shift the data &quot;to the right&quot; in
order to make space for the inserted value.

My expectation was that copying memory is extremely fast, and I was surprised
that so much time is spent in memmove. But then I had the idea that memmove
is slow because it&#39;s moving overlapping regions, which must be implemented
in a tight loop, instead of copying large pages of memory. I wrote a small
microbenchmark to find out whether there was a performance difference between
memcpy and memmove, expecting memcpy to win hands down.

I ran my benchmark on two machines (core i5, core i7) and saw that memmove is
actually faster than memcpy, on the older core i7 even nearly twice as fast!
Now I am looking for explanations.

Here is my benchmark. It copies 100 mb with memcpy, and then moves about 100 mb with memmove; source and destination are overlapping. Various &quot;distances&quot;
for source and destination are tried. Each test is run 10 times, the average
time is printed.

https://gist.github.com/cruppstahl/78a57cdf937bca3d062c

Here are the results on the Core i5 (Linux 3.5.0-54-generic #81~precise1-Ubuntu
SMP x86_64 GNU/Linux, gcc is 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5). The number
in brackets is the distance (gap size) between source and destination:

    memcpy        0.0140074
    memmove (002) 0.0106168
    memmove (004) 0.01065
    memmove (008) 0.0107917
    memmove (016) 0.0107319
    memmove (032) 0.0106724
    memmove (064) 0.0106821
    memmove (128) 0.0110633

Memmove is implemented as a SSE optimized assembler code, copying from back
to front. It uses hardware prefetch to load the data into the cache, and
copies 128 bytes to XMM registers, then stores them at the destination.

([memcpy-ssse3-back.S][1], lines 1650 ff)

    L(gobble_ll_loop):
	    prefetchnta -0x1c0(%rsi)
	    prefetchnta -0x280(%rsi)
	    prefetchnta -0x1c0(%rdi)
	    prefetchnta -0x280(%rdi)
	    sub	$0x80, %rdx
	    movdqu	-0x10(%rsi), %xmm1
	    movdqu	-0x20(%rsi), %xmm2
	    movdqu	-0x30(%rsi), %xmm3
	    movdqu	-0x40(%rsi), %xmm4
	    movdqu	-0x50(%rsi), %xmm5
	    movdqu	-0x60(%rsi), %xmm6
	    movdqu	-0x70(%rsi), %xmm7
	    movdqu	-0x80(%rsi), %xmm8
	    movdqa	%xmm1, -0x10(%rdi)
	    movdqa	%xmm2, -0x20(%rdi)
	    movdqa	%xmm3, -0x30(%rdi)
	    movdqa	%xmm4, -0x40(%rdi)
	    movdqa	%xmm5, -0x50(%rdi)
	    movdqa	%xmm6, -0x60(%rdi)
	    movdqa	%xmm7, -0x70(%rdi)
	    movdqa	%xmm8, -0x80(%rdi)
	    lea	-0x80(%rsi), %rsi
	    lea	-0x80(%rdi), %rdi
	    jae	L(gobble_ll_loop)

Why is memmove faster then memcpy? I would expect memcpy to copy memory pages,
which should be much faster than looping. In worst case I would expect memcpy
to be as fast as memmove.

PS: I know that I cannot replace memmove with memcpy in my code. I know that
the code sample mixes C and C++. This question is really just for academic
purposes.

UPDATE 1
-----------------

I ran some variations of the tests, based on the various answers.

  1. When running memcpy twice, then the second run is faster than the first one.
  2. When &quot;touching&quot; the destination buffer of memcpy (`memset(b2, 0, BUFFERSIZE...)`) then the first run of memcpy is also faster.
  3. memcpy is still a little bit slower than memmove.

Here are the results:

    memcpy        0.0118526
    memcpy        0.0119105
    memmove (002) 0.0108151
    memmove (004) 0.0107122
    memmove (008) 0.0107262
    memmove (016) 0.0108555
    memmove (032) 0.0107171
    memmove (064) 0.0106437
    memmove (128) 0.0106648

My conclusion: based on a comment from @Oliver Charlesworth, the operating system has to commit physical memory as soon as the memcpy destination buffer is accessed for the very first time (if someone knows how to &quot;proof&quot; this then please add an answer!). In addition, as @Mats Petersson said, memmove is cache friendlier than memcpy.

Thanks for all the great answers and comments!


  [1]: http://downloads.yoctoproject.org/mirror/sources/svn/www.eglibc.org/svn/branches/eglibc-2_13/libc/sysdeps/x86_64/multiarch/memcpy-ssse3-back.S

Why is memmove faster than memcpy?

Jon Skeet recently raised an interesting programming topic on his blog: [&quot;There&#39;s a hole in my abstraction, dear Liza, dear Liza&quot;](https://codeblog.jonskeet.uk/2010/07/29/there-s-a-hole-in-my-abstraction-dear-liza-dear-liza/) (emphasis added):

&gt; I have a set – a `HashSet`, in fact. I want to remove some items from it… and many of the items may well not exist. In fact, in our test case, *none* of the items in the &quot;removals&quot; collection will be in the original set. This sounds – and indeed *is* – extremely easy to code. After all, we’ve got [`Set&lt;T&gt;.removeAll`](https://docs.oracle.com/javase/6/docs/api/java/util/Set.html#removeAll(java.util.Collection)) to help us, right?
&gt;
&gt; We specify the size of the &quot;source&quot; set and the size of the &quot;removals&quot; collection on the command line, and build both of them. The source set contains only non-negative integers; the removals set contains only negative integers. We measure how long it takes to remove all the elements using `System.currentTimeMillis()`, which isn’t the world most accurate stopwatch but is more than adequate in this case, as you’ll see. Here’s the code:
&gt; 
&gt;     import java.util.*;
&gt;     public class Test 
&gt;     { 
&gt;         public static void main(String[] args) 
&gt;         { 
&gt;            int sourceSize = Integer.parseInt(args[0]); 
&gt;            int removalsSize = Integer.parseInt(args[1]); 
&gt;             
&gt;            Set&lt;Integer&gt; source = new HashSet&lt;Integer&gt;(); 
&gt;            Collection&lt;Integer&gt; removals = new ArrayList&lt;Integer&gt;(); 
&gt;             
&gt;            for (int i = 0; i &lt; sourceSize; i++) 
&gt;            { 
&gt;                source.add(i); 
&gt;            } 
&gt;            for (int i = 1; i &lt;= removalsSize; i++) 
&gt;            { 
&gt;                removals.add(-i); 
&gt;            } 
&gt;             
&gt;            long start = System.currentTimeMillis(); 
&gt;            source.removeAll(removals); 
&gt;            long end = System.currentTimeMillis(); 
&gt;            System.out.println(&quot;Time taken: &quot; + (end - start) + &quot;ms&quot;); 
&gt;         }
&gt;     }
&gt;
&gt; Let’s start off by giving it an easy job: **a source set of 100 items, and 100 to remove:**
&gt;
&gt; &lt;!-- language: lang-none --&gt;
&gt;
&gt;     c:UsersJonTest&gt;java Test 100 100
&gt;     Time taken: 1ms
&gt;
&gt; Okay, so we hadn’t expected it to be slow… clearly we can ramp things up a bit. How about a source of one million items and 300,000 items to remove?
&gt;
&gt; &lt;!-- language: lang-none --&gt;
&gt;
&gt;     c:UsersJonTest&gt;java Test 1000000 300000
&gt;     Time taken: 38ms
&gt;
&gt; Hmm. That still seems pretty speedy. Now I feel I’ve been a little bit cruel, asking it to do all that removing. Let’s make it a bit easier – 300,000 source items and 300,000 removals:
&gt;
&gt; &lt;!-- language: lang-none --&gt;
&gt;
&gt;     c:UsersJonTest&gt;java Test 300000 300000
&gt;     Time taken: 178131ms
&gt;
&gt; Excuse me? Nearly three *minutes*? Yikes! Surely it ought to be easier to remove items from a *smaller* collection than the one we managed in 38ms?

Can someone explain why this is happening? Why is the `HashSet&lt;T&gt;.removeAll` method so slow?



The HashSet&lt;T&gt;.removeAll method is surprisingly slow



Recently began branching out from my safe place (R) into Python and and am a bit confused by the cell localization/selection in `Pandas`. I&#39;ve read the documentation but I&#39;m struggling to understand the practical implications of the various localization/selection options. 

 Is there a reason why I should ever use `.loc` or `.iloc` over `at`, and `iat` or vice versa?  **In what situations should I use which method?**


-----

&gt; &lt;sub&gt;Note: future readers be aware that this question is old and was written before pandas v0.20 when there used to exist a function called `.ix`. This method was later split into two - `loc` and `iloc` - to make the explicit distinction between positional and label based indexing. Please beware that `ix` was discontinued due to inconsistent behavior and being hard to grok, and no longer exists in current versions of pandas (&gt;= 1.0).&lt;/sub&gt;

pandas loc vs. iloc vs. at vs. iat?

    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; in (&#39;x&#39;,)&quot;)
    0.04869917374131205
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; == &#39;x&#39;&quot;)
    0.06144205736110564

Also works for tuples with multiple elements, both versions seem to grow linearly:

    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; in (&#39;x&#39;, &#39;y&#39;)&quot;)
    0.04866674801541748
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; == &#39;x&#39; or &#39;x&#39; == &#39;y&#39;&quot;)
    0.06565782838087131
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; in (&#39;y&#39;, &#39;x&#39;)&quot;)
    0.08975995576448526
    &gt;&gt;&gt; timeit.timeit(&quot;&#39;x&#39; == &#39;y&#39; or &#39;x&#39; == &#39;y&#39;&quot;)
    0.12992391047427532

Based on this, I think I should *totally* start using `in` everywhere instead of `==`!

Why is &#39;x&#39; in (&#39;x&#39;,) faster than &#39;x&#39; == &#39;x&#39;?

What is the meaning of 

    {...this.props}

I am trying to use it like that

     &lt;div {...this.props}&gt; Content Here &lt;/div&gt;

What is the meaning of {...this.props} in Reactjs

On submission of a form, I&#39;m trying to `doSomething()` instead of the default post behaviour. 

Apparently in React, [onSubmit is a supported event for forms.][1] However, when I try the following code:

    var OnSubmitTest = React.createClass({
        render: function() {
            doSomething = function(){
               alert(&#39;it works!&#39;);
            }
        
            return &lt;form onSubmit={doSomething}&gt;
            &lt;button&gt;Click me&lt;/button&gt;
            &lt;/form&gt;;
        }
    });

The method `doSomething()` is run, but thereafter, the default post behaviour is still carried out. 

You can test this in my [jsfiddle][2].

My question: How do I prevent the default post behaviour?


  [1]: http://facebook.github.io/react/docs/events.html#form-events
  [2]: https://jsfiddle.net/ayda5w9m/

Setting onSubmit in React.js

I have 

    var TestApp = React.createClass({
          getComponent: function(){
              console.log(this.props);
          },
          render: function(){
            return(
                 &lt;div&gt;
                 &lt;ul&gt;
                    &lt;li onClick={this.getComponent}&gt;Component 1&lt;/li&gt;
                 &lt;/ul&gt;
                 &lt;/div&gt;
            );
          }
    });
    React.renderComponent(&lt;TestApp /&gt;, document.body);

I want to color the background of the clicked list element. How can I do this in React ?

Something like 

    $(&#39;li&#39;).on(&#39;click&#39;, function(){
        $(this).css({&#39;background-color&#39;: &#39;#ccc&#39;});
    });



React JS onClick event handler

&lt;!-- language-all: lang-js --&gt;

I have a simple `react` component with a form in it:

    var AddAppts = React.createClass({
    	handleClick: function() {
    		var title = this.refs.title.getDOMNode().value;
    		....
    
    		var appt = {
    			heading: title
    			...
    		}
    
    		CalendarActions.addAppointment(appt);
    	},
    	
    	render: function() {
    		return (
    			&lt;div&gt;
    				&lt;label&gt;Description&lt;/label&gt;
    				&lt;input ref=&quot;title&quot;&gt;&lt;/input&gt;
    				...
    			&lt;/div&gt;
    		);
    	}
    });
    module.exports = AddAppts;

I am trying to `render` this component in another `react` component:

      var AddAppt = require(&#39;./AddAppts&#39;);

      render: function() {
        return (
          &lt;div&gt;
            &lt;AddAppt /&gt;
          &lt;/div&gt;
        );
      }

but I get this error: 

     Uncaught Error: Invariant Violation: addComponentAsRefTo(...): Only a ReactOwner can have refs. This usually means that you&#39;re trying to add a ref to a component that doesn&#39;t have an owner (that is, was not created inside of another component&#39;s `render` method). Try rendering this component inside of a new top-level component which will hold the ref.

I have googled it, but cannot figure out what I need to do to fix this issue. 

What does &#39;Only a ReactOwner can have refs.&#39; mean?

I have been thinking and I am confused with the routing between Client and Server. Suppose I use ReactJS for server-side rendering before sending the request back to web browser, and use react-router as a client-side routing to switch between pages without refreshing as SPA.

What comes to mind is:

- How are the routes interpreted? For example, a request from Home page (`/home`) to Posts page (`/posts`)
- Where does the routing go, on server-side or client?
- How does it know how it is processed?



Client Routing (using react-router) and Server-Side Routing

I&#39;m making a Javascript class and I&#39;d like to have a public static field like in Java. This is the relevant code:

    export default class Agent {
        CIRCLE: 1,
        SQUARE: 2,
        ...

This is the error I get:

    line 2, col 11, Class properties must be methods. Expected &#39;(&#39; but instead saw &#39;:&#39;.

It looks like ES6 modules don&#39;t allow this. Is there a way to get the desired behavior or do I have to write a getter?

How do I make a &quot;public static field&quot; in an ES6 class?

I created this fiddle to and it works well as per my requirements: [Fiddle][1]

  [1]: https://jsfiddle.net/swateekj/ekm342n5/1/

However, when I use the same in my application I get an error in the browser console saying **Cannot read property &#39;aDataSort&#39; of undefined**

In my application, the javascript reads something like as below: I have checked the controller output...it works well and is printed on the console too.

    $(document).ready(function() {
    	
    	$.getJSON(&quot;three.htm&quot;, function(data) {
            	 // console.log(&quot;loadDataTable &gt;&gt;  &quot;+JSON.stringify(data));
                 })
                 .fail(function( jqxhr, textStatus, error ) {
                 var err = textStatus + &#39;, &#39; + error;
                 alert(err);
                 console.log( &quot;Request Failed: &quot; + err);
                 })
                 .success(function(data){
                	 loadDataTable(data);
                 });
    	
    	function loadDataTable(data){
    		 $(&quot;#recentSubscribers&quot;).dataTable().fnDestroy();	 
    		 var oTable = $(&#39;#recentSubscribers&#39;).dataTable({
    		     &quot;aaData&quot; : JSON.parse(data.subscribers),
    			 &quot;processing&quot;: true,
    			&quot;bPaginate&quot;: false,
    			&quot;bFilter&quot;: false,
    			&quot;bSort&quot;: false,
    			&quot;bInfo&quot;: false,
    			&quot;aoColumnDefs&quot;: [{
    			&quot;sTitle&quot;: &quot;Subscriber ID&quot;,
    			&quot;aTargets&quot;: [0]
    		}, {
    			&quot;sTitle&quot;: &quot;Install Location&quot;,
    			&quot;aTargets&quot;: [1]
    		}, {
    			&quot;sTitle&quot;: &quot;Subscriber Name&quot;,
    			&quot;aTargets&quot;: [2]
    		}, {
    			&quot;aTargets&quot;: [0], 
    			&quot;mRender&quot;: function (data, type, full) {
    				return &#39;&lt;a style=&quot;text-decoration:none;&quot; href=&quot;#&quot; class=&quot;abc&quot;&gt;&#39; + data + &#39;&lt;/a&gt;&#39;;
    			}
    		}],
    			&quot;aoColumns&quot;: [{
    			&quot;mData&quot;: &quot;code&quot;
    		}, {
    			&quot;mData&quot;: &quot;acctNum&quot;
    		}, {
    			&quot;mData&quot;: &quot;name&quot;
    		}]
    		    });
    		
    	}		
    			
    })

JQuery Datatables : Cannot read property &#39;aDataSort&#39; of undefined

In C#, we have [`Enumerable.First(predicate)`](https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.first). Given this JavaScript code:

    function process() {
      var firstMatch = [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;].filter(function(e) {
        return applyConditions(e);
      }).shift();

      if(!firstMatch) {
        return;
      }

      // do something else
    }

    function applyConditions(element) {
      var min = 97;
      var max = 122;

      var random = Math.floor(Math.random() * (max - min + 1) + min);

      return element === String.fromCharCode(random);
    }

other than `forEach`, using loop, using multiple or operators or implicitly calling `some(predicate)`, is there a smarter way of finding the `firstMatch`? Preferably a JavaScript function (something like `filterFirst(pedicate)`) which short-circuits on first match resembling C#&#39;s `Enumerable.First()` implementation? 

FWIW, I am targeting node.js / io.js runtimes.

Equivalent to LINQ&#39;s Enumerable.First(predicate)

I try to use node-vlc with nw.js (v0.12.0-alpha2). When i launch my app without nw.js it works, but when i launch it with nw.js i got an error:

&gt; Uncaught Error: Module did not self-register.&quot;, source: /home/alexis/Bureau/dev/jukebox/node_modules/vlc/node_modules/ffi/node_modules/bindings/bindings.js (84)

I tried some commands with nw-gyp but it couldn&#39;t help me.
I am on Ubuntu 14, 64-bit.

Content Type	Original Author	Original Content on Stackoverflow
Question	XpertSiji	View Question on Stackoverflow
Solution 1 - Performance	Jeremy D	View Answer on Stackoverflow

Advantages and Disadvantages of using ReactJS

Performance Problem Overview

Performance Solutions

Solution 1 - Performance

Download vagrant box file locally from atlas and configuring it

Checking if a double value is an integer - Swift

Attributions