SurviveJS

If you like a discrete control flow, then Polymer is a valid approach. TBH, if your application isn't beyond moderately complex, it doesn't matter too much which framework you choose as long as you have relatively clean separation of logic and control flows. React (with a flux-like control flow library, such as Redux) has a higher cognitive load to start. Where it shines is as additional features are added, there is very little additional complexity. Where with Polymer (or Angular) your application as will see a curve of additional complexity as features are added. I started a pretty basic setup for React + Webpack with hot reloading[1]. I'm going to add in Redux next, then Router... At which point I'm planning on adding in material-ui[2]. From there, I'll try to keep it updated or forked to use as a base application. I started it off by following te SurviveJS book[3], but my direction is a bit different. I'd also recommend reading the full stack redux tutorial[4]. [1] https://github.com/tracker1/r3k-example [2] http://material-ui.com/#/ [3] http://survivejs.com/ [4] http://survivejs.com/

I used the older React+Webpack version of https://survivejs.com/ to learn React recently. You build a small Kanban/Trello webapp.

This is the best resource I've found so far: http://survivejs.com/webpack/introduction/

How to learn? Take a look at http://survivejs.com/ and then http://teropa.info/blog/2015/09/10/full-stack-redux-tutorial.html

These resources have been very helpful to me: http://survivejs.com https://github.com/markerikson/react-redux-links https://github.com/HenrikJoreteg/hjs-webpack

SurviveJS book, you can read it online for free: http://survivejs.com/webpack_react/introduction/ http://survivejs.com/ Full-Stack Redux Tutorial: http://teropa.info/blog/2015/09/10/full-stack-redux-tutorial.html

I strongly agree. I had to set up a React application not so long ago and the Webpack docs were completely useless. I ended up following a step by step guide made by someone else, which was really easy to follow and reason about: http://survivejs.com/webpack_react/developing_with_webpack/

Seems like http://survivejs.com/ might be along those lines. You might also want to check out some of the various boilerplates people have posted on Github. Searching for some combination of your preferred stack tools + "boilerplate" should turn up a number of results.

I just started on http://survivejs.com/ which does that. Have yet to make a comparison with React for Beginners though.

If you want to get started with this stuff but you're feeling lost or overwhelmed then the free SurviveJS - Webpack and React book is a nice place to start! It covers many of these tools. http://survivejs.com

I just self-published my first book (http://survivejs.com/). Writing books is way harder than people think. Writing isn't enough as you need to tackle other aspects, such as marketing and sales, as well. If you are not native, you have the extra challenge of learning to write. In short, it's definitely possible to earn a living out of technical writing. Getting started is the hardest part. If you don't have a reputation, you will need to build one. Growing audience will take time, but it will pay dividends. To keep this comment short, I'll just link to a series of articles (and presentation slides) I've written about my experiences. Hopefully these help! Here we go: * http://agile.fi/survivejs-writing-a-book-in-a-lean-way/ * http://survivejs.com/blog/succeed-at-technical-books/ * http://survivejs.com/blog/survivejs-interview/ * https://survivejs.github.io/how-to-write-a-book-and-survivejs-it/ (Chrome works the best) Best of luck!

It's really not difficult, it just looks more complicated than it is. If you want a good start, try the Webpack book by SurviveJS. You can read most of it in an hour or two and not only create a config but actually understand how webpack works: https://survivejs.com/webpack/introduction/ There are also slimmer/newer/zero config alternatives like: https://poi.js.org/ https://neutrino.js.org/ https://parceljs.org

Q: Should one get familiar/experienced with React[0][1] first before jumping into React Native dev? Or is this tutorial sufficiently stand-alone without React (web) experience? [0] http://survivejs.com/react/introduction/ [1] https://online.reacttraining.com/p/reactjsfundamentals

I tried survivejs but whole complexity and explanations started falling apart when flux and whole concept of provider was introduced. [1] http://survivejs.com/react/implementing-kanban/react-and-flux/

Can you please add some documentation for sourcemap and debugging to the doc? WP 1's sourcemap doc is confusing as hell and WP 2's doc just copied that over. I imagine debugging un-transpiled code with sourcemap is one of the most common use-cases. And I'm not alone if you look at the disqus of WP's doc[0] and a blog by @bebraw[1], one of the guys running webpack.js.org. I even opened an issue[2], I hope it can make into your MVP. [0]: http://survivejs.com/webpack/developing-with-webpack/enabling-sourcema… [1]: https://webpack.github.io/docs/configuration.html [2]: https://github.com/webpack/webpack.js.org/issues/273

I just finished going through this http://survivejs.com/webpack_react/introduction/ whole thing building a kanban board using react and altjs. It was really interesting, though a much simpler version of what was posted in the OP I learned a lot about webpack and react, and got to try a different flavor of flux I hadn't experimented with before (alt.js). I'm excited to dive into the OPs tutorial however. It looks really interesting.

This is really awesome. Thanks very much. I managed to find this today http://survivejs.com/webpack_react/introduction/

http://survivejs.com/webpack_react/webpack_compared/ https://medium.com/@housecor/browserify-vs-webpack-b3d7ca08a0a9

The SurviveJS book is a good reference for this: http://survivejs.com/webpack_react/

Partial paste from https://survivejs.com/blog/rambda-interview/#how-does-rambda-differ-fr… --- The main reason for the better performance is that Rambda methods only need to take care for currying and execution, while Ramda methods cover more use cases. Therefore Ramda have more elaborate boilerplate around the actual execution, which results in slower performance. We can see an illustration of that in the code of `find` method of Ramda and Rambda. Ramda: var _curry2 = require('./internal/_curry2'); var _dispatchable = require('./internal/_dispatchable'); var _xfind = require('./internal/_xfind'); module.exports = _curry2(_dispatchable(['find'], _xfind, function find(fn, list) { var idx = 0; var len = list.length; while (idx < len) { if (fn(list[idx])) { return list[idx]; } idx += 1; } })); Rambda: function find(fn, arr){ if (arr === undefined) { return holder => find(fn, holder) } return arr.find(fn) }

I took a look. This seems intriguing because it doesn't bring the whole RxJS with it to make observables work. Though I'm a bit baffled by the developer's statements about immutability of values in his SurviveJS interview [1]: "With mutable data structures, it is trivial to guarantee that there is only one version of a certain domain object in memory." I'd like to know how this mutable values can be tracked while immutable values can just equality check. I'm currently learning ClojureScript with few simple projects, and its immutability both pleases me and drives me crazy. Though I can agree on his point that Flux (and Redux) do take over your application. I'd definitely like to use something else with my next React project if possible, and Mobx looks it could fit the bill. Also, SurviveJS is a good React and Webpack book that's continuously expanded and adapted to use different libraries (like for Redux and Mobx). You should buy it! [1] http://survivejs.com/blog/mobservable-interview/