Need advice about which tool to choose?Ask the StackShare community!

Node.js

98.7K
78.6K
+ 1
8.3K
Rails

13.8K
9.2K
+ 1
5.4K
Add tool

Rails vs Node - Help me Decide


Rails, is a server-side web application framework written in Ruby. Rails is a model–view–controller (MVC) framework, providing default structures for a database, a web service, and for web pages. Node.Js is a JavaScript runtime built on Chrome’s V8 JavaScript engine. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient.

In this post, we’ll objectively look at a few of their differences, strengths and weaknesses to help you decide which, and when to use these technologies.

Community Support

Node The Node.Js community is broad, inclusive, and excited to enable as many users to contribute in whatever way they can. It is worthy to note that Node.Js has a package manager npm which has the largest ecosystem of open source libraries in the world. Node.Js also enjoys the support of the wider JavaScript community network.

As a way of keeping developers in sync, Node.Js has a committee that is directly in charge of global outward-facing community outreach efforts. They also organize local and international meetups and conferences to bring developers together. Node has not been around as much as the likes of Rails and Django, however, it is gaining steady popularity and usage. So far it has received, 54.3k stars, 11.7k repo forks with 2.1k contributions on Github.

Node Github repo

Community Support

Rails Rails have been in existence way longer than Node.Js hence, it has a very broad community support. The vast number of Plugins and Ruby Gems available for Rails has made it one of the most supported web framework available. Given that Rails has been around for a long time, it has a lot of people actively using and contributing. You can get involved with the community online on the Ruby on Rails: Talk mailing list, the Ruby on Rails StackOverflow Q&A tag, or the #rubyonrails IRC channel on Freenode.

As a way of keeping the community spirit high and bringing members together, they also do a yearly RailsConf conference for people to meet and share in real life. So far, Rails has received 41.1k stars, 16.6k repo forks with 3.6k contributions on Github.

Rails Github repo

Pros and Cons

Now, let’s take a look at a few strengths and weaknesses of these technologies and hopefully help you decide which will best suit your needs.

Node.js Pros and Cons

The Pros:

High Market Demand At this time, Node.js is on the cutting edge of web development, and the excitement for Rails has really gone down. More companies are hiring JS developers than any other language. This makes Node almost the most in-demand back-end solution right now. Data from Indeed shows that there 9.4K job postings for Node and 3.3K postings for Rails. TechMagic also shows a graph of Node.Js job trends vs that of Rails.

Comprehensive Node.JS covers everything from HTTP server to templating engine etc. Rails rely on something like Nginx or Apache with mod_rails to work. Moreso, it has the same language on both the client and server side making it even more lucrative and comprehensive. Plesk did a comparison post that further showcases this as well as Codeburst Node.js Cons.

High Performance Because of the fantastic npm modules available to Node.js, and the Chrome’s v8 JavaScript engine, it is vigorously fast. When performance is a factor, Node.js performance better than Rails, more like better than any other web framework as it runs on the Google JavaScript engine which is lightning fast. Moreso, half of the respondents of Node.js 2017 User Survey noticed improved application performance in comparison to other solutions. Also, LinkedIn replaced their back-end mobile infrastructure built on Ruby on Rails with Node.Js some time ago for performance and scalability reasons.

Scalability Because Node is asynchronous and runs on a single thread, it has been found by many companies to be very scalable. As a matter of fact, companies like Twitter’s new web stack is built on Node.js.

The Cons:

Single CPU Node.Js is bound to a single CPU, and as a result, it is not suitable for processor intensive tasks according to this recent findings on Codeburst.

Unending Frameworks Just like JavaScript, Node.js has tons of frameworks and there’s still more coming every day. This can get a little weary for developers as they will have to constantly learn the new frameworks to stay up to par. According to Pramod on Codeburst, Node.js remains inconsistent with it’s changing API’s but might change for good in time.

Not so backward compatible Because of the inconsistency in Node.Js API’s, it keeps changing at frequent intervals. As a result, it is often not very backward compatible. A statement on the release website just showed that they have made minor changes to support backward-compatibility.

Asynchronous Node is asynchronous. Hence, you’re going to run into a lot of callback functions that can potentially pile up to what is called a callback hell. However, the Node.js community has devised a few ways to prevent this on CypherTrick.

Rails Pros and Cons

The Pros: Consistency Rails is very consistent in it’s development structure given that it follows the MVC pattern. As a result, most, if not all Rails applications will look the same with regards to core files and application structure. According to Mical on NetGuru, Rails still maintain one of the best industry standards.

Development efficiency Rails has an efficient system of modules and a package manager that makes it super easy. It also has tons of gems that could serve for pretty much any purpose. This in turn speeds up development time and increases productivity.

Ease of migration Rails is also one of the very few web frameworks that has a really good database migration functionality. Creating, editing and updating tables and columns in databases can be done directly on Rails without having to change settings on the database manually.

Vibrant community According to Micals RoR community post, Rails has an amazing community of developers who are constantly working to improve Rails by way of addition of new functionalities, creation of guides, attending to issues, etc.

The Cons: Performance One of the major pitfalls of Rails is that it is relatively slow. Both the runtime speed and the boot time speed are all slow as compared to that of their alternatives Node.js and GoLang. As a result, LinkedIn replaced their back-end mobile infrastructure built on Ruby on Rails with Node.Js some time ago for performance and scalability reasons.

Errors are expensive to fix If you’re able to be thorough and pay attention to all the small details during development, Rails will definitely be your helpful friend. However, if you make a wrong architecture decision during development, it could turn into a very expensive ordeal. Rails structural deficiencies are hard to fix because Rails is an open framework, where all components are tightly coupled and depend on each other. For instance, too much reliance on ActiveRecord makes an application logic tightly coupled with database models, which leads to maintainability problems in the long run.

Scaling Rails has been understood to have major scaling issues for big projects. As much as it works well for small applications, once capacity grows and you have need for scaling, it gets generally difficult with Rails. Company’s like Twitter has had to move away from Rails at some point when they faced a major scaling issue.

Strict nature Rails is a very opinionated framework as some will say. It forces you to follow a particular way. Some do see it as a good thing but we understand that flexibility is important not just for the project but for the developers creative skill.

Learning curve

Rails learning curve Rails follows the MVC structure, this makes it easier to understand for developers who are already familiar with the MVC framework. It however makes it a bit more difficult for non MVC experienced developers when trying to quickly get started on Rails. Moreso, it is vast with tons of gems and libraries, it takes quiet some time to get experienced with the framework given the number of tools you’ll need to get familiar with.

Node.Js learning curve Node runs on JavaScript, which according to BusinessInsider is the most popular and in demand language in the world. This alone makes it pretty much easy to use given the fact that almost every developer (even non JavaScript developers) are in certain ways very familiar with JavaScript syntax and concepts. However, it is worthy to note that Node itself is different from JavaScript, but being that it was built with JavaScript, JavaScript developers use it to maintain stack consistency. This however, means that developers coming from non JavaScript backgrounds like (Java, C#, PHP etc) will have to first understand JavaScript in order to efficiently use Node.

Getting started

Getting started with Rails:

  • Step1: Download and install Ruby and SQLite3
  • Step2: Confirm installation by running this command:
    $ ruby -v
    // this should print a value like this
    // ruby 2.3.1p112

Rails require Ruby version 2.2.2 or later.

  • Step3: If you are working on Windows, you should also install the Ruby Installer Development Kit.
  • Step4: Confirm SQLite3 version by running this command:
    $ sqlite3 --version 
  • Step5: Install Rails using the gem installation command:
    $ gem install rails
  • Step6: Verify Rails installation by running this command:
    $ rails --version
  • Step7: Create a new Rails app, switch to it’s folder and start the server:
    //create a new app "newProject"
    $ rails new newProject
    // swicth to the project folder
    $ cd newProject
    // start the server
    $ bin/rails server

Now open a browser window and navigate to localhost:3000. You should see the Rails default information page:

Getting started with Node.Js:

  • Step1: Download and install Node
  • Step2: Confirm Node version:
    $ node -v
  • Step3: Create new Node project, switch to the project folder and open it up in VSCode:
    // create project folder
    $ mkdir newProject
    // switch into the project folder
    $ cd newProject
    // initialize a Node project in it
    $ npm init -y
    // ... next open up the project folder in your editor ... //
    $ code .
  • Step4: Create an app.js file in the project root directory and update it with the code:
    const http = require('http');
    const hostname = '127.0.0.1';
    const port = 3000;

    const server = http.createServer((req, res) => {
      res.statusCode = 200;
      res.setHeader('Content-Type', 'text/plain');
      res.end('Hello World\n');
    });
    server.listen(port, hostname, () => {
      console.log(`Server running at http://${hostname}:${port}/`);
    });
  • Step5: Run the Node app:
    $ node app.js

Now visit localhost:3000 and you will see a message 'Hello Node!!' with this output:

Performance

Performance is a major issue for the Ruby on Rails community. Given that the framework is heavy and embodies a large number of mixins and gems that further contributes to the slow runtime and boot time of Rails applications. As compared with the likes of Node.Js, GoLang and Python, they all outperform Rails given that it has the lowest runtime and boot time speed.

That said, Rails has been making consistent improvements to increase performance. This has kept all the big companies running on Rails afloat without issues till date. On the 16th of September 2018, Daniel J Colson posted on the Rails blog about some major performance improvements some of which are:

  1. Do less work and use less memory - This successfully replaced 1682 system calls with just 14.
  2. Use faster globs for template resolving - This made file storage 1.58% faster, stopped the allocation of arrays on no args etc.

You can also check out the full list of the most recent changes on their Github repo.

Node on the other hand is a JavaScript runtime powered by Chrome v8 JavaScript engine which makes it lightning fast. As a result, Node has one of the fastest runtime and boot time speed. Node.Js also owes its fast performance to the fact that it is single-threaded and asynchronous. This means that every I/O operation doesn’t block other operations. Hence, you can read files, send mails, query the database, etc all at the same time.

Companies and individuals have found their applications to be twice and thrice faster with Node than with other conventional frameworks. However, given that it is single threaded, performance suffers a bit of a downfall during heavy CPU intensive tasks.

image from Techmagic on medium

As can be seen from the table above, Rails has the slowest runtime when compared with the likes of Java and JavaScript.

Community Impact Numbers

These technology are both widely used by developers around the world. We’ll curate the ratings given by users on different platforms as at the time of writing to help you understand how other developers see them:

Platform specific metrics:

| Framework | Hackernews Pts | Reddit Pts | StackOverflow Qs | Github Stars | Stack Jobs | | ------------- | ------------------ | -------------- | -------------------- | ---------------- | -------------- | | Node | 3.86K | 3.4K | 246K | 54.3k | 5.21K | | Rails | 2.37K | 1.29K | 298K | 41.1K | 3.95K |

According to this Stackshare ratings, 2178 companies on their platform use Rails including twitter, AirBnb and Codecademy. It also integrates with over 39 tools. The same ratings puts Node.Js on 3404 companies and 93 tools.

Conclusion

Node.Js is perfect for web apps, mobile apps, real-time applications (instant messaging, live chat), online gaming apps, e-commerce transaction software, and much more. It's also a good choice if you're dealing with microservice architecture, which can lay the foundation for advanced systems – bear in mind that apps like Netflix or Uber were built using Node.Js.

Rails is definitely one of the best web development frameworks to consider for your next project. With Rails, you can do pretty much the same as with other good frameworks. The excellent community, a quality code base, the sheer size of the module database, and the maintainability of Rails applications made it the preferred choice for such successful projects as Airbnb, GitHub, BaseCamp, Zendesk, and Bloomberg. However, the devil is in the detail. Rails is surely a good choice if your project has tight deadlines and budget requirements.

Node.js vs Rails: What are the differences?

Node.js: A platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices; Rails: Web development that doesn't hurt. Rails is a web-application framework that includes everything needed to create database-backed web applications according to the Model-View-Controller (MVC) pattern.

Node.js and Rails can be categorized as "Frameworks (Full Stack)" tools.

"Npm", "Javascript" and "Great libraries" are the key factors why developers consider Node.js; whereas "Rapid development", "Great gems" and "Great community" are the primary reasons why Rails is favored.

Node.js and Rails are both open source tools. Rails with 43.6K GitHub stars and 17.5K forks on GitHub appears to be more popular than Node.js with 35.5K GitHub stars and 7.78K GitHub forks.

According to the StackShare community, Node.js has a broader approval, being mentioned in 4102 company stacks & 4028 developers stacks; compared to Rails, which is listed in 2321 company stacks and 796 developer stacks.

Decisions about Node.js and Rails

We choose Next.js for our React framework because it's very minimal and has a very organized file structure. Also, it offers key features like zero setups, automatic server rendering and code splitting, typescript support. Our app requires some loading time to process the video, server-side rendering will allow our website to display faster than client-side rending.

See more
Ing. Alvaro RodrĂ­guez Scelza
Software Systems Engineer at Ripio · | 11 upvotes · 50.1K views

I was considering focusing on learning RoR and looking for a work that uses those techs.

After some investigation, I decided to stay with C# .NET:

  • It is more requested on job positions (7 to 1 in my personal searches average).

  • It's been around for longer.

  • it has better documentation and community.

  • One of Ruby advantages (its amazing community gems, that allows to quickly build parts of your systems by merely putting together third party components) gets quite complicated to use and maintain in huge applications, where building and reusing your own components may become a better approach.

  • Rail's front end support is starting to waver.

  • C# .NET code is far easier to understand, debug and maintain. Although certainly not easier to learn from scratch.

  • Though Rails has an excellent programming speed, C# tends to get the upper hand in long term projects.

I would avise to stick to rails when building small projects, and switching to C# for more long term ones.

Opinions are welcome!

See more
Hampton Catlin
VP of Engineering at Rent The Runway · | 7 upvotes · 68.9K views

Starting a new company in 2020, with a whole new stack, is a really interesting opportunity for me to look back over the last 20 years of my career with web software and make the right decision for my company.

And, I went with the most radical decision– which is to ignore "sexy" / "hype" technologies almost entirely, and go back to a stack that I first used over 15 years ago.

For my purposes, we are building a video streaming platform, where I wanted rapid customer-facing feature development, high testability, simple scaling, and ease of hiring great, experienced talent. To be clear, our web platform is NOT responsible for handling the actual bits and bytes of the video itself, that's an entirely different stack. It simply needs to manage the business rules and the customers experience of the video content.

I reviewed a lot of different technologies, but none of them seemed to fit the bill as well as Rails did! The hype train had long left the station with Rails, and the community is a little more sparse than it was previously. And, to be honest, Ruby was the language that was easiest for developers, but I find that most languages out there have adopted many of it's innovations for ease of use – or at least corrected their own.

Even with all of that, Rails still seems like the best framework for developing web applications that are no more complex than they need to be. And that's key to me, because it's very easy to go use React and Redux and GraphQL and a whole host of AWS Lamba's to power my blog... but you simply don't actually NEED that.

There are two choices I made in our stack that were new for me personally, and very different than what I would have chosen even 5 years ago.

1) Postgres - I decided to switch from MySql to Postgres for this project. I wanted to use UUID's instead of numeric primary keys, and knew I'd have a couple places where better JSON/object support would be key. Mysql remains far more popular, but almost every developer I respect has switched and preferred Postgres with a strong passion. It's not "sexy" but it's considered "better".

2) Stimulus.js - This was definitely the biggest and wildest choice to make. Stimulus is a Javascript framework by my old friend Sam Stephenson (Prototype.js, rbenv, turbolinks) and DHH, and it is a sort of radical declaration that your Javascript in the browser can be both powerful and modern AND simple. It leans heavily on the belief that HTML-is-good and that data-* attributes are good. It focuses on the actions and interactions and not on the rendering aspects. It took me a while to wrap my head around, and I still have to remind myself, that server-side-HTML is how you solve many problems with this stack, and avoid trying to re-render things just in the browser. So far, I'm happy with this choice, but it is definitely a radical departure from the current trends.

See more
Pros of Node.js
Pros of Rails
  • 1.4K
    Npm
  • 1.3K
    Javascript
  • 1.1K
    Great libraries
  • 1K
    High-performance
  • 789
    Open source
  • 477
    Great for apis
  • 467
    Asynchronous
  • 414
    Great community
  • 385
    Great for realtime apps
  • 290
    Great for command line utilities
  • 77
    Node Modules
  • 75
    Websockets
  • 65
    Uber Simple
  • 53
    Great modularity
  • 53
    Allows us to reuse code in the frontend
  • 38
    Easy to start
  • 33
    Great for Data Streaming
  • 29
    Realtime
  • 25
    Awesome
  • 23
    Non blocking IO
  • 16
    Can be used as a proxy
  • 15
    High performance, open source, scalable
  • 14
    Non-blocking and modular
  • 13
    Easy and Fun
  • 12
    Same lang as AngularJS
  • 11
    Easy and powerful
  • 10
    Future of BackEnd
  • 9
    Fast
  • 8
    Cross platform
  • 8
    Scalability
  • 6
    Mean Stack
  • 6
    Fullstack
  • 6
    Simple
  • 5
    Easy concurrency
  • 5
    Great for webapps
  • 4
    Easy to use and fast and goes well with JSONdb's
  • 4
    Friendly
  • 4
    React
  • 4
    Fast, simple code and async
  • 4
    Typescript
  • 3
    Its amazingly fast and scalable
  • 3
    Isomorphic coolness
  • 3
    Great speed
  • 3
    Scalable
  • 3
    Control everything
  • 3
    Fast development
  • 2
    One language, end-to-end
  • 2
    Scales, fast, simple, great community, npm, express
  • 2
    TypeScript Support
  • 2
    Easy to learn
  • 2
    Easy to use
  • 2
    It's fast
  • 2
    Less boilerplate code
  • 2
    Blazing fast
  • 2
    Not Python
  • 2
    Performant and fast prototyping
  • 2
    Sooper easy for the Backend connectivity
  • 2
    Great community
  • 1
    Easy
  • 1
    Lovely
  • 0
    Event Driven
  • 0
    Javascript2
  • 845
    Rapid development
  • 647
    Great gems
  • 603
    Great community
  • 478
    Convention over configuration
  • 416
    Mvc
  • 349
    Great for web
  • 344
    Beautiful code
  • 311
    Open source
  • 270
    Great libraries
  • 260
    Active record
  • 105
    Elegant
  • 87
    Easy to learn
  • 85
    Easy Database Migrations
  • 77
    Makes you happy
  • 72
    Free
  • 62
    Great routing
  • 53
    Has everything you need to get the job done
  • 41
    Great Data Modeling
  • 38
    Beautiful
  • 38
    MVC - Easy to start on
  • 35
    Easy setup
  • 26
    Great caching
  • 25
    Ultra rapid development time
  • 22
    It's super easy
  • 17
    Great Resources
  • 16
    Easy to build mockups that work
  • 14
    Less Boilerplate
  • 7
    API Development
  • 7
    Developer Friendly
  • 6
    Great documentation
  • 5
    Easy REST API creation
  • 5
    Quick
  • 4
    Haml and sass
  • 4
    Intuitive
  • 4
    Easy to learn, use, improvise and update
  • 4
    Great language
  • 2
    Legacy
  • 2
    Jet packs come standard
  • 2
    Easy and fast
  • 2
    Metaprogramming
  • 2
    It works
  • 1
    It's intuitive
  • 1
    Cancan
  • 1
    Easy Testing
  • 1
    Convention over configuration

Sign up to add or upvote prosMake informed product decisions

Cons of Node.js
Cons of Rails
  • 46
    Bound to a single CPU
  • 37
    New framework every day
  • 33
    Lots of terrible examples on the internet
  • 28
    Asynchronous programming is the worst
  • 22
    Callback
  • 16
    Javascript
  • 11
    Dependency based on GitHub
  • 10
    Dependency hell
  • 10
    Low computational power
  • 7
    Can block whole server easily
  • 6
    Callback functions may not fire on expected sequence
  • 6
    Very very Slow
  • 3
    Unneeded over complication
  • 3
    Breaking updates
  • 3
    Unstable
  • 1
    No standard approach
  • 20
    Too much "magic" (hidden behavior)
  • 13
    Poor raw performance
  • 11
    Asset system is too primitive and outdated
  • 6
    Bloat in models
  • 6
    Heavy use of mixins
  • 3
    Very Very slow

Sign up to add or upvote consMake informed product decisions

What is Node.js?

Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

What is Rails?

Rails is a web-application framework that includes everything needed to create database-backed web applications according to the Model-View-Controller (MVC) pattern.

Need advice about which tool to choose?Ask the StackShare community!

What companies use Node.js?
What companies use Rails?

Sign up to get full access to all the companiesMake informed product decisions

What tools integrate with Node.js?
What tools integrate with Rails?

Sign up to get full access to all the tool integrationsMake informed product decisions

Blog Posts

Oct 24 2019 at 7:43PM
https://img.stackshare.io/stack/513891/default_86b138c409d64e353c3d509121b4ac1dd9cf31c4.png logo

AppSignal

JavaScriptNode.jsJava+8
5
660
Oct 3 2019 at 7:13PM
https://img.stackshare.io/stack/511159/default_5f04358e03a27bf2607a39dd9b409dd7830ce4d3.png logo

Ably Realtime

JavaScriptPythonNode.js+8
4
3130
Node.jsnpmKubernetes+6
1
1065
GitNode.jsFirebase+5
7
1488
Jun 6 2019 at 5:11PM
https://img.stackshare.io/stack/372376/default_573a26a621134fbcbde85e58b2c8544189ae0fba.jpg logo

AppSignal

RedisRubyKafka+9
15
1044
What are some alternatives to Node.js and Rails?
AngularJS
AngularJS lets you write client-side web applications as if you had a smarter browser. It lets you use good old HTML (or HAML, Jade and friends!) as your template language and lets you extend HTML’s syntax to express your application’s components clearly and succinctly. It automatically synchronizes data from your UI (view) with your JavaScript objects (model) through 2-way data binding.
PHP
Fast, flexible and pragmatic, PHP powers everything from your blog to the most popular websites in the world.
Python
Python is a general purpose programming language created by Guido Van Rossum. Python is most praised for its elegant syntax and readable code, if you are just beginning your programming career python suits you best.
JavaScript
JavaScript is most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic,and supports object-oriented, imperative, and functional programming styles.
React
Lots of people use React as the V in MVC. Since React makes no assumptions about the rest of your technology stack, it's easy to try it out on a small feature in an existing project.
See all alternatives
Interest over time