Setting up a new Express project is very easy. It consists of installing a handful of libraries through NPM run a single npm install and everything is ready to go.
Express' extremely powerful routing API allows developers to do tasks ranging from building a REST API to building the routes for a simple web app and then take it to the next level by using route parameters and query strings.
Express considers itself to be a "minimalistic unopinionated framework", it basically lets the developer determine how their project will be organized. On one hand, this gives anyone terrific power and flexibility to use any library they want for a certain task and to organize their project structure however they want. But on the other hand, there's no single recommended way of organizing things, which can be a trap for beginners and experienced developers alike and result in unmaintainable projects.
Node.js Foundation
Announcement here
The Node.js Foundation is a Collaborative Project at The Linux Foundation. Linux Foundation Collaborative Projects are independently funded software projects that harness the power of collaborative development to fuel innovation across industries and ecosystems.
Being a somewhat old Node.js web app framework and being one of the most widely used frameworks, Express.js has matured quite a lot during all that time. It's more stable than its competitors and a huge community backing it.
Express takes advantage of Node's NPM to distribute and install countless plugins made by third parties which solve almost anything a developer would want to do with Express.
TJ Holowaychuk recently announced that he is leaving node and needs maintainers for his projects, which include Express.js. Most of the core team moved to Koa.
Save a change in the source file and watch how all connected clients refresh automatically - browser tabs, mobile apps running in the simulator or on the physical device.
Or, deploy a Meteor app (meteor deploy myapp) and all clients, plus all mobile apps with the server set to myapp.meteor.com will automatically reload to use the code changes.
This drastically reduces the development cycle for apps in the App Store, where a regular update can wait for one to two weeks before being approved.
The same code can be run on both the server and the client, because Meteor is a full-stack JavaScript-everywhere platform. A common example of code that should run on both the client and the server is input validation - on the client for speed/UX, and on the server for security (the client can't be trusted).
Meteor was developed with simplicity in mind, even for beginners who have just started using JavaScript frameworks. One of the reasons that beginners should start with Meteor is that Meteor is a full-stack framework, this way they can get the complete learning experience when it comes to web development (back-end and front-end development), all by using a single platform and a single language.
Furthermore, Meteor does not have complex and esoteric concepts that may be hard to grasp by a beginner, it has a clear documentation and well-established coding conventions.
There's also a very useful resource for learning Meteor in the form of a book: Discover Meteor, by the authors of many Meteor packages.
A Meteor package can supply code for both the client and the server, and for mobile (Cordova) apps. For example, an autocomplete package supplies both server code to search a collection, and client code to display the results. The mdg:camera package supports the native camera if the app is built for mobile, or the HTML getUserMedia API to take pictures from the browser.
Because Meteor is full-stack (as opposed to just View), it seems like it would be difficult to integrate into existing projects, even if those projects used Mongo and Node.
It's common for the front-end and back-end to lose sync if an internet connection is flaky. Even though the connection should be in real-time, if the connection is weak, you may lose that real-time sync. For example, in chat applications you may have to refresh the page to get the latest updated data from the server.
MongoDB advertises scalability but only if you don't care about data-integrity. There are other backend options but none of them are officially supported.
Meteor is built on top of Node.js and jQuery on the client.
Express, Sails, Hapi and others are only server-side frameworks. Angular, React, Ember, Backbone are client-only libraries. Meteor is a full-stack framework, enabling the client and server to communicate data seamlessly, in real-time. You don't have to write any REST API or pub/sub code - Meteor takes care of it all automatically for you.
Meteor does not have support for server-side rendering of views, which is extremely helpful when it comes to SEO. However, there's a third-party server-side rendering package available for download. The Meteor team has also said that server-side rendering is on the roadmap.
Meteor can generate mobile (iOS and Android) apps from the same codebase as the web app, using the Cordova (PhoneGap) library (which brings native device functionality to JavaScript applications).
You no longer need to learn Java, Objective-C or Swift to build native apps. Meteor-generated mobile apps are JavaScript, HTML and CSS bundles that run in a UIWebView (on iOS) or WebView (on Android). Apps can be run locally in the iOS/Android emulator, or on physical devices. You can also publish them to Google Play Store or Apple's App Store.
Moreover, these hybrid mobile apps benefit from hot code push, which dramatically accelerates the development cycle.
Meteor uses MongoDB, eliminating the choice among NoSQL databases. MongoDB is highly scalable - used to store petabytes of data and perform billions of operations daily at eBay, FIFA, Adobe, Craigslist, McAffee, Foursquare and others.
However, any write locks the entire database. And no joins as in SQL.
The community behind Meteor has created a useful application for debugging Meteor apps that will automatically delete collections and display client-side documents, allow you to control subscriptions and lets you modify the documents.
Meteor also has great support for server-side debugging, and WebStorm has also released full support for Meteor, including debugging capabilities.
Meteor uses both your existing front-end library and it's own library called Blaze, which is integrated beautifully in the framework and fulfills the purpose of a true MV* front-end framework.
Meteor uses Kadira which is an excellent performance monitoring tool for Meteor apps. It profiles CPU and RAM consumption, subscription latency and throughput etc.
Meteor also has an official testing framework called Velocity. Velocity enables real-time unit testing and integration with Jasmine or Mocha syntax. Tests are automatically run when code is saved and the testing result is indicated by a green or red dot in the upper right corner of the app.
Meteor's package repository called Atmosphere has more than 5000 packages available. What's more is that Meteor can also use into the packages available for the Node ecosystem.
Meteor uses both your existing front-end library and it's own library called Blaze, which is integrated beautifully in the framework and fulfills the purpose of a true MV* front-end framework.
While Meteor only supports MongoDB and Redis natively, MySQL support is on the roadmap, and there are 3rd-party packages that integrate MySQL reactively with Meteor to some extent, such as numtel:mysql. For reactive PostgreSQL support, there is numtel:pg.
Sails.js is built with a focus on building real time communication apps such as chat or multiplayer games, so naturally it has Socket.io extremely well supported.
This could be a huge plus, if you prefer to build your apps using the Model View Controller architecture. Using Sails.js you'll find the task of separating the business logic from the user interface and keeping the interactions between them in a separate layer, extremely easy.
Sails.js uses Waterline ORM at its backend which means you can store your data in any datastore that you like; all you have to do is make a change to the Waterline adapter, this will allow you to store your data in MySQL/Redis or any other kind of database.
Clear documentation and easy to understand. The file structure gives you a way to understand where you can start to develop when you encounter a new Sails project
The built-in Waterline is not well designed and is not suitable for production environments. Populating more than 1 level deep is a nightmare, there is no transaction support, new features/bug fixes are not implemented anywhere near a timely manner (the most requested feature 'deep populate' has been lingering in their github issues list for over a year and a half now).
Generators functions are of course a huge plus, but at the time Koa team has transcended generations functions and shifted towards async/await style programming. It has made the Koa best framework available in the market.
Using generators (a bleeding edge feature, even for Node.js) would clean up your code from the mess caused by all those callbacks; making your code more manageable.
Feather can sync events happening in two different Node processes or even servers in real-time. For example: an event happens in server A, the user connected to server B is instantly notified of that event.
This is done through a central Redis or Mongo collection or through a websocket libraries' clustering library.
Through services, Feathers provides instant CRUD functionality, it also can easily expose a RESTful and real-time API through HTTP/HTTPS and websockets.
FeatherJS uses primus which is a universal wrapper for real-time frameworks. Through primus you can easily choose which socket transport you want to use.
Feathers makes extensive use of modules (which are called Feathers services). These services work like ExpressJS middleware and can be used with app.use('/path', serviceObject).
Services help developers keep their applications modular and as minimal as possible, without any unnecessary libraries or bloat.
Since Feathers itself is built on top of Express (it's a thin wrapper over socket.io, primus and Express) and because of Feathers' highly modular nature, it's very easy to integrate Feathers in an existing Express project.
As most of the benchmarks have already revealed, for large inflows of traffic, apps powered by Restify perform below par and are easily beaten by Express.js in terms of load time (in heavy traffic).
As the name suggests, Restify is devoted solely to creating an elegant REST API. The API is the core of your site or service, so it makes sense to use a framework that excels at that.
Mach has some pretty cool streaming functionalities built directly into it, if your web app provides any audio/video/data streaming features, you can consider using Mach to build it.
Since Mach already is asynchronous (stateless) which means your logic is implemented by using promises (then objects); hence your functions are pretty independent and composable.
No complex layers between plain HTTP requests and the corresponding JS functions invoked. Which in turn means each GET/POST/PUT or any other HTTP request is directly mapped to a Javascript function. Hence leading to a huge increase in performance for your app
One of the distinguishing features of Mach is it's robustness, errors won't be terminating your complete app, instead they'll bubble up so you can handle them gracefully.
Like most of the Node.js's core, Mach is an asynchronous web framework too. Each response (of a request) can simply be hooked up to a then method so that its result or the reason for failure can be retrieved after the action is complete. If you're wondering what async operations are, here's a pretty good explanation for you
Add to Chrome
Add to Edge
Add to Firefox
Add to Opera
Add to Brave
Add to Safari