What are the advantages and disadvantages of Node.js and Python as back-end service programming languages?

1. Characteristics of NodeJS

Let’s first take a look at the introduction on the NodeJS official website:

Node.js?is 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.

Its features are:

1. It is a Javascript running environment

2. It relies on the Chrome V8 engine for code interpretation

3. Event-driven

4. Non-blocking I/O

5. Lightweight, scalable, suitable for real-time data interaction applications

6. Single process , single-threaded

2. The solution to system bottlenecks brought by NodeJS

Its emergence can indeed provide us with new ideas and solutions to solve system bottlenecks in reality, as follows Let's see what problems it solves.

1. Concurrent connections

For example, imagine a scenario where we queue up to handle business at the bank. Let’s look at the following two models.

(1) System thread model:

The problem with this model is obvious. The server has only one thread, and only one concurrent request (user) can be processed when it arrives, and the rest must wait first. , this is blocking, the request currently enjoying the service blocks subsequent requests.

(2) Multi-threading, thread pool model:

This model has improved over the previous one. It adjusts the number of server threads to improve the reception and response to concurrent requests. , but when the concurrency is high, the request still needs to wait, which has a more serious problem. At the code level, let's take a look at the process of client request and server communication:

Every time a connection is established between the server and the client, a set of matching resources must be allocated to the connection, which mainly reflects For system memory resources, taking PHP as an example, maintaining a connection may require 20M of memory. This is why generally when the amount of concurrency is large, you need to open more servers.

So how does NodeJS solve this problem? Let's look at another model and imagine the scene where we order food at a fast food restaurant.

(3) Asynchronous, event-driven model

We also need to initiate a request and wait for the server-side response; but what is different from the bank example is that this time we take it after ordering the meal When we arrive at a number and get the number, we often wait in the seat, and the requests behind us will continue to be processed. Similarly, if we get a number and then wait aside, the receptionist can continue to process it.

When the meal is numbered, the number will be called. We get our own meal and proceed with the subsequent processing (eating). This action of calling a number is called a callback in NodeJS. It can continue to execute the subsequent logic (eating) after the event (cooking, I/O) is completed. This reflects the salient features of NodeJS, asynchronous mechanism and event-driven The whole process does not block the connection of new users (ordering food), and there is no need to maintain the connection between users who have already ordered food and the chef.

Based on this mechanism, in theory, NodeJS can respond to users who request connections one after another. Therefore, NodeJS can support higher concurrency than Java and PHP programs. Although maintaining the event queue also requires costs, due to NodeJS is single-threaded. The longer the event queue is, the longer it takes to get a response. The amount of concurrency will still be insufficient.

To summarize how NodeJS solves the problem of concurrent connections: change the way to connect to the server, each connection emits (emit) an event (Event) running in the NodeJS engine process, and puts it into the event queue , instead of spawning a new OS thread for each connection (and allocating some accompanying memory for it).

2. I/O blocking

Another problem that NodeJS solves is I/O blocking. Look at this business scenario: you need to pull data from multiple data sources, and then for processing.

(1) Serial acquisition of data, this is our general solution, take PHP as an example

If the acquisition of profile and timeline operations each require 1S, then serial acquisition requires 2S.

(2) NodeJS non-blocking I/O, emitting/listening events to control the execution process

NodeJS will create a thread to execute when encountering an I/O event, and then the main thread will The execution continues. Therefore, the action of getting profile triggers an I/O event, and the action of getting timeline will be executed immediately. The two actions are executed in parallel. If each takes 1S, then the total time is 1S. After their I/O operations are completed, an event, profile and timeline are emitted. After receiving the event, the agent continues to execute the subsequent logic. This is the feature of NodeJS non-blocking I/O.

To summarize: Java and PHP also have ways to implement parallel requests (sub-threads), but NodeJS can do it very naturally through callback functions (Callback) and asynchronous mechanisms.

3. Advantages and Disadvantages of NodeJS

Advantages: 1. High concurrency (the most important advantage)

2. Suitable for I/O-intensive applications

p>

Disadvantages: 1. Not suitable for CPU-intensive applications; the main challenges that CPU-intensive applications bring to Node are: due to the single-threading of JavaScript, if there are long-running calculations (such as large loops), This will cause the CPU time slice to be unable to be released, making subsequent I/O unable to be initiated;

Solution: Decompose large computing tasks into multiple small tasks so that the computing can be released in a timely manner without blocking the initiation of I/O calls. ;

2. Only supports single-core CPU and cannot fully utilize the CPU

3. Low reliability. Once a certain link of the code crashes, the entire system will collapse

Cause: single process, single thread

Solution: (1) Nnigx reverse proxy, load balancing, open multiple processes, bind multiple ports;

(2) Open multiple processes to listen to the same port and use the cluster module;

4. The quality of the open source component library is uneven, it updates quickly, and it is not backward compatible

5. Debugging is inconvenient. The error has no stack trace

4. Scenarios suitable for NodeJS

1. RESTful API

This is the most ideal application scenario for NodeJS and can handle tens of thousands of connections. , there is not much logic in itself, you just need to request the API, organize the data and return it. It essentially just looks up some values ??from some database and composes them into a response. Since responses are small amounts of text and inbound requests are small amounts of text, the traffic is not high and a single machine can handle the API needs of even the busiest companies.

2. Unify the UI layer of Web applications

The current MVC architecture, in a sense, Web development has two UI layers, one is in the browser and we finally As you can see, the other one is on the server side, responsible for generating and splicing pages.

I won’t discuss whether this architecture is good or bad, but there is another practice, service-oriented architecture, which can better separate the dependencies of the front and back ends. If all key business logic is encapsulated into REST calls, it means that the upper layer only needs to consider how to use these REST interfaces to build specific applications. Those backend programmers don't care about how specific data is passed from one page to another. They don't care whether user data updates are obtained asynchronously through Ajax or by refreshing the page.

3. Applications with a large number of Ajax requests

For example, in personalized applications, each user will see a different page and the cache will be invalid. Ajax requests need to be initiated when the page is loaded. NodeJS can respond to a large number of concurrent requests. In short, NodeJS is suitable for use in scenarios with high concurrency, I/O intensive, and a small amount of business logic.

Advantages and Disadvantages of Python

Advantages

Simplicity——Python is a language that represents simplicity. Reading a good Python program feels like reading English, even though the English requirements are very strict! This pseudocode nature of Python is one of its greatest strengths. It allows you to focus on solving problems rather than figuring out the language itself.

Easy to learn——As you are about to see, Python is extremely easy to get started. As mentioned earlier, Python has an extremely simple syntax.

Free and open source——Python is one of FLOSS (free/open source software). Simply put, you are free to distribute copies of this software, read its source code, make changes to it, and use parts of it in new free software. FLOSS is based on the concept of a group sharing knowledge. This is one of the reasons why Python is so great - it was created and constantly improved by a group of people who want to see a better Python.

High-level language - When you write a program in Python, you don't need to think about low-level details such as how to manage the memory used by your program.

Portability - Due to its open source nature, Python has been ported to many platforms (with modifications to enable it to work on different platforms). If you are careful to avoid using system-dependent features, then all of your Python programs will run without modification on any of the platforms listed below. These platforms include Linux, Windows, FreeBSD, Macintosh, Solaris, OS/2, Amiga, AROS, AS/400, BeOS, OS/390, z/OS, Palm OS, QNX, VMS, Psion, Acom RISC OS, VxWorks, PlayStation, Sharp Zaurus, Windows CE and even PocketPC, Symbian and Google's Android platform based on Linux!

Explanatory - This point requires some explanation. A program written in a compiled language such as C or C++ can be converted from a source file (i.e., C or C++ language) into a language used by your computer (binary code, i.e., 0s and 1s). This process is done through the compiler and different flags and options. When you run your program, the linker/reloader software copies your program from the hard drive into memory and runs it. Programs written in Python do not need to be compiled into binary code. You can run programs directly from source code. Inside the computer, the Python interpreter converts the source code into an intermediate form called bytecode, which is then translated into the machine language used by the computer and run. In fact, all this makes using Python simpler since you no longer need to worry about how to compile the program, how to ensure that the correct libraries are linked and reproduced, etc. Since you only need to copy your Python program to another computer and it will work, this also makes your Python program more portable.

Object-oriented - Python supports both process-oriented programming and object-oriented programming. In "procedural-oriented" languages, programs are built from procedures or simply functions that are reusable code. In "object-oriented" languages, programs are built from objects that combine data and functionality. Compared to other major languages ??such as C++ and Java, Python implements object-oriented programming in a very powerful and simple way.

Scalability - If you need a critical piece of code to run faster or want certain algorithms to be kept private, you can write part of your program in C or C++, and then add it to your Use them in Python programs.

Embeddability - You can embed Python into your C/C++ program to provide scripting functionality to your program users.

Rich libraries——The Python standard library is indeed huge. It can help you with various tasks, including regular expressions, document generation, unit testing, threads, databases, web browsers, CGI, FTP, email, XML, XML-RPC, HTML, WAV files, password systems, GUI (Graphical User Interface), Tk and other system-related operations. Remember, all of these features are available as long as Python is installed. This is called Python's "full-featured" philosophy. In addition to the standard library, there are many other high-quality libraries, such as wxPython, Twisted, and the Python imaging library, among others.

Summary--Python is indeed a very exciting and powerful language. It combines high performance with features that make writing programs easy and fun.

Standardized code——Python uses forced indentation to make the code extremely readable.

Disadvantages

Forced indentation

This may not be called a limitation, but the way it uses indentation to distinguish statement relationships still brings benefits to many beginners. Comes the confusion. Even experienced Python programmers can fall into traps. The most common situation is that mixing tabs and spaces will cause errors, which cannot be distinguished with the naked eye.

Problems with single-line statements and command line output

Many times the program cannot be written into one line, such as import sys; for i in sys.path:print i. Perl and awk do not have this restriction. They can easily complete simple programs under the shell. They do not need to write the program into a .py file like Python. (For many users, this is not a limitation)

NO.1 Running speed, if you have speed requirements, rewrite the key parts in C++.

NO.2 The domestic market is small (there are currently only a few web2.0 companies that use Python as the main development tool in China). But as time goes by, many domestic software companies, especially game companies, have begun to use it on a large scale.

No.3 There is a lack of Chinese information (there are only a handful of good python Chinese information).

Thanks to the community, several excellent textbooks have been translated, but there are many entry-level textbooks, and advanced content can only be viewed in English.

NO.4 There are too many architecture choices (there is no official .net architecture like C#, and there is no relatively centralized architecture development like ruby ??due to its short history. Ruby on Rails architecture develops small and medium-sized web programs in the world Invincible). However, this also shows from another side that Python is relatively excellent, attracting more talents and many projects.