## 1. Bất đồng bộ

Khi người ta giải quyết ["c10k problem"](http://www.kegel.com/c10k.html) và sau đó là sự ra đời của Nginx, lập trình bất đồng bộ được quan tâm hơn và ngày càng được cải thiện để dễ dàng cài đặt hơn so với phiên bản gốc của nó.

Ở phiên bản gốc, bạn phải biết những khái niệm như non-blocking socket, multiplexer, selector, ... của OS để có thể triển khai một ứng dụng xử lí bất đồng bộ:

```c 
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    perror("socket");
    exit(1);
}
	
last_fd = sockfd;

my_addr.sin_family = AF_INET;         /* host byte order */
my_addr.sin_port = htons(MYPORT);     /* short, network byte order */
my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */
bzero(&(my_addr.sin_zero), 8);        /* zero the rest of the struct */

if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
    perror("bind");
    exit(1);
}

if (listen(sockfd, BACKLOG) == -1) {
    perror("listen");
    exit(1);
}

if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
	perror("accept");
}

fcntl(last_fd, F_SETFL, O_NONBLOCK); /* Change the socket into non-blocking state	*/
fcntl(new_fd, F_SETFL, O_NONBLOCK); /* Change the socket into non-blocking state	*/

	while(1){
		for (i=sockfd;i<=last_fd;i++){
			printf("Round number %d\n",i);
       			if (i = sockfd){
                ...
```
Giờ đây, chuyện đó "dễ như trở bàn tay" nhờ sự cải tiến vượt trội về mặt cú pháp.
Cú pháp async/await được [giới thiệu lần đầu bởi C#](https://en.wikipedia.org/wiki/Async/await) và sau đó được nhiều ngôn ngữ lập trình khác triển khai như Javascript, Python, Java, C++, Rust, Swift,...

"Kĩ thuật lập trình" bất đồng bộ chuyển sang "cú pháp của ngôn ngữ lập trình".

## 2. Bất đồng bộ trong Python trước PEP 492

Xử lí bất đồng bộ trong Python là hoàn toàn có thể do Python hỗ trợ các API non-blocking socket của OS như selector, multiplexing,... Tuy nhiên, sử dụng các API này để triển khai một ứng dụng bất đồng bộ khá khó khăn.

```python 
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(("0.0.0.0", port_number))
server_socket.listen(max_clients)

inputs = [server_socket]
outputs = []

while True:
        readable, writable, exceptional = select.select(inputs, outputs, inputs, 1)
        for s in readable:
                if s is server_socket:
                connection, client_address = s.accept()
                connection.setblocking(0)
                inputs.append(connection)
                threading.Thread(target=handle_client, args=(connection, client_address)).start()
```

Do đó, những lập trình viên trong cộng đồng đã kết hợp những API đó với coroutine để thực hiện việc triển khai bất đồng bộ.

Coroutine là một khái niệm phổ biến trong rất nhiều ngôn ngữ lập trình và lần đầu được giới thiệu trong Python với [PEP 342](https://peps.python.org/pep-0342/) do Guido van Rossum và Phillip J. Eby đề xuất vào năm 2005 trong phiên bản Python 2.5.

Nếu muốn hiểu rõ hơn việc sử dụng coroutine để triển khai lập trình bất đồng bộ như thế nào, các bạn có thể đọc 2 bài viết dưới đây của mình để biết chi tiết hơn:

- [Bất đồng bộ trong Python - Coroutine | Phần 1](/posts/asynchronous-in-python-part-1)
- [Bất đồng bọ trong Python - Event loop | Phần 2](/posts/bat-dong-bo-trong-pythonphan-2-event-loop)

Một trong những framework nổi tiếng triển khai xử lí bất đồng bộ là [Tornado](https://en.wikipedia.org/wiki/Tornado_(web_server)). 
Tornado là một networking framework triển khai bất đồng bộ trên coroutine cho những mục đích:
- TCP/UDP server
- HTTP server và HTTP client
- Mail server 

## 3. Sự ra đời của PEP 492 và kỉ nguyên async/await

Vào năm 2015, PEP 492 ra đời do Yury Selivanov đề xuất. Với việc sử dụng coroutine để thực hiện cú pháp của async/await, Python đã có thể thực hiện các toán tử bất đồng bộ trở nên dễ dàng hơn rất nhiều cho lập trình viên.

Thay vì phải làm việc với các low-level API, làm việc với coroutine thuần túy, giờ đây, chúng ta chỉ cần biết đến 2 keyword vô cùng phổ biến trong các ngôn ngữ lập trình: `async/await`.

```python 
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.setblocking(False)
listener.bind((host, port))
listener.listen(1024)

loop = asyncio.get_event_loop()
while True:
    client, addr = await loop.sock_accept(listener)
    loop.create_task(handle_client(client))
```

Tác giả cũng nêu rõ lí do khi thiết kế cú pháp `async/await` như sau:
> The growth of Internet and general connectivity has triggered the proportionate need for responsive and scalable code. This proposal aims to answer that need by making writing explicitly asynchronous, concurrent Python code easier and more Pythonic.

Như đã nói ở trên, bản thân `async/await` chỉ là cú pháp với mục đích làm cho code trở nên dễ đọc. Những gì thực sự được xử lí đằng sau nó là coroutine nên không sai khi nói rằng, asynchronous của Python được hiện thực hóa bởi coroutine.


## 4. ASGI và sự trỗi dậy của webserver bất đồng bộ

Trước khi ASGI được sinh ra, WSGI là tiêu chuẩn phổ biến để ứng dụng web giao tiếp với webserver. Tiêu chuẩn này được giới thiệu bởi [PEP 333](https://peps.python.org/pep-0333/) vào cuối năm 2003. Nó tập trung phát triển giao diện dựa trên API đồng bộ của network: blocking. Do đó, để thực hiện scale hiệu năng, multi-thread được sử dụng kết hợp, tương tự như trường hợp của Apache HTTP Server.

Chúng ta có các webserver triển khai tiêu chuẩn này như [Gunicorn](https://gunicorn.org), [uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/) hay Nginx với sự hỗ trợ của module [ngx_http_uwsgi_module](https://nginx.org/en/docs/http/ngx_http_uwsgi_module.html).

Một số web framework triển khai tiêu chuẩn này như [Django](https://www.djangoproject.com), [Flask](https://flask.palletsprojects.com), [Bottle](https://bottlepy.org/docs/dev/),...

Vào tháng 9 - 2018, phiên bản 1.0 của ASGI ra đời, mở đầu cho một kỉ nguyên mới của web development. Với việc ASGI ra đời, một loạt các thư viện và framework hỗ trợ bất đồng bộ ra đời như uvicorn, hypercorn, django v3, fastapi, starlette, quart, sanic,...

Mọi người dần biết tới và sử dụng các framework bất đồng bộ nhiều hơn nhờ sự hỗ trợ của các web framework này.

Với database, chúng ta có: 
- [asyncpg](https://github.com/MagicStack/asyncpg)
- [databases](https://github.com/encode/databases)
- [sqlmodel](https://github.com/tiangolo/sqlmodel)
- [aiomysql](https://github.com/aio-libs/aiomysql)
- [aiopg](https://github.com/aio-libs/aiopg)
- ...

Với http client, ta có thể sử dụng [httpx](https://github.com/encode/httpx), nó có giao diện hoàn toàn giống với [requests](https://requests.readthedocs.io/en/latest/).

Với web framework, chúng ta có:
- [FastAPI](https://github.com/tiangolo/fastapi)
- [Sanic](https://github.com/sanic-org/sanic)
- [Quart](https://github.com/pallets/quart)
- [Starlette](https://github.com/encode/starlette),...
- ...

Với web server có: 
- [unicorn](https://github.com/encode/uvicorn)
- [hypercorn](https://github.com/pgjones/hypercorn)
- ...

Còn rất nhiều thư viện khác đã hỗ trợ bất đồng bộ mà ta có thể sử dụng.

Hiện tại trên Github, một số group đáng quan tâm vền trending này có thể kể đến như:
- [MagicStack](https://github.com/MagicStack)
- [Encode](https://github.com/encode)
- [aio-libs](https://github.com/aio-libs)

Một vài cá nhân đáng chú ý như:

- [@samuelcolvin](https://github.com/samuelcolvin) - tác giả của Pydantic
- [@tiangolo](https://github.com/tiangolo) - tác giả của FastAPI và sqlmodel
- [@tomchristie](https://github.com/tomchristie) - maintainer của nhiều thư viện async như httpx, uvicorn, starlette,...
- [@Marcelo Trylesinski](https://github.com/Kludex) - maintainer của nhiều thư viện như starlette, uvicorn,...
- [@Yury Selivanov](https://github.com/1st1) - tác giả của PEP 492


## 5. Tóm lại

Python thật sự đang có sự thay đổi khá nhiều về mảng web development nói chung và stack xử lí bất đồng bộ - scalable application nói chung.
Hãy cùng điểm qua một vài cột mốc trước khi kết thúc bài viết

- 1991: Python được tạo ra và hỗ trợ low-level API cho non-blocking
- 2003: WSGI ra đời - đánh dấu cho kỉ nguyên web development trên Python
- 2005: PEP 342 giới thiệu về coroutine
- 2015: PEP 492 giới thiệu cú pháp `async/await`
- 2018: ASGI ra đời, đánh dấu kỉ nguyên bùng nổ của các framework bất đồng bộ


Mình hi vọng qua bài viết này, các bạn có thể nắm rõ hơn lịch sử phát triển của hệ sinh thái bất động bộ Python nói chung và sự phát triển cũng như những trending trong phát triển web nói riêng của Python.


#### 1. Độ phủ sóng

Thật khó để đem cái này ra so sánh khi Javascript vừa có thể làm backend và frontend. Trong khi đó, Python có thể làm backend, AI, automation,... Nhưng với một software engineer như mình thì Javascript vẫn có độ phủ sóng cao hơn vì mình chỉ cần học 1 loại cú pháp và giờ mình có thể làm cả frontend và backend :smile:.

#### 2. Cú pháp

Mình là người rất thích cú pháp của C vì tính rõ ràng của nó nên có những cú pháp được mang lên cả Javascript và Python làm mình khá happy.

Nhưng tại sao Javascript có **switch case** còn Python lại không có!!!!.

<Image
  src="https://meme-arsenal.com/memes/7d70b26fc3a93cd663768d1c52a445b5.jpg"
  title="Mấy người nghĩ switch case vô dụng sao!!!"
  height={130}
/>

Một điểm nữa Javascript ăn đứt Python đó là nó cho phép truyền định nghĩa hàm vào tham số của hàm khác. Ok, tôi hiểu nỗi khổ của mấy ông, cũng vì mấy ông đâu có cái này **{ }** để định nghĩa hàm.

```javascript
javascript(function () {
  console.log("Python");
});
```

```python
python(def javascript():???)
```

Tương tự, **lambda** trong Python thì đúng là vô dụng khi nó không thể thực hiện nhiều hơn 1 câu lệnh.

Cân kèo 1 xíu, Python cũng có những điểm mạnh riêng của nó mà Javascript không thể có như

```python
arr = [i for i in range(100)]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ..., 100]
```

Còn ông này thì :/

```javascript
arr = [];
for (let i = 0; i < 100; ++i) {
  arr.push(i);
}
```

Một trong những đặc sản của Javascript là cái thứ của nợ này

```javascript
[0] == ![0]; // true

Array(3) == ",,"; // true

typeof null; // "object"
null instanceof Object; // false

"string" instanceof String; // false
```

#### 3. Tối ưu

Phần này Javascript ăn Python. Javascript làm rất tốt việc tối ưu bộ nhớ. Nó có thể xác định được kiểu của biến và bỏ qua khá nhiều công đoạn giúp nó đạt hiệu quả tính toán cao hơn. Trong khi đó, điều này chỉ có trong các bản Python mở rộng như Pypy chứ cái ông Python thường thì lại không có.

Mọi người có thể đem 2 đoạn mã này ra so sánh

```javascript
function fib(n) {
  if (n < 2) return n;
  return fib(n - 1) + fib(n - 2);
}

const start = Date.now();
fib(40);
console.log(Date.now() - start);
```

Còn đây là Python

```python
from time import time

def fib(n):
  if n < 2:
    return n
  return fib(n-1) + fib(n-2)

start = time();
fib(40)
print(time()-start)
```

Javascript nhanh hơn Python tầm 1.5 lần.

### Vậy, nên dùng cái nào?

Với kinh nghiệm của mình, ai muốn làm web thì học javascript là lợi nhất do nó có thể làm cả backend và frontend. Hơn nữa, việc làm web bằng Javascript có ưu điểm là có rất nhiều builtin tiện lợi cho dân web.

Còn ai muốn học AI, data hay làm mấy tool automation hay thuật toán gì đó thì nên học Python. Đặc biệt, mình thấy Python xử lí string khá ngon và ngắn gọn.

Tóm lại mình viết bài này với lí do là khi chuyển sang Javascript mình thấy nó khá tiện lợi với công việc của mình nên quay lại chù cái thằng Python :smile:.


Trong nhiều năm phát triển, các lập trình viên đã biến Python thành một hệ sinh thái màu mỡ và khiến cho bất cứ công ty công nghệ nào cũng muốn áp dụng nó vào trong các dự án của công ty mình. Vậy Python đã trở nên phổ biến như thế nào?

<Image
  src="/images/GuidoAvatar_400x400.jpg"
  title="Guido van Rossum - cha đẻ của Python"
  height={200}
/>

Python xuất hiện khoảng hơn 30 năm và đúng như chiến lược và mục đích của những nhà sáng lập: tính đơn giản, linh hoạt, khả năng mở rộng cùng với sự phát triển mạnh mẽ của sức mạnh phần cứng đã giúp Python có chỗ đứng vững chắc trên bản đồ thế giới các ngôn ngữ lập trình.

### Python đã chinh phục thế giới lập trình như thế nào?

Như mình đã nói, Python thường được mọi người biết đến là ngôn ngữ cho học máy, khoa học dữ liệu và tính toán khoa học. Thật vậy, trong cộng đồng Python có riêng một hệ sinh thái nổi bật cho lĩnh vực này là [SciPy](https://scipy.org). Đây là một tập hợp các thư viện cho việc tính toán khoa học như:

- NumPy - tính toán đại số và ma trận
- SciPy - tính toán khoa học với các hàm được tối ưu trong Fortran
- matplotlib - sử dụng cho vẽ biểu đồ
- IPython - trình thông dịch cho việc tính toán phân tán
- pandas - xử lí, phân tích các tập dữ liệu dạng chuỗi và bảng

Ngoài ra, ở mảng này, còn có các thư viện cho học máy như Theano, MXnet, Tensorflow, scikit-learn, ...

Vào năm 2003, Phillip J. Eby đề xuất một tiêu chuẩn nhằm cải thiện mảng phát triển web cho Python thay vì sử dụng giao tiếp CGI trước đó. Nó được biết đến với cái tên [PEP333](https://www.python.org/dev/peps/pep-0333/). Nhờ nó, các lập trình viên như có một quy chuẩn để phát triển các ứng dụng web mà không phải lo về vấn đề giao tiếp với webserver. Thời điểm này, có rất nhiều các framework web ra đời và nổi tiếng đến tận ngày nay như Diango(2005), web2py(2007), Bottle(2009), pyramid(2010), Flask(2010).

<Image
  src="/images/logoPython.png"
  title="Biểu tượng của Python"
  height={150}
/>

Khoảng những năm 2015 đến 2016, các thành viên trong core team của Python đã đề xuất một tiêu chuẩn cho phép các nhà phát triển tạo ra các task vụ bất đồng bộ một cách dễ dàng mà không phải phụ thuộc vào các thư viện bên thứ ba khác nhau. Đó là PEP 492 và PEP 530 và mình có giới thiệu về chúng trong <Link href="/posts/bat-dong-bo-trong-python-phan-1-coroutine">bài viết này</Link>. Thật đáng ngưỡng mộ vì khi sinh ra, Python không được định hướng để thực hiện các toán tử async như Javasript hay Go, nhưng quá trình thai nghén làm nền cho việc này đã xuất hiện từ các phiên bản tiền nhiệm và nó có một hiệu năng có thể coi là chấp nhận được.

Mảng tự động hóa hay các framework cho việc kiểm thử cũng trở thành mục tiêu của cộng đồng Python: chúng ta có các ansible, docker, unittest(JUnit trong Python), pytest, nose...

Sự phát triển đó yêu cầu Python phải hỗ trợ các tính năng khác chẳng hạn như phát triển các interface cho các phần mềm bên thứ 3 để các nhà phát triển tích hợp với các ứng dụng của họ như Redis, RabitMQ, background job...

Thực sự, hệ sinh thái của Python là vô cùng lớn và thật hiếm thấy ở một ngôn ngữ nào mà mọi thứ lại đầy đủ như vậy.

Vậy làm sao mà từ một ngôn ngữ, không quá già nhưng cũng không quá trẻ có thể trở thành một đế chế cho tới ngày nay?

### Python làm mình trở nên tốt hơn như thế nào?

Không có thứ gì sinh ra đã là hoàn hảo, có chăng tác giả của Python đã tạo ra một ngôn ngữ mà ngay cả những người chưa từng viết code cũng có thể đọc hiểu những dòng code. Tất cả những gì Python có khi ấy là một cú pháp trong sáng (chắc chỉ kém Pascal :smile:).

Đầu tiên, Python là mã nguồn mở, nơi mà bất cứ ai cũng có thể tham gia phát triển và đóng góp. Sự sáng tạo của các nhà phát triển khắp nơi là những phản hồi quý giá nhất mà Python có. Họ là người thấy được những vấn đề bất tiện, họ có thể đóng góp thầm chí là đề xuất và cài đặt giải pháp, điều này thật tuyệt vời.

Trình thông dịch của Python (standard) được viết hoàn toàn bằng C, điều này đồng nghĩa với việc nó có thể mở rộng bằng mã C - điều mà rất nhiều các ngôn ngữ sau này cũng sử dụng như Java, Javascript, Julia hay Go. Python là ngôn ngữ kiểu động, mọi thứ cần được kiểm tra kĩ lưỡng trước khi thực thi. Chính điều đó vừa là điểm mạnh (linh hoạt) cũng đồng thời là điểm yếu với thời gian xử lí chậm chạp. Bạn có thể mất 20ms cho một phép tính trong C những lại cần 200ms trong Python. Đừng lo, bạn có thể viết chúng trong C và tích hợp vào trình thông dịch của Python như là phần mở rộng, điều đó sẽ giúp bạn đạt được hiệu năng đáng kinh ngạc. Nhưng bạn thấy nó quá khó để viết bằng mã C, đừng lo, vấn đề của bạn cũng là vấn đề của các nhà phát triển khác.
Chúng ta có một công cụ giúp bạn transpile code tựa Python sang C là Cython, nó sẽ giúp bạn đỡ vất vả hơn, điều này thật tuyệt.

<Image
  src="/images/django-hexbin.png"
  title="Django - một trong những web framaework nổi tiếng được viết bằng Python"
  height={150}
/>

Khi chưa có sự tham gia của JS hay Go như bây giờ, các nhà phát triển sử dụng nhiều các thư viện xử lí bất đồng bộ để tăng hiệu năng của Python như dask, eventlet hay curio...

Vào năm 2015, thời điểm phát triển mạnh mẽ của JS với engine V8 đã biến JS trở thành ông vua của thể loại bất động bộ, đặc biệt là các ứng dụng network. Nhận thấy điều này, các nhà phát triển Python đã đề xuất các tiêu chuẩn để Python có thể cạnh tranh với JS ở lĩnh vực này. Họ đã build tính năng này từ đầu và thật kinh ngạc, hiệu năng của nó chẳng thua kém gì người hàng xóm JS cả.

Vậy tóm lại, sự thành công của Python là kết quả của việc luôn làm mới bản thân, có sự đóng góp của chính những người trực tiếp trải nghiệm, hàng loạt các PEP, những hội nghị chia sẻ được tổ chức hằng năm đã đưa Python lên đến thời kì đỉnh cao như bây giờ.

### Vậy Python có phải là viên đạn bạc?

Tuy Python có nhiều lợi thế như vậy nhưng chúng ta không nên áp dụng nó vào mọi lĩnh vực bởi những lí do sau:

- tuy Python có thể mở rộng bằng C nhưng trong một dự án lớn, việc quản lí code tốt lại là vẫn đề cần cân nhắc. Bạn có thể viết bằng C với một hiệu năng thần thánh nhưng bạn không thể quản lí toàn bộ số code đó thì mọi thứ đều trở nên vô nghĩa.
- chính sự sáng sủa, dễ học, dễ đọc của Python nên nó khiến code của bạn có quá nhiều black box. Bạn có các hàm có sẵn những thực sự bạn không biết chúng chạy ra sao, bạn cũng không cần phải khai báo biến mà có thể dụng với bất kì loại giá trị nào. Chính điều đó khiến code của bạn trở nên rối rắm và khó lường.
- việc Python thường xuyên có những cập nhật dẫn đến việc mất tính ổn định và đồng nhất giữa các phiên bản. Bạn phải cân nhắc kĩ lưỡng trước khi nâng cấp lên một phiên bản mới hơn và thường thì nó sẽ có một vài breaking change rất dễ gặp nếu như không đọc kĩ lưu ý của nhà phát triển.

Như vậy, mình đã chia sẻ cho bạn những lí do mà theo mình đã đưa Python đến một vị trí như bây giờ. Hi vọng qua bài viết này, bạn sẽ có cái nhìn chính xác hơn trước khi đưa Python vào dự án của bản thân.


Tag: python

Từ PEP 492 tới kỉ nguyên bất đồng bộ

Python vs Javascript, còn tôi là trọng tài

Python trở nên "tốt" như thế nào?