రోడ్‌రన్నర్: PHP చనిపోవడానికి లేదా గోలాంగ్ రక్షించడానికి నిర్మించబడలేదు

హలో, హబ్ర్! మేము Badooలో చురుకుగా ఉన్నాము PHP పనితీరుపై పని చేస్తోంది, మేము ఈ భాషలో చాలా పెద్ద వ్యవస్థను కలిగి ఉన్నందున మరియు పనితీరు యొక్క సమస్య డబ్బు ఆదా చేసే అంశం. పది సంవత్సరాల క్రితం, మేము దీని కోసం PHP-FPMని సృష్టించాము, ఇది మొదట PHP కోసం ప్యాచ్‌ల సమితి, మరియు తరువాత అధికారిక పంపిణీలో భాగమైంది.

ఇటీవలి సంవత్సరాలలో, PHP గొప్ప పురోగతిని సాధించింది: చెత్త కలెక్టర్ మెరుగుపడింది, స్థిరత్వం స్థాయి పెరిగింది - ఈ రోజు మీరు ఎటువంటి సమస్యలు లేకుండా PHP లో డెమోన్లు మరియు దీర్ఘకాల స్క్రిప్ట్‌లను వ్రాయవచ్చు. ఇది స్పైరల్ స్కౌట్‌ను మరింత ముందుకు వెళ్లడానికి అనుమతించింది: రోడ్‌రన్నర్, PHP-FPM వలె కాకుండా, అభ్యర్థనల మధ్య మెమరీని శుభ్రపరచదు, ఇది అదనపు పనితీరు ప్రయోజనాలను అందిస్తుంది (ఈ విధానం అభివృద్ధి ప్రక్రియను క్లిష్టతరం చేస్తుంది). మేము ప్రస్తుతం ఈ సాధనంతో ప్రయోగాలు చేస్తున్నాము, కానీ భాగస్వామ్యం చేయడానికి మా వద్ద ఇంకా ఫలితాలు ఏవీ లేవు. వారి కోసం వేచి ఉండడాన్ని మరింత సరదాగా చేయడానికి, మేము స్పైరల్ స్కౌట్ నుండి RoadRunner ప్రకటన యొక్క అనువాదాన్ని ప్రచురిస్తున్నాము.

వ్యాసం నుండి వచ్చే విధానం మాకు దగ్గరగా ఉంటుంది: మా సమస్యలను పరిష్కరించేటప్పుడు, మేము చాలా తరచుగా PHP మరియు Go కలయికను ఉపయోగిస్తాము, రెండు భాషల ప్రయోజనాలను పొందడం మరియు ఒకదానికొకటి అనుకూలంగా వదులుకోవడం లేదు.

ఆనందించండి!

గత పదేళ్లలో, మేము జాబితా నుండి కంపెనీల కోసం దరఖాస్తులను సృష్టించాము ఫార్చ్యూన్ XX, మరియు 500 కంటే ఎక్కువ మంది వినియోగదారులు లేని వ్యాపారాల కోసం. ఈ సమయంలో, మా ఇంజనీర్లు ప్రధానంగా PHPలో బ్యాకెండ్‌ను అభివృద్ధి చేశారు. కానీ రెండు సంవత్సరాల క్రితం, మా ఉత్పత్తుల పనితీరుపై మాత్రమే కాకుండా, వాటి స్కేలబిలిటీపై కూడా ఏదో పెద్ద ప్రభావం చూపింది - మేము మా టెక్నాలజీ స్టాక్‌కు గోలాంగ్ (గో)ని పరిచయం చేసాము.

దాదాపు వెంటనే, 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 పొడిగింపు (స్వూల్) ఉపయోగించి వ్రాయగలమని మాకు తెలుసు. మరియు ప్రతి పద్ధతికి దాని స్వంత మెరిట్‌లు ఉన్నప్పటికీ, రెండు ఎంపికలు మాకు సరిపోవు - మేము ఇంకా ఏదో కోరుకుంటున్నాము. మాకు కేవలం వెబ్ సర్వర్ కంటే ఎక్కువ అవసరం ఉంది - PHPలోని “హార్డ్ స్టార్ట్”తో సంబంధం ఉన్న సమస్యల నుండి మమ్మల్ని రక్షించగల పరిష్కారాన్ని పొందాలని మేము ఆశిస్తున్నాము, అదే సమయంలో నిర్దిష్ట అనువర్తనాల కోసం సులభంగా స్వీకరించవచ్చు మరియు విస్తరించవచ్చు. అంటే, మాకు అప్లికేషన్ సర్వర్ అవసరం.

దీనికి సహాయం చేయగలరా? భాష అప్లికేషన్‌లను సింగిల్ బైనరీలుగా కంపైల్ చేస్తుంది కాబట్టి ఇది సాధ్యమవుతుందని మాకు తెలుసు; ఇది క్రాస్ ప్లాట్‌ఫారమ్; HTTPతో పని చేయడానికి దాని స్వంత, చాలా సొగసైన, సమాంతర ప్రాసెసింగ్ మోడల్ (కరెన్సీ) మరియు లైబ్రరీని ఉపయోగిస్తుంది; చివరకు, వేలాది ఓపెన్ సోర్స్ లైబ్రరీలు మరియు ఇంటిగ్రేషన్‌లు మాకు అందుబాటులో ఉంటాయి.

రెండు ప్రోగ్రామింగ్ భాషలను కలపడం కష్టాలు

రెండు లేదా అంతకంటే ఎక్కువ అప్లికేషన్లు ఒకదానితో ఒకటి ఎలా సంభాషించుకోవాలో నిర్ణయించడం మొదటి దశ.

ఉదాహరణకు, ఉపయోగించడం అద్భుతమైన లైబ్రరీ అలెక్స్ పాలెస్ట్రాస్ PHP మరియు Go ప్రక్రియల మధ్య మెమరీ భాగస్వామ్యాన్ని అమలు చేయగలడు (Apacheలో mod_php వలె). కానీ ఈ లైబ్రరీ మా సమస్యను పరిష్కరించడానికి దాని వినియోగాన్ని పరిమితం చేసే లక్షణాలను కలిగి ఉంది.

మేము మరొక, మరింత సాధారణమైన, విధానాన్ని ఉపయోగించాలని నిర్ణయించుకున్నాము: సాకెట్లు/పైప్‌లైన్‌ల ద్వారా ప్రక్రియల మధ్య పరస్పర చర్యను రూపొందించడానికి. ఈ విధానం గత దశాబ్దాలుగా దాని విశ్వసనీయతను నిరూపించింది మరియు ఆపరేటింగ్ సిస్టమ్ స్థాయిలో బాగా ఆప్టిమైజ్ చేయబడింది.

ప్రారంభించడానికి, మేము ప్రక్రియల మధ్య డేటాను మార్పిడి చేయడానికి మరియు ప్రసార లోపాలను నిర్వహించడానికి సాధారణ బైనరీ ప్రోటోకాల్‌ను సృష్టించాము. దాని సరళమైన రూపంలో, ఈ రకమైన ప్రోటోకాల్ సమానంగా ఉంటుంది నెట్ స్ట్రింగ్ с స్థిర పరిమాణం ప్యాకెట్ హెడర్ (మా సందర్భంలో 17 బైట్లు), ఇది ప్యాకెట్ రకం, దాని పరిమాణం మరియు డేటా సమగ్రతను తనిఖీ చేయడానికి బైనరీ మాస్క్ గురించి సమాచారాన్ని కలిగి ఉంటుంది.

PHP వైపు మేము ఉపయోగించాము ప్యాక్ ఫంక్షన్, మరియు గో వైపు - ఒక లైబ్రరీ ఎన్కోడింగ్/బైనరీ.

ఒక ప్రోటోకాల్ సరిపోదని మాకు అనిపించింది - కాబట్టి మేము కాల్ చేసే సామర్థ్యాన్ని జోడించాము PHP నుండి నేరుగా సేవల నెట్/rpcకి వెళ్లండి. మేము గో లైబ్రరీలను PHP అప్లికేషన్‌లలో సులభంగా ఇంటిగ్రేట్ చేయగలము కాబట్టి ఇది తరువాత అభివృద్ధిలో మాకు చాలా సహాయపడింది. ఈ పని ఫలితాన్ని చూడవచ్చు, ఉదాహరణకు, మా ఇతర ఓపెన్ సోర్స్ ఉత్పత్తిలో గోరిడ్జ్.

బహుళ PHP వర్కర్లలో టాస్క్‌లను పంపిణీ చేయడం

ఇంటరాక్షన్ మెకానిజంను అమలు చేసిన తర్వాత, మేము PHP ప్రక్రియలకు పనులను అత్యంత సమర్థవంతంగా ఎలా బదిలీ చేయాలో ఆలోచించడం ప్రారంభించాము. ఒక పని వచ్చినప్పుడు, అప్లికేషన్ సర్వర్ దానిని పూర్తి చేయడానికి ఉచిత వర్కర్‌ని తప్పక ఎంచుకోవాలి. ఒక వర్కర్/ప్రాసెస్ ఎర్రర్‌తో ముగిసిపోయినా లేదా “మరణించినా”, మేము దానిని తీసివేసి, దాన్ని భర్తీ చేయడానికి కొత్తదాన్ని సృష్టిస్తాము. మరియు వర్కర్/ప్రాసెస్ విజయవంతంగా పూర్తయినట్లయితే, మేము దానిని టాస్క్‌లను నిర్వహించడానికి అందుబాటులో ఉన్న కార్మికుల సమూహానికి తిరిగి ఇస్తాము.

మేము ఉపయోగించిన క్రియాశీల కార్మికుల కొలను నిల్వ చేయడానికి బఫర్ చేయబడిన ఛానెల్, ఊహించని విధంగా "చనిపోయిన" కార్మికులను పూల్ నుండి తీసివేయడానికి, మేము ట్రాకింగ్ ఎర్రర్‌లు మరియు వర్కర్ స్టేట్స్ కోసం మెకానిజంను జోడించాము.

ఫలితంగా, బైనరీ రూపంలో సమర్పించబడిన ఏవైనా అభ్యర్థనలను ప్రాసెస్ చేయగల సామర్థ్యం గల PHP సర్వర్‌ని మేము అందుకున్నాము.

మా అప్లికేషన్ వెబ్ సర్వర్‌గా పనిచేయడానికి, మేము ఏవైనా ఇన్‌కమింగ్ HTTP అభ్యర్థనలను సూచించడానికి విశ్వసనీయ PHP ప్రమాణాన్ని ఎంచుకోవాలి. మా విషయంలో మేము కేవలం రూపాంతరం చెందుతాయి గో టు ఫార్మాట్ నుండి net/http అభ్యర్థన PSR-7కాబట్టి ఇది నేడు అందుబాటులో ఉన్న చాలా PHP ఫ్రేమ్‌వర్క్‌లకు అనుకూలంగా ఉంటుంది.

PSR-7 మార్పులేనిదిగా పరిగణించబడుతున్నందున (కొందరు సాంకేతికంగా అది కాదని చెబుతారు), డెవలపర్లు అభ్యర్థనను ప్రాథమికంగా గ్లోబల్ ఎంటిటీగా పరిగణించని అప్లికేషన్‌లను వ్రాయవలసి ఉంటుంది. ఇది దీర్ఘకాల PHP ప్రక్రియల భావనతో చక్కగా సరిపోతుంది. ఇంకా పేరు పెట్టని మా తుది అమలు ఇలా ఉంది:

రోడ్ రన్నర్‌ని పరిచయం చేస్తున్నాము - అధిక-పనితీరు గల PHP అప్లికేషన్ సర్వర్

మా మొదటి టెస్ట్ టాస్క్ API బ్యాకెండ్, ఇది క్రమానుగతంగా ఊహించని అభ్యర్థనలను (సాధారణం కంటే చాలా తరచుగా) ఎదుర్కొంటుంది. చాలా సందర్భాలలో nginx తగినంతగా ఉన్నప్పటికీ, మేము క్రమం తప్పకుండా 502 ఎర్రర్‌లను ఎదుర్కొంటాము ఎందుకంటే లోడ్‌లో ఆశించిన పెరుగుదల కోసం మేము సిస్టమ్‌ను త్వరగా సమతుల్యం చేయలేము.

ఈ పరిష్కారాన్ని భర్తీ చేయడానికి, మేము 2018 ప్రారంభంలో మా మొదటి PHP/Go అప్లికేషన్ సర్వర్‌ని అమలు చేసాము. మరియు వెంటనే మేము అద్భుతమైన ప్రభావాన్ని పొందాము! మేము 502 దోషాన్ని పూర్తిగా వదిలించుకోవడమే కాకుండా, మేము సర్వర్‌ల సంఖ్యను మూడింట రెండు వంతుల వరకు తగ్గించగలిగాము, ఇంజనీర్లకు మరియు ఉత్పత్తి నిర్వాహకులకు చాలా డబ్బు మరియు తలనొప్పిని ఆదా చేసాము.

సంవత్సరం మధ్య నాటికి, మేము మా పరిష్కారాన్ని పూర్తి చేసాము, MIT లైసెన్స్ క్రింద GitHubలో ప్రచురించాము మరియు దానిని పిలిచాము రోడ్ రన్నర్, తద్వారా దాని అద్భుతమైన వేగం మరియు సామర్థ్యాన్ని నొక్కి చెబుతుంది.

రోడ్‌రన్నర్ మీ డెవలప్‌మెంట్ స్టాక్‌ను ఎలా మెరుగుపరుస్తుంది

అప్లికేషన్ రోడ్ రన్నర్ అభ్యర్థన PHPని తాకడానికి ముందే JWT ధృవీకరణను నిర్వహించడానికి, అలాగే Prometheusలో WebSockets మరియు గ్లోబల్ స్టేట్ అగ్రిగేషన్‌ను నిర్వహించడానికి గో వైపు మిడిల్‌వేర్ నెట్/httpని ఉపయోగించడానికి మాకు అనుమతినిచ్చింది.

అంతర్నిర్మిత RPCకి ధన్యవాదాలు, మీరు పొడిగింపు రేపర్‌లను వ్రాయకుండానే PHP కోసం ఏదైనా Go లైబ్రరీల APIని తెరవవచ్చు. మరీ ముఖ్యంగా, కొత్త HTTP కాని సర్వర్‌లను అమలు చేయడానికి రోడ్‌రన్నర్‌ని ఉపయోగించవచ్చు. ఉదాహరణలు PHPలో హ్యాండ్లర్‌లను ప్రారంభించడం AWS లాంబ్డా, నమ్మకమైన క్యూ బస్టర్‌లను సృష్టించడం మరియు జోడించడం కూడా GRPC మా దరఖాస్తులకు.

PHP మరియు Go కమ్యూనిటీల సహాయంతో, మేము పరిష్కారం యొక్క స్థిరత్వాన్ని పెంచాము, కొన్ని పరీక్షలలో అప్లికేషన్ పనితీరును 40 రెట్లు పెంచాము, డీబగ్గింగ్ సాధనాలను మెరుగుపరిచాము, Symfony ఫ్రేమ్‌వర్క్‌తో అమలు చేసిన ఏకీకరణ మరియు HTTPS, HTTP/కి మద్దతును జోడించాము. 2, ప్లగిన్‌లు మరియు PSR-17.

తీర్మానం

కొంతమంది వ్యక్తులు ఇప్పటికీ PHP యొక్క పాత వీక్షణలో చిక్కుకున్నారు, ఇది నెమ్మదిగా, గజిబిజిగా ఉండే భాష WordPress ప్లగిన్‌లను వ్రాయడానికి మాత్రమే మంచిది. ఈ వ్యక్తులు PHPకి పరిమితిని కలిగి ఉన్నారని కూడా చెప్పవచ్చు: అప్లికేషన్ తగినంత పెద్దది అయినప్పుడు, మీరు మరింత "పరిణతి చెందిన" భాషను ఎంచుకోవాలి మరియు అనేక సంవత్సరాలుగా పేరుకుపోయిన కోడ్ బేస్‌ను తిరిగి వ్రాయాలి.

వీటన్నింటికీ నేను సమాధానం చెప్పాలనుకుంటున్నాను: మరోసారి ఆలోచించండి. మీరు మాత్రమే PHP కోసం ఏవైనా పరిమితులను సెట్ చేయగలరని మేము విశ్వసిస్తున్నాము. మీరు మీ జీవితమంతా ఒక భాష నుండి మరొక భాషకు దూకడం ద్వారా మీ అవసరాలకు సరైన సరిపోలికను కనుగొనడానికి ప్రయత్నించవచ్చు లేదా మీరు భాషలను సాధనాలుగా భావించడం ప్రారంభించవచ్చు. PHP వంటి భాష యొక్క గ్రహించిన లోపాలు వాస్తవానికి దాని విజయానికి కారణాలు కావచ్చు. మరియు మీరు దీన్ని గో వంటి మరొక భాషతో మిళితం చేస్తే, మీరు కేవలం ఒక భాషకు పరిమితం చేయబడిన దానికంటే చాలా శక్తివంతమైన ఉత్పత్తులను సృష్టించవచ్చు.

Go మరియు PHP కలయికతో పనిచేసినందున, మేము వాటిని ప్రేమిస్తున్నామని చెప్పవచ్చు. మేము ఒకదానికొకటి త్యాగం చేయడానికి ప్లాన్ చేయము, బదులుగా ఈ డ్యూయల్ స్టాక్ నుండి మరింత ఎక్కువ విలువను పొందడానికి మార్గాలను అన్వేషించండి.

UPD: మేము RoadRunner సృష్టికర్తను మరియు అసలు కథనం యొక్క సహ రచయితను స్వాగతిస్తున్నాము - లాచెసిస్

మూలం: www.habr.com