ਹਾਂ, ਵਰਜੀਨੀਆ, ਉੱਥੇ *ਹੈ* ਏ ਸੈਂਟਾ ਕਲੌਸ 2023 ਵਿੱਚ ਵੈੱਬ ਫਰੇਮਵਰਕ ਵਿੱਚ ਅੰਤਰ
ਸਮੱਗਰੀ
- ਜਾਣ-ਪਛਾਣ
- ਟੈਸਟ
- PHP/Laravel
- ਸ਼ੁੱਧ PHP
- ਲਾਰਵੇਲ 'ਤੇ ਮੁੜ ਵਿਚਾਰ ਕਰਨਾ
- ਜੰਜੋ
- ਫਲਾਸਕ
- ਸਟਾਰਲੇਟ
- Node.js/ExpressJS
- ਜੰਗਾਲ/ਐਕਟਿਕਸ
- ਤਕਨੀਕੀ ਕਰਜ਼ਾ
- ਸਰੋਤ
ਜਾਣ-ਪਛਾਣ
ਮੇਰੇ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਨੌਕਰੀ ਇੰਟਰਵਿਊਆਂ ਵਿੱਚੋਂ ਇੱਕ ਤੋਂ ਬਾਅਦ, ਮੈਨੂੰ ਇਹ ਜਾਣ ਕੇ ਹੈਰਾਨੀ ਹੋਈ ਕਿ ਜਿਸ ਕੰਪਨੀ ਲਈ ਮੈਂ ਅਰਜ਼ੀ ਦਿੱਤੀ ਸੀ ਉਹ ਅਜੇ ਵੀ ਲਾਰਵੇਲ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀ ਸੀ, ਇੱਕ PHP ਫਰੇਮਵਰਕ ਜਿਸਦੀ ਮੈਂ ਇੱਕ ਦਹਾਕੇ ਪਹਿਲਾਂ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਸੀ। ਇਹ ਉਸ ਸਮੇਂ ਲਈ ਢੁਕਵਾਂ ਸੀ, ਪਰ ਜੇਕਰ ਤਕਨਾਲੋਜੀ ਅਤੇ ਫੈਸ਼ਨ ਵਿੱਚ ਇੱਕ ਹੀ ਸਥਿਰਤਾ ਹੈ, ਤਾਂ ਇਹ ਸਟਾਈਲ ਅਤੇ ਸੰਕਲਪਾਂ ਦੀ ਨਿਰੰਤਰ ਤਬਦੀਲੀ ਅਤੇ ਮੁੜ ਸੁਰਜੀਤੀ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ JavaScript ਪ੍ਰੋਗਰਾਮਰ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸ਼ਾਇਦ ਇਸ ਪੁਰਾਣੇ ਚੁਟਕਲੇ ਤੋਂ ਜਾਣੂ ਹੋਵੋਗੇ
ਪ੍ਰੋਗਰਾਮਰ 1: "ਮੈਨੂੰ ਇਹ ਨਵਾਂ JavaScript ਫਰੇਮਵਰਕ ਪਸੰਦ ਨਹੀਂ ਹੈ!"
ਪ੍ਰੋਗਰਾਮਰ 2: "ਚਿੰਤਾ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ। ਬਸ ਛੇ ਮਹੀਨੇ ਇੰਤਜ਼ਾਰ ਕਰੋ ਅਤੇ ਇਸਦੀ ਥਾਂ ਲੈਣ ਲਈ ਕੋਈ ਹੋਰ ਹੋਵੇਗਾ!"
ਉਤਸੁਕਤਾ ਦੇ ਕਾਰਨ, ਮੈਂ ਇਹ ਦੇਖਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਕਿ ਅਸਲ ਵਿੱਚ ਕੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਅਸੀਂ ਪੁਰਾਣੇ ਅਤੇ ਨਵੇਂ ਨੂੰ ਟੈਸਟ ਵਿੱਚ ਪਾਉਂਦੇ ਹਾਂ. ਬੇਸ਼ੱਕ, ਵੈਬ ਬੈਂਚਮਾਰਕ ਅਤੇ ਦਾਅਵਿਆਂ ਨਾਲ ਭਰਿਆ ਹੋਇਆ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਧ ਪ੍ਰਸਿੱਧ ਸ਼ਾਇਦ ਹੈ TechEmpower ਵੈੱਬ ਫਰੇਮਵਰਕ ਬੈਂਚਮਾਰਕਸ ਇੱਥੇ . ਹਾਲਾਂਕਿ ਅਸੀਂ ਅੱਜ ਉਨ੍ਹਾਂ ਵਾਂਗ ਲਗਭਗ ਗੁੰਝਲਦਾਰ ਕੁਝ ਨਹੀਂ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ। ਅਸੀਂ ਚੀਜ਼ਾਂ ਨੂੰ ਵਧੀਆ ਅਤੇ ਸਧਾਰਨ ਰੱਖਾਂਗੇ ਤਾਂ ਜੋ ਇਹ ਲੇਖ ਇਸ ਵਿੱਚ ਬਦਲ ਨਾ ਜਾਵੇ ਜੰਗ ਅਤੇ ਸ਼ਾਂਤੀ , ਅਤੇ ਇਹ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਪੜ੍ਹਨ ਦੇ ਸਮੇਂ ਤੱਕ ਜਾਗਦੇ ਰਹਿਣ ਦਾ ਥੋੜ੍ਹਾ ਜਿਹਾ ਮੌਕਾ ਹੋਵੇਗਾ। ਆਮ ਚੇਤਾਵਨੀਆਂ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ: ਇਹ ਤੁਹਾਡੀ ਮਸ਼ੀਨ 'ਤੇ ਇੱਕੋ ਜਿਹਾ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ, ਵੱਖ-ਵੱਖ ਸੌਫਟਵੇਅਰ ਸੰਸਕਰਣ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਸ਼੍ਰੋਡਿੰਗਰ ਦੀ ਬਿੱਲੀ ਅਸਲ ਵਿੱਚ ਇੱਕ ਜੂਮਬੀ ਬਿੱਲੀ ਬਣ ਗਈ ਸੀ ਜੋ ਉਸੇ ਸਮੇਂ ਅੱਧੀ ਜਿੰਦਾ ਅਤੇ ਅੱਧੀ ਮਰੀ ਹੋਈ ਸੀ।
ਟੈਸਟ
ਟੈਸਟਿੰਗ ਵਾਤਾਵਰਣ
ਇਸ ਟੈਸਟ ਲਈ, ਮੈਂ ਆਪਣੇ ਲੈਪਟਾਪ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ, ਜਿਵੇਂ ਕਿ ਇੱਥੇ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।
╰─➤ uname -a
Linux jimsredmi 5.10.174-1-MANJARO #1 SMP PREEMPT Tuesday Mar 21 11:15:28 UTC 2023 x86_64 GNU/Linux
╰─➤ cat /proc/cpuinfo
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 126
model name : Intel(R) Core(TM) i5-1035G1 CPU @ 1.00GHz
stepping : 5
microcode : 0xb6
cpu MHz : 990.210
cache size : 6144 KB
ਹੱਥ ਵਿੱਚ ਕੰਮ
ਸਾਡੇ ਕੋਡ ਵਿੱਚ ਹਰੇਕ ਬੇਨਤੀ ਲਈ ਤਿੰਨ ਸਧਾਰਨ ਕਾਰਜ ਹੋਣਗੇ:
- ਇੱਕ ਕੂਕੀ ਤੋਂ ਵਰਤਮਾਨ ਉਪਭੋਗਤਾ ਦੀ ਸੈਸ਼ਨ ID ਪੜ੍ਹੋ
- ਇੱਕ ਡੇਟਾਬੇਸ ਤੋਂ ਵਾਧੂ ਜਾਣਕਾਰੀ ਲੋਡ ਕਰੋ
- ਉਹ ਜਾਣਕਾਰੀ ਉਪਭੋਗਤਾ ਨੂੰ ਵਾਪਸ ਕਰੋ
ਤੁਸੀਂ ਪੁੱਛ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਕਿਹੋ ਜਿਹਾ ਮੁਹਾਵਰੇ ਵਾਲਾ ਟੈਸਟ ਹੈ? ਖੈਰ, ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਪੰਨੇ ਲਈ ਨੈੱਟਵਰਕ ਬੇਨਤੀਆਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ sessionvars.js ਨਾਮਕ ਇੱਕ ਵੇਖੋਗੇ ਜੋ ਬਿਲਕੁਲ ਉਹੀ ਕੰਮ ਕਰਦਾ ਹੈ।
ਤੁਸੀਂ ਦੇਖਦੇ ਹੋ, ਆਧੁਨਿਕ ਵੈਬ ਪੇਜ ਗੁੰਝਲਦਾਰ ਜੀਵ ਹਨ, ਅਤੇ ਸਭ ਤੋਂ ਆਮ ਕੰਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਡਾਟਾਬੇਸ ਸਰਵਰ 'ਤੇ ਵਾਧੂ ਲੋਡ ਤੋਂ ਬਚਣ ਲਈ ਗੁੰਝਲਦਾਰ ਪੰਨਿਆਂ ਨੂੰ ਕੈਚ ਕਰਨਾ।
ਜੇਕਰ ਅਸੀਂ ਹਰ ਵਾਰ ਇੱਕ ਗੁੰਝਲਦਾਰ ਪੰਨੇ ਨੂੰ ਮੁੜ-ਰੈਂਡਰ ਕਰਦੇ ਹਾਂ ਜਦੋਂ ਕੋਈ ਉਪਭੋਗਤਾ ਇਸਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਪ੍ਰਤੀ ਸਕਿੰਟ ਲਗਭਗ 600 ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸੇਵਾ ਕਰ ਸਕਦੇ ਹਾਂ।
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1/system/index.en.html
Running 10s test @ http://127.0.0.1/system/index.en.html
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 186.83ms 174.22ms 1.06s 81.16%
Req/Sec 166.11 58.84 414.00 71.89%
6213 requests in 10.02s, 49.35MB read
Requests/sec: 619.97
Transfer/sec: 4.92MB
ਪਰ ਜੇ ਅਸੀਂ ਇਸ ਪੰਨੇ ਨੂੰ ਇੱਕ ਸਥਿਰ HTML ਫਾਈਲ ਦੇ ਰੂਪ ਵਿੱਚ ਕੈਸ਼ ਕਰਦੇ ਹਾਂ ਅਤੇ Nginx ਨੂੰ ਇਸ ਨੂੰ ਵਿੰਡੋ ਦੇ ਬਾਹਰ ਉਪਭੋਗਤਾ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਟੌਸ ਕਰਨ ਦਿੰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਪ੍ਰਤੀ ਸਕਿੰਟ 32,000 ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸੇਵਾ ਕਰ ਸਕਦੇ ਹਾਂ, 50x ਦੇ ਇੱਕ ਕਾਰਕ ਦੁਆਰਾ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਵਧਾ ਸਕਦੇ ਹਾਂ.
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1/system/index.en.html
Running 10s test @ http://127.0.0.1/system/index.en.html
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 3.03ms 511.95us 6.87ms 68.10%
Req/Sec 8.20k 1.15k 28.55k 97.26%
327353 requests in 10.10s, 2.36GB read
Requests/sec: 32410.83
Transfer/sec: 238.99MB
ਸਟੈਟਿਕ index.en.html ਉਹ ਹਿੱਸਾ ਹੈ ਜੋ ਹਰ ਕਿਸੇ ਨੂੰ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸਿਰਫ਼ ਉਹ ਹਿੱਸੇ ਜੋ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ sessionvars.js ਵਿੱਚ ਭੇਜੇ ਜਾਂਦੇ ਹਨ। ਇਹ ਨਾ ਸਿਰਫ਼ ਡੇਟਾਬੇਸ ਲੋਡ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਸਾਡੇ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਇੱਕ ਬਿਹਤਰ ਅਨੁਭਵ ਬਣਾਉਂਦਾ ਹੈ, ਸਗੋਂ ਕੁਆਂਟਮ ਸੰਭਾਵਨਾਵਾਂ ਨੂੰ ਵੀ ਘਟਾਉਂਦਾ ਹੈ ਕਿ ਜਦੋਂ ਕਲਿੰਗਨਜ਼ ਹਮਲਾ ਹੁੰਦਾ ਹੈ ਤਾਂ ਸਾਡਾ ਸਰਵਰ ਇੱਕ ਵਾਰਪ ਕੋਰ ਉਲੰਘਣਾ ਵਿੱਚ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਭਾਫ਼ ਬਣ ਜਾਵੇਗਾ।
ਕੋਡ ਦੀਆਂ ਲੋੜਾਂ
ਹਰੇਕ ਫਰੇਮਵਰਕ ਲਈ ਵਾਪਸ ਕੀਤੇ ਕੋਡ ਦੀ ਇੱਕ ਸਧਾਰਨ ਲੋੜ ਹੋਵੇਗੀ: ਉਪਭੋਗਤਾ ਨੂੰ ਦਿਖਾਓ ਕਿ ਉਹਨਾਂ ਨੇ "ਗਿਣਤੀ x ਹੈ" ਕਹਿ ਕੇ ਪੰਨੇ ਨੂੰ ਕਿੰਨੀ ਵਾਰ ਤਾਜ਼ਾ ਕੀਤਾ ਹੈ। ਚੀਜ਼ਾਂ ਨੂੰ ਸਧਾਰਨ ਰੱਖਣ ਲਈ, ਅਸੀਂ ਹੁਣੇ ਲਈ Redis ਕਤਾਰਾਂ, Kubernetes ਕੰਪੋਨੈਂਟਸ, ਜਾਂ AWS Lambdas ਤੋਂ ਦੂਰ ਰਹਾਂਗੇ।
ਹਰੇਕ ਉਪਭੋਗਤਾ ਦਾ ਸੈਸ਼ਨ ਡੇਟਾ ਇੱਕ PostgreSQL ਡੇਟਾਬੇਸ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਵੇਗਾ।
ਅਤੇ ਇਸ ਡੇਟਾਬੇਸ ਸਾਰਣੀ ਨੂੰ ਹਰੇਕ ਟੈਸਟ ਤੋਂ ਪਹਿਲਾਂ ਕੱਟਿਆ ਜਾਵੇਗਾ।
ਸਰਲ ਪਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ Pafera ਦਾ ਆਦਰਸ਼... ਸਭ ਤੋਂ ਹਨੇਰੀ ਸਮਾਂਰੇਖਾ ਤੋਂ ਬਾਹਰ...
ਅਸਲ ਟੈਸਟ ਦੇ ਨਤੀਜੇ
PHP/Laravel
ਠੀਕ ਹੈ, ਇਸ ਲਈ ਹੁਣ ਅਸੀਂ ਆਖਰਕਾਰ ਆਪਣੇ ਹੱਥਾਂ ਨੂੰ ਗੰਦੇ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ। ਅਸੀਂ Laravel ਲਈ ਸੈੱਟਅੱਪ ਨੂੰ ਛੱਡ ਦੇਵਾਂਗੇ ਕਿਉਂਕਿ ਇਹ ਸਿਰਫ਼ ਸੰਗੀਤਕਾਰ ਅਤੇ ਕਾਰੀਗਰਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ ਹੁਕਮ.
ਪਹਿਲਾਂ, ਅਸੀਂ .env ਫਾਈਲ ਵਿੱਚ ਸਾਡੀਆਂ ਡਾਟਾਬੇਸ ਸੈਟਿੰਗਾਂ ਨੂੰ ਸੈੱਟਅੱਪ ਕਰਾਂਗੇ
DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=sessiontest
DB_USERNAME=sessiontest
DB_PASSWORD=sessiontest
ਫਿਰ ਅਸੀਂ ਇੱਕ ਸਿੰਗਲ ਫਾਲਬੈਕ ਰੂਟ ਸੈਟ ਕਰਾਂਗੇ ਜੋ ਸਾਡੇ ਕੰਟਰੋਲਰ ਨੂੰ ਹਰ ਬੇਨਤੀ ਭੇਜਦਾ ਹੈ।
Route::fallback(SessionController::class);
ਅਤੇ ਗਿਣਤੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਕੰਟਰੋਲਰ ਨੂੰ ਸੈੱਟ ਕਰੋ. Laravel, ਮੂਲ ਰੂਪ ਵਿੱਚ, ਡੇਟਾਬੇਸ ਵਿੱਚ ਸੈਸ਼ਨਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਇਹ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ session() ਸਾਡੇ ਸੈਸ਼ਨ ਦੇ ਡੇਟਾ ਦੇ ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ, ਇਸ ਲਈ ਸਾਡੇ ਪੇਜ ਨੂੰ ਰੈਂਡਰ ਕਰਨ ਲਈ ਕੋਡ ਦੀਆਂ ਕੁਝ ਲਾਈਨਾਂ ਦੀ ਲੋੜ ਸੀ।
class SessionController extends Controller
{
public function __invoke(Request $request)
{
$count = session('count', 0);
$count += 1;
session(['count' => $count]);
return 'Count is ' . $count;
}
}
php-fpm ਅਤੇ Nginx ਸੈਟ ਅਪ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸਾਡਾ ਪੰਨਾ ਬਹੁਤ ਵਧੀਆ ਲੱਗ ਰਿਹਾ ਹੈ ...
╰─➤ php -v
PHP 8.2.2 (cli) (built: Feb 1 2023 08:33:04) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.2, Copyright (c) Zend Technologies
with Xdebug v3.2.0, Copyright (c) 2002-2022, by Derick Rethans
╰─➤ sudo systemctl restart php-fpm
╰─➤ sudo systemctl restart nginx
ਘੱਟੋ ਘੱਟ ਜਦੋਂ ਤੱਕ ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਟੈਸਟ ਦੇ ਨਤੀਜੇ ਨਹੀਂ ਵੇਖਦੇ ...
PHP/Laravel
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1
Running 10s test @ http://127.0.0.1
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 1.08s 546.33ms 1.96s 65.71%
Req/Sec 12.37 7.28 40.00 56.64%
211 requests in 10.03s, 177.21KB read
Socket errors: connect 0, read 0, write 0, timeout 176
Requests/sec: 21.04
Transfer/sec: 17.67KB
ਨਹੀਂ, ਇਹ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ। ਸਾਡੀ ਟੈਸਟ ਮਸ਼ੀਨ 600 ਬੇਨਤੀਆਂ ਪ੍ਰਤੀ ਸਕਿੰਟ ਇੱਕ ਗੁੰਝਲਦਾਰ ਪੰਨੇ ਨੂੰ ਰੈਂਡਰ ਕਰਨ ਤੋਂ ਲੈ ਕੇ 21 ਬੇਨਤੀਆਂ ਪ੍ਰਤੀ ਸਕਿੰਟ ਰੈਂਡਰਿੰਗ "ਗਿਣਤੀ 1 ਹੈ" ਹੋ ਗਈ ਹੈ।
ਤਾਂ ਕੀ ਗਲਤ ਹੋਇਆ? ਕੀ ਸਾਡੀ PHP ਸਥਾਪਨਾ ਵਿੱਚ ਕੁਝ ਗਲਤ ਹੈ? ਕੀ php-fpm ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਦੇ ਸਮੇਂ Nginx ਕਿਸੇ ਤਰ੍ਹਾਂ ਹੌਲੀ ਹੋ ਰਿਹਾ ਹੈ?
ਸ਼ੁੱਧ PHP
ਚਲੋ ਇਸ ਪੰਨੇ ਨੂੰ ਸ਼ੁੱਧ PHP ਕੋਡ ਵਿੱਚ ਦੁਬਾਰਾ ਕਰੀਏ।
<?php
// ====================================================================
function uuid4()
{
return sprintf(
'%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
mt_rand(0, 0xffff), mt_rand(0, 0xffff),
mt_rand(0, 0xffff),
mt_rand(0, 0x0fff) | 0x4000,
mt_rand(0, 0x3fff) | 0x8000,
mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
);
}
// ====================================================================
function Query($db, $query, $params = [])
{
$s = $db->prepare($query);
$s->setFetchMode(PDO::FETCH_ASSOC);
$s->execute(array_values($params));
return $s;
}
// ********************************************************************
session_start();
$sessionid = 0;
if (isset($_SESSION['sessionid']))
{
$sessionid = $_SESSION['sessionid'];
}
if (!$sessionid)
{
$sessionid = uuid4();
$_SESSION['sessionid'] = $sessionid;
}
$db = new PDO('pgsql:host=127.0.0.1 dbname=sessiontest user=sessiontest password=sessiontest');
$data = 0;
try
{
$result = Query(
$db,
'SELECT data FROM usersessions WHERE uid = ?',
[$sessionid]
)->fetchAll();
if ($result)
{
$data = json_decode($result[0]['data'], 1);
}
} catch (Exception $e)
{
echo $e;
Query(
$db,
'CREATE TABLE usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)'
);
}
if (!$data)
{
$data = ['count' => 0];
}
$data['count']++;
if ($data['count'] == 1)
{
Query(
$db,
'INSERT INTO usersessions(uid, data)
VALUES(?, ?)',
[$sessionid, json_encode($data)]
);
} else
{
Query(
$db,
'UPDATE usersessions
SET data = ?
WHERE uid = ?',
[json_encode($data), $sessionid]
);
}
echo 'Count is ' . $data['count'];
ਅਸੀਂ ਹੁਣ ਉਹੀ ਕਰਨ ਲਈ ਕੋਡ ਦੀਆਂ 98 ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਜੋ ਲਾਰਵੇਲ ਵਿੱਚ ਕੋਡ ਦੀਆਂ ਚਾਰ ਲਾਈਨਾਂ (ਅਤੇ ਸੰਰਚਨਾ ਦੇ ਕੰਮ ਦਾ ਪੂਰਾ ਸਮੂਹ) ਨੇ ਕੀਤਾ ਹੈ। (ਬੇਸ਼ੱਕ, ਜੇਕਰ ਅਸੀਂ ਸਹੀ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਅਤੇ ਉਪਭੋਗਤਾਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨ ਵਾਲੇ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਕੀਤਾ, ਤਾਂ ਇਹ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਤੋਂ ਦੁੱਗਣਾ ਹੋਵੇਗਾ।) ਸ਼ਾਇਦ ਅਸੀਂ ਇਸਨੂੰ ਪ੍ਰਤੀ ਸਕਿੰਟ 30 ਬੇਨਤੀਆਂ ਤੱਕ ਕਰ ਸਕਦੇ ਹਾਂ?
PHP/Pure PHP
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1
Running 10s test @ http://127.0.0.1
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 140.79ms 27.88ms 332.31ms 90.75%
Req/Sec 178.63 58.34 252.00 61.01%
7074 requests in 10.04s, 3.62MB read
Requests/sec: 704.46
Transfer/sec: 369.43KB
ਵਾਹ! ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਸਾਡੀ PHP ਸਥਾਪਨਾ ਵਿੱਚ ਕੁਝ ਵੀ ਗਲਤ ਨਹੀਂ ਹੈ। ਸ਼ੁੱਧ PHP ਸੰਸਕਰਣ ਪ੍ਰਤੀ ਸਕਿੰਟ 700 ਬੇਨਤੀਆਂ ਕਰ ਰਿਹਾ ਹੈ.
ਜੇ PHP ਵਿੱਚ ਕੁਝ ਵੀ ਗਲਤ ਨਹੀਂ ਹੈ, ਤਾਂ ਸ਼ਾਇਦ ਅਸੀਂ ਲਾਰਵੇਲ ਨੂੰ ਗਲਤ ਢੰਗ ਨਾਲ ਸੰਰਚਿਤ ਕੀਤਾ ਹੈ?
ਲਾਰਵੇਲ 'ਤੇ ਮੁੜ ਵਿਚਾਰ ਕਰਨਾ
ਕੌਂਫਿਗਰੇਸ਼ਨ ਮੁੱਦਿਆਂ ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਸੁਝਾਵਾਂ ਲਈ ਵੈੱਬ ਨੂੰ ਸਕੋਰ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਦੋ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਤਕਨੀਕਾਂ ਹਰ ਬੇਨਤੀ ਲਈ ਉਹਨਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਬਚਣ ਲਈ ਕੌਂਫਿਗਰੇਸ਼ਨ ਅਤੇ ਰੂਟ ਡੇਟਾ ਨੂੰ ਕੈਸ਼ ਕਰਨਾ ਸੀ। ਇਸ ਲਈ, ਅਸੀਂ ਉਨ੍ਹਾਂ ਦੀ ਸਲਾਹ ਲਵਾਂਗੇ ਅਤੇ ਇਹਨਾਂ ਟਿਪਸ ਨੂੰ ਅਜ਼ਮਾਵਾਂਗੇ।
╰─➤ php artisan config:cache
INFO Configuration cached successfully.
╰─➤ php artisan route:cache
INFO Routes cached successfully.
ਕਮਾਂਡ ਲਾਈਨ 'ਤੇ ਸਭ ਕੁਝ ਵਧੀਆ ਲੱਗ ਰਿਹਾ ਹੈ। ਆਓ ਬੈਂਚਮਾਰਕ ਨੂੰ ਦੁਬਾਰਾ ਕਰੀਏ।
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1
Running 10s test @ http://127.0.0.1
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 1.13s 543.50ms 1.98s 61.90%
Req/Sec 25.45 13.39 50.00 55.77%
289 requests in 10.04s, 242.15KB read
Socket errors: connect 0, read 0, write 0, timeout 247
Requests/sec: 28.80
Transfer/sec: 24.13KB
ਖੈਰ, ਅਸੀਂ ਹੁਣ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ 21.04 ਤੋਂ ਵਧਾ ਕੇ 28.80 ਬੇਨਤੀ ਪ੍ਰਤੀ ਸਕਿੰਟ ਕਰ ਦਿੱਤਾ ਹੈ, ਲਗਭਗ 37% ਦਾ ਨਾਟਕੀ ਵਾਧਾ! ਇਹ ਕਿਸੇ ਵੀ ਸਾਫਟਵੇਅਰ ਪੈਕੇਜ ਲਈ ਕਾਫੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੋਵੇਗਾ... ਇਸ ਤੱਥ ਨੂੰ ਛੱਡ ਕੇ ਕਿ ਅਸੀਂ ਅਜੇ ਵੀ ਸ਼ੁੱਧ PHP ਸੰਸਕਰਣ ਦੀਆਂ ਬੇਨਤੀਆਂ ਦੀ ਗਿਣਤੀ ਦਾ 1/24ਵਾਂ ਹਿੱਸਾ ਹੀ ਕਰ ਰਹੇ ਹਾਂ।
ਜੇਕਰ ਤੁਸੀਂ ਸੋਚ ਰਹੇ ਹੋ ਕਿ ਇਸ ਟੈਸਟ ਵਿੱਚ ਕੁਝ ਗਲਤ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਲੁਸਿੰਡਾ PHP ਫਰੇਮਵਰਕ ਦੇ ਲੇਖਕ ਨਾਲ ਗੱਲ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਆਪਣੇ ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਵਿੱਚ, ਉਸ ਨੇ ਲੂਸਿੰਡਾ ਲਾਰਵੇਲ ਨੂੰ ਕੁੱਟ ਰਹੀ ਹੈ HTML ਬੇਨਤੀਆਂ ਲਈ 36x ਅਤੇ JSON ਬੇਨਤੀਆਂ ਲਈ 90x।
ਅਪਾਚੇ ਅਤੇ Nginx ਦੋਵਾਂ ਨਾਲ ਮੇਰੀ ਆਪਣੀ ਮਸ਼ੀਨ 'ਤੇ ਟੈਸਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੇਰੇ ਕੋਲ ਉਸ 'ਤੇ ਸ਼ੱਕ ਕਰਨ ਦਾ ਕੋਈ ਕਾਰਨ ਨਹੀਂ ਹੈ. ਲਾਰਵੇਲ ਅਸਲ ਵਿੱਚ ਸਹੀ ਹੈ ਉਹ ਹੌਲੀ! ਆਪਣੇ ਆਪ ਵਿੱਚ PHP ਇੰਨਾ ਬੁਰਾ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਲਾਰਵੇਲ ਹਰੇਕ ਬੇਨਤੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਵਾਧੂ ਪ੍ਰੋਸੈਸਿੰਗ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਮੈਨੂੰ 2023 ਵਿੱਚ ਲਾਰਵੇਲ ਨੂੰ ਇੱਕ ਵਿਕਲਪ ਵਜੋਂ ਸਿਫਾਰਸ਼ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਲੱਗਦਾ ਹੈ।
ਜੰਜੋ
ਲਈ PHP/Wordpress ਖਾਤੇ ਵੈੱਬ 'ਤੇ ਸਾਰੀਆਂ ਵੈੱਬਸਾਈਟਾਂ ਦਾ ਲਗਭਗ 40% , ਇਸ ਨੂੰ ਹੁਣ ਤੱਕ ਦਾ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਫਰੇਮਵਰਕ ਬਣਾ ਰਿਹਾ ਹੈ। ਹਾਲਾਂਕਿ ਨਿੱਜੀ ਤੌਰ 'ਤੇ, ਮੈਨੂੰ ਪਤਾ ਲੱਗਿਆ ਹੈ ਕਿ ਪ੍ਰਸਿੱਧੀ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਗੁਣਵੱਤਾ ਵਿੱਚ ਅਨੁਵਾਦ ਨਹੀਂ ਕਰਦੀ ਹੈ, ਜਿੰਨਾ ਕਿ ਮੈਂ ਆਪਣੇ ਆਪ ਨੂੰ ਉਸ ਅਸਾਧਾਰਣ ਗੋਰਮੇਟ ਭੋਜਨ ਲਈ ਅਚਾਨਕ ਬੇਕਾਬੂ ਇੱਛਾ ਮਹਿਸੂਸ ਕਰਦਾ ਹਾਂ. ਦੁਨੀਆ ਦਾ ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ ਰੈਸਟੋਰੈਂਟ ... ਮੈਕਡੋਨਲਡਸ ਕਿਉਂਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਸ਼ੁੱਧ PHP ਕੋਡ ਦੀ ਜਾਂਚ ਕਰ ਚੁੱਕੇ ਹਾਂ, ਅਸੀਂ ਖੁਦ Wordpress ਦੀ ਜਾਂਚ ਨਹੀਂ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ, ਕਿਉਂਕਿ Wordpress ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਵਾਲੀ ਕੋਈ ਵੀ ਚੀਜ਼ ਬਿਨਾਂ ਸ਼ੱਕ ਪ੍ਰਤੀ ਸਕਿੰਟ 700 ਬੇਨਤੀਆਂ ਤੋਂ ਘੱਟ ਹੋਵੇਗੀ ਜੋ ਅਸੀਂ ਸ਼ੁੱਧ PHP ਨਾਲ ਵੇਖੀਆਂ ਹਨ।
Django ਇੱਕ ਹੋਰ ਪ੍ਰਸਿੱਧ ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਚੱਲ ਰਿਹਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਅਤੀਤ ਵਿੱਚ ਇਸਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਸ਼ਾਇਦ ਇਸ ਦੇ ਸ਼ਾਨਦਾਰ ਡੇਟਾਬੇਸ ਪ੍ਰਸ਼ਾਸਨ ਇੰਟਰਫੇਸ ਨੂੰ ਯਾਦ ਕਰ ਰਹੇ ਹੋਵੋਗੇ ਅਤੇ ਨਾਲ ਹੀ ਹਰ ਚੀਜ਼ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਸੰਰਚਿਤ ਕਰਨਾ ਕਿੰਨਾ ਤੰਗ ਕਰਨ ਵਾਲਾ ਸੀ ਜਿਸ ਤਰ੍ਹਾਂ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਸੀ। ਆਓ ਦੇਖੀਏ ਕਿ Django 2023 ਵਿੱਚ ਕਿੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਨਵੇਂ ASGI ਇੰਟਰਫੇਸ ਦੇ ਨਾਲ ਜੋ ਇਸ ਨੇ ਵਰਜਨ 4.0 ਵਿੱਚ ਜੋੜਿਆ ਹੈ।
Django ਸੈਟ ਅਪ ਕਰਨਾ ਲਾਰਵੇਲ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਦੇ ਸਮਾਨ ਹੈ, ਕਿਉਂਕਿ ਉਹ ਦੋਵੇਂ ਉਸ ਉਮਰ ਦੇ ਸਨ ਜਿੱਥੇ MVC ਆਰਕੀਟੈਕਚਰ ਸਟਾਈਲਿਸ਼ ਅਤੇ ਸਹੀ ਸਨ। ਅਸੀਂ ਬੋਰਿੰਗ ਕੌਂਫਿਗਰੇਸ਼ਨ ਨੂੰ ਛੱਡ ਦੇਵਾਂਗੇ ਅਤੇ ਸਿੱਧੇ ਦ੍ਰਿਸ਼ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ ਜਾਵਾਂਗੇ।
from django.shortcuts import render
from django.http import HttpResponse
# =====================================================================
def index(request):
count = request.session.get('count', 0)
count += 1
request.session['count'] = count
return HttpResponse(f"Count is {count}")
ਕੋਡ ਦੀਆਂ ਚਾਰ ਲਾਈਨਾਂ ਲਾਰਵੇਲ ਸੰਸਕਰਣ ਦੇ ਸਮਾਨ ਹਨ। ਆਓ ਦੇਖੀਏ ਕਿ ਇਹ ਕਿਵੇਂ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ।
╰─➤ python --version
Python 3.10.9
Python/Django
╰─➤ gunicorn --access-logfile - -k uvicorn.workers.UvicornWorker -w 4 djangotest.asgi
[2023-03-21 15:20:38 +0800] [2886633] [INFO] Starting gunicorn 20.1.0
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000/sessiontest/
Running 10s test @ http://127.0.0.1:8000/sessiontest/
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 277.71ms 142.84ms 835.12ms 69.93%
Req/Sec 91.21 57.57 230.00 61.04%
3577 requests in 10.06s, 1.46MB read
Requests/sec: 355.44
Transfer/sec: 148.56KB
ਪ੍ਰਤੀ ਸਕਿੰਟ 355 ਬੇਨਤੀਆਂ 'ਤੇ ਬਿਲਕੁਲ ਵੀ ਬੁਰਾ ਨਹੀਂ। ਇਹ ਸ਼ੁੱਧ PHP ਸੰਸਕਰਣ ਦੀ ਸਿਰਫ ਅੱਧੀ ਕਾਰਗੁਜ਼ਾਰੀ ਹੈ, ਪਰ ਇਹ ਲਾਰਵੇਲ ਸੰਸਕਰਣ ਨਾਲੋਂ 12 ਗੁਣਾ ਵੀ ਹੈ। Django ਬਨਾਮ Laravel ਬਿਲਕੁਲ ਕੋਈ ਮੁਕਾਬਲਾ ਨਹੀਂ ਜਾਪਦਾ ਹੈ।
ਫਲਾਸਕ
ਵੱਡੀ ਹਰ ਚੀਜ਼-ਸਮੇਤ-ਰਸੋਈ-ਸਿੰਕ ਫਰੇਮਵਰਕ ਤੋਂ ਇਲਾਵਾ, ਇੱਥੇ ਛੋਟੇ ਫਰੇਮਵਰਕ ਵੀ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਬਾਕੀ ਨੂੰ ਸੰਭਾਲਣ ਦਿੰਦੇ ਹੋਏ ਕੁਝ ਬੁਨਿਆਦੀ ਸੈੱਟਅੱਪ ਕਰਦੇ ਹਨ। ਵਰਤਣ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਵਿੱਚੋਂ ਇੱਕ ਫਲਾਸਕ ਅਤੇ ਇਸਦੇ ਏਐਸਜੀਆਈ ਹਮਰੁਤਬਾ ਕੁਆਰਟ ਹੈ। ਮੇਰਾ ਆਪਣਾ PaferaPy ਫਰੇਮਵਰਕ ਫਲਾਸਕ ਦੇ ਸਿਖਰ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਇਸਲਈ ਮੈਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੇ ਹੋਏ ਚੀਜ਼ਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨਾ ਕਿੰਨਾ ਆਸਾਨ ਹੈ।
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# Session benchmark test
import json
import psycopg
import uuid
from flask import Flask, session, redirect, url_for, request, current_app, g, abort, send_from_directory
from flask.sessions import SecureCookieSessionInterface
app = Flask('pafera')
app.secret_key = b'secretkey'
dbconn = 0
# =====================================================================
@app.route('/', defaults={'path': ''}, methods = ['GET', 'POST'])
@app.route('/<path:path>', methods = ['GET', 'POST'])
def index(path):
"""Handles all requests for the server.
We route all requests through here to handle the database and session
logic in one place.
"""
global dbconn
if not dbconn:
dbconn = psycopg.connect('dbname=sessiontest user=sessiontest password=sessiontest')
cursor = dbconn.execute('''
CREATE TABLE IF NOT EXISTS usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)
''')
cursor.close()
dbconn.commit()
sessionid = session.get('sessionid', 0)
if not sessionid:
sessionid = uuid.uuid4().hex
session['sessionid'] = sessionid
cursor = dbconn.execute("SELECT data FROM usersessions WHERE uid = %s", [sessionid])
row = cursor.fetchone()
count = json.loads(row[0])['count'] if row else 0
count += 1
newdata = json.dumps({'count': count})
if count == 1:
cursor.execute("""
INSERT INTO usersessions(uid, data)
VALUES(%s, %s)
""",
[sessionid, newdata]
)
else:
cursor.execute("""
UPDATE usersessions
SET data = %s
WHERE uid = %s
""",
[newdata, sessionid]
)
cursor.close()
dbconn.commit()
return f'Count is {count}'
ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਫਲਾਸਕ ਸਕ੍ਰਿਪਟ ਸ਼ੁੱਧ PHP ਸਕ੍ਰਿਪਟ ਨਾਲੋਂ ਛੋਟੀ ਹੈ। ਮੈਨੂੰ ਪਤਾ ਲੱਗਿਆ ਹੈ ਕਿ ਮੇਰੇ ਦੁਆਰਾ ਵਰਤੀ ਗਈ ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚੋਂ, ਪਾਈਥਨ ਟਾਈਪ ਕੀਤੇ ਕੀਸਟ੍ਰੋਕ ਦੇ ਰੂਪ ਵਿੱਚ ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਵੱਧ ਭਾਵਪੂਰਤ ਭਾਸ਼ਾ ਹੈ। ਬ੍ਰੇਸ ਅਤੇ ਬਰੈਕਟਸ ਦੀ ਘਾਟ, ਸੂਚੀ ਅਤੇ ਡਿਕਟ ਸਮਝ, ਅਤੇ ਸੈਮੀਕੋਲਨ ਦੀ ਬਜਾਏ ਇੰਡੈਂਟੇਸ਼ਨ 'ਤੇ ਆਧਾਰਿਤ ਬਲਾਕਿੰਗ ਪਾਈਥਨ ਨੂੰ ਇਸਦੀ ਸਮਰੱਥਾਵਾਂ ਵਿੱਚ ਸਧਾਰਨ ਪਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਬਣਾਉਂਦੀ ਹੈ।
ਬਦਕਿਸਮਤੀ ਨਾਲ, ਪਾਈਥਨ ਵੀ ਸਭ ਤੋਂ ਹੌਲੀ ਆਮ ਉਦੇਸ਼ ਵਾਲੀ ਭਾਸ਼ਾ ਹੈ, ਇਸਦੇ ਬਾਵਜੂਦ ਕਿ ਇਸ ਵਿੱਚ ਕਿੰਨਾ ਸਾਫਟਵੇਅਰ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਉਪਲਬਧ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਗਿਣਤੀ ਸਮਾਨ ਭਾਸ਼ਾਵਾਂ ਨਾਲੋਂ ਲਗਭਗ ਚਾਰ ਗੁਣਾ ਵੱਧ ਹੈ ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਡੋਮੇਨਾਂ ਨੂੰ ਕਵਰ ਕਰਦੀ ਹੈ, ਫਿਰ ਵੀ ਕੋਈ ਇਹ ਨਹੀਂ ਕਹੇਗਾ ਕਿ ਪਾਈਥਨ ਤੇਜ਼ ਹੈ ਅਤੇ ਨਾ ਹੀ NumPy ਵਰਗੇ ਸਥਾਨਾਂ ਤੋਂ ਬਾਹਰ ਹੈ।
ਆਓ ਦੇਖੀਏ ਕਿ ਸਾਡਾ ਫਲਾਸਕ ਸੰਸਕਰਣ ਸਾਡੇ ਪਿਛਲੇ ਫਰੇਮਵਰਕ ਨਾਲ ਕਿਵੇਂ ਤੁਲਨਾ ਕਰਦਾ ਹੈ।
Python/Flask
╰─➤ gunicorn --access-logfile - -w 4 flasksite:app
[2023-03-21 15:32:49 +0800] [2856296] [INFO] Starting gunicorn 20.1.0
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 91.84ms 11.97ms 149.63ms 86.18%
Req/Sec 272.04 39.05 380.00 74.50%
10842 requests in 10.04s, 3.27MB read
Requests/sec: 1080.28
Transfer/sec: 333.37KB
ਸਾਡੀ ਫਲਾਸਕ ਸਕ੍ਰਿਪਟ ਅਸਲ ਵਿੱਚ ਸਾਡੇ ਸ਼ੁੱਧ PHP ਸੰਸਕਰਣ ਨਾਲੋਂ ਤੇਜ਼ ਹੈ!
ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਤੋਂ ਹੈਰਾਨ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਹ ਅਹਿਸਾਸ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਜਦੋਂ ਅਸੀਂ ਗਨੀਕੋਰਨ ਸਰਵਰ ਨੂੰ ਚਾਲੂ ਕਰਦੇ ਹਾਂ ਤਾਂ ਸਾਡੀ ਫਲਾਸਕ ਐਪ ਆਪਣੀ ਸਾਰੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਸੰਰਚਨਾ ਕਰਦੀ ਹੈ, ਜਦੋਂ ਕਿ PHP ਹਰ ਵਾਰ ਨਵੀਂ ਬੇਨਤੀ ਆਉਣ 'ਤੇ ਸਕ੍ਰਿਪਟ ਨੂੰ ਮੁੜ-ਐਕਜ਼ੀਕਿਊਟ ਕਰਦਾ ਹੈ। ਇਹ' ਫਲਾਸਕ ਇੱਕ ਨੌਜਵਾਨ, ਉਤਸੁਕ ਟੈਕਸੀ ਡਰਾਈਵਰ ਹੋਣ ਦੇ ਬਰਾਬਰ ਹੈ, ਜਿਸਨੇ ਪਹਿਲਾਂ ਹੀ ਕਾਰ ਸਟਾਰਟ ਕੀਤੀ ਹੈ ਅਤੇ ਸੜਕ ਦੇ ਕਿਨਾਰੇ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੈ, ਜਦੋਂ ਕਿ PHP ਇੱਕ ਪੁਰਾਣਾ ਡਰਾਈਵਰ ਹੈ ਜੋ ਇੱਕ ਕਾਲ ਆਉਣ ਦੀ ਉਡੀਕ ਵਿੱਚ ਆਪਣੇ ਘਰ ਰੁਕਦਾ ਹੈ ਅਤੇ ਉਦੋਂ ਹੀ ਗੱਡੀ ਚਲਾਉਂਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਚੁੱਕਣ ਲਈ ਉੱਪਰ. ਇੱਕ ਪੁਰਾਣਾ ਸਕੂਲੀ ਮੁੰਡਾ ਹੋਣ ਦੇ ਨਾਤੇ ਅਤੇ ਉਹਨਾਂ ਦਿਨਾਂ ਤੋਂ ਆ ਰਿਹਾ ਹੈ ਜਦੋਂ PHP ਸਾਦੇ HTML ਅਤੇ SHTML ਫਾਈਲਾਂ ਵਿੱਚ ਇੱਕ ਸ਼ਾਨਦਾਰ ਤਬਦੀਲੀ ਸੀ, ਇਹ ਮਹਿਸੂਸ ਕਰਨਾ ਥੋੜ੍ਹਾ ਉਦਾਸ ਹੈ ਕਿ ਕਿੰਨਾ ਸਮਾਂ ਬੀਤ ਗਿਆ ਹੈ, ਪਰ ਡਿਜ਼ਾਈਨ ਦੇ ਅੰਤਰ ਅਸਲ ਵਿੱਚ ਇਸਨੂੰ PHP ਲਈ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੇ ਹਨ Python, Java, ਅਤੇ Node.js ਸਰਵਰਾਂ ਨਾਲ ਮੁਕਾਬਲਾ ਕਰੋ ਜੋ ਸਿਰਫ਼ ਮੈਮੋਰੀ ਵਿੱਚ ਰਹਿੰਦੇ ਹਨ ਅਤੇ ਇੱਕ ਜੁਗਲਰ ਦੀ ਨਿਮਰਤਾ ਨਾਲ ਬੇਨਤੀ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ।
ਸਟਾਰਲੇਟ
ਫਲਾਸਕ ਸਾਡਾ ਹੁਣ ਤੱਕ ਦਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਫਰੇਮਵਰਕ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਅਸਲ ਵਿੱਚ ਬਹੁਤ ਪੁਰਾਣਾ ਸਾਫਟਵੇਅਰ ਹੈ। ਪਾਈਥਨ ਕਮਿਊਨਿਟੀ ਨੇ ਕੁਝ ਸਾਲ ਪਹਿਲਾਂ ਨਵੇਂ ਐਸੀਕ੍ਰੋਨਸ ASGI ਸਰਵਰਾਂ 'ਤੇ ਸਵਿਚ ਕੀਤਾ ਸੀ, ਅਤੇ ਬੇਸ਼ੱਕ, ਮੈਂ ਖੁਦ ਉਨ੍ਹਾਂ ਦੇ ਨਾਲ ਬਦਲਿਆ ਹੈ।
ਪੈਫੇਰਾ ਫਰੇਮਵਰਕ ਦਾ ਸਭ ਤੋਂ ਨਵਾਂ ਸੰਸਕਰਣ, PaferaPyAsync , ਸਟਾਰਲੇਟ 'ਤੇ ਆਧਾਰਿਤ ਹੈ। ਹਾਲਾਂਕਿ ਫਲਾਸਕ ਦਾ ਇੱਕ ASGI ਸੰਸਕਰਣ ਹੈ ਜਿਸਨੂੰ Quart ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਕੁਆਰਟ ਅਤੇ ਸਟਾਰਲੇਟ ਵਿਚਕਾਰ ਪ੍ਰਦਰਸ਼ਨ ਅੰਤਰ ਮੇਰੇ ਲਈ ਇਸਦੀ ਬਜਾਏ ਸਟਾਰਲੇਟ ਉੱਤੇ ਮੇਰੇ ਕੋਡ ਨੂੰ ਰੀਬੇਸ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਸਨ।
ਐਸੀਕ੍ਰੋਨਸ ਪ੍ਰੋਗਰਾਮਿੰਗ ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਲਈ ਡਰਾਉਣੀ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਇਹ ਅਸਲ ਵਿੱਚ ਕੋਈ ਔਖਾ ਸੰਕਲਪ ਨਹੀਂ ਹੈ Node.js ਮੁੰਡਿਆਂ ਦੁਆਰਾ ਇੱਕ ਦਹਾਕੇ ਪਹਿਲਾਂ ਸੰਕਲਪ ਨੂੰ ਪ੍ਰਸਿੱਧ ਬਣਾਉਣ ਲਈ ਧੰਨਵਾਦ।
ਅਸੀਂ ਮਲਟੀਥ੍ਰੈਡਿੰਗ, ਮਲਟੀਪ੍ਰੋਸੈਸਿੰਗ, ਡਿਸਟ੍ਰੀਬਿਊਟਿਡ ਕੰਪਿਊਟਿੰਗ, ਵਾਅਦਾ ਚੇਨਿੰਗ, ਅਤੇ ਉਹਨਾਂ ਸਾਰੇ ਮਜ਼ੇਦਾਰ ਸਮਿਆਂ ਦੇ ਨਾਲ ਸਹਿਮਤੀ ਨਾਲ ਲੜਦੇ ਸੀ ਜੋ ਸਮੇਂ ਤੋਂ ਪਹਿਲਾਂ ਬੁੱਢੇ ਹੋ ਜਾਂਦੇ ਸਨ ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਅਨੁਭਵੀ ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੂੰ ਨਿਰਾਸ਼ ਕਰਦੇ ਸਨ। ਹੁਣ, ਅਸੀਂ ਸਿਰਫ਼ ਟਾਈਪ ਕਰਦੇ ਹਾਂ async ਸਾਡੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸਾਹਮਣੇ ਅਤੇ await ਕਿਸੇ ਵੀ ਕੋਡ ਦੇ ਸਾਮ੍ਹਣੇ ਜਿਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ। ਇਹ ਅਸਲ ਵਿੱਚ ਨਿਯਮਤ ਕੋਡ ਨਾਲੋਂ ਵਧੇਰੇ ਵਰਬੋਸ ਹੈ, ਪਰ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਪ੍ਰਾਈਮਿਟਿਵਜ਼, ਸੰਦੇਸ਼ ਪਾਸ ਕਰਨ ਅਤੇ ਵਾਅਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਨਾਲੋਂ ਵਰਤਣ ਲਈ ਬਹੁਤ ਘੱਟ ਤੰਗ ਕਰਨ ਵਾਲਾ ਹੈ।
ਸਾਡੀ ਸਟਾਰਲੇਟ ਫਾਈਲ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# Session benchmark test
import json
import uuid
import psycopg
from starlette.applications import Starlette
from starlette.responses import Response, PlainTextResponse, JSONResponse, RedirectResponse, HTMLResponse
from starlette.routing import Route, Mount, WebSocketRoute
from starlette_session import SessionMiddleware
dbconn = 0
# =====================================================================
async def index(R):
global dbconn
if not dbconn:
dbconn = await psycopg.AsyncConnection.connect('dbname=sessiontest user=sessiontest password=sessiontest')
cursor = await dbconn.execute('''
CREATE TABLE IF NOT EXISTS usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)
''')
await cursor.close()
await dbconn.commit()
sessionid = R.session.get('sessionid', 0)
if not sessionid:
sessionid = uuid.uuid4().hex
R.session['sessionid'] = sessionid
cursor = await dbconn.execute("SELECT data FROM usersessions WHERE uid = %s", [sessionid])
row = await cursor.fetchone()
count = json.loads(row[0])['count'] if row else 0
count += 1
newdata = json.dumps({'count': count})
if count == 1:
await cursor.execute("""
INSERT INTO usersessions(uid, data)
VALUES(%s, %s)
""",
[sessionid, newdata]
)
else:
await cursor.execute("""
UPDATE usersessions
SET data = %s
WHERE uid = %s
""",
[newdata, sessionid]
)
await cursor.close()
await dbconn.commit()
return PlainTextResponse(f'Count is {count}')
# *********************************************************************
app = Starlette(
debug = True,
routes = [
Route('/{path:path}', index, methods = ['GET', 'POST']),
],
)
app.add_middleware(
SessionMiddleware,
secret_key = 'testsecretkey',
cookie_name = "pafera",
)
ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਇਹ ਸਾਡੀ ਫਲਾਸਕ ਸਕ੍ਰਿਪਟ ਤੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕਾਪੀ ਅਤੇ ਪੇਸਟ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਸਿਰਫ ਕੁਝ ਰੂਟਿੰਗ ਬਦਲਾਅ ਅਤੇ async/await ਕੀਵਰਡਸ.
ਕਾਪੀ ਅਤੇ ਪੇਸਟ ਕੋਡ ਅਸਲ ਵਿੱਚ ਸਾਨੂੰ ਕਿੰਨਾ ਸੁਧਾਰ ਦੇ ਸਕਦਾ ਹੈ?
Python/Starlette
╰─➤ gunicorn --access-logfile - -k uvicorn.workers.UvicornWorker -w 4 starlettesite:app 130 ↵
[2023-03-21 15:42:34 +0800] [2856220] [INFO] Starting gunicorn 20.1.0
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 21.85ms 10.45ms 67.29ms 55.18%
Req/Sec 1.15k 170.11 1.52k 66.00%
45809 requests in 10.04s, 13.85MB read
Requests/sec: 4562.82
Transfer/sec: 1.38MB
ਸਾਡੇ ਕੋਲ ਇੱਕ ਨਵਾਂ ਚੈਂਪੀਅਨ ਹੈ, ਇਸਤਰੀ ਅਤੇ ਸੱਜਣ! ਸਾਡਾ ਪਿਛਲਾ ਉੱਚ 704 ਬੇਨਤੀਆਂ ਪ੍ਰਤੀ ਸਕਿੰਟ 'ਤੇ ਸਾਡਾ ਸ਼ੁੱਧ PHP ਸੰਸਕਰਣ ਸੀ, ਜਿਸ ਨੂੰ ਸਾਡੇ ਫਲਾਸਕ ਸੰਸਕਰਣ ਦੁਆਰਾ 1080 ਬੇਨਤੀਆਂ ਪ੍ਰਤੀ ਸਕਿੰਟ 'ਤੇ ਪਛਾੜ ਦਿੱਤਾ ਗਿਆ ਸੀ। ਸਾਡੀ ਸਟਾਰਲੇਟ ਸਕ੍ਰਿਪਟ 4562 ਬੇਨਤੀਆਂ ਪ੍ਰਤੀ ਸਕਿੰਟ 'ਤੇ ਸਾਰੇ ਪਿਛਲੇ ਦਾਅਵੇਦਾਰਾਂ ਨੂੰ ਕੁਚਲ ਦਿੰਦੀ ਹੈ, ਮਤਲਬ ਕਿ ਸ਼ੁੱਧ PHP ਨਾਲੋਂ 6x ਸੁਧਾਰ ਅਤੇ ਫਲਾਸਕ ਨਾਲੋਂ 4x ਸੁਧਾਰ।
ਜੇਕਰ ਤੁਸੀਂ ਅਜੇ ਤੱਕ ਆਪਣੇ WSGI Python ਕੋਡ ਨੂੰ ASGI ਵਿੱਚ ਨਹੀਂ ਬਦਲਿਆ ਹੈ, ਤਾਂ ਹੁਣ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਵਧੀਆ ਸਮਾਂ ਹੋ ਸਕਦਾ ਹੈ।
Node.js/ExpressJS
ਹੁਣ ਤੱਕ, ਅਸੀਂ ਸਿਰਫ PHP ਅਤੇ ਪਾਈਥਨ ਫਰੇਮਵਰਕ ਨੂੰ ਕਵਰ ਕੀਤਾ ਹੈ। ਹਾਲਾਂਕਿ, ਦੁਨੀਆ ਦਾ ਇੱਕ ਵੱਡਾ ਹਿੱਸਾ ਅਸਲ ਵਿੱਚ ਆਪਣੀਆਂ ਵੈਬਸਾਈਟਾਂ ਲਈ Java, DotNet, Node.js, Ruby on Rails, ਅਤੇ ਹੋਰ ਅਜਿਹੀਆਂ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ ਕਿਸੇ ਵੀ ਤਰ੍ਹਾਂ ਦੁਨੀਆ ਦੇ ਸਾਰੇ ਈਕੋਸਿਸਟਮ ਅਤੇ ਬਾਇਓਮ ਦੀ ਇੱਕ ਵਿਆਪਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਜੈਵਿਕ ਰਸਾਇਣ ਵਿਗਿਆਨ ਦੇ ਬਰਾਬਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ, ਅਸੀਂ ਸਿਰਫ਼ ਉਹਨਾਂ ਫਰੇਮਵਰਕ ਦੀ ਚੋਣ ਕਰਾਂਗੇ ਜੋ ਕੋਡ ਟਾਈਪ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਆਸਾਨ ਹਨ। ਜਿਸ ਵਿੱਚੋਂ Java ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਨਹੀਂ ਹੈ।
ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ K&R C ਜਾਂ Knuths ਦੀ ਆਪਣੀ ਕਾਪੀ ਦੇ ਹੇਠਾਂ ਛੁਪਾ ਰਹੇ ਹੋ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਕਲਾ ਪਿਛਲੇ ਪੰਦਰਾਂ ਸਾਲਾਂ ਤੋਂ, ਤੁਸੀਂ ਸ਼ਾਇਦ Node.js ਬਾਰੇ ਸੁਣਿਆ ਹੋਵੇਗਾ। ਸਾਡੇ ਵਿੱਚੋਂ ਜਿਹੜੇ JavaScript ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਲੈ ਕੇ ਹੁਣ ਤੱਕ ਮੌਜੂਦ ਹਨ, ਆਧੁਨਿਕ JavaScript ਦੀ ਸਥਿਤੀ ਤੋਂ ਜਾਂ ਤਾਂ ਬਹੁਤ ਹੀ ਡਰੇ ਹੋਏ, ਹੈਰਾਨ ਜਾਂ ਦੋਵੇਂ ਹਨ, ਪਰ ਇਸ ਗੱਲ ਤੋਂ ਇਨਕਾਰ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਕਿ JavaScript ਸਰਵਰਾਂ 'ਤੇ ਵੀ ਗਿਣੀ ਜਾਣ ਵਾਲੀ ਤਾਕਤ ਬਣ ਗਈ ਹੈ। ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਤੌਰ 'ਤੇ. ਆਖਰਕਾਰ, ਸਾਡੇ ਕੋਲ ਹੁਣ ਭਾਸ਼ਾ ਵਿੱਚ ਮੂਲ 64 ਬਿੱਟ ਪੂਰਨ ਅੰਕ ਵੀ ਹਨ! ਇਹ ਹੁਣ ਤੱਕ 64 ਬਿੱਟ ਫਲੋਟਸ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾ ਰਹੀ ਹਰ ਚੀਜ਼ ਨਾਲੋਂ ਕਿਤੇ ਬਿਹਤਰ ਹੈ!
ExpressJS ਸੰਭਵ ਤੌਰ 'ਤੇ ਵਰਤਣ ਲਈ ਸਭ ਤੋਂ ਆਸਾਨ Node.js ਸਰਵਰ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਆਪਣੇ ਕਾਊਂਟਰ ਨੂੰ ਸੇਵਾ ਦੇਣ ਲਈ ਇੱਕ ਤੇਜ਼ ਅਤੇ ਗੰਦਾ Node.js/ExpressJS ਐਪ ਕਰਾਂਗੇ।
/**********************************************************************
* Simple session test using ExpressJS.
**********************************************************************/
var L = console.log;
var uuid = require('uuid4');
var express = require('express');
var session = require('express-session');
var MemoryStore = require('memorystore')(session);
var { Client } = require('pg')
var db = 0;
var app = express();
const PORT = 8000;
//session middleware
app.use(
session({
secret: "secretkey",
saveUninitialized: true,
resave: false,
store: new MemoryStore({
checkPeriod: 1000 * 60 * 60 * 24 // prune expired entries every 24h
})
})
);
app.get('/',
async function(req,res)
{
if (!db)
{
db = new Client({
user: 'sessiontest',
host: '127.0.0.1',
database: 'sessiontest',
password: 'sessiontest'
});
await db.connect();
await db.query(`
CREATE TABLE IF NOT EXISTS usersessions(
uid TEXT PRIMARY KEY,
data TEXT
)`,
[]
);
};
var session = req.session;
if (!session.sessionid)
{
session.sessionid = uuid();
}
var row = 0;
let queryresult = await db.query(`
SELECT data::TEXT
FROM usersessions
WHERE uid = $1`,
[session.sessionid]
);
if (queryresult && queryresult.rows.length)
{
row = queryresult.rows[0].data;
}
var count = 0;
if (row)
{
var data = JSON.parse(row);
data.count += 1;
count = data.count;
await db.query(`
UPDATE usersessions
SET data = $1
WHERE uid = $2
`,
[JSON.stringify(data), session.sessionid]
);
} else
{
await db.query(`
INSERT INTO usersessions(uid, data)
VALUES($1, $2)`,
[session.sessionid, JSON.stringify({count: 1})]
);
count = 1;
}
res.send(`Count is ${count}`);
}
);
app.listen(PORT, () => console.log(`Server Running at port ${PORT}`));
ਇਹ ਕੋਡ ਅਸਲ ਵਿੱਚ ਪਾਈਥਨ ਸੰਸਕਰਣਾਂ ਨਾਲੋਂ ਲਿਖਣਾ ਸੌਖਾ ਸੀ, ਹਾਲਾਂਕਿ ਜਦੋਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵੱਡੀਆਂ ਹੋ ਜਾਂਦੀਆਂ ਹਨ, ਤਾਂ ਮੂਲ JavaScript ਬਹੁਤ ਜ਼ਿਆਦਾ ਬੇਲੋੜੀ ਹੋ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਠੀਕ ਕਰਨ ਦੀਆਂ ਸਾਰੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਜਿਵੇਂ ਕਿ ਟਾਈਪਸਕ੍ਰਿਪਟ ਪਾਈਥਨ ਨਾਲੋਂ ਤੇਜ਼ੀ ਨਾਲ ਵਧੇਰੇ ਵਰਬੋਸ ਬਣ ਜਾਂਦੀ ਹੈ।
ਆਓ ਦੇਖੀਏ ਕਿ ਇਹ ਕਿਵੇਂ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ!
Node.js/ExpressJS
╰─➤ node --version v19.6.0
╰─➤ NODE_ENV=production node nodejsapp.js 130 ↵
Server Running at port 8000
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 90.41ms 7.20ms 188.29ms 85.16%
Req/Sec 277.15 37.21 393.00 81.66%
11018 requests in 10.02s, 3.82MB read
Requests/sec: 1100.12
Transfer/sec: 390.68KB
ਤੁਸੀਂ Node.js' ਬਾਰੇ ਪ੍ਰਾਚੀਨ (ਇੰਟਰਨੈੱਟ ਮਿਆਰਾਂ ਅਨੁਸਾਰ ਪ੍ਰਾਚੀਨ...) ਲੋਕ-ਕਥਾਵਾਂ ਸੁਣੀਆਂ ਹੋਣਗੀਆਂ। ਸਪੀਡ, ਅਤੇ ਉਹ ਕਹਾਣੀਆਂ ਜ਼ਿਆਦਾਤਰ ਸੱਚੀਆਂ ਹਨ ਸ਼ਾਨਦਾਰ ਕੰਮ ਲਈ ਧੰਨਵਾਦ ਜੋ ਗੂਗਲ ਨੇ V8 JavaScript ਇੰਜਣ ਨਾਲ ਕੀਤਾ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਹਾਲਾਂਕਿ ਸਾਡੀ ਤੇਜ਼ ਐਪ ਫਲਾਸਕ ਸਕ੍ਰਿਪਟ ਨੂੰ ਪਛਾੜਦੀ ਹੈ, ਇਸਦੀ ਸਿੰਗਲ ਥਰਿੱਡਡ ਪ੍ਰਕਿਰਤੀ ਨੂੰ ਸਟਾਰਲੇਟ ਨਾਈਟ ਦੁਆਰਾ ਚਲਾਏ ਗਏ ਚਾਰ ਅਸਿੰਕ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੁਆਰਾ ਹਰਾਇਆ ਜਾਂਦਾ ਹੈ ਜੋ "ਨੀ!" ਕਹਿੰਦਾ ਹੈ।
ਆਓ ਕੁਝ ਹੋਰ ਮਦਦ ਲਈਏ!
╰─➤ pm2 start nodejsapp.js -i 4
[PM2] Spawning PM2 daemon with pm2_home=/home/jim/.pm2
[PM2] PM2 Successfully daemonized
[PM2] Starting /home/jim/projects/paferarust/nodejsapp.js in cluster_mode (4 instances)
[PM2] Done.
┌────┬──────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼──────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ nodejsapp │ default │ N/A │ cluster │ 37141 │ 0s │ 0 │ online │ 0% │ 64.6mb │ jim │ disabled │
│ 1 │ nodejsapp │ default │ N/A │ cluster │ 37148 │ 0s │ 0 │ online │ 0% │ 64.5mb │ jim │ disabled │
│ 2 │ nodejsapp │ default │ N/A │ cluster │ 37159 │ 0s │ 0 │ online │ 0% │ 56.0mb │ jim │ disabled │
│ 3 │ nodejsapp │ default │ N/A │ cluster │ 37171 │ 0s │ 0 │ online │ 0% │ 45.3mb │ jim │ disabled │
└────┴──────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
ਠੀਕ ਹੈ! ਹੁਣ ਇਹ ਚਾਰ ਤੇ ਚਾਰ ਦੀ ਲੜਾਈ ਹੈ! ਆਓ ਬੈਂਚਮਾਰਕ ਕਰੀਏ!
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8000
Running 10s test @ http://127.0.0.1:8000
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 45.09ms 19.89ms 176.14ms 60.22%
Req/Sec 558.93 97.50 770.00 66.17%
22234 requests in 10.02s, 7.71MB read
Requests/sec: 2218.69
Transfer/sec: 787.89KB
ਅਜੇ ਵੀ ਸਟਾਰਲੇਟ ਦੇ ਪੱਧਰ 'ਤੇ ਬਿਲਕੁਲ ਨਹੀਂ ਹੈ, ਪਰ ਇਹ ਤੇਜ਼ ਪੰਜ ਮਿੰਟ ਦੀ JavaScript ਹੈਕ ਲਈ ਬੁਰਾ ਨਹੀਂ ਹੈ। ਮੇਰੀ ਆਪਣੀ ਜਾਂਚ ਤੋਂ, ਇਹ ਸਕ੍ਰਿਪਟ ਅਸਲ ਵਿੱਚ ਡੇਟਾਬੇਸ ਇੰਟਰਫੇਸਿੰਗ ਪੱਧਰ 'ਤੇ ਥੋੜੀ ਜਿਹੀ ਪਿੱਛੇ ਰੱਖੀ ਜਾ ਰਹੀ ਹੈ ਕਿਉਂਕਿ ਨੋਡ-ਪੋਸਟਗ੍ਰੇਸ ਕਿਤੇ ਵੀ ਓਨਾ ਕੁ ਕੁਸ਼ਲ ਨਹੀਂ ਹੈ ਜਿੰਨਾ ਸਾਈਕੋਪਜੀ ਪਾਈਥਨ ਲਈ ਹੈ। ਡਾਟਾਬੇਸ ਡ੍ਰਾਈਵਰ ਦੇ ਤੌਰ 'ਤੇ sqlite 'ਤੇ ਸਵਿਚ ਕਰਨਾ ਉਸੇ ExpressJS ਕੋਡ ਲਈ ਪ੍ਰਤੀ ਸਕਿੰਟ 3000 ਤੋਂ ਵੱਧ ਬੇਨਤੀਆਂ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।
ਧਿਆਨ ਦੇਣ ਵਾਲੀ ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਪਾਈਥਨ ਦੀ ਹੌਲੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਪੀਡ ਦੇ ਬਾਵਜੂਦ, ASGI ਫਰੇਮਵਰਕ ਅਸਲ ਵਿੱਚ ਕੁਝ ਵਰਕਲੋਡਾਂ ਲਈ Node.js ਹੱਲਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀਯੋਗੀ ਹੋ ਸਕਦੇ ਹਨ।
ਜੰਗਾਲ/ਐਕਟਿਕਸ
ਇਸ ਲਈ ਹੁਣ, ਅਸੀਂ ਪਹਾੜ ਦੀ ਚੋਟੀ ਦੇ ਨੇੜੇ ਆ ਰਹੇ ਹਾਂ, ਅਤੇ ਪਹਾੜ ਦੁਆਰਾ, ਮੇਰਾ ਮਤਲਬ ਹੈ ਚੂਹਿਆਂ ਅਤੇ ਆਦਮੀਆਂ ਦੁਆਰਾ ਇੱਕੋ ਜਿਹੇ ਰਿਕਾਰਡ ਕੀਤੇ ਗਏ ਸਭ ਤੋਂ ਉੱਚੇ ਬੈਂਚਮਾਰਕ ਸਕੋਰ।
ਜੇਕਰ ਤੁਸੀਂ ਵੈੱਬ 'ਤੇ ਉਪਲਬਧ ਜ਼ਿਆਦਾਤਰ ਫਰੇਮਵਰਕ ਬੈਂਚਮਾਰਕਾਂ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਇੱਥੇ ਦੋ ਭਾਸ਼ਾਵਾਂ ਹਨ ਜੋ ਸਿਖਰ 'ਤੇ ਹਾਵੀ ਹੁੰਦੀਆਂ ਹਨ: C++ ਅਤੇ Rust। ਮੈਂ 90 ਦੇ ਦਹਾਕੇ ਤੋਂ C++ ਨਾਲ ਕੰਮ ਕੀਤਾ ਹੈ, ਅਤੇ MFC/ATL ਇੱਕ ਚੀਜ਼ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਮੇਰੇ ਕੋਲ ਆਪਣਾ ਆਪਣਾ Win32 C++ ਫਰੇਮਵਰਕ ਵੀ ਸੀ, ਇਸਲਈ ਮੇਰੇ ਕੋਲ ਭਾਸ਼ਾ ਦਾ ਬਹੁਤ ਅਨੁਭਵ ਹੈ। ਕਿਸੇ ਚੀਜ਼ ਨਾਲ ਕੰਮ ਕਰਨਾ ਬਹੁਤ ਮਜ਼ੇਦਾਰ ਨਹੀਂ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਇਸਨੂੰ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹੋ, ਇਸ ਲਈ ਅਸੀਂ ਇਸਦੀ ਬਜਾਏ ਇੱਕ ਜੰਗਾਲ ਸੰਸਕਰਣ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ। ;)
ਜਿੱਥੋਂ ਤੱਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਜਾਂਦੀਆਂ ਹਨ, ਜੰਗਾਲ ਮੁਕਾਬਲਤਨ ਨਵੀਂ ਹੈ, ਪਰ ਇਹ ਮੇਰੇ ਲਈ ਉਤਸੁਕਤਾ ਦਾ ਵਿਸ਼ਾ ਬਣ ਗਿਆ ਜਦੋਂ ਲਿਨਸ ਟੋਰਵਾਲਡਜ਼ ਨੇ ਘੋਸ਼ਣਾ ਕੀਤੀ ਕਿ ਉਹ ਜੰਗਾਲ ਨੂੰ ਲੀਨਕਸ ਕਰਨਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰੇਗਾ। ਸਾਡੇ ਪੁਰਾਣੇ ਪ੍ਰੋਗ੍ਰਾਮਰਾਂ ਲਈ, ਇਹ ਉਹੀ ਹੈ ਜਿਵੇਂ ਕਿ ਇਹ ਕਹਿਣਾ ਕਿ ਇਹ ਨਵੀਂ ਫੈਂਗਲੀਡ ਨਿਊ ਏਜ ਹਿੱਪੀ ਥਿੰਗੀ ਅਮਰੀਕੀ ਸੰਵਿਧਾਨ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਸੋਧ ਹੋਣ ਜਾ ਰਹੀ ਹੈ।
ਹੁਣ, ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਤਜਰਬੇਕਾਰ ਪ੍ਰੋਗਰਾਮਰ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਬੈਂਡਵੈਗਨ 'ਤੇ ਨੌਜਵਾਨ ਲੋਕਾਂ ਵਾਂਗ ਤੇਜ਼ੀ ਨਾਲ ਛਾਲ ਨਹੀਂ ਮਾਰਦੇ ਹੋ, ਨਹੀਂ ਤਾਂ ਤੁਸੀਂ ਭਾਸ਼ਾ ਜਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ ਤੇਜ਼ੀ ਨਾਲ ਤਬਦੀਲੀਆਂ ਕਰਕੇ ਸਾੜ ਸਕਦੇ ਹੋ। (ਕੋਈ ਵੀ ਜਿਸਨੇ AngularJS ਦੇ ਪਹਿਲੇ ਸੰਸਕਰਣ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਉਹ ਜਾਣ ਜਾਵੇਗਾ ਕਿ ਮੈਂ ਕਿਸ ਬਾਰੇ ਗੱਲ ਕਰ ਰਿਹਾ ਹਾਂ।) ਜੰਗਾਲ ਅਜੇ ਵੀ ਉਸ ਪ੍ਰਯੋਗਾਤਮਕ ਵਿਕਾਸ ਪੜਾਅ ਵਿੱਚ ਕੁਝ ਹੱਦ ਤੱਕ ਹੈ, ਅਤੇ ਮੈਨੂੰ ਇਹ ਮਜ਼ਾਕੀਆ ਲੱਗ ਰਿਹਾ ਹੈ ਕਿ ਵੈੱਬ 'ਤੇ ਬਹੁਤ ਸਾਰੀਆਂ ਕੋਡ ਉਦਾਹਰਣਾਂ ਵੀ ਨਹੀਂ ਹਨ। ਪੈਕੇਜਾਂ ਦੇ ਮੌਜੂਦਾ ਸੰਸਕਰਣਾਂ ਨਾਲ ਹੁਣ ਕੰਪਾਇਲ ਕਰੋ।
ਹਾਲਾਂਕਿ, ਰਸਟ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੁਆਰਾ ਦਿਖਾਈ ਗਈ ਕਾਰਗੁਜ਼ਾਰੀ ਤੋਂ ਇਨਕਾਰ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਕਦੇ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕੀਤੀ ripgrep ਜਾਂ fd-ਲੱਭੋ ਵੱਡੇ ਸਰੋਤ ਕੋਡ ਦੇ ਰੁੱਖਾਂ 'ਤੇ, ਤੁਹਾਨੂੰ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਇੱਕ ਸਪਿਨ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਹ ਜ਼ਿਆਦਾਤਰ ਲੀਨਕਸ ਡਿਸਟਰੀਬਿਊਸ਼ਨਾਂ ਲਈ ਸਿਰਫ਼ ਪੈਕੇਜ ਮੈਨੇਜਰ ਤੋਂ ਉਪਲਬਧ ਹਨ। ਤੁਸੀਂ Rust... a ਬਹੁਤ a ਲਈ ਵਰਬੋਸਿਟੀ ਦੀ ਬਹੁਤ ਪ੍ਰਦਰਸ਼ਨ ਦੇ.
Rust ਲਈ ਪੂਰਾ ਕੋਡ ਥੋੜਾ ਵੱਡਾ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਇੱਥੇ ਸੰਬੰਧਿਤ ਹੈਂਡਲਰਾਂ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰਾਂਗੇ:
// =====================================================================
pub async fn RunQuery(
db: &web::Data<Pool>,
query: &str,
args: &[&(dyn ToSql + Sync)]
) -> Result<Vec<tokio_postgres::row::Row>, tokio_postgres::Error>
{
let client = db.get().await.unwrap();
let statement = client.prepare_cached(query).await.unwrap();
client.query(&statement, args).await
}
// =====================================================================
pub async fn index(
req: HttpRequest,
session: Session,
db: web::Data<Pool>,
) -> Result<HttpResponse, Error>
{
let mut count = 1;
if let Some(sessionid) = session.get::<String>("sessionid")?
{
let rows = RunQuery(
&db,
"SELECT data
FROM usersessions
WHERE uid = $1",
&[&sessionid]
).await.unwrap();
if rows.is_empty()
{
let jsondata = serde_json::json!({
"count": 1,
}).to_string();
RunQuery(
&db,
"INSERT INTO usersessions(uid, data)
VALUES($1, $2)",
&[&sessionid, &jsondata]
).await
.expect("Insert failed!");
} else
{
let jsonstring:&str = rows[0].get(0);
let countdata: CountData = serde_json::from_str(jsonstring)?;
count = countdata.count;
count += 1;
let jsondata = serde_json::json!({
"count": count,
}).to_string();
RunQuery(
&db,
"UPDATE usersessions
SET data = $1
WHERE uid = $2
",
&[&jsondata, &sessionid]
).await
.expect("Update failed!");
}
} else
{
let sessionid = Uuid::new_v4().to_string();
let jsondata = serde_json::json!({
"count": 1,
}).to_string();
RunQuery(
&db,
"INSERT INTO usersessions(uid, data)
VALUES($1, $2)",
&[&sessionid, &jsondata]
).await
.expect("Insert failed!");
session.insert("sessionid", sessionid)?;
}
Ok(HttpResponse::Ok().body(format!(
"Count is {:?}",
count
)))
}
ਇਹ Python/Node.js ਸੰਸਕਰਣਾਂ ਨਾਲੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਗੁੰਝਲਦਾਰ ਹੈ...
Rust/Actix
╰─➤ cargo run --release
[2023-03-21T23:37:25Z INFO actix_server::builder] starting 4 workers
Server running at http://127.0.0.1:8888/
╰─➤ wrk -d 10s -t 4 -c 100 http://127.0.0.1:8888
Running 10s test @ http://127.0.0.1:8888
4 threads and 100 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 9.93ms 3.90ms 77.18ms 94.87%
Req/Sec 2.59k 226.41 2.83k 89.25%
102951 requests in 10.03s, 24.59MB read
Requests/sec: 10267.39
Transfer/sec: 2.45MB
ਅਤੇ ਹੋਰ ਵੀ ਬਹੁਤ ਵਧੀਆ!
Actix/deadpool_postgres ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਾਡਾ ਜੰਗਾਲ ਸਰਵਰ ਸਾਡੇ ਪਿਛਲੇ ਚੈਂਪੀਅਨ ਸਟਾਰਲੇਟ ਨੂੰ +125%, ExpressJS ਨੂੰ +362%, ਅਤੇ ਸ਼ੁੱਧ PHP ਨੂੰ +1366% ਨਾਲ ਹਰਾਉਂਦਾ ਹੈ। (ਮੈਂ ਪਾਠਕ ਲਈ ਅਭਿਆਸ ਵਜੋਂ ਲਾਰਵੇਲ ਸੰਸਕਰਣ ਦੇ ਨਾਲ ਪ੍ਰਦਰਸ਼ਨ ਡੈਲਟਾ ਨੂੰ ਛੱਡਾਂਗਾ।)
ਮੈਂ ਪਾਇਆ ਹੈ ਕਿ ਜੰਗਾਲ ਭਾਸ਼ਾ ਨੂੰ ਸਿੱਖਣਾ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਔਖਾ ਰਿਹਾ ਹੈ ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ 6502 ਅਸੈਂਬਲੀ ਦੇ ਬਾਹਰ ਜੋ ਕੁਝ ਵੀ ਦੇਖਿਆ ਹੈ ਉਸ ਨਾਲੋਂ ਇਸ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਗੌਚ ਹਨ, ਪਰ ਜੇਕਰ ਤੁਹਾਡਾ ਜੰਗਾਲ ਸਰਵਰ 14 ਗੁਣਾ ਵੱਧ ਲੈ ਸਕਦਾ ਹੈ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਤੁਹਾਡੇ PHP ਸਰਵਰ ਦੇ ਰੂਪ ਵਿੱਚ, ਫਿਰ ਸ਼ਾਇਦ ਸਵਿਚ ਕਰਨ ਵਾਲੀਆਂ ਤਕਨਾਲੋਜੀਆਂ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੁਝ ਹੈ। ਇਸ ਲਈ ਪੈਫੇਰਾ ਫਰੇਮਵਰਕ ਦਾ ਅਗਲਾ ਸੰਸਕਰਣ ਜੰਗਾਲ 'ਤੇ ਅਧਾਰਤ ਹੋਵੇਗਾ। ਸਿੱਖਣ ਦੀ ਵਕਰ ਸਕਰਿਪਟਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨਾਲੋਂ ਬਹੁਤ ਉੱਚੀ ਹੈ, ਪਰ ਪ੍ਰਦਰਸ਼ਨ ਇਸਦੀ ਕੀਮਤ ਵਾਲਾ ਹੋਵੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ Rust ਸਿੱਖਣ ਲਈ ਸਮਾਂ ਨਹੀਂ ਲਗਾ ਸਕਦੇ ਹੋ, ਤਾਂ Starlette ਜਾਂ Node.js 'ਤੇ ਆਪਣੇ ਤਕਨੀਕੀ ਸਟੈਕ ਨੂੰ ਆਧਾਰਿਤ ਕਰਨਾ ਵੀ ਕੋਈ ਮਾੜਾ ਫੈਸਲਾ ਨਹੀਂ ਹੈ।
ਤਕਨੀਕੀ ਕਰਜ਼ਾ
ਪਿਛਲੇ ਵੀਹ ਸਾਲਾਂ ਵਿੱਚ, ਅਸੀਂ ਸਸਤੀ ਸਥਿਰ ਹੋਸਟਿੰਗ ਸਾਈਟਾਂ ਤੋਂ ਲੈ ਕੇ LAMP ਸਟੈਕ ਨਾਲ ਸਾਂਝੀ ਹੋਸਟਿੰਗ ਤੱਕ VPSes ਨੂੰ AWS, Azure, ਅਤੇ ਹੋਰ ਕਲਾਉਡ ਸੇਵਾਵਾਂ ਨੂੰ ਕਿਰਾਏ 'ਤੇ ਦੇਣ ਤੱਕ ਚਲੇ ਗਏ ਹਾਂ। ਅੱਜਕੱਲ੍ਹ, ਬਹੁਤ ਸਾਰੀਆਂ ਕੰਪਨੀਆਂ ਡਿਜ਼ਾਇਨ ਫੈਸਲੇ ਲੈ ਕੇ ਸੰਤੁਸ਼ਟ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਉਹ ਉਪਲਬਧ ਜਾਂ ਸਸਤਾ ਲੱਭ ਸਕਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਸੁਵਿਧਾਜਨਕ ਕਲਾਉਡ ਸੇਵਾਵਾਂ ਦੇ ਆਗਮਨ ਨੇ ਹੌਲੀ ਸਰਵਰਾਂ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ 'ਤੇ ਹੋਰ ਹਾਰਡਵੇਅਰ ਸੁੱਟਣਾ ਆਸਾਨ ਬਣਾ ਦਿੱਤਾ ਹੈ। ਇਸ ਨਾਲ ਉਨ੍ਹਾਂ ਨੂੰ ਲੰਬੇ ਸਮੇਂ ਦੇ ਤਕਨੀਕੀ ਕਰਜ਼ੇ ਦੀ ਕੀਮਤ 'ਤੇ ਬਹੁਤ ਛੋਟੀ ਮਿਆਦ ਦੇ ਲਾਭ ਮਿਲੇ ਹਨ।
70 ਸਾਲ ਪਹਿਲਾਂ, ਸੋਵੀਅਤ ਯੂਨੀਅਨ ਅਤੇ ਅਮਰੀਕਾ ਵਿਚਕਾਰ ਇੱਕ ਵੱਡੀ ਪੁਲਾੜ ਦੌੜ ਸੀ। ਸੋਵੀਅਤਾਂ ਨੇ ਜ਼ਿਆਦਾਤਰ ਸ਼ੁਰੂਆਤੀ ਮੀਲ ਪੱਥਰ ਜਿੱਤੇ। ਉਨ੍ਹਾਂ ਕੋਲ ਸਪੁਟਨਿਕ ਵਿੱਚ ਪਹਿਲਾ ਉਪਗ੍ਰਹਿ, ਲਾਈਕਾ ਵਿੱਚ ਪੁਲਾੜ ਵਿੱਚ ਪਹਿਲਾ ਕੁੱਤਾ, ਲੂਨਾ 2 ਵਿੱਚ ਪਹਿਲਾ ਚੰਦਰਮਾ ਪੁਲਾੜ ਯਾਨ, ਯੂਰੀ ਗਾਗਰੀਨ ਅਤੇ ਵੈਲਨਟੀਨਾ ਟੇਰੇਸ਼ਕੋਵਾ ਵਿੱਚ ਪੁਲਾੜ ਵਿੱਚ ਪਹਿਲਾ ਆਦਮੀ ਅਤੇ ਔਰਤ, ਅਤੇ ਹੋਰ ਵੀ...
ਪਰ ਉਹ ਹੌਲੀ-ਹੌਲੀ ਤਕਨੀਕੀ ਕਰਜ਼ਾ ਇਕੱਠਾ ਕਰ ਰਹੇ ਸਨ।
ਹਾਲਾਂਕਿ ਸੋਵੀਅਤ ਸੰਘ ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਪ੍ਰਾਪਤੀ ਲਈ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਸਨ, ਉਹਨਾਂ ਦੀਆਂ ਇੰਜੀਨੀਅਰਿੰਗ ਪ੍ਰਕਿਰਿਆਵਾਂ ਅਤੇ ਟੀਚੇ ਉਹਨਾਂ ਨੂੰ ਲੰਬੇ ਸਮੇਂ ਦੀ ਸੰਭਾਵਨਾ ਦੀ ਬਜਾਏ ਥੋੜ੍ਹੇ ਸਮੇਂ ਦੀਆਂ ਚੁਣੌਤੀਆਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣ ਰਹੇ ਸਨ। ਹਰ ਵਾਰ ਜਦੋਂ ਉਹ ਛਾਲ ਮਾਰਦੇ ਸਨ ਤਾਂ ਉਹ ਜਿੱਤ ਜਾਂਦੇ ਸਨ, ਪਰ ਉਹ ਵਧੇਰੇ ਥੱਕੇ ਅਤੇ ਹੌਲੀ ਹੋ ਰਹੇ ਸਨ ਜਦੋਂ ਕਿ ਉਹਨਾਂ ਦੇ ਵਿਰੋਧੀ ਫਾਈਨਲ ਲਾਈਨ ਵੱਲ ਲਗਾਤਾਰ ਕਦਮ ਚੁੱਕਦੇ ਰਹੇ।
ਇੱਕ ਵਾਰ ਜਦੋਂ ਨੀਲ ਆਰਮਸਟ੍ਰਾਂਗ ਨੇ ਲਾਈਵ ਟੈਲੀਵਿਜ਼ਨ 'ਤੇ ਚੰਦਰਮਾ 'ਤੇ ਆਪਣੇ ਇਤਿਹਾਸਕ ਕਦਮ ਰੱਖੇ, ਤਾਂ ਅਮਰੀਕੀਆਂ ਨੇ ਅਗਵਾਈ ਕੀਤੀ, ਅਤੇ ਫਿਰ ਸੋਵੀਅਤ ਪ੍ਰੋਗਰਾਮ ਦੇ ਫਿੱਕੇ ਪੈਣ ਕਾਰਨ ਉਥੇ ਹੀ ਰਹੇ। ਇਹ ਅੱਜ ਕੰਪਨੀਆਂ ਨਾਲੋਂ ਵੱਖਰਾ ਨਹੀਂ ਹੈ ਜਿਨ੍ਹਾਂ ਨੇ ਅਗਲੀ ਵੱਡੀ ਚੀਜ਼, ਅਗਲੀ ਵੱਡੀ ਅਦਾਇਗੀ, ਜਾਂ ਅਗਲੀ ਵੱਡੀ ਤਕਨੀਕ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕੀਤਾ ਹੈ ਜਦੋਂ ਕਿ ਲੰਬੇ ਸਮੇਂ ਲਈ ਸਹੀ ਆਦਤਾਂ ਅਤੇ ਰਣਨੀਤੀਆਂ ਵਿਕਸਿਤ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਰਹੇ ਹਨ.
ਮਾਰਕੀਟ ਵਿੱਚ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਹੋਣ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਤੁਸੀਂ ਉਸ ਮਾਰਕੀਟ ਵਿੱਚ ਪ੍ਰਮੁੱਖ ਖਿਡਾਰੀ ਬਣ ਜਾਓਗੇ। ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਚੀਜ਼ਾਂ ਨੂੰ ਸਹੀ ਕਰਨ ਲਈ ਸਮਾਂ ਕੱਢਣਾ ਸਫਲਤਾ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ, ਪਰ ਨਿਸ਼ਚਿਤ ਤੌਰ 'ਤੇ ਲੰਬੇ ਸਮੇਂ ਦੀਆਂ ਪ੍ਰਾਪਤੀਆਂ ਦੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੀ ਕੰਪਨੀ ਲਈ ਤਕਨੀਕੀ ਲੀਡ ਹੋ, ਤਾਂ ਆਪਣੇ ਕੰਮ ਦੇ ਬੋਝ ਲਈ ਸਹੀ ਦਿਸ਼ਾ ਅਤੇ ਟੂਲ ਚੁਣੋ। ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਕੁਸ਼ਲਤਾ ਦੀ ਥਾਂ ਪ੍ਰਸਿੱਧੀ ਨਾ ਆਉਣ ਦਿਓ।
ਸਰੋਤ
Rust, ExpressJS, Flask, Starlette, ਅਤੇ Pure PHP ਸਕ੍ਰਿਪਟਾਂ ਵਾਲੀ 7z ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ?
ਲੇਖਕ ਬਾਰੇ |
|
|
ਜਿਮ ਉਦੋਂ ਤੋਂ ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਰ ਰਿਹਾ ਹੈ ਜਦੋਂ ਉਸਨੂੰ 90 ਦੇ ਦਹਾਕੇ ਦੌਰਾਨ IBM PS/2 ਵਾਪਸ ਮਿਲਿਆ ਸੀ। ਅੱਜ ਤੱਕ, ਉਹ ਅਜੇ ਵੀ ਹੱਥਾਂ ਨਾਲ HTML ਅਤੇ SQL ਲਿਖਣ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਆਪਣੇ ਕੰਮ ਵਿੱਚ ਕੁਸ਼ਲਤਾ ਅਤੇ ਸ਼ੁੱਧਤਾ 'ਤੇ ਧਿਆਨ ਦਿੰਦਾ ਹੈ। |
