How to Spot a Good Node.JS Developer?

Node.JS Development Technology

Node.JS is an open source, cross-platform, JavaScript run time environment that executes JavaScript outside of a browser. (courtesy: Wikipedia)

Sounds great.

Node.JS uses an event-driven, non-blocking I/O model that makes it lightweight and efficient.

Sounds even better.

But what does all these mean?

If you are still wondering about it, then please don’t read further. Unless you are passionate about JavaScript. And really want to become a Node.JS Developer.

A Bit about Node.JS

The speed, accessibility and sharing capabilities of Node.JS has made it an incredibly popular platform for creating intuitive and responsive web apps.

Before looking at a Node.JS Developer, it’s important to acknowledge what sets Node.JS apart. According to Amith, Chief Executive Officer, Spericorn, “It is the ecosystem around Node.JS that sets it apart from other platforms. Node is open source and has been the run time choice for developers over the last several years. As the ecosystem grows, so does the ease of use and the ability to deliver quickly.”

You have hundreds and thousands of code packages and modules – code written by developers and accessed publicly – that any developer can use to help build functionalities in web apps they are developing. Absolutely no reinventing the wheel. Fascinating, isn’t it?

Another feature is that while shifting from front-end to back-end development, developers don’t need to switch platforms or worry about compatibility issues because Node.JS Developers can write full stack code.

How Do You Spot a Good Node.JS Developer?

“There are only 10 types of people in this world, those who understand binary and those who don’t.”

From our experience with Node.JS Development projects, we have collated a few points on how to spot a good Node.JS Developer. Some of the characteristics of such a developer is as follows.

Stays Away From Complexity

Let me give you an example of “use-strict” which enforces JavaScript strict mode for modules. It’s just three lines of code.

var module = require(‘module’)
module.wrapper[0] += ‘”use strict”;’
Object.freeze(module.wrap)

This module is written by Isaac Z. Schlueter, the creator of NPM.

The principle of KISS (Keep It Short & Simple) is there for a reason. The human brain can process only 5 to 7 items in its working memory at any given time. Keeping your code in small modules enables you and other developers to understand and test it better. When you write a code at the peak of your mental capacity, it might be hard for you or someone else to understand it later, even for people who are familiar with the intricacies of algorithms. Node.JS uses the asynchronous way and “keeping it simple” really works with it.

Uses Asynchronous Code

Since Node.JS Developers deal with building web applications, they use asynchronous code to avoid blocking threads. Whether you are writing concurrent or non-concurrent systems, a good Node.JS Developer always write asynchronous code.

Avoids Blocking “require”

Node uses CommonJS module format for the module loading system. It has a built-in “require” function which includes modules from separate files. The module loading is done in a synchronous way. A Node.JS Developer understands that “require” is cached. As long as there are no drastic changes to the resolved filename, the code from the module will be executed and loaded in to the variable just once. Thus module loading is optimized which makes Node.JS efficient.

You know that “require” is cached but what’s more interesting is that you can have code outside of the “module.exports.” Knowing that some code might run only once, this feature can turn out to be an advantage for you.

Checks for Errors

You know that Node uses the event loop and executes asynchronously. Errors are separated from the context of any error handler when they occur. Let’s take “try…catch” as an example. If we cannot wrap the request call in a “try…catch” block, then errors will start flowing from request unhandled. Node.JS Developers deal with this by making error as a call back argument. So, you need to manually handle the error in every callback. You do it by checking for an error (make sure it’s not null) and displaying the error message to the user and logging it, or passing it by calling the callback with error.

Another way of dealing with this is the “okay library” to avoid manual error check on innumerable nested callbacks.

Listens to the “error” Events

Most Node objects/classes extends the event emitter and emit the “error” event. This brings developers to an opportunity to identify errors and handle them before it becomes critical.

It might be a good idea to make a habit of creating event listeners for “error” by using “.on():

Understands NPM (Node Package Manager)

NPM, Node.JS’ package ecosystem, is the largest ecosystem of open source libraries in the world. It has packages you can use in your apps to make your development faster. Most of the packages in NPM have dependencies on other libraries. This means packages are modular.

Node.JS Developers know that there is “- - save” (for npm install) which installs a module and creates and entry in “package.json”. Then there is “- - save-dev” for devDependencies. What is probably not a common knowledge is that you can use “– S and – D “ instead of “- - save” and “- - save-dev”.

For locking down dependencies, you may use “shrinkwrap: npm shrinkwrap” which creates a new file with exact versions of dependencies of dependencies.

These are some of the pointers which could tell you if your Node.JS Developer is going to be an asset to your development efforts. There’s no argument on the fact that your development team should be made up of “good” developers. Some of their characteristics are:

• Realization that there are always “bigger trees.” Nobody is irreplaceable and that there is always a better developer.
• Willingness to take responsibility for errors and learn from them.
• Ability to write structured code with a design that can be debugged easily.
• Constantly attempts to understand how things work.
• Ability to keep up with learning new technologies.
• Ability to communicate/cooperate well with other team members.
• Likes problem solving.

There is another parameter which is hard to quantify and which will tell you if your developer is good or not. It’s the quality of code. Mostly organizations and developer teams will have their own ways and systems of judging the quality of code.

Node.JS Developers @ Spericorn

It might look like blowing our own trumpet, but there doesn’t seem to be any other way to say it. Our Node.JS Developers don’t want to simply solve problems, but they strive to find the best method to do it. They always work best on difficult tasks – this is what makes our developers highly productive and they are able to achieve what normal developers can’t. Thanks to this love of challenge, we are on the constant prowl to get challenging assignments because we don’t want to keep them bored!

Our Node.JS team have a strong sense of curiosity and would stop at nothing to find out why something works or doesn’t work. They are so passionate about coding that they program during their spare time, either on side projects or simply trying out new platforms and technologies.

This kindhearted bunch of people takes immense pleasure in helping new programmers to become better. Along with deep knowledge of tools, they are patient enough to explain why things work and make the newbies understand and learn.

If you have a new Node.JS project or just want to understand why things work with Node or don’t, just ask us. We would be more than happy to assist you.