`end` and `finish` are the same event BUT on different types of Streams.

 - `stream.Readable` fires ONLY `end` and NEVER `finish`
 - `stream.Writable` fires ONLY `finish` and NEVER `end`

Source: https://nodejs.org/dist/latest-v5.x/docs/api/stream.html

**Why the different naming of the same event?**

The only reason I could think of is because of duplex streams (`stream.Duplex`), which implement both `stream.Readable` and `stream.Writable` interfaces (https://nodejs.org/dist/latest-v5.x/docs/api/stream.html#stream_class_stream_duplex) are readable and writable stream at the same time. To differentiate between end of reading and end of writing on the stream you must have a different event fired. SO, for Duplex streams `end` is end of reading and `finish` is end of writing.

In most cases, having a parent tag isn&#39;t an issue. 

    React.createClass({
        render: function() {
            return (
                &lt;tbody&gt;
                    &lt;tr&gt;&lt;td&gt;Item 1&lt;/td&gt;&lt;/tr&gt;
                    &lt;tr&gt;&lt;td&gt;Item 2&lt;/td&gt;&lt;/tr&gt;
                &lt;/tbody&gt;
            );
        }
    });

But there are some cases where it makes sense to have sibling elements in one render function without a parent, and especially in the case of a table, you don&#39;t want to wrap a table row in a `div`.

    React.createClass({
        render: function() {
            return (
                &lt;tr&gt;&lt;td&gt;Item 1&lt;/td&gt;&lt;/tr&gt;
                &lt;tr&gt;&lt;td&gt;Item 2&lt;/td&gt;&lt;/tr&gt;
            );
        }
    });

The second example gives the following error: `Adjacent XJS elements must be wrapped in an enclosing tag while parsing file`.

How can I render two sibling elements without wrapping them in a `&lt;div&gt;` or something similar? 

How do I render sibling elements without wrapping them in a parent tag?

From an architecture perspective I&#39;m trying to get a better understand of how and where files deployed to eb (t2) server are stored.

I see some .zip files in s3 that show when I upload something via the eb interface, though how/where exactly does this get end up on my ec2(t2) server?




Where does elastic beanstalk t2 server store my node.js app files?

Node.js streams triggers both `end` and `finish` events. What&#39;s the difference between both?

What&#39;s the difference between end and finish events in Node streams

<p>Node.js streams triggers both <code>end</code> and <code>finish</code> events. What's the difference between both?</p>


What does the `i` command do in the npm CLI?

I saw it used like this:

```bash
npm i package
```

What does the `npm i` command do?

I have a payment system using node.js and braintree, when the payment is successful I want to send the user to the back end. My back end is setup elsewhere. 

I have tried 

    res.writeHead(301,
      {Location: &#39;http://app.example.io&#39;}
    );
    res.end();

So window.location is obviously not available. I cant think of any ways to redirect a user?

In express how do I redirect a user to an external url?

A new stable release of Node.js (0.12) has landed recently with an upgraded Google&#39;s v8 JavaScript engine, *v3.28.73*.

## What ECMAScript 6 features are currently present in Node.js, without using the `--harmony` flag?

I have checked several sites claiming to list the ES 6 features but all of them seem out of date - most prominently, [this table](http://kangax.github.io/compat-table/es6/#node) (**Update:** *now updated with current Node.js status as of 0.12*), because several of the features are listed as requiring the `--harmony` flag while I found some of them being enabled by default (Maps, Sets, Symbols, to name a few). **Update**: [Node specific tables][1] have since been made available

Also, trying to google this information purely for the v8 engine gives too up-to-date information - current v8 release is *4.2.\**, which is quite ahead of what Node.js uses.

My hopes are that this question (and its answers) will become a comprehensive summary on what ES 6 features are now available to Node.js developers.

## ES 6 features enabled in Node.js 0.12 I currently know of:

- Maps, Sets / WeakMaps, WeakSets
- Symbols
- Object.observe
- Promises
- Number
  - .isInteger
  - .isSafeInteger
  - .isNaN
  - .EPSILON
  - .MIN_SAFE_INTEGER
  - .MAX_SAFE_INTEGER
- Math
  - .clz32
  - .imul
  - .sign
  - .log10
  - .log2
  - .log1p
  - .expm1
  - .cosh
  - .sinh
  - .tanh
  - .acosh
  - .asinh
  - .atanh
  - .trunc
  - .fround
  - .cbrt
  - .hypot


  [1]: http://node.green/

ECMAScript 6 features available in Node.js 0.12

I am trying to define some endpoints and do a test using `nodejs`. In `server.js` I have:

    var express = require(&#39;express&#39;);
    var func1 = require(&#39;./func1.js&#39;);
    var port = 8080;
    var server = express();
    
    server.configure(function(){
      server.use(express.bodyParser());
    });

    server.post(&#39;/testend/&#39;, func1.testend);

and in `func1.js`:

        var testend = function(req, res) {
               serialPort.write(&quot;1&quot;, function(err, results) {
               serialPort.write(&quot;2&quot; + &quot;\n&quot;, function(err, results) {
               });
          });
       });
        exports.testend = testend;

Now in `test.js` I am trying to use this endpoint:

    var should = require(&#39;should&#39;);
    var assert = require(&#39;assert&#39;);
    var request = require(&#39;supertest&#39;);
    var http = require(&#39;http&#39;);
    var app = require(&#39;./../server.js&#39;);
    var port = 8080;

    describe(&#39;Account&#39;, function() {
            var url = &quot;http://localhost:&quot; + port.toString();
            it(&#39;test starts&#39;, function(done) {
                    request(url).post(&#39;/testend/&#39;)
                    // end handles the response
                    .end(function(err, res) {
                            if (err) {
                                    throw err;
                            }
                            res.body.error.should.type(&#39;string&#39;);
                            done();
                    });
            });
    });

But when I run `node test.js` I am getting this error:

&lt;pre&gt;
describe(&#39;Account&#39;, function() {
^

ReferenceError: describe is not defined
    at Object.&lt;anonymous&gt; (/test/test.js:9:1)
    at Module._compile (module.js:456:26)
    at Object.Module._extensions..js (module.js:474:10)
    at Module.load (module.js:356:32)
    at Function.Module._load (module.js:312:12)
    at Function.Module.runMain (module.js:497:10)
    at startup (node.js:119:16)
    at node.js:906:3
&lt;/pre&gt;

How can I fix the issue?


ReferenceError: describe is not defined NodeJs

I would like to use google web starter kit. I installed node.js v0.12.0, `node-sass` &amp; `gulp`.

And then ran:

    $ sudo npm install

When I typed `gulp serve` then got this error:

    Using gulpfile ~/web-starter-kit/gulpfile.js Starting &#39;styles&#39;... &#39;styles&#39; errored after 93 ms 
    Error: `libsass` bindings not found. Try reinstalling `node-sass`? at getBinding

I reinstalled node and gulp but this doesn&#39;t help.

What should I do next?

Try reinstalling `node-sass` on node 0.12?

The javadoc for Stream states:

&gt; Streams have a BaseStream.close() method and implement AutoCloseable, but nearly all stream instances do not actually need to be closed after use. Generally, only streams whose source is an IO channel (such as those returned by Files.lines(Path, Charset)) will require closing. Most streams are backed by collections, arrays, or generating functions, which require no special resource management. (If a stream does require closing, it can be declared as a resource in a try-with-resources statement.) 

Therefore, the vast majority of the time one can use Streams in a one-liner, like `collection.stream().forEach(System.out::println);` but for `Files.lines` and other resource-backed streams, one must use a try-with-resources statement or else leak resources.

This strikes me as error-prone and unnecessary. As Streams can only be iterated once, it seems to me that there is no a situation where the output of `Files.lines` should not be closed as soon as it has been iterated, and therefore the implementation should simply call close implicitly at the end of any terminal operation. Am I mistaken?

Why is Files.lines (and similar Streams) not automatically closed?

Currently, the only stable way to process a series of async results in JavaScript is using the event system. However, three alternatives are being developed:

Streams: https://streams.spec.whatwg.org
&lt;br&gt;
Observables: https://tc39.github.io/proposal-observable
&lt;br&gt;
Async Iterators: https://tc39.github.io/proposal-async-iteration

What are the differences and benefits of each over events and the others?

Do any of these intend to replace events?

Events vs Streams vs Observables vs Async Iterators

What are the options to read/write files in .Net Core?

I am working on my first .Net Core app and looking for 
`File.Read*`/`File.Write*` functions (`System.IO` from `.Net`) alternatives.



How to read/write files in .Net Core?

What is the basic difference between stream processing and traditional message processing? As people say that kafka is good choice for stream processing but essentially kafka is a messaging framework similar to ActivMQ, RabbitMQ etc.

Why do we generally not say that ActiveMQ is good for stream processing as well.

Is it the speed at which messages are consumed by the consumer determines if it is a stream?

Difference between stream processing and message processing

I&#39;m learning about working with streams in Python and I noticed that the [IO docs][1] say the following:

&gt;The easiest way to create a binary stream is with open() with &#39;b&#39; in the mode string:
&gt;
&gt;`f = open(&quot;myfile.jpg&quot;, &quot;rb&quot;)`
&gt;
&gt;In-memory binary streams are also available as BytesIO objects:
&gt;
&gt;`f = io.BytesIO(b&quot;some initial binary data: \x00\x01&quot;)`

What is the difference between `f` as defined by `open` and `f` as defined by `BytesIO`. In other words, what makes a &quot;In-memory binary stream&quot; and how is that different from what `open` does?


  [1]: https://docs.python.org/3/library/io.html

Content Type	Original Author	Original Content on Stackoverflow
Question	Simon Boudrias	View Question on Stackoverflow
Solution 1 - node.js	tiblu	View Answer on Stackoverflow

What's the difference between end and finish events in Node streams

node.js Problem Overview

node.js Solutions

Solution 1 - node.js

Where does elastic beanstalk t2 server store my node.js app files?

How do I render sibling elements without wrapping them in a parent tag?

Attributions