Django vs. Node.js: Comparing Web Frameworks and Runtime Environments

When it comes to building websites, there are many technologies to choose from. Some heavy favorites include Django and Node.js. But comparing these two technologies is like comparing apples to oranges. Both make building websites easier, but the similarities end there.

Django is an open-source, Python-based web framework. Node.js is a runtime environment used for running JavaScript code. If you’re new to programming, you might be thinking: “What the heck is a runtime environment!?” Fear not, Friend. I’ll explain what Django and Node.js are and why you might want to use them. Read on. 

But first, Python

Wikipedia refers to Python as an interpreted, high-level, and general-purpose programming language. Python is useful for many things, including task automation, data processing, desktop and web apps, artificial intelligence, and building websites.

But what does high-level and interpreted mean? All programming languages are either high level or low level. The higher the level of language, the easier it is for humans to understand. The lower the level, the easier it is for computers to understand.

High-low level languages.

High-level languages exist to make it easier for humans to write code. But all code must convert to a low-level language for it to work on a computer. This is where the interpreted part comes in.

There are two ways to convert high-level programming languages to low-level ones. The first is to translate high-level to low-level by compiling the code using a compiler. A compiler works by taking the code and converting it into a low-level language that the computer can run.

If you have a large application, the compiling process can take a long time (minutes or even hours). You need to wait for the compiling process to complete each time you want to test changes to your code. This slows down software development. Not good.

The second way is to use an interpreter. An interpreter is an application that you install before you run your code. If you want to run Python code, you need to install the Python interpreter. (This is the same for any high-level language, like Ruby, for instance.)

With interpreted languages, compiling happens when the code runs. This speeds up the development cycle because you don’t need to compile your whole project before testing it. You simply run the code, and the interpreter will do the compiling in real-time.

What is Django?

Django is a Python web framework. Web frameworks make building websites easier by providing website functionality out-of-the-box. Let’s take HyperText Transfer Protocol, or HTTP for short, for example. All websites need to handle requests from a web browser using HTTP Protocol. (This is why all websites addresses start with “HTTP.”)

With Python, you could build this functionality from scratch. Or you could save time by using a web framework that provides this functionality for you, like Django.

For an in-depth exploration of Django, check out What is Django? Meet Python’s All-Star Web Framework.

What is JavaScript?

To understand Node.js, we must first speak of JavaScript (JS). JavaScript is another popular programming language with many uses. Almost every website uses JavaScript to provide some form of functionality. JavaScript validates user inputs, provides interactive chat, data visualizations, and analytical tracking. Any time you interact with a website, JavaScript is at play.

An example of a feature built using JavaScript.

Unlike Python, which runs on your computer’s operating system, JavaScript runs inside the web browser, on the client-side. 

JavaScript is a highly popular language, so many developers have experience with it. But this experience only allowed developers to create apps in the browser. That is until Node.js came along…

JavaScript usage is limited to the web browser.

Introducing Node.js

Node.js is not a programming language or a framework; it is a JavaScript runtime environment. The name runtime is confusing because it has many meanings in programming. Like how long it takes for a program to run, for instance. When it comes to Node.js, the runtime environment implements the functions built into a programming language.

Node.js expands on the potential of JavaScript. It enables you to build applications not in the browser but on Windows, macOS, or Linux operating systems. This empowers developers to build entire architectures in a single language.

Node.js is the key to unlocking the full potential of JavaScript.

Node.js takes the V8 JavaScript engine—the Google Chrome browser component that runs JavaScript—and repurposes it to run JavaScript on a computer.

The V8 JavaScript engine works by compiling JavaScript (a high-level programming language) into a low-level language that the machine can understand. This is exactly what the Python interpreter does, too. This is why — in my humble opinion — it’s better to compare Node.js to Python than it is to Django.

And compare we shall…

Node.js vs. Python: apples and pears

Even though JavaScript is popular, it has a reputation for being a bit of a diva to work with. In my experience, this boils down to its dramatic history.

A brief history of JavaScript (Browser Wars)

History is boring to some, and I get it. But this chronology will help you better understand JavaScript and Node.js.

1990s

• The Netscape Navigator web browser (now defunct) launches JavaScript as a feature to add dynamic behavior to websites. (Things that change and move on a web page without you having to reload. This helps to make websites interactive, rather than static pages on a screen.)
• Competing with Netscape, Microsoft launches its own web browser: Internet Explorer.
• Microsoft reverse engineered its version of JavaScript, JScript, to allow JavaScript websites to load in their browser. JScript is a far cry from JavaScript, leading to many broken websites and compatibility issues.
• Netscape submits JavaScript to standards organization ECMA International to create a common standard of JavaScript so it can work across all browsers.
• Microsoft initially participates in the development of this standard.

2000s

• Internet Explorer gains 95% of web browser market share, Microsoft pulls out of the standardization project.
• The Mozilla Firefox browser launches and eats into Internet Explorer’s market share.
• Mozilla joins ECMA international work on various JavaScript alternatives.
• Google launches Chrome in 2008. Powered by the V8 JavaScript, Chrome outperforms competitors.
• In 2009, all companies agree to combine their relevant work, resulting in the ECMAScript 5 standard.

(The above timeline is from Wikipedia. You can find the full chronology of events here.)

JavaScript’s background helps to understand its various quirks and questionable design choices. It also helps to explain why so many developers use JavaScript only when necessary.

Python, in contrast, had a more consistent upbringing with far less drama. Guido van Rossum created Python in 1980 and led the project until 2018. The Python Software Foundation currently maintains it, now focusing on improving the language through developer input, robust documentation, frequent bug fixes, and transparent design decisions.

Python is much easier for developers to use, too. It runs on computers using the Python interpreter and prioritizes code readability.

Many developers prefer Python over JavaScript when writing backend server side code. But Node.js still plays an important role in software development. In fact, there is one area where it truly excels…

Blocking vs. non-blocking I/O model

We’re getting technical now, but this will help you understand the differences behind the technologies. In Python, each line of code executes in order. We call this blocking (or synchronous) code execution. Imagine we have a Python application for sending a movie file to a user. The sequence might look like this:

Flow diagram of a movie request (using rough numbers to demonstrate the point)

The first two parts of the process—receiving the request and opening the file—take very little time (2ms). But the last detail—sending data to the user—takes 15 minutes. Python code executes in order. This means an application must complete a request before it can receive another. Assuming it takes 15 minutes to send the movie file to a user, this means we can handle a new request every 15 minutes.

Imagine if there was a 15-minute delay every time you clicked on a YouTube video? In the programming world, this is what we call unscalable.

Python’s solution to this problem is multi-threading. This is where many instances of the same application run at the same time, like having many browser windows open on your computer. Applications running in different threads cannot communicate with each other. This leads to problems, such as deleting a file another thread is using.

Node.js has an advantage over Python when it comes to handling asynchronous event-driven non-blocking code. This is when an event, like a user request, triggers many pieces of code to execute at the same time. Node.js code runs in a single thread and uses something called the event loop. The event loop can focus on handling incoming requests.

Time-intensive operations, like network transfers, can be managed using callback functions. Callback functions work by executing code and telling it to call another function once the task finishes. Like calling a customer service line, but instead of being on hold, you provide a call back number so they can reach you. 

With Node.js, the movie file example we’ve been talking about would instead look like this:

Flow diagram using asynchronous code.

Sending data to various users happens asynchronously. This means the application can handle more requests while the data is transferring.

Node.js is great for building real-time applications that handle long-running processes in an asynchronous fashion.

So, which one should you use?

Django and Node.js are different technologies used for different purposes. Their strengths complement each other, and often they are both used together to deliver a great user experience. Here are some examples of when you would use them.

Using only Node.js

If you’re familiar with JavaScript and want to build something swiftly, then Node.js is a great choice. There are many web frameworks available for Node.js, such as Express, Koa, and Meteor. These are perfect if you want to build a quick prototype or a small app that doesn’t need a lot of backend server code.

But keep in mind that using JavaScript on the backend can sometimes be unpredictable and difficult to debug. So, it may not be ideal for complex apps that need to scale.

Using Django only

If you’re building a website that requires backend code scalability, consider using Django. When it comes to the rapid development of apps serving web pages at a large scale, Django is one of the best options available. It’s tried and tested, feature-rich, secure, and well supported by a growing community of Python developers.

Using Django and Node.js together

Building a web app that handles lots of requests and real-time data connectivity with complex backend code? Consider using both Django and Node.js together. If you are making an online learning platform like Udemy.com, combining Node.js with Django would provide the best user experience.

You could build the website using Django. This would take care of the main features like browsing courses, user registration, login, payments, and course enrolment. But for something like video streaming, Node.js would be an added benefit. 

Any way you slice it, learning the nuances of Django and Node.js and how they work together helps you as a developer. 

Want to learn more about Python? We cover all the details in our course: Python for Beginners: Learn how to code properly in 2021.