Whether it's the increasingly challenging workload or you simply want to enhance your Node.js app's tolerance to failure and availability, there comes a time when you just need to scale it up, right? To “squeeze” the best performance out of your entire infrastructure of... nodes. Well then, here's how to scale your Node.js app:
And scaling up your web back-end app at different levels — overall improving its throughout — sure isn't an afterthought with Node.js:
Scalability is built in the very core of the runtime.
And the infrastructure of nodes, strategically distributed, communicating with each other, is what makes this framework particularly scalable.
So, what is the best way to scale up your Node.js app?
Which are the most powerful built-in tools for scalability to explore and to “exploit”? And what are the best strategies to go for depending on your specific scenario and scalable architecture needs?
Horizontally Scaling Your Node.js App
Horizontal scaling comes down to... duplicating:
Basically, you duplicate your application instance, enabling it to “cope with” a larger number of incoming connections.
Note: you can horizontally scale your Node.js app either across different machines or on a single multi-core machine.
A word of caution: do keep in mind, though, that this scaling solution might add up unnecessary complexity to your app's infrastructure; it might entail the need to provision and to maintain a load balancer, might make troubleshooting more challenging, and even change the way you deploy your app.
That being said: make sure that it's specifically this Node.js scaling solution that your project needs before you go ahead and implement it!
Vertical Scaling
If your scalability architecture needs involve nothing more than:
injecting more power
adding more memory
… with no particular “tweaking” applied to the code, then vertical scaling might just be the right answer to the “how to scale your Node.js app” dilemma.
Here's why:
by default, Node won't use more than 1.76GB of 64-bit machines' memory
in case of a 32GB of RAM machine, for instance, the Node process will limit itself to only a fraction of its memory
Have Multiple Processes Running on The Same Machine
Here's another possible answer to your “How to Scale your Node.js app” question:
Have multiple processes running on the same port.
It goes without saying that this scaling solution calls for some kind of internal load balancing that would distribute the incoming connections across the entire ecosystem of cores/processes.
Word of caution!
Not sure whether there's any need to add this: keep the number of running processes lower than that of the cores!
Hereinafter, let's focus on 2 Node.js built-in tools for scalability that you might want to tap into:
The Cluster Module
Node's cluster module makes a great starter for scaling up your application on a single machine.
How does it work precisely?
It makes setting up child processes sharing server ports conveniently easy.
Practically, one “master” process will be in charge with spawning all the child processes (and there's one “worker” for each core), those that actually run your Node.js app.
Feel free to dig here into more details on the whole process.
Yet, there are certain limitations to this basic scaling solution:
in case one of your child processes “dies”, it doesn't... regenerate itself
you'll need to handle the master-worker processes difference... the “old school way”, using an “if-else” block
there's no way of modifying multiple processes, at once, on-the-fly!
Note: yet, when it comes to the “dead child processes” drawback, there's... hope. For instance, use this piece of code that would enable the master process to... respawn the “worker”:
cluster.on('exit', (worker, code, signal) => {
cluster.fork();
});
And voila! This drawback has been taken off your list!
The PM2 Cluster Module
Using the PM2 cluster module, “how to scale your Node.js app” dilemma turns into:
“Lay back and let the PM2... clusterfy your server for you!”
All you need to do is “trigger” this command's superpower:
pm2 start app.js -i 4 –name="api"
It will instantly create a 4-node cluster for you!
Now, here are some more details about what's going on “under the hood” during this process:
the PM2 daemon will take over the ex “master process'” role and spawn N processes (the former “worker processes”) while relying on round-robin balancing
moreover, if it's PM2 process manager that you're using, your process gets automatically scaled across all the existing cores (no need to trigger the cluster module for that anymore)
also, the same PM2 process manager will ensure that processes restart, instantly, if they happen to crash
You'll just need to write your Node.js app as if it were for single-core usage and the PM2 module will make sure that it gets scaled for multi-core.
Note: now if you want to scale your Node.js application further, you might want to consider deploying more machines...
Scaling Across Multiple Machines with Network Load Balancing
The underlying process is more than similar to the “multiple core scaling” one, if you come to think of it:
Instead of several cores, you'll have several machines; each one will be running one or more processes and will get “backed up” by a load balancer redirecting traffic to each machine in this infrastructure.
“And how does a network balancer work, more precisely?” you might ask yourself:
Once a request is sent to a node, the balancer sends the traffic to a specific process.
And there are 2 ways of deploying your internal balancer:
deploy a machine and set up a network balancer yourself, using NGINX
use a managed load balancer (like Elastic Load Balancer); setting it up is conveniently easy and it “spoils” you with all kinds of built-in features, such as auto-scaling
Now if your “How to scale your Node.js app” question turns into a “Isn't it risky to have just one point of failure for my infrastructure?":
Just deploy multiple load balancers instead of relying on a single balancer.
They would be all pointing to the same servers, needless to add.
Note: for distributing traffic across your “ecosystem” of internal balancers, you could just add several DNS “A” records to your main domain.
How to Scale Your Node.js App: 3 Scaling Strategies to Consider
1. Decomposing
“Microservice” is another word for this scaling strategy. For practically you'll be “juggling” with multiple microservices (although their size is of no significant importance, actually).
Or multiple applications, with different codebases (and in many cases, each one of them has its own UI and dedicated database).
And it's by services and functionalities that you'll be decomposing/scaling your Node.js app. A strategy that can lead to unexpected issues in the long run, but which, if implemented correctly, translates into clear gains for your apps' performance.
2. Splitting
Or “horizontal partitioning” or “sharding”, if you prefer. This strategy involves splitting your app into multiple instances, each one responsible for a single, specific part of your app's data!
Word of caution: data partitioning calls for a lookup before you carry out each operation; this way you'll identify the right instance of the application to be used.
Take this example here:
You might want to partition your Node.js app's users by language or area of interest. In this case, a lookup step is a must; you'll need to check that information, first things first.
3. Cloning
And this is the easiest strategy at hand for solving your “How to scale your Node.js app” dilemma!
Just clone your Node.js back-end application, multiple times, and assign a specific part of the workload to each cloned instance!
It's both effective and cost-effective!
Moreover, Node's cluster module makes cloning on a single server ideally easy to implement!
And this is “How to scale your Node.js app”! See? You have not just one, but several Node.js built-in tools at hand and various strategies to choose from, depending on your scaling needs.
Which scaling solution suits you/your app project best?
RADU SIMILEANU / May 03'2018
Have no fear... Node.js 10 is here (since April 24, actually)! And, as expected, this version is planned to grow into the platform's official Long Term Support version (in October 2018); to be supported for 3 years after that date.
So? What's in it for you, the back-end web developer?
Are there any new features and improvements worth getting really excited about? Which are they and how precisely will they improve the overall developer experience.
Now before we take a deep dive into the “steamy fresh load” of new features, I feel like pointing out that:
it's mostly incremental improvements, applied throughout the entire codebase of the platform, that Node.js 10 ships with
… performance, reliability and stability-centered improvements, bubbling up to the back-end developer's experience
But let's name these improvements that ship with the new version of Node.js. Let's talk specific incremental changes, shall we?
10 of the “really worth getting excited about” ones:
1. Error-Handling Improvements
And error messages/error-handling improvements do make the majority of semver-major commits (approx. 300) that Node.js ships with.
It's a “pledge” made since Node.js 8.0.0 to assign static error codes to all Error objects:
“Error messages should be useful, more consistent and predictable”, this has been the “pledge” driving all the sustained efforts geared at improving error-handling.
Note: error codes have been included in Node.js 10, making constant error-checking conveniently easier!
2. Enhanced JavaScript Language Capabilities
There's an entire list of Node.js 10 language improvements (you can find them all here) worth exploring and... exploiting, I'll outline the highlights only:
you now get to use line and paragraph separator symbols (U+2028 and U+2029) in string literals, that match JSON
V8 “introduces”: String.prototype.trimEnd(), String.prototype.trim(), String.prototype.trimStart()
prototype.toString() returns the exact “pieces” of the source code text (comments and whitespace here included!)
the catch clause of the try statements no longer calls for a parameter
3. The Node.js fs (file system) Has Been Significantly Overhauled
And here are the most “dramatic” improvements made during this overhaul:
the type checking and error handling have been improved
the code got restructured, for easier maintainability
a new experimental fs/promises API got implemented, featuring first-class Promise-based API
Speaking of this new API, its “role” is that of generating a warning at runtime, the very first time that it gets used. Hopefully, things will turn out “bugs-free” so that it can grow from experimental to stable.
4. Node.js 10 Ships with Full Support for N-API
N-API — the ABI stable (Node.js) API for native modules — has leveled up to a stable version in Node.js 10.
What does this mean?
it provides a stable module API, one that is not influenced by the changes in Node.js's V8 JavaScript engine
the API layer makes upgrading a whole lot easier, streamlining production deployments and... easing module maintainers' lives
… and it goes without saying that this bubbles up to native modules' maintenance costs, as well
In short: say goodbye to module breakage!
5. The Assert Module: Explore Some Crucial Improvements
All efforts targetting the assert module have been aimed at easing the internal implementation and improving the developer experience.
But let me point out some of these improvements that eventually fleshed out and landed in Node.js 10:
a new “diff” view got implemented, for whenever assertion errors get generated
overall the output becomes more descriptive, more... “verbose” (and implicitly more useful)
better object comparisons
promises support
detailed error messages
6. Node.js 10 Ships With V8 6.6: Expect a Major Performance Boost
Get ready to “exploit” V8 6.6's range of performance improvements to their full potential! Along with its new set of JavaScript language features!
From them all, I can't but mention:
the async functions
the async generators
the promise execution
7. Cryptographic Support
Node.js 10 is the first version of the platform to include OpenSSL 1.x! And this can only translate into:
Enhanced protection for your priceless data!
Now, if I am to outline just 2 of the OpenSSL features to look forward tapping into, I should definitely mention:
the Polu1305 authenticator
the ChaCha 20 cipher
8. The Trace Events Mechanism: Monitoring Your Code's Performance Just Got Easier
That's right! Keeping a close eye on how your code's performing and being able to quickly diagnose any emerging issues is easier than ever with Node.js 10!
Basically, what these trace events do is enabling that all the diagnostic information output gets collected to a file accessible to the Chrome browsers DevTools utility.
No need to use a command-line flag anymore to trigger this whole trace events mechanism underlying Node.js.
And since we're here, let me point out to you 2 trace events-related improvements worth getting (really) excited about:
the node.perf.usertiming category got added — its role is that of capturing, in the trace events timelines, all the Performance API user timer marks and measures.
the JavaScript API got implemented, as well; enabling/disabling trace events dynamically is now possible in Node.js:
const trace_events = require('trace_events')
const tracing = trace_events.createTracing({
categories: ['node.async_hooks', 'v8']
})
tracing.enable()
// do stuff
tracing.disable()
9. HTTP and HTTP/2 Improvements
Another thing to get excited about, when it comes to Node.js 10's release, is given by all the incremental improvements made to HTTP and HTTP/2.
Let me detail a bit:
when it comes to HTTP, the changes applied range from improved Streams API compatibility to stricter standards support, to improve header and error handling
now when it comes to HTTP/2, significant progress has been made for getting it the closest to “stable mode” as possible before Node.js 10 reaches its Long Terms Support cycle. And I'm talking here about improvements made to the way trailing headers requests and responses get implemented and about overall improvements of the internal implementation and the public API
10. Node.js Ships With The Experimental Node-ChakraCore
And how does this impact the developer experience? Your experience?
using the JavaScript engine to its full potential
tapping into the Time Travel debugging
… gets a whole lot easier for you. You're practically enabled to detect errors way before they even get to “infest” your code.
The END! This is how our list of 10 Node.js 10 features worth getting (really) excited about looks like! Do explore them and start your preparations for moving over to this new version of Node.js before October!
RADU SIMILEANU / May 02'2018
Here you are now: your Angular 4 front-end app ready to... wow its users! “Almost ready” actually! For it still needs styling... And what better HTML and CSS framework to go for than Bootstrap, right? But how to use Bootstrap with Angular 4 more precisely?
How do you properly integrate it into your Angular 4 CLI project?
Great news: you have not just one, but 3 options at hand for adding it!
Let me get into details:
On Using Bootstrap in Your Front-End Development Process
Is there any need to list here the reasons why it's precisely Bootstrap that you're planning to implement into your Angular CLI project? Angular 4, to be more specific.
After all, it's the most popular framework for styling websites built in HTML, CSS and modern web & mobile JavaScript frameworks (like Angular here):
It's an open source, feature-rich framework that turns front-end development into a such a “breeze”. Basically, it empowers you to build responsive layouts without the need to be a CSS “expert”.
And now, let's break down further with the step-by-step “tutorial” on how to use Bootstrap with Angular 4:
Step 1: Create a New Angular Project Using Angular CLI
The very first step to take is obviously setting up a brand new project.
Use the Angular Command Line Interface to generate it.
But first, install it to on your system:
$ npm install -g @angular/cli
It's only then, once you've installed its NPM package, that you can go ahead and... generate your new project.
For doing this, just type the following command in your CLI:
$ ng new myproject
Next, feel free to change into that specific directory and to turn on the web server:
$ cd myproject
$ ng serve
“App works!” This is the message that you should be seeing in your browser right now.
Step 2: Install Bootstrap to Your Project
Now that you've launched your new Angular project, it's time to add your Bootstrap library, as well.
And you sure aren't nickel and dimed in options. There are 4 ways to add Bootstrap to Angular 4.
Step 3: How to Use Bootstrap with Angular 4 — 3 Different Ways to Integrate It
Option 1: Install Bootstrap from CDN
And there are 2 particular files that you'll need to install from CDN into your project:
the Bootstrap CCS file
the Bootstrap JavaScript file
Note: keep in mind to add the jQuery JavaScript library file, as well!
Next, open the src/index.html file and insert the following:
the <link> element to add the Bootstrap CSS file at the end of the head section
a <script> element for adding jQuery at the bottom of the body section
a <script> element for inserting the Bootstrap JS file at the bottom of the body section
Eager to see “Bootstrap in action” in one of your project's component templates? Then give it a try:
open the src/app/app.component.html
enter the following code there:
<div class="container">
<div class="jumbotron">
<h1>Welcome</h1>
<h2>Angular & Bootstrap Demo</h2>
</div>
<div class="panel panel-primary">
<div class="panel-heading">Status</div>
<div class="panel-body">
<h3>{{title}}</h3>
</div>
</div>
</div>
And it's the following message that this HTML template code should trigger in your browser:
“app works!”
Note: go for a Bootstrap theme of your choice; once you've downloaded it (from Bootswatch.com for instance), its bootstrap.min.css file will get instantly opened up in your browser.
Just copy the file's URL and use it to replace the string assigned to the href attribute of the <link> element, in the index.html file.
And voila! It's precisely those colors, defined by your chosen theme, that get displayed in the browser now!
Option 2: Install Bootstrap using NPM
And here's another valid answer to your “How to use Bootstrap with Angular 4” dilemma!
Simply enter:
$ npm install bootstrap@3 jquery –save
It's this command that will integrate Bootstrap and jQuery into the node_modules folder of your Angular 4 project directory.
Moreover, it will include these 2 dependencies in the package.json file, as well.
Once properly installed, you can find both packages at:
node_modules/bootstrap/dist/css/bootstrap.min.css
node_modules/bootstrap/dist/js/bootstrap.min.js
node_modules/jquery/dist/jquery.min.js
Note! You have 2 options for integrating those files into your Angular 4 project:
add the file paths to the script array and to the file path of the angular-cli.json file
add the corresponding <script> and <link> elements to your index.html file
Option 3: Add NG-Bootstrap to Your Project
The great thing about this method is that you'll no longer need to add jQuery and Bootstrap dependencies. Ng-Bootstrap comes packed with a set of built-in native Angular directives which are already CSS and Bootstrap's markup-based.
Now, getting back to our initial “How to use Bootstrap with Angular 4” question, let's see how we install this NPM package.
For this, just enter the following command in your Angular 4 project directory:
npm install --save @ng-bootstrap/ng-bootstrap
Next, make sure you also install Bootstrap 4 to your project:
$ npm install bootstrap@4.0.0-alpha.6
And, the final step is to add the following files:
jquery.min.js
bootstrap.min.js
bootstrap.min.css
… to your .angular-cli.json file
Now you still need to import the Ng-Bootstrap’s core module — NgbModule — from its @ng-bootstrap/ng-bootstrap package.
To do this, just type the following import statement into app.module.ts:
import {NgbModule} from '@ng-bootstrap/ng-bootstrap';
All there's left for you to do now is to add the NgbModule to the @NgModuledecorator's imports array.
And since we're here, you'll find some more than “enlightening” info (chunks of code here included!) on the 2 different options at hand for importing the NGBModule:
either in your project's child modules
or in your the root module itself
… in this article here on Using Bootstrap with Angular.
Using The NG-Bootstrap Components: Which Are They?
With the NgbModule installed into your Angular 4 project, you're now able to use the Ng-Bootstrap components.
To leverage them in your app.component.html.
Speaking of which, here are the components at hand:
Accordion
Alert
Rating
Tabs
Carousel
Progressbar
Collapse
Datepicker
Buttons
Pagination
Typeahead
Popover
Timepicker
Dropdown
Modal
Tooltip
The END! Does this answer your “How to Use Bootstrap with Angular 4” question?
Which method of adding this front-end framework to your project is more suitable for you?
Silviu Serdaru / Apr 30'2018
What's the deal with the virtual DOM? How React virtual DOM works precisely? It's significantly faster, without question, and it brings a whole series of benefits to coding.
How come?
Which efficiency issues of the “real” DOM does it solve? And what makes the way that React.js manipulates the DOM better than the “standard” way?
Let's get you some answers:
But First: What Is the DOM Anyway?
"Document Object Model."
It's only but natural that, before we get into details on React and the Virtual DOM, we gain a deep understanding of the DOM itself.
Therefore, here's a definition that hopefully sheds enough light on this concept:
DOM is a tree-structured abstraction of (or an in-memory representation, if you prefer) a page's HTML code. One that preserves the parent/child relationships between the nodes within its tree-like structure.
Any better?
The major benefit is the API that it provides, that allows us, developers, to easily scan through the HTML elements of a page and to manipulate them as needed. For instance:
to add new nodes
to edit a given node's content
to remove specific nodes
And What Is DOM Manipulation More Precisely?
It's the very process that enables the content on any of your website's pages to be dynamically updated.
Needless to add that it's JavaScript that you would use when handling the DOM. Also, methods such as:
removeChild
getElementByID
… are included in the API that the “actual” DOM provides you with.
What Efficiency Challenges Does the "Real" DOM Face?
Now, before we go back to your initial “dilemma” (“how React Virtual DOM works”), let's see why a “virtual” DOM was even needed in the first place.
What efficiency issues of the “real” DOM does it address?
So, it's JavaScript that we use as we manipulate the DOM, right? And it used to work fantastic back in the days when static UIs would “rule” and the concept of dynamically updating nodes wasn't yet... “invented”.
Well, since then things have changed...
The DOM manipulation, once the core process of all modern interactive web pages, started to show its limitations. And that because the “real” DOM would update a “target” node along with the entire web page (with its corresponding layout and CSS).
For instance, imagine that:
You have a list of items and it's just one of those items that you need to update. Traditionally, the “real” DOM would re-render the entire list and not exclusively the items that receive updates. See?
Just think of a scenario where you have an SPA (Single Page App). One with thousands of dynamically generated nodes, that would all need to “listen to” lots of future updates and to re-render them in the UI.
It's here that things get discouragingly... slow!
The real DOM can't cope with pages carrying thousands and thousands of components to be re-rendered when updates are being passed through.
It's in this context here that the virtual DOM stepped in! And it's React that makes the most of it.
Clear enough?
How React Virtual DOM Works: Snapshots, Diffing and Reconciliation
Before we get into the “how”, let's shed some light on the “what”. What is the “virtual” DOM?
A light-weight abstraction/copy of the HTML DOM, having the same properties as the “real” one. The only difference is that it can't write to the screen like the actual DOM “can”. Also, it's local to React.
A copy of the actual DOM that you get to update “intensively” without impacting the real DOM.
Note: do keep in mind that it isn't React that introduced this concept since there are plenty of other libraries who're using it.
Snapshots, Diffing and Reconciliation
Now, let's get into details on how React virtual DOM works.
a. First of all, React takes a virtual DOM snapshot before doing any updates.
b. It will then use it (this record of the DOM state) to compare it against the updated virtual DOM, before applying any changes to the actual DOM itself.
And it's a “diffing algorithm” that supports all this comparing and enables React to identify any changes. To detect the updates that have been applied.
Also, the entire process is called “reconciliation”:
Whenever updates need to be made to the actual DOM, React updates the Virtual DOM first, and then, once it has done its compairing, it syncs the Real DOM.
In other words: before applying any of the requested updates, React makes a copy of the virtual DOM, that it will then set against the updated virtual DOM (diffing). It's during this diffing-reconciliation process that React detects the changes that have been applied and identifies the objects to be updated.
And it's precisely those objects that it will update in the actual DOM.
The huge benefits?
virtual DOM updates a whole lot faster
it updates exclusively the “target” nodes, leaving the rest ones of the page alone
Summing Up
To recap, let's try and sum up this whole “How React Virtual DOM Works” guide here to its bare essentials.
So, here's how React updates the DOM in 3 simple steps:
first, it applies the given updates to the whole Virtual DOM
then, it compares it with the snapshot of the virtual DOM that it will have taken, using an algorithm called “diffing” during this whole process of comparing and spotting any changes/contrasts
then, it's specifically (and exclusively) those changed elements that it updates in the actual DOM
The END! Have I managed to make this process any clearer for you? Can you now see what's “under the hood” of the way React updates DOM?
And the specific reasons why it's so much faster than the real DOM manipulation?
RADU SIMILEANU / Apr 26'2018
A great developer experience or a great user experience? A familiar web technology for you to code in or native-like performance for your users? And these are just some of the questions “taunting” you right now, while dealing with a PhoneGap vs React Native dilemma, right?
Each platform comes with its own “temptations” to... lure you in:
PhoneGap promises you an “easy life” as a mobile app developer, enabling you to use any JavaScript library and framework that you're comfortable working with
React Native promises you to inject native-like performance into your app and thus... to perfect the user experience
So, which one to go with?
PhoneGap: A Brief Overview
A compromise! This is, in my opinion, the perfect word/metaphor to describe PhoneGap.
A compromise in terms of user experience and performance, since it's hybrid mobile apps that you get to build using this technology:
a JS/CSS/HTML app having a browser-based UI (giving you the freedom to work in any of your preferred web technologies)
that exposes native mobile device APIs and data; accessing phone components through the API navigator
While a more “formal” definition would go something like this:
PhoneGap is a distribution of Apache Cordova — coming with a few tweaks and custom packages — that you can use for embedding websites in mobile apps via WebView.
In short: more than a website, yet not a fully native mobile app. A hybrid app compromise!
A Few Words About React Native
In a PhoneGap vs React Native debate, the latter would always have its native components rendering “trump card” up its sleeve:
For a React Native-powered app is written in JS, like a PhoneGap one, yet it doesn't just render a webview, but REAL native components instead!
And that, my friend, would also win over users: it's better user experience and zero compromises on performance that you get “rewarded” with for using React Native.
You could also take this mobile app development platform as the answer to users' becoming more and more demanding:
If hybrid, HTML 5 and/or mobile web apps used to be enough to “satisfy” their needs, while being a “blessing” for developers' budgets, as well, mobile users started to crave native-like performance. And so, React Native emerged!
It's a convenient “bridge” between JS and native platforms:
React Native apps get written in JavaScript
they “play by the rules” and meet the standards of the operating system
... while accessing a big part of the native platforms via this metaphoric “bridge” that React Native creates
PhoneGap: Tempting Benefits vs Discouraging Disadvantages
Now in order to get an accurate score to our “PhoneGap vs React Native” debate here, we'd better go “pros and cons harvesting”, right?
So, without any further ado, I'll list some of PhoneGap's “irresistible” advantages first:
it “spoils” the developer with a wide range of frameworks/libraries to choose from; if you're a big fan of web technologies, if you enjoy building UIs in HTML and CSS, you'll love the rich collection of choices that PhoneGaps puts at your disposal
therefore, PhoneGap is easy to work with and developer-friendly
it's not bound to any specific framework
PhoneGap-based apps perform within wrappers targeted to each platform and use API bindings that comply with the all the given standards for accessing each mobile device's data, network status, sensors
it's based on the “write once run on every platform” philosophy: you get to “reap” the benefits of cross-platform development; just “work your magic” in any of the web technologies that you're comfortable with and have your app running on all available platforms
… with no need to get yourself tangled up in each platform's native development language
your app will have a similar UI on all native platforms
And now, the limitations that you need to consider when building mobile apps using PhoneGap:
by far the biggest inconvenience is the sluggish performance (leading to poor user experience, needless to add); and it's a more than predictable drawback considering that the web was created for web pages, not for heavy, animations-loaded, complex apps
you risk to get all the issues of the web, as well, right out-of-the-box, along with your PhoneGap hybrid app. Bugs specific to certain browsers or styles that work differently depending on the browser here included!
In short: on one hand, you get to enjoy a great developer experience, on the other hand, you risk to compromise the user's experience!
React Native: Top Pros and Cons
In a PhoneGap vs React Native “competition” the former would always fall behind when it comes to performance: React Native is undoubtedly faster.
And here are some other benefits to "reap" for using React Native to build your mobile app:
it renders real native components instead of a webview
also, since it renders NATIVE views without using webview as an intermediary, expect to face no browser compatibility challenges
there's strong social proof, highly relevant evidence for its reliability: Instagram, Airbnb, Uber
it's committed to the “learn once, write everywhere” philosophy; once you're familiar with React, you'll be writing native apps in no time, with no need to delve into Java or Objective-C coding, unless you want to extend your app's functionality
moreover, React's backed by a huge community, so during your learning time and then during your app development process, you can rely on plenty of “expert” support
the user experience is significantly improved: a React Native app will always have a native look and feel to it compared to a mobile web app
also, since it renders native views, expect smoother, high performant animations, as well
Yet, React Native does come with some drawbacks, as well, that might discourage some (even you!):
you need to be familiar with React, there's way around it
you'll need to write an app for every native platform (due to that above-mentioned JS-native platform based structure) since some of the components might be platform-specific
don't expect to be able to use HTML: it's native components that you'll need to "juggle with"
And The Answer to “Your PhoneGap vs React Native” Dilemma” Is...
“It depends!”
If you've already used React for the web, so you're definitely not stepping on alien ground, go with React Native!
It would be a pity not to leverage your React knowledge and not to benefit from all the top performance that you get to inject into your mobile app!
Not familiar with React? And, moreover, you love having an entire “palette” of familiar web technologies at hand, to just “grab and use”?
Then you'll love PhoneGap's “developer friendly” approach!
The END! Hope I've included all the most relevant pros and cons and managed to pull off some good explanations on why some developers get seduced by Facebook' baby, React Native, while others prefer to tap into familiar PhoneGap's own advantages.
How about you? Where do you stand now?
Silviu Serdaru / Mar 01'2018
Last' year's “Should I learn Nodejs?” dilemma has turned into an “I'll strive to become a better Nodejs developer!” resolution this year. Nodejs is already developers' “adored” framework and building "the next big thing" in terms of Nodejs-backed apps is the new challenge in 2018! And this definitely calls for a shiny and new set of coding habits to integrate into your Nodejs app development workflow.
New code practices to stick to when writing Nodejs apps, new coding standards that you should follow and techniques to master for using this framework to its full potential. To your future apps' advantage, of course.
Speaking of which, here's a list of 12 Nodejs development pieces of advice for you to consider if one of your resolutions for 2018 has been: “To become a Nodejs padawan!”
1. Start to Learn The Basics of Import and Import()
Think ahead of ES modules' current situation. Which is the following:
ES modules have been supported since Node.8.5
it's true, though, that they're still wearing their “experimental-modules” flag
yet they're already being used, intensively, with the @std/esm library (and transpilers)
Do consider learning the basics and be ready to level up from there. Since it's pretty obvious that 2018 has lots in store for the ES modules.
2. Integrate Asynchronous Programming Into Your Nodejs App Development Workflow
There are 2 ways of carrying out your input/output operations and setting up your Nodejs development environment:
synchronously, having your resources blocked for some time
asynchronously (Node.js' innovative application of asynchronous programming): where tasks can be carried out simultaneously since the resources don't get blocked
Now just consider a scenario of multiple operations to be performed, where resources keep getting blocked... This would have a dramatic impact on your Nodejs app's performance!
In other words: embrace the asynchronous code!
Use async-await! Turn it into your own “trump card” for handling async events and embrace the simplified version of the once so overwhelming code bases.
3. Modularize Your Code: One of The Very Best Coding Habits to Develop
Keep it small! Get into the habit of writing “bite-sized” chunks of code replacing the tediously long blocks of code that you might be used to right now.
Here's why:
it will be fairly easier for you to embrace the asynchronous coding philosophy this way
small-sized pieces of code will be easier to handle, adjust and closely monitor both for you and for anyone in your development team
handling a cluster of bite-sized chunks of code gets particularly convenient when it's a complex Nodejs app development project that you're dealing with
4. Master Containerization & Adopt the Microservice Architecture
Since the Nodejs application architecture is a microservices-based one.
Therefore, one of the best code practices to incorporate into your workflow is using containers. Containerize your Nodejs apps and streamline your services deployment by tapping into these 2 techs this year:
Docker:
the software technology to generate your containers
… which are nothing less than all-in-one pieces of software encapsulating all the resources that they need to run: system tools, code, runtime, system libraries
containers that will increase your deployments' security level
and that you even get to use for simulating production environments locally
Kubernetes:
an open-source system that you get to use for automating everything Docker containers-related: scaling, deployment, containerized apps management...
Friendly advice: before you jump straight to containerizing your services, take some time to upgrade your existing code; for this, apply the principles included in the 12-factor app methodology.
5. Nodejs Application Performance Monitoring: Make It an Ongoing Process
Especially if it's a complex microservice ecosystem that you need to keep a close eye on!
Monitor your system, using the ever-improving toolbox at your disposal, detect and fix errors before they even get to catch your app users' attention.
Close and on-going monitoring sure is one of the very best Nodejs app development habits that you could develop this year!
6. Mind The Bugs in the Code, That You Might Leave Behind
Be alert and avoid those scenarios where you leave trouble-making bugs behind, as you “knit” your web of code.
And being alert means:
tracking your error events
detecting errors in their early infancy
Note: luckily for you, incorporating this practice into your Nodejs app development process is somewhat easier when using this framework.
7. Get Acquainted With HTTP/2
Again: always be one step ahead of the game! And since we can't but anticipate that HTTP/2 will be going from experimental to stable this year in Nodejs, make sure it won't “take you by surprise”.
HTTP/2 has multiplexing and server push, with a signification impact on the native module loading in browsers.
So, there's no doubt about it: it's going to lose the “experimental” flag, that it has been wearing since Nodejs 8.8, and become the new standard with Nodejs this year.
8. Use Semantic Versioning: Another Nodejs App Development Habit to Form
And this practice is what sets apart a Nodejs padawan from a Node.js... enthusiast.
If you've decided to learn Nodejs this year, make sure you delve deep(er) into its set of best practices (don't just scratch the surface): use semantic versioning for letting the users know that you've updated the app.
To inform them about the actions that they should perform in order to update the app to its latest version.
In short: by updating your packages without SemVer you risk breaking up your precious app!
9. Turn Securing Your Nodejs Application Into Your Top Priority
Make sure your Nodejs app is 100% secure above all! Apps' security has been both the vulnerable aspect and the ultimate objective for app developers in 2017.
And 2018 is no different from this standpoint!
Run tests over tests to “challenge” your Nodejs app's security by tapping into all the apps that this framework puts at your disposal:
Snyk
Data Validation
Node Security Platform
Brute Force Protection
Session Management
If there's a vulnerability there, somewhere, within your app, make sure you track it down before... it gets exploited!
10. Adhere to The JavaScript Standard Style for Writing Your Code
Following a set of coding standards will just guarantee you that no big issues will show up later on. In this respect, the JavaScript standard style makes the best choice for your Nodejs app development workflow.
Here's why:
you get to “hunt down” style issues and coding errors early in the development process
it sets the single space after keywords “rule”
it will automate your code's formatting by running standard-fix
it sets the “function name followed by space” standard
and the “single quotes for strings” one
11. Put All Your “Require” Statements at the Top
“Pin” this app development advice right on top of your list of best practices!
It will make all the difference! By grouping all your “require” statements right at the top you'll practically:
steer clear of performance issues, since “Require” is synchronous and it will simply block the executions (thus avoiding ugly scenarios)
Major tip: use Node's built-in module loading system; it comes with a "require" function which will automatically load the modules existing in separate files.
END of the list! These are the top code practices & new “healthy” habits to get into this year for making the most of this framework.
And thus turn your Nodejs app development projects into the next famous apps built with Nodejs!
RADU SIMILEANU / Feb 15'2018
Ready to set up your web app? One which, needless to add, should deliver your users a feature-rich front-end experience? Great! Now comes the truly challenging part: deciding which JavaScript UI component library — Vue vs React — is right for your web project!
For its specific needs and requirements:
is it a small or a large scale one?
is it one overloaded with dynamic elements?
do you plan to go mobile, too?
do you want it built fast or do you want it capable to scale up in order to accommodate all future functionalities and features?
And the debate is nothing but:
convenient simplicity and lightness vs superpower backed up by a thriving community
But let's not move away from your initial “dilemma”:
“In a Vue vs React competition, where I get to choose the most appropriate front-end framework that should power my future app, which one's the winner?”
Let's bring in the 2 contestants on the “stage” now, shall we?
But First: 2 Crucial Questions That You Should Be Asking Yourself Beforehand
1. Will it be a web or a native app?
And this is a critical question to be asking yourself way before you start your “investigations” on the 2 competing JavaScript UI component libraries.
Here's why:
React has got you covered whether it's a web application (ReactJS), a native mobile app (React Native) or... even a virtual reality front-end app that you're planning to develop. And this is, no doubt, one of the most heavy-weighing answers to the question: “Why React over Vue?”
Vue2.0 has made a big step forward, towards a native approach (and here I'm referring to Weex, of course); and even if it still can't get anywhere close to React Native's built-in support for building native mobile apps, it's still a “promise” for the future to come.
2. How Much Time Do You Have Till You Need to Actually Start Building It?
In other words: is it an “ASAP” type of app developing situation or you do have the “luxury” to invest as much time as needed in learning a new JS framework?
And this question is more than relevant (and helpful for narrowing your 2 choices down to 1 from the start) since:
ReactJS can be discouraging for some, due to its quite steep learning curve; from its terminology to its heavy documentation, everything looks less familiar, less intuitive, more frustratingly complex
Vue.js, on the other hand, has “seduced” lots of its current advocates precisely with its low learning curve: it “spoils" them with familiar CSS, HTML, ES6 and where do you add that it doesn't call for a Webpack either.
Basically, you get to explore and capitalize upon Vue.js's potential right away, in pretty much any code sharing environment.
Go With Vue.JS If...
1. It's simplicity in syntax that you value most in a web framework
In a “Why moving from React to Vue?” debate, the argument of “extreme simplicity” would have to be the strongest one.
That's right, this JavaScript UI framework's simplicity is built deep into its design.
Moreover, the familiarity of the concepts that it uses (or better said “copies” from its main 2 “rivals: React's virtual DOM and Angular's two-way data binding) could be enough to help you find the answer to your “Vue js vs React” personal debate.
You just run your Vue.js project right from your web browser!
And its simple syntax bubbles up to the easiness of altering the state data (not to mention that this also makes it significantly easier to pick it up).
2. It's a small scale, ideally fast web app that you're planning to build
Since page size is a game-changer (isn't it?) when it comes to building an app, Vue.js comes to tempt you with its surprisingly low weight (approx. 25.6KB once minified).
Now you do the math how this will impact the rendering system and, overall, how it will tilt the balance in any “Vue js vs React speed” comparison.
3. You're more into a “templatey” way of building apps
And how could you “resist” a default template structure after all (and even so more if you're not new to AngularJS)? One that uses old-style HTML templates.
Basically, you get to drop your markup into an HTML file and thus:
use already familiar (aren't they) HTML attributes for injecting the needed functionality into your default template
use pre-processors
clearly separate layout from functionality
… as compared to building your app using ReactJS, which uses a whole different approach: it requires you to put together your own DOM using a JSX syntax.
Note:
yet, some might argue though that templating comes at a cost, that of learning the extended HTML syntax, as compared to the rendering functions. And, moreover, that React's JSX syntax puts superpowers in the hands of the developer, once he/she gets familiar with it. Since it enables him/her to use JavaScript in his template.
And yet: stay assured, Vue.js 2 now provides you with both render functions and a templating option for setting up your web app!
Go With ReactJS If...
1. You Want to Easily Build an App That Should Work on Both Web and Mobile
Convenience at its best! This is how we might call Facebook's “protegee's” two-faceted nature:
ReactJS for building your high-power, interactive web app's interface with
React Native for building your next best thing in terms of native apps
No need for you to knee deep in learning the nitty-gritty of a whole new JavaScript UI component-based library.
Instead, you'll be using the already familiar React for carrying out both your plans (to build a web and a native app), “juggling” with web components and respectively with native components.
2. It's a Complex, Large Scale App Project That You Have in Mind
If that's the case, then the following argument might just be a decisive one in your Vue vs React “dilemma”.
For React is built with the specific needs of large-scale apps in mind! Which means that it's perfectly equipped for injecting them with high performance!
And it's precisely when you're dealing with an overly complex app project that you realize that:
transparency and testability are crucial for you
a template system is way too restrictive, far less configurable (although it would help you to create a React app and get it up and running in no time)
In this respect, React's JavaScript-made templates grant you the freedom you need for:
reusing
easily testing
restructuring
… your conveniently decomposed code.
And this is the “superpower” that React lays in your hands: it allows you to “split” its JavaScript structure into multiple components, that you can easily test and reuse!
It “spoils” you with an ideally configurable rendering system.
3. It's a Huge Ecosystem and a Thriving Comunity that you value most
React's indisputable “fame” — not to mention Facebook's backing — does come with its benefits. Advantages that you can capitalize upon:
more resources out there for you to delve yourself in and to leverage in your app (tutorials, articles, Stack Overflow answers, etc.)
a wide range of add-ons and tools for you to select from and boost your project with
the guarantee that you'll benefit from continued maintenance (given by Facebook's patronage and, therefore, by the whole “army” of React developers that commit themselves to keep it closely
monitored)
And The Winner of This "Vue vs React" Dabate Is...
Have I made you even more confused? Is it even harder to state which front-end JavaScript framework would win the Vue vs React debate?
One's “seducing” you with a simple syntax and set up, the other one with its scaling capabilities.
One “boasts” with faster rendering if it's a small app that it's powering, while the other one empowers you to build both web and native mobile apps.
And where do you add that the two UI frameworks share a considerably large set of features, as well:
they're both conveniently lightweight
they're both open source
they both use virtual DOM and reactive components
they both rely on server-side rendering
… and are both component-based libraries providing you with a “backbone” in terms of functionality.
So you'll need to rely on third-party frameworks for handling any extra functionality (state management, routing, etc.) that you're planning to equip your future app with.
Decisions, decisions...
Now here are a few conclusions deriving from my little presentation here that might help you decide a bit easier:
opt for Vue.js if it's a new JavaScript framework that you'd like to drop into an already existing codebase
choose the React library if you're planning to leverage web technologies to develop a native mobile app
go with React if it's a SPA or a really complex, large-sized app that you're planning to build
So, is it any easier for you now to solve your Vue vs React dilemma?
Silviu Serdaru / Jan 08'2018
There's no such thing as “the best web technology” but “the best technology for particular use cases”! For your web projects' particular needs:
do you want it developed fast or do you want it to work fast?
what's crucial for your specific project: that your web technology should scale great or that it should be flexible and IDE friendly?
do you value a highly expressive language or one that's the same on the server and on the client's side (for back-end and front-end)?
Take some time to answer the above questions. Then see if can find your priority features and the capabilities that you're looking for in a web technology and whether your project fits any of the use cases for Node.js that we'll be pointing out here below. Keep reading...
But First: What Is Node.js?
Just a few words about this web technology competing for the “chance” to power your future web project:
a JavaScript platform or “runtime environment” if you prefer
built to enable you to develop fast and highly scalable server-side apps
comes with a unique I/O model which makes it particularly lightweight and excellent for handling big flows of data (real-time situations handling a ton of requests)
Reasons Why Node.js Is Increasingly Popular
And here we're thinking about companies such as Uber, LinkedIn and... NASA that saw huge potential in Node.js!
But don't take these brands/enterprise names as unique arguments for jumping on the Node.js trend! Better scan through, ponder on and put the following reasons for why you should be choosing this technology against your own project's needs and particularities:
your development team will get to use the same language, both on the client and on the server side (so both on the front-end and the back-end); this can only lead to an efficiency boost and to reduced development costs (since your front-end and back-end developers will then be cross-functional)
the same feature practically speeds up the whole development process (parts of your app can get shared and reused from the back-end to the front end and vice versa)
Node.js is a full-stack technology: you get everything you need for Node.js to work all in one package, from the HTTP server to the templating engine
it's free and open-source technology
it loads fast (and here we're comparing it against Ruby on Rails)
Use Cases Where Node.js Works Best
1. For Developing Real-Time Apps
If it's a real-time app that you're planning to build, then Node.js makes THE excellent choice. It's built to:
make sharing and reusing of library code packages a breeze
handle heavy loads of concurrent client requests depending on instant response time like no other rivaling technology out there
speed up the client-server data sync
process massive loads of data in real time
But let's talk facts!
Meaning specific examples of “apps/sites where:
big flows of data need to get processed in real time
multiple connections are simultaneously active and requiring immediate response time (relying on asynchronous interactions, like Quora.com for instance)
So here it is, our list of real-time app examples, of use cases where Node.js works best:
chat apps (instant-messaging, live-chat apps)
collaboration tools: drawing/editing-type apps
e-commerce transaction apps
video conference apps (depending on VoIP and specific hardware to work)
multiplayer games/online gaming apps
In short: Node.js isn't the unique solution, in terms of web technology, to develop your real-time app with, yet the:
unmatched performance that it will turbocharge your future app with (it can handle big data flows and multiple requests and all this without compromising on page load time)
ease of development that it “lures” you with
… do put it on top of your potential web technologies to power your app with!
2. For Building Single-Page Apps Heavy on Processing on The Client Side
Is it a single-page app site that you're planning to build? One of those modern web apps dealing with a lot of rendering, of processing on the client's side mostly (having a back-end playing a single role: providing a JSON API)?
Then you can't choose a more appropriate web technology!
Thanks to its unique I/O model, Node.js is equipped to process high volumes of I/O driven requests and data sharing tasks (e.g. the validation code shared between the client and the server)
In other words: it's a powerful technology “capable” to handle great piles of instant data, of IO-bound requests, one that should scale easily and process the multitude of requests at high speed that you're building, then Node.js is the one for the job!
Note: do keep in mind, though, that if it's more than shuffling data around that you need your web technology to excel at, if there's a lot of CPU processing (e.g. image processing) involved, then you might want to consider other technology for your web project!
3. For Building Streaming-Data Apps
Node.js does a remarkable job, thanks to its capabilities to process massive loads of data in real-time when it comes to supercharging streaming apps.
Let us give you just a few examples of data streamlining tasks where you could leverage Node.js's capabilities:
encoding files while uploading them
uploading files in real-time
building proxies between layers of data
4. For Building REST/JSON APIs
Facing the challenge of wrapping web services or data sources (so other data sources) and displaying them via a JSON or a REST programming interface? Node.js will “save the day”, once again!
Since it:
runs on Javascript
“boasts” with a one of a kind I/O model
… it makes the handiest tool/web technology for you to go for whenever it's APIs that you need to build!
Does any of these 4 ideal use cases for Node.js match your own? Do this platform's features and functionalities meet your specific web project's needs? If so: entirely or just partially?
Adrian Ababei / Sep 22'2017
“Teach a man to fish and you feed him”.
In other words: don't expect us to reveal to you, by the end of this post, which is the ultimate winner of this Angular vs React's debate! Which is the right JavaScript technology for your next web project. For we won't!
Instead:
we'll be helping you weight the 2 widely-used JS frameworks' advantages/disadvantages
we'll encourage you to evaluate all their key aspects
… so you should be able to answer THE question yourself: “Should I choose Angular or React for my next web project?”
Angular vs React: Introducing The 2 Competing Technologies
Before you get to run your “magnifying glass” over these two popular JavaScript frameworks' key strong points and drawbacks, while comparing them against your own web project's requirements, allow us to briefly introduce them into the “arena”:
Angular: a full-stack, feature-reach JavaScript MVW framework
… built so that it can provide you (or your team of developers) with all the needed tools out-of-the-box! Where do you add that:
it's search giant Google-supported
tailored to fit large enterprise teams' specific workflows
designed to help you build highly interactive, fast-loading websites and web apps
React: so much more than “just” a JavaScript library for building great interfaces
Otherwise, how could you have even considered comparing it to a full-blown framework like Angular, right?
React is many developers' top choice (and it sure has its own "fan club" within our Toronto web development team here, as well) whenever they're looking for an ideally lightweight, easy to tweak and twist framework for building dynamic, high trafficked (having data that's frequently changing) web apps!
Now that we've introduced the 2 “contestants” competing for the chance to be powering your new web project, let's go on and highlight their pros and cons (tackling multiple key aspects), so you can evaluate them yourself:
Angular Vs React: Comparing 11 of Their Key Features
1. Performance
We need to admit that the 2 JS technologies are comparable from a performance perspective. Yet, we can still outline a few performance-impacting features inclining the balance to one side or another:
Angular:
it supports caching (along with other processes), which means that the server performs at its best
yet, its large size does negatively influence load times on mobile devices
React: constant components re-rendering can lead to performance issues, especially if it's an app handling a heavy load of data that you're planning to build
2. Flexibility
Angular: doesn't allow you too much freedom for customizing your app/website so that it meets your needs in the smallest details
React: highly flexible
3. Development Time
Angular:
your development team will need to invest a significant amount of time in understanding the code (there's a whole lot of unnecessary syntax required), in debugging
it calls for Angular-specific syntax and 3rd party libraries
its layered, hierarchical structure can be quite discouraging for a developer working with Angular for the first time
React:
its Flux architecture is highly convenient and competitive to MVC
is quite easy for developers to understand it
the longer time required to set up a React project might look like a drawback to you, yet once you've built your React-powered app adding on new cool features later on is considerably easier
4. Feature Set
Angular: it does come packed with “out-of-the-box” tooling and built-in best practices
React: although not a full-stack JavaScript framework as Angular, if React will be your final choice you can stay reassured: “when in need”, there's practically a third party library for pretty much everything
5. Scalability
Angular: is built to scale easily, its design, as well as its powerful CLI, being the best proofs
React: designed to be easily tested and, implicitly, scalable
6. Learning Curve
Angular:
be prepared to invest significant time resources in learning this over-sized library
moreover, learning “just” Angular is not merely enough: you'll then need to get yourself familiarized with MVC, with Typescript...
React:
on the bright side: it works with the fewest abstractions
on the... less bright side: you'll still need to take your time to learn all the best practices (and there aren't precisely “a few” only)
7. 3rd Party Library Integration
Angular: when it comes to the 3rd party library compatibility aspect of this Angular vs React “debate”, Angular's not doing so well: Typescript demands type definitions for every single library that you'd want to integrate
React:
it's written on pure JavaScript logic
it integrates perfectly with 3rd party libraries (even with the DOM based ones!)
8. Applicability
Angular: used mostly for building enterprise, traditional form apps
React: it usually powers complex, high-performance sites/mobile or web apps featuring complex user interfaces, with multiple events, multiple inputs (each one “risking” to impact the other's screen)
9. Native Rendering
Angular: comes packed with Ionic 2 and NativeScript
React: it's significantly better “equipped” for native rendering thanks to ReactWindows, Next.js, Alibaba, React Native
10. Size
Angular: it does have a substantial size, which inevitably impacts its performance on mobile
React: smaller sized and, implicitly, conveniently lightweight
11. Optimization Goals
Angular: it's aimed at “boosting” the productivity of development teams working within a company
React: performance, flexibility, and simplicity are this JS technology's main “objectives”
And Last: 9 Key Questions to Ask Yourself Before Making Your Choice
Don't rush in to give your own verdict on this Angular vs React debate. Not just yet.
Not before you've asked yourself these key last questions strategically chosen to “cement” your final decision:
Do you represent a company or are you a Drupal developer working in an enterprise-level team? Then you're definitely better off with Angular! It's designed to boost large teams of developers' productivity and to adapt to big companies' workflows (just let Angular's CLI outline and guide you along the step-by-step path to take for completing your application!).
Are you a start up digital business instead? Then React might just better meet your company's specific needs.
Do you have a “secret” weakness for templates? Then Angular is the JavaScript that you'll feel most comfortable working with on your next web project!
Do you love Typescript? “Angular” is the answer to your own “Angular vs React” dilemma
Do you love “getting your hands dirty” in customization, to be given the chance to tweak your app/website whenever and however you'd like to? React will grant you this freedom!
Is high performance a major issue for you? React!
Is productivity one of your main goals? Higher placed in your hierarchy than... flexibility, let's say? Angular!
Do you have a particular interest in open source web technologies? And does a “guarantor” like giant search engine Google weight a lot in your decision-making process? Then don't “torment” yourself any longer and choose Angular with no hesitation!
Do you fancy building an app with complex, eye-catching interfaces, yet one with a small footprint? Then it writes “React” all over your project!
We strongly hope this little “questionnaire” here, along with our comparison tackling these two JS technologies' major aspects, will help you make up your mind faster. Help you make the right decision for your upcoming web project.
Final note: there's no such thing as “THE” perfect choice for each company, development team, project environment, and use case. Not even a “one size fits all” platform for all of your future web projects. Do keep that in mind!
Adrian Ababei / Sep 14'2017