లూప్ ఇంజనీరింగ్ (Loop engineering) ప్రస్తుతం బాగా ప్రాచుర్యం పొందుతోంది. మీరు ఏదైనా టెక్నికల్ ఫోరమ్ను స్క్రోల్ చేస్తే, AI ఏజెంట్లను కేవలం తెలివైన ప్రాంప్ట్లతో శిక్షణ ఇచ్చే చాట్బాట్లుగా చూడటం ఆపివేయాలని వాదించే గొంతులను మీరు వింటారు. దానికి బదులుగా, మనం లూప్లను డిజైన్ చేయాలని వారు చెబుతున్నారు: అంటే ఏజెంట్ స్వయంగా ప్లాన్ చేసుకునేలా, అమలు చేసేలా, తన పనిని తాను తనిఖీ చేసుకునేలా మరియు మనం నిద్రపోతున్నప్పుడు కూడా పునరావృతం (iterate) చేసుకునేలా చేసే స్వయంప్రతిపత్తి కలిగిన చక్రాలు (autonomous cycles). ఈ ప్రతిపాదన చాలా ఆకర్షణీయంగా ఉంటుంది. లూప్ సరిగ్గా నిర్మించబడితే, ఏజెంట్ నిరంతర మానవ పర్యవేక్షణ లేకుండానే పనిని పూర్తి చేస్తుంది, తద్వారా ముడి ఉద్దేశ్యాన్ని (raw intent) రాత్రికి రాత్రే పూర్తి స్థాయి అవుట్పుట్గా మారుస్తుంది.
ఆ వాగ్దానం సిద్ధాంతపరంగా అద్భుతంగా పనిచేస్తుంది. కానీ ఆచరణలో, చాలా ఏజెంట్లు ఇప్పటికే లూప్లను ఉపయోగిస్తున్నాయి. అవి కోడ్ను జనరేట్ చేస్తాయి, కంపైలర్ ఎర్రర్లను లేదా టెస్ట్ ఫెయిల్యూర్లను తనిఖీ చేస్తాయి, కోడ్ను సరిచేస్తాయి మరియు మళ్ళీ రన్ చేస్తాయి. ఈ ప్రాథమిక ఫీడ్బ్యాక్ సైకిల్ కొత్తదేమీ కాదు. ప్రస్తుతం మద్దతుదారులు కోరుతున్నది అంతకంటే ప్రతిష్టాత్మకమైనది: కేవలం సింటాక్స్ ఎర్రర్లనే కాకుండా, మొత్తం టాస్క్ను నియంత్రించే ఒక 'అవుటర్ లూప్' (outer loop). ఆ అవుటర్ లూప్ను నిర్మించడమే అసలైన సవాలు, ఎందుకంటే సాఫ్ట్వేర్ ఇంజనీరింగ్ అనేది స్థిరమైన నియమాలు కలిగిన క్లోజ్డ్ సిస్టమ్ కాదు.
లూప్ డిజైన్ సమస్య
ప్రొడక్ట్ లక్ష్యాలు గందరగోళంగా ఉంటాయి. మీరు ఎప్పుడూ 'డెఫినిషన్ ఆఫ్ డన్' (definition of done) అనే ఖచ్చితమైన నిర్వచనంతో పనిని ప్రారంభించరు. చాలా సందర్భాలలో, మీరు పనిలో పూర్తిగా నిమగ్నమై ఉన్నప్పుడే అసలు లక్ష్యం ఏమిటో తెలుస్తుంది. వైట్బోర్డ్పై సరళంగా అనిపించిన ఒక అవసరం (requirement), పని చేసే క్రమంలో ఎడ్జ్ కేసులు (edge cases) ఎదురైనప్పుడు పరిష్కారం యొక్క రూపురేఖలనే పూర్తిగా మార్చేస్తుంది. మీరు ఒక ఏజెంట్ను కఠినమైన లూప్లో బంధించినప్పుడు, ఆ కఠినత్వమే ఒక లోపంగా మారుతుంది. ఆ లూప్ తప్పు లక్ష్యం వైపు పదేపదే ప్రయత్నిస్తూనే ఉంటుంది. అంతకంటే దారుణంగా, ఒక ఫ్లెక్సిబుల్ లూప్ కొన్నిసార్లు తాను సాధించిన అవుట్పుట్కు అనుగుణంగా లక్ష్యాన్ని నిశ్శబ్దంగా మార్చుకోవడం ద్వారా సమస్యను పరిష్కరించడానికి ప్రయత్నిస్తుంది. ఈ రెండు ఫలితాలు ఉపయోగపడవు. ఒకటి కంప్యూట్ వనరులను వృథా చేస్తుంది; మరొకటి నమ్మకంగా చెత్తను (garbage) పంపిస్తుంది.
దీని వెనుక ఉన్న లోతైన సమస్య 'స్పెసిఫికేషన్ ఖర్చు' (specification cost). మీరు ఒక లూప్ పర్యవేక్షణ లేకుండా నడవాలనుకుంటే, దాదాపు ప్రతి విషయాన్ని ఊహించి మీరు ఒక స్పెసిఫికేషన్ను రాయాలి. ఏజెంట్ ఖచ్చితంగా ఏమి మార్చాలి? ఏ పాత ప్రవర్తనను (behavior) మార్చకూడదు మరియు భద్రపరచాలి? ఏ ఖచ్చితమైన పరిస్థితుల్లో ఏజెంట్ పునరావృతం (iterate) చేయడం ఆపివేయాలి? ఏ రిస్క్లు ఆమోదయోగ్యమైనవి మరియు ఏ సైడ్ ఎఫెక్ట్స్ తక్షణమే ఆపడానికి కారణం కావాలి? ఆ డాక్యుమెంట్ను రాయడమే, ఏజెంట్తో కలిసి రియల్ టైమ్లో పనిని పూర్తి చేయడం కంటే ఎక్కువ సమయం తీసుకోవచ్చు. వెరిఫికేషన్ అనేది పని చేయడం కంటే చాలా తక్కువ ఖర్చుతో కూడుకున్నదైతేనే ఆటోమేషన్ వల్ల లాభం ఉంటుంది, లేదంటే మీరు ఆటోమేషన్ కోసం భారీ ముందస్తు పన్నును (upfront tax) చెల్లిస్తున్నట్లే.
లూప్లు నిజంగా ఎక్కడ ఉపయోగపడతాయి
దీని అర్థం లూప్ ఇంజనీరింగ్ పనికిరాదని కాదు. ఇది ఒక ప్రత్యేకమైన సాధనం మాత్రమే, సార్వత్రిక వ్యూహం కాదు. వెరిఫికేషన్ ఖర్చులు పెరుగుతున్నప్పుడు మరియు విజయం సాధించడానికి కావాల్సిన ప్రమాణాలు స్పష్టంగా ఉన్నప్పుడు లూప్లు అద్భుతంగా పనిచేస్తాయి. ఈ క్రింది మూడు సందర్భాలలో ఇది నిజమవుతుంది.
నిత్యേന చేసే యాంత్రిక పనులు. సీనియర్ ఇంజనీర్లు రిటైర్ అవ్వాలనుకునే పనుల గురించి ఆలోచించండి: నిర్దిష్ట క్రమంలో అప్లికేషన్లను ప్రారంభించడం, ప్రతి దశను ధృవీకరించడానికి డిప్లాయ్మెంట్ UI ద్వారా క్లిక్ చేయడం, రిలీజ్ తర్వాత తెలిసిన ఎర్రర్ స్ట్రింగ్స్ కోసం లాగ్లను గ్రెప్ చేయడం (grepping logs), లేదా కాన్ఫిగరేషన్ ఫైల్ అన్ని సరైన నోడ్స్కు వ్రాయబడిందో లేదో తనిఖీ చేయడం. ఈ దశలు మనుషులకు విసుగు కలిగించేవి, కానీ వెరిఫికేషన్ చేయడానికి చాలా సులభం. ఒక లూప్ ఈ ప్రక్రియను పర్యవేక్షిస్తూ, ప్రతి రీస్టార్ట్ తర్వాత హెల్త్ ఎండ్పాయింట్లు (health endpoints) తనిఖీ చేయగలదు మరియు ఏదైనా సమస్య కనిపించగానే రోల్బ్యాక్ చేయగలదు. మానవుడు ఇంకా రోల్అవుట్ ప్లాన్ను నిర్వచిస్తారు, కానీ లూప్ దానిని యంత్రంలాంటి ఓపికతో అమలు చేస్తుంది.
కొలవగలిగే ఆప్టిమైజేషన్ లక్ష్యాలు. విజయం అనేది ఒక సంఖ్యగా ఉన్నప్పుడు, లూప్లు అత్యంత ప్రభావవంతంగా పనిచేస్తాయి. p99 లేటెన్సీని 150 మిల్లీసెకన్ల కంటే తగ్గించడం. మెమరీ ఫుట్ప్రింట్ను ఇరవై శాతం తగ్గించడం. ఒక హాట్ పాత్ను పైథాన్ నుండి రస్ట్ (Rust) కి మార్చడం మరియు అన్ని పాత యూనిట్ టెస్ట్లు పాస్ అయ్యేలా చూడటం. లూప్ ఒక మార్పును జనరేట్ చేయగలదు, దానిని బెంచ్మార్క్ చేయగలదు, ఫలితాన్ని మెరుగుపరిచిన వెర్షన్ను ఉంచుకుని, మిగిలిన వాటిని పక్కన పెట్టగలదు. వెరిఫికేషన్ ఆటోమేటెడ్ మరియు సెర్చ్ స్పేస్ పెద్దదిగా ఉన్నందున, మాన్యువల్ రివ్యూ వల్ల అయ్యే ఖర్చును లూప్ లేకుండా భరించడం అసాధ్యం. ఇక్కడ లక్ష్యం స్థిరంగా ఉంటుంది, కానీ దారి తెలియదు. ఇదే లూప్లకు సరైన అవకాశం.
ఆపరేషనల్ ప్లేబుక్స్. ఇన్సిడెంట్ రెస్పాన్స్ మరియు సపోర్ట్ టికెట్లు తరచుగా మనుషులు ఇప్పటికే గుర్తించిన నమూనాలను (patterns) అనుసరిస్తాయి. ఒక నిర్దిష్ట రకమైన ప్రొడక్షన్ ఎర్రర్కు ఎల్లప్పుడూ క్రెడెన్షియల్ను రొటేట్ చేయడం మరియు క్యాచీని క్లియర్ చేయడం అవసరం కావచ్చు. మూడు నిర్దిష్ట పరిస్థితులు నెరవేరినప్పుడు ఒక సపోర్ట్ రిక్వెస్ట్ను రీఫండ్ ద్వారా పరిష్కరించవచ్చు. ఒక లూప్ ఆ ట్రిగ్గర్లను గమనిస్తూ ప్లేబుక్ను అమలు చేయగలదు, ప్యాటర్న్ మారినప్పుడు మాత్రమే ఎస్కలేట్ చేస్తుంది. అది ప్లేబుక్ సరైనదని నిర్ణయించదు; అది కేవలం ఆన్-కాల్ ఇంజనీర్లు చేయలేనంత వేగంతో మరియు స్థాయిలో స్థిరత్వాన్ని (consistency) అమలు చేస్తుంది.
రెగ్యులేటర్లు, రిఫరెన్స్-సెట్టర్లు కాదు
ప్రస్తుత చర్చల్లో చాలా వరకు ఒక ముఖ్యమైన వ్యత్యాసం లోపించింది. లూప్లు (Loops) అనేవి నియంత్రకాలు (regulators). థర్మోస్టాట్ ఒక గదిని డెబ్బై రెండు డిగ్రీల వద్ద ఎలా ఉంచుతుందో, అలాగే అవి ఒక వ్యవస్థను ముందుగా నిర్ణయించిన లక్ష్యంతో అనుసంధానించబడేలా చేస్తాయి. కానీ థర్మోస్టాట్ ఆ డెబ్బై రెండు డిగ్రీలను ఎంచుకోదు. అది సరైన ఉష్ణోగ్రత అని ఎవరో ముందుగా నిర్ణయించాల్సి ఉంటుంది.
సాఫ్ట్వేర్కు వర్తింపజేస్తే, లూప్లో ఉన్న ఒక ఏజెంట్ (agent) రోజంతా బగ్లను సరిచేయడం, ఫంక్షన్లను రీఫ్యాక్టర్ చేయడం లేదా పారామీటర్లను ట్యూన్ చేయడం వంటివి చేయగలదు. అయితే, ఏ ఫీచర్ నిజంగా కస్టమర్కు సహాయపడుతుందో లేదా తదుపరి రిలీజ్ కంటే ముందు ఒక బగ్ను సరిచేయడం విలువైనదా అనేది అది నిర్ణయించలేదు. ఆ ఎంపికలకు బిజినెస్ కాంటెక్స్ట్ (business context), యూజర్ ఇబ్బందులు (user pain) మరియు వ్యూహాత్మక ప్రాధాన్యత (strategic priority) గురించి విచక్షణ అవసరం. ఏజెంట్లు అమలు చేస్తాయి. మనుషులు నిర్ణయిస్తారు. ఈ రెండింటినీ గందరగోళం చేయడం వల్ల, టీమ్లు తప్పు సమస్యను పరిష్కరించే అద్భుతంగా ఆప్టిమైజ్ చేయబడిన వ్యవస్థలను రూపొందించే ప్రమాదం ఉంది.
Loop engineering ఉపయోగకరమైనదే, కానీ అది పరిమితమైనది. ఇది యంత్రాన్ని క్రమశిక్షణతో మరియు వేగంతో నడపడానికి మీకు సహాయపడుతుంది. ఏ యంత్రాన్ని నిర్మించాలి, అది ఎవరి కోసం, లేదా మానవ కోణంలో విజయం అంటే ఏమిటి అనేది ఇది నిర్ణయించదు. ఏ ఫీచర్ ముఖ్యమైనది, ఏ రిస్క్ ఆమోదయోగ్యమైనది మరియు లక్ష్యాన్ని ఎప్పుడు మార్చాలి అనే విచక్షణ మీతోనే ఉంటుంది. మీరు స్వయంచాలకంగా (automatically) ధృవీకరించగలిగేంతగా మీకు బాగా తెలిసిన పనుల కోసం లూప్లను నిర్మించండి. మిగిలినవన్నీ మీ నియంత్రణలోనే ఉంచుకోండి.
ఈ వ్యాసం “Loop Engineering Minus The Hype.” లో Isaac Hagoel చర్చించిన ఆలోచనల ఆధారంగా రూపొందించబడింది. మరిన్ని ఇంజనీరింగ్ చర్చల కోసం, Telegram లో మా లెర్నింగ్ కమ్యూనిటీలో చేరండి.