RoadRunner: PHP ගොඩනඟා ඇත්තේ මිය යාමට හෝ Golang ගලවා ගැනීමට නොවේ

හෙලෝ, හබ්ර්! අපි Badoo හි ක්‍රියාකාරී වෙමු PHP කාර්ය සාධනය මත වැඩ කිරීම, මෙම භාෂාවෙන් අපට තරමක් විශාල පද්ධතියක් ඇති බැවින් සහ කාර්ය සාධනය පිළිබඳ ගැටළුව මුදල් ඉතිරි කිරීමේ කාරණයකි. මීට වසර දහයකට පෙර, අපි මේ සඳහා PHP-FPM නිර්මාණය කළෙමු, එය මුලින් PHP සඳහා පැච් කට්ටලයක් වූ අතර පසුව නිල බෙදා හැරීමේ කොටසක් විය.

මෑත වසරවලදී, PHP විශාල ප්‍රගතියක් ලබා ඇත: කසළ එකතු කරන්නා වැඩිදියුණු වී ඇත, ස්ථායීතාවයේ මට්ටම වැඩි වී ඇත - අද ඔබට කිසිදු ගැටළුවක් නොමැතිව PHP හි ඩීමන් සහ දිගුකාලීන ස්ක්‍රිප්ට් ලිවිය හැකිය. මෙය Spiral Scout හට තවත් ඉදිරියට යාමට ඉඩ ලබා දුන්නේය: RoadRunner, PHP-FPM මෙන් නොව, ඉල්ලීම් අතර මතකය පිරිසිදු නොකරයි, එය අමතර කාර්ය සාධන ප්‍රතිලාභ ලබා දෙයි (මෙම ප්‍රවේශය සංවර්ධන ක්‍රියාවලිය සංකීර්ණ කරයි). අපි දැනට මෙම මෙවලම සමඟ අත්හදා බලමින් සිටිමු, නමුත් අපට තවම බෙදා ගැනීමට ප්‍රතිඵල කිසිවක් නොමැත. ඔවුන් එනතුරු බලා සිටීම වඩාත් විනෝදජනක කිරීමට, අපි Spiral Scout වෙතින් RoadRunner නිවේදනයේ පරිවර්තනයක් ප්‍රකාශයට පත් කරන්නෙමු.

ලිපියේ ප්‍රවේශය අපට සමීප ය: අපගේ ගැටළු විසඳීමේදී, අපි බොහෝ විට භාවිතා කරන්නේ PHP සහ Go සංයෝජනයක්, භාෂා දෙකෙහිම ප්‍රතිලාභ ලබා ගැනීම සහ එකක් අනෙකට පක්ෂව අත් නොහරින්න.

භුක්ති විඳින්න!

පසුගිය වසර දහය තුළ, අපි ලැයිස්තුවෙන් සමාගම් සඳහා අයදුම්පත් නිර්මාණය කර ඇත ෆෝචූන් 500, සහ පරිශීලකයින් 500 කට නොවැඩි ප්‍රේක්ෂක පිරිසක් සිටින ව්‍යාපාර සඳහා. මේ කාලය පුරාවටම, අපගේ ඉංජිනේරුවන් ප්‍රධාන වශයෙන් PHP හි පසුපෙළ සංවර්ධනය කරන ලදී. නමුත් වසර දෙකකට පෙර, යමක් අපගේ නිෂ්පාදනවල ක්‍රියාකාරිත්වයට පමණක් නොව, ඒවායේ පරිමාණය කෙරෙහි ද විශාල බලපෑමක් ඇති කළේය - අපි අපගේ තාක්‍ෂණ තොගයට Golang (Go) හඳුන්වා දුන්නෙමු.

40x දක්වා වේගවත් කාර්ය සාධනයක් සහිත විශාල යෙදුම් තැනීමට Go අපට ඉඩ දී ඇති බව වහාම වාගේ අපි සොයා ගත්තෙමු. එය සමඟ, භාෂා දෙකෙහිම වාසි ඒකාබද්ධ කිරීමෙන් PHP වලින් ලියා ඇති නිෂ්පාදන පුළුල් කිරීමට අපට හැකි විය.

Go සහ PHP වල එකතුවක් සැබෑ සංවර්ධන ගැටළු විසඳීමට උපකාරී වන ආකාරය සහ එය අපට සම්බන්ධ සමහර ගැටළු ඉවත් කළ හැකි මෙවලමක් බවට පත් වී ඇති ආකාරය අපි ඔබට කියන්නෙමු. PHP මියයන ආකෘතිය.

ඔබගේ එදිනෙදා PHP සංවර්ධන පරිසරය

PHP හි මිය යන ආකෘතිය නැවත පණ ගැන්වීමට ඔබට Go භාවිතා කළ හැකි ආකාරය ගැන කතා කිරීමට පෙර, අපි ඔබේ සම්මත PHP සංවර්ධන පරිසරය දෙස බලමු.

බොහෝ අවස්ථාවලදී, ඔබ යෙදුම ධාවනය කරන්නේ nginx වෙබ් සේවාදායකය සහ PHP-FPM සේවාදායකයේ එකතුවක් භාවිතා කරමිනි. පළමුවැන්න ස්ථිතික ගොනු සපයන අතර නිශ්චිත ඉල්ලීම් PHP-FPM වෙත හරවා යවයි, PHP-FPM විසින්ම PHP කේතය ක්‍රියාත්මක කරයි. සමහර විට ඔබ Apache සහ mod_php වෙතින් අඩු ජනප්‍රිය සංයෝජනයක් භාවිතා කරයි. නමුත් එය ටිකක් වෙනස් ලෙස ක්රියා කළත්, මූලධර්ම සමාන වේ.

PHP-FPM යෙදුම් කේතය ක්‍රියාත්මක කරන්නේ කෙසේදැයි බලමු. ඉල්ලීමක් පැමිණි විට, PHP-FPM විසින් ළමා PHP ක්‍රියාවලිය ආරම්භ කර ඉල්ලීම් විස්තර එහි ප්‍රාන්තයේ කොටසක් ලෙස සම්මත කරයි (_GET, _POST, _SERVER, ආදිය).

PHP ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමේදී ප්‍රාන්තය වෙනස් විය නොහැක, එබැවින් නව ආදාන දත්ත කට්ටලයක් ලබා ගැනීමට ඇත්තේ එක් ක්‍රමයක් පමණි: ක්‍රියාවලි මතකය ඉවත් කර එය නැවත ආරම්භ කිරීමෙන්.

මෙම ක්රියාත්මක කිරීමේ ආකෘතිය බොහෝ වාසි ඇත. මතක පරිභෝජනය ගැන ඔබ එතරම් කරදර විය යුතු නැත, සියලුම ක්‍රියාවලීන් සම්පූර්ණයෙන්ම හුදකලා වී ඇති අතර, ඉන් එකක් මිය ගියහොත්, එය ඉතිරි ක්‍රියාවලීන්ට බල නොපාමින් ස්වයංක්‍රීයව ප්‍රතිනිර්මාණය වේ. නමුත් මෙම ප්‍රවේශය යෙදුම පරිමාණය කිරීමට උත්සාහ කරන විට පෙනෙන අවාසි ද ඇත.

සාමාන්‍ය PHP පරිසරයක අවාසි සහ අකාර්යක්ෂමතාව

ඔබ PHP හි වෘත්තීය සංවර්ධනයේ යෙදී සිටින්නේ නම්, නව ව්‍යාපෘතියක් ආරම්භ කළ යුත්තේ කොතැනින්දැයි ඔබ දන්නවා - රාමුවක් තෝරා ගැනීමෙන්. එය යැපීම් එන්නත්, ORM, පරිවර්තන සහ සැකිලි සඳහා පුස්තකාල වලින් සමන්විත වේ. ඇත්ත වශයෙන්ම, සියලුම පරිශීලක ආදානය පහසුවෙන් එක් වස්තුවකට දැමිය හැකිය (Symfony/HttpFoundation හෝ PSR-7). රාමු නියමයි!

නමුත් සෑම දෙයකටම එහි මිල තිබේ. ඕනෑම ව්‍යවසාය මට්ටමේ රාමුවක් තුළ, සරල පරිශීලක ඉල්ලීමක් සැකසීමට හෝ දත්ත සමුදායකට ප්‍රවේශ වීමට, ඔබට අවම වශයෙන් ගොනු දුසිම් ගණනක් පූරණය කිරීමට, පන්ති ගණනාවක් නිර්මාණය කිරීමට සහ වින්‍යාස කිහිපයක් විග්‍රහ කිරීමට සිදුවේ. නමුත් නරකම දෙය නම්, එක් එක් කාර්යය සම්පූර්ණ කිරීමෙන් පසු ඔබට සියල්ල නැවත සකස් කර නැවත ආරම්භ කිරීමට අවශ්‍ය වනු ඇත: ඔබ දැන් ආරම්භ කළ සියලුම කේතය නිෂ්ඵල වේ, එහි ආධාරයෙන් ඔබ තවදුරටත් වෙනත් ඉල්ලීමක් ක්‍රියා නොකරනු ඇත. වෙනත් භාෂාවකින් ලියන ඕනෑම ක්‍රමලේඛකයෙකුට මෙය පවසන්න, එවිට ඔහුගේ මුහුණේ වියවුල් බවක් ඔබට පෙනෙනු ඇත.

PHP ඉංජිනේරුවන් මෙම ගැටලුව විසඳීමට වසර ගණනාවක් ගත කර ඇත, දක්ෂ කම්මැලි පැටවීමේ ශිල්පීය ක්‍රම, මයික්‍රොෆ්‍රේම්වර්ක්, ප්‍රශස්ත පුස්තකාල, හැඹිලි ආදිය භාවිතා කර ඇත. නමුත් අවසානයේදී, ඔබට තවමත් සම්පූර්ණ යෙදුම නැවත සකස් කර නැවත නැවත ආරම්භ කිරීමට සිදුවේ. (පරිවර්තකයාගේ සටහන: මෙම ගැටලුව පැමිණීමත් සමඟ අර්ධ වශයෙන් විසඳනු ඇත පූර්ව පැටවීම PHP 7.4 හි)

Go සමඟ PHP එක ඉල්ලීමකට වඩා ජීවත් විය හැකිද?

මිනිත්තු කිහිපයකට (පැය හෝ දින දක්වා) වඩා දිගු කාලයක් පවතින PHP ස්ක්‍රිප්ට් ලිවීමට හැකිය: උදාහරණයක් ලෙස, ක්‍රෝන් කාර්යයන්, CSV විග්‍රහ කරන්නන්, පෝලිම් බස්ටර්. ඔවුන් සියල්ලෝම එකම දර්ශනයට අනුව ක්‍රියා කරති: ඔවුන් කාර්යයක් ලබාගෙන, එය ක්‍රියාත්මක කර, ඊළඟ එක එනතෙක් බලා සිටිති. කේතය මතකයේ පවතින අතර, රාමුව සහ යෙදුම පූරණය කිරීමට අමතර පියවර රැසක් අවශ්‍ය වන බැවින් වටිනා මිලි තත්පර ඉතිරි කරයි.

නමුත් දිගුකාලීන පිටපත් සංවර්ධනය කිරීම එතරම් පහසු නැත. ඕනෑම දෝෂයක් ක්‍රියාවලිය සම්පූර්ණයෙන්ම විනාශ කරයි, මතක කාන්දුවීම් හඳුනා ගැනීම ඔබව පිස්සු වට්ටයි, ඔබට තවදුරටත් F5 නිදොස්කරණය භාවිතා කළ නොහැක.

PHP 7 නිකුත් කිරීමත් සමඟ තත්වය වැඩිදියුණු වී ඇත: විශ්වාසදායක කසළ එකතු කරන්නෙකු දර්ශනය වී ඇත, දෝෂ හැසිරවීමට පහසු වී ඇති අතර කර්නල් දිගු දැන් කාන්දුවීම් වලින් ආරක්ෂා වී ඇත. ඇත්ත, ඉංජිනේරුවන් තවමත් මතකය සමඟ ප්‍රවේශම් විය යුතු අතර කේතයේ රාජ්‍ය ගැටලු පිළිබඳව දැනුවත් විය යුතුය (මේ දේවල් ගැන කරදර විය යුතු නැති භාෂාවක් තිබේද?). එහෙත්, PHP 7 හි, අපව බලා සිටින විස්මයන් අඩුය.

දිගුකාලීන PHP ස්ක්‍රිප්ට් සමඟ වැඩ කිරීමේ ආකෘතිය ගෙන, HTTP ඉල්ලීම් සැකසීම වැනි වඩාත් සුළු කාර්යයන් සඳහා එය අනුවර්තනය කර, එමඟින් එක් එක් ඉල්ලීම සඳහා මුල සිට සියල්ල පැටවීමේ අවශ්‍යතාවය ඉවත් කළ හැකිද?

මෙම ගැටළුව විසඳීම සඳහා, අපට පළමුව HTTP ඉල්ලීම් පිළිගත හැකි සේවාදායක යෙදුමක් ක්‍රියාත්මක කිරීමට අවශ්‍ය වූ අතර සෑම විටම එය මරා නොදමා ඒවා එකින් එක PHP සේවකයාට යොමු කළ යුතුය.

අපි පිරිසිදු PHP (PHP-PM) හෝ C දිගුව (Swoole) භාවිතයෙන් වෙබ් සේවාදායකයක් ලිවිය හැකි බව අපි දැන සිටියෙමු. සෑම ක්‍රමයකටම තමන්ගේම කුසලතා තිබුණද, විකල්ප දෙකම අපට නොගැලපේ - අපට තවත් යමක් අවශ්‍ය විය. අපට හුදෙක් වෙබ් සේවාදායකයකට වඩා වැඩි යමක් අවශ්‍ය විය - PHP හි “දෘඪ ආරම්භය” හා සම්බන්ධ ගැටළු වලින් අපව ගලවා ගත හැකි විසඳුමක් ලබා ගැනීමට අපි බලාපොරොත්තු වූ අතර, ඒ සමඟම නිශ්චිත යෙදුම් සඳහා පහසුවෙන් අනුවර්තනය වී පුළුල් කළ හැකිය. එනම්, අපට යෙදුම් සේවාදායකයක් අවශ්‍ය විය.

මේකට උදව් කරන්න යන්න පුලුවන්ද? භාෂාව විසින් යෙදුම් තනි ද්විමය වශයෙන් සම්පාදනය කරන නිසා එය කළ හැකි බව අපි දැන සිටියෙමු. එය හරස් වේදිකාවකි; HTTP සමඟ වැඩ කිරීම සඳහා තමන්ගේම, ඉතා අලංකාර, සමාන්තර සැකසුම් ආකෘතිය (සමගාමී) සහ පුස්තකාලය භාවිතා කරයි; අවසාන වශයෙන්, දහස් ගණනක් විවෘත මූලාශ්‍ර පුස්තකාල සහ ඒකාබද්ධ කිරීම් අපට ලබා ගත හැකි වනු ඇත.

ක්‍රමලේඛන භාෂා දෙකක් ඒකාබද්ධ කිරීමේ දුෂ්කරතා

පළමු පියවර වූයේ යෙදුම් දෙකක් හෝ වැඩි ගණනක් එකිනෙකා සමඟ සන්නිවේදනය කරන්නේ කෙසේද යන්න තීරණය කිරීමයි.

උදාහරණයක් ලෙස, භාවිතා කිරීම අපූරු පුස්තකාලය Alex Palaestras හට PHP සහ Go ක්‍රියාවලි අතර මතක බෙදාගැනීම ක්‍රියාත්මක කළ හැකිය (Apache හි mod_php හා සමාන). නමුත් මෙම පුස්තකාලය අපගේ ගැටලුව විසඳීම සඳහා එහි භාවිතය සීමා කරන විශේෂාංග ඇත.

අපි තවත් පොදු, ප්‍රවේශයක් භාවිතා කිරීමට තීරණය කළෙමු: සොකට්/නල මාර්ග හරහා ක්‍රියාවලි අතර අන්තර්ක්‍රියා ගොඩනැගීමට. මෙම ප්රවේශය පසුගිය දශක කිහිපය තුළ එහි විශ්වසනීයත්වය ඔප්පු කර ඇති අතර මෙහෙයුම් පද්ධති මට්ටමින් හොඳින් ප්රශස්ත කර ඇත.

ආරම්භ කිරීම සඳහා, අපි ක්‍රියාවලි අතර දත්ත හුවමාරු කිරීම සහ සම්ප්‍රේෂණ දෝෂ හැසිරවීම සඳහා සරල ද්විමය ප්‍රොටෝකෝලයක් නිර්මාණය කළෙමු. එහි සරලම ආකාරයෙන්, මෙම වර්ගයේ ප්රොටෝකෝලය සමාන වේ netstring с ස්ථාවර ප්‍රමාණයේ පැකට් ශීර්ෂකය (අපගේ නඩුවේ බයිට් 17), දත්ත අඛණ්ඩතාව පරීක්ෂා කිරීම සඳහා පැකට් වර්ගය, එහි විශාලත්වය සහ ද්විමය ආවරණයක් පිළිබඳ තොරතුරු අඩංගු වේ.

අපි පාවිච්චි කරපු PHP පැත්තෙන් ඇසුරුම් කාර්යය, සහ Go පැත්තේ - පුස්තකාලයක් කේතනය / ද්විමය.

එක් ප්‍රොටෝකෝලයක් ප්‍රමාණවත් නොවන බව අපට පෙනුණි - එබැවින් අපි ඇමතීමේ හැකියාව එකතු කළෙමු PHP වෙතින් සෘජුවම සේවා net/rpc වෙත යන්න. PHP යෙදුම් වලට Go පුස්තකාල පහසුවෙන් අනුකලනය කළ හැකි බැවින් මෙය පසුව අපට සංවර්ධනයට බොහෝ උපකාර විය. මෙම කාර්යයේ ප්රතිඵලය, උදාහරණයක් ලෙස, අපගේ අනෙකුත් විවෘත මූලාශ්ර නිෂ්පාදනයේ දැකිය හැකිය ගෝරිජ්.

බහු PHP සේවකයින් හරහා කාර්යයන් බෙදා හැරීම

අන්තර්ක්‍රියා යාන්ත්‍රණය ක්‍රියාත්මක කිරීමෙන් පසු, PHP ක්‍රියාවලීන් වෙත කාර්යයන් වඩාත් කාර්යක්ෂමව මාරු කරන්නේ කෙසේදැයි අපි සිතීමට පටන් ගත්තෙමු. කාර්යයක් පැමිණි විට, යෙදුම් සේවාදායකය එය සම්පූර්ණ කිරීම සඳහා නිදහස් සේවකයෙකු තෝරාගත යුතුය. සේවකයෙකු/ක්‍රියාවලියක් දෝෂයකින් අවසන් වුවහොත් හෝ "මියගිය" නම්, අපි එය ඉවත් කර එය ප්‍රතිස්ථාපනය කිරීමට නව එකක් සාදන්නෙමු. සේවකයා/ක්‍රියාවලිය සාර්ථකව නිම කර ඇත්නම්, අපි එය කාර්යයන් ඉටු කිරීමට ඇති සේවක සංචිතයට ආපසු යමු.

අපි භාවිතා කළ ක්රියාකාරී සේවකයින්ගේ සංචිතයක් ගබඩා කිරීම සඳහා buffered නාලිකාව, අනපේක්ෂිත ලෙස "මියගිය" කම්කරුවන් සංචිතයෙන් ඉවත් කිරීම සඳහා, අපි ලුහුබැඳීමේ දෝෂ සහ සේවක තත්ත්වයන් සඳහා යාන්ත්රණයක් එකතු කළා.

එහි ප්‍රතිඵලයක් වශයෙන්, ද්විමය ආකාරයෙන් ඉදිරිපත් කරන ඕනෑම ඉල්ලීමක් සැකසීමට හැකියාව ඇති ක්‍රියාකාරී PHP සේවාදායකයක් අපට ලැබුණි.

අපගේ යෙදුම වෙබ් සේවාදායකයක් ලෙස ක්‍රියා කිරීම සඳහා, එන ඕනෑම HTTP ඉල්ලීමක් නියෝජනය කිරීමට අපට විශ්වාසදායක PHP ප්‍රමිතියක් තෝරා ගැනීමට සිදු විය. අපේ නඩුවේ අපි නිකම් පරිවර්තනය Go to format වෙතින් net/http ඉල්ලීම PSR-7එබැවින් එය අද පවතින බොහෝ PHP රාමු සමඟ අනුකූල වේ.

PSR-7 වෙනස් නොවන ලෙස සලකනු ලබන නිසා (සමහර අය එය තාක්ෂණික වශයෙන් එය එසේ නොවන බව පවසනු ඇත), සංවර්ධකයින්ට ඉල්ලීම ගෝලීය ආයතනයක් ලෙස මූලික වශයෙන් නොසලකන යෙදුම් ලිවීමට සිදුවේ. මෙය දිගුකාලීන PHP ක්‍රියාවලි සංකල්පය සමඟ හොඳින් ගැලපේ. තවමත් නම් කර නොතිබූ අපගේ අවසාන ක්‍රියාවට නැංවීම මෙසේය:

RoadRunner හඳුන්වාදීම - ඉහළ කාර්යසාධනයක් සහිත PHP යෙදුම් සේවාදායකය

අපගේ පළමු පරීක්ෂණ කාර්යය වූයේ API පසුපෙළ වන අතර එය වරින් වර අනපේක්ෂිත ඉල්ලීම් (සාමාන්‍යයට වඩා බොහෝ විට) අත්විඳින ලදී. බොහෝ අවස්ථාවන්හිදී nginx ප්‍රමාණවත් වුවද, අපේක්ෂිත බර වැඩිවීම සඳහා පද්ධතිය ඉක්මනින් සමතුලිත කිරීමට අපට නොහැකි වූ නිසා අපට නිතිපතා දෝෂ 502 ක් හමු විය.

මෙම විසඳුම ප්‍රතිස්ථාපනය කිරීමට, අපි 2018 මුල් භාගයේදී අපගේ පළමු PHP/Go යෙදුම් සේවාදායකය යෙදුවෙමු. වහාම අපට ඇදහිය නොහැකි බලපෑමක් ඇති විය! 502 දෝෂය සම්පූර්ණයෙන්ම නැති කළා පමණක් නොව, ඉන්ජිනේරුවන්ට සහ නිෂ්පාදන කළමනාකරුවන්ට විශාල මුදලක් ඉතිරි කර, හිසරදයක් වන සර්වර් ගණන තුනෙන් දෙකකින් අඩු කිරීමට අපට හැකි විය.

වසර මැද වන විට, අපි අපගේ විසඳුම පරිපූර්ණ කර, MIT බලපත්‍රය යටතේ එය GitHub මත ප්‍රකාශයට පත් කර, එය හැඳින්වූවා. මාර්ග ධාවකය, එමගින් එහි ඇදහිය නොහැකි වේගය සහ කාර්යක්ෂමතාව අවධාරණය කරයි.

RoadRunner හට ඔබේ සංවර්ධන තොගය වැඩිදියුණු කළ හැක්කේ කෙසේද?

අයදුම්පත මාර්ග ධාවකය ඉල්ලීම PHP වෙත පැමිණීමට පෙර JWT සත්‍යාපනය කිරීමට මෙන්ම Prometheus හි WebSockets සහ ගෝලීය රාජ්‍ය එකතුව හැසිරවීමට Go පැත්තේ Middleware net/http භාවිතා කිරීමට අපට අවසර දී ඇත.

ගොඩනඟන ලද RPC වලට ස්තුතිවන්ත වන්න, ඔබට PHP සඳහා ඕනෑම Go පුස්තකාලයක API දිගු එතුම ලිවීමෙන් තොරව විවෘත කළ හැක. වඩාත් වැදගත් වන්නේ, නව HTTP නොවන සේවාදායකයන් යෙදවීමට RoadRunner භාවිතා කළ හැක. උදාහරණ ලෙස PHP හි හැන්ඩ්ලර් දියත් කිරීම ඇතුළත් වේ ඒඩබ්ලිව්එස් ලැම්බඩා, විශ්වසනීය පෝලිම් බස්ටර් නිර්මාණය කිරීම සහ එකතු කිරීම පවා gRPC අපගේ යෙදුම් වෙත.

PHP සහ Go ප්‍රජාවන්ගේ සහාය ඇතිව, අපි විසඳුමේ ස්ථායිතාව වැඩි කර ඇත, සමහර පරීක්ෂණ වලදී යෙදුම් කාර්ය සාධනය 40 ගුණයකින් වැඩි කර ඇත, නිදොස් කිරීමේ මෙවලම් වැඩි දියුණු කර ඇත, Symfony රාමුව සමඟ ඒකාබද්ධ කිරීම ක්‍රියාත්මක කර, සහ HTTPS, HTTP/ සඳහා සහය එක් කර ඇත. 2, ප්ලගින, සහ PSR-17.

නිගමනය

වර්ඩ්ප්‍රෙස් ප්ලගීන ලිවීමට පමණක් හොඳ මන්දගාමී, කරදරකාරී භාෂාවක් ලෙස සමහර අය තවමත් PHP හි යල් පැන ගිය දර්ශනයට හසු වී ඇත. PHP හි සීමාවක් ඇති බව මෙම පුද්ගලයින් පැවසිය හැකිය: යෙදුම ප්‍රමාණවත් තරම් විශාල වූ විට, ඔබට වඩාත් “පරිණත” භාෂාවක් තෝරාගෙන වසර ගණනාවක් තිස්සේ එකතු වී ඇති කේත පදනම නැවත ලිවිය යුතුය.

මේ සියල්ලට මට පිළිතුරු දීමට අවශ්‍යයි: නැවත සිතන්න. PHP සඳහා ඕනෑම සීමාවක් සැකසිය හැක්කේ ඔබට පමණක් බව අපි විශ්වාස කරමු. ඔබට ඔබේ මුළු ජීවිතයම එක් භාෂාවකින් තවත් භාෂාවකට පැනීම, ඔබේ අවශ්‍යතා සඳහා පරිපූර්ණ ගැලපීම සොයා ගැනීමට උත්සාහ කිරීම හෝ ඔබට භාෂා මෙවලම් ලෙස සිතීමට පටන් ගත හැකිය. PHP වැනි භාෂාවක පවතින අඩුපාඩු එහි සාර්ථකත්වයට හේතු විය හැක. ඔබ එය Go වැනි වෙනත් භාෂාවක් සමඟ ඒකාබද්ධ කළහොත්, ඔබ එක් භාෂාවකට පමණක් සීමා වූවාට වඩා බලවත් නිෂ්පාදන නිර්මාණය කළ හැකිය.

Go සහ PHP සංයෝගයක් සමඟ වැඩ කිරීමෙන්, අපි ඔවුන්ට ආදරය කරන බව පැවසිය හැකිය. අපි එකක් අනෙකා වෙනුවෙන් කැප කිරීමට සැලසුම් නොකරමු, නමුත් මෙම ද්විත්ව තොගයෙන් ඊටත් වඩා වටිනාකමක් ලබා ගැනීමට ක්‍රම සොයමු.

UPD: අපි RoadRunner හි නිර්මාතෘ සහ මුල් ලිපියේ සම-කර්තෘ සාදරයෙන් පිළිගනිමු - Lachesis

මූලාශ්රය: www.habr.com