Share

Reposted From Medium

Like the Node community itself, things are moving at a lightning pace at NodeSource with literally everyone at the company completely engaged: consulting or training with customers, developing our new suite of enterprise Node tools, and participating in community activities and projects.

We have, however, taken some time to reflect on the progress that Node and NodeSource has made in the past year and to share that with the community in the form of our newly published white paper, The State of Node in the Enterprise. The paper provides our perspective on the role of Node in enterprise development, common factors of successful implementations, and how NodeSource can help you get there.

Here’s an excerpt:

The Essence of Node

The growing popularity of Node is the result of a confluence of factors. First, there is an increasing need to quickly build fast, scalable, distributed web applications. Second, there is inherent risk associated with running large, complex monolithic applications. Third, software developers are looking to develop a skill set that has lasting value in the job market.

In order to understand how gains can be achieved using Node, it is important to understand what makes it so unique and powerful.

JavaScript on the Server

At the most basic level, Node is a platform for running JavaScript on the server. There are some key benefits associated with this model. First, there is already a large JavaScript developer community that is building some of the world’s most exciting web applications. Second, JavaScript consistently ranks among the most popular programming languages. “Developer joy” is a common theme for Node and this largely relates to JavaScript’s approachability and the high levels of productivity it affords.

JavaScript on the server with Node further establishes it as the language of the web and its new uses on the server are helping to shape the future of the language itself.

Asynchronous Programming

Node requires developers to embrace a different mindset in the form of asynchronous programming — as opposed to the traditional serial, or sequential programming.By treating I/O as a special class of operation, developers must design highly performant applications by default, but it does come with the burden of adjusting the way the programmer thinks about the execution of their code. Node is single-threaded by nature, and while some consider this a weakness, it should instead be embraced as a win for application design.

Applications built with Node are built for predictable scalability; the idiomatic design patterns adopted by Node programmers confer robust scalability by nature without the overhead required by complicated synchronization mechanisms.
JavaScript — and Node by extension — was designed for the web and the browser, where nothing is synchronous. Asynchronous JavaScript programs can perform many complex, parallel tasks in the browser. Node takes asynchronicity to the extreme on the server, making it the perfect choice for I/O-heavy and highly concurrent applications.

Module-driven Development

Node is a highly productive platform that is modular by nature and has a track record as a key component in an agile technology stack. Node embraces the new mantra of “Throw-awayability” that is becoming pervasive in the services oriented software design world. Node encourages developers to think in terms of creating small services that can be easily replaced or updated when necessary.

By adopting a module-driven approach, Node developers can deconstruct the functionality of large monolithic applications and redesign them as a series of Node modules, bundled together to form a collection of services. This establishes an elegant simplicity in building scalable application functionality that improves both business and developer agility and leads to greater code-reuse.

Small Core, Vibrant Ecosystem

The main risk in large monolithic applications and traditional development methods is the natural mission creep of applications and the development environments that build them. Over time this results in feature rich but bloated products.

Node avoids this scenario by creating a small core of essential functionality that is studiously defended and constantly debated by the Node community. This pushes experimentation to the edges and encourages a vibrant ecosystem and development culture. It also ensures that spurious functionality does not become a permanent part of the Node environment. This ethos also extends to Node-style development, with developers constantly thinking about how to keep modules small and focused and splitting apart functionality where the “do one thing well” rule is broken.

New Models in Open Source

Most IT organizations now realize the increasing difficulty of modernizing their approach to development and operations without embracing open source technology to some degree. Gartner predicts that by 2016, “the vast majority of mainstream IT organizations will leverage non-trivial elements of open source software” in mission-critical solutions.
Node was born in the new era of open source, embodied by the GitHub model of developer interaction, collaboration and governance. Both Node and GitHub allow for a public and private open source development platform that empowers a growing, global community of developers.
Enterprises adopting Node are generally seeking to capture some of the obvious benefits of open source development practices and ethos. The culture and development workflow of Node encourages greater collaboration, communication and code-sharing — engineering practices that often go missing as enterprises grow and change over time.

Read On

The above excerpt is an abridged version of the first section of the white paper. The rest of the paper is the product of our work in the Node community and the experience gained from customer engagements. We hope you find it useful.
Read the paper

Contributors: Rod Vagg, Dan Shaw, Joe McCann