సాఫ్ట్‌వేర్ కుళ్ళిపోవడాన్ని సరిచేయండి

క్రమానుగత కుళ్ళిపోవడం

మీరు వెంటనే మీ అప్లికేషన్ కోసం తరగతులు రాయడం ప్రారంభించకూడదు. మొదట దానిని రూపొందించాలి. డిజైన్ ఆలోచనాత్మక నిర్మాణంతో ముగించాలి. మరియు ఈ నిర్మాణాన్ని పొందడానికి, మీరు వ్యవస్థను స్థిరంగా విచ్ఛిన్నం చేయాలి.

కుళ్ళిపోవడం తప్పనిసరిగా క్రమానుగతంగా నిర్వహించబడాలి - మొదట, సిస్టమ్ దాని ఆపరేషన్‌ను అత్యంత సాధారణ రూపంలో వివరించే పెద్ద ఫంక్షనల్ మాడ్యూల్స్ / సబ్‌సిస్టమ్‌లుగా విభజించబడింది. అప్పుడు ఫలిత మాడ్యూల్స్ మరింత వివరంగా విశ్లేషించబడతాయి మరియు సబ్‌మాడ్యూల్స్ లేదా వస్తువులుగా విభజించబడ్డాయి.

వస్తువులను ఎంచుకునే ముందు, సిస్టమ్‌ను కనీసం మానసికంగా ప్రాథమిక సెమాంటిక్ బ్లాక్‌లుగా విభజించండి. చిన్న అప్లికేషన్‌లలో, సాధారణంగా దీన్ని చేయడం చాలా సులభం: సిస్టమ్ మొదట సబ్‌సిస్టమ్‌లు / ప్యాకేజీలుగా విభజించబడినందున, మరియు ప్యాకేజీలు తరగతులుగా విభజించబడినందున, కొన్ని స్థాయిల క్రమానుగత స్థాయిలు సరిపోతాయి.

ఈ ఆలోచన కనిపించేంత చిన్నవిషయం కాదు. ఉదాహరణకు, మోడల్-వ్యూ-కంట్రోలర్ (MVC) వంటి సాధారణ "ఆర్కిటెక్చరల్ నమూనా" యొక్క సారాంశం ఏమిటి?

ప్రెజెంటేషన్‌ని బిజినెస్ లాజిక్ నుండి వేరు చేయడం గురించి ఇదంతా . మొదట, ఏదైనా వినియోగదారు అప్లికేషన్ రెండు మాడ్యూల్‌లుగా విభజించబడింది - ఒకటి వ్యాపార తర్కాన్ని (మోడల్) అమలు చేయడానికి బాధ్యత వహిస్తుంది మరియు రెండవది వినియోగదారుతో పరస్పర చర్య చేయడానికి బాధ్యత వహిస్తుంది (యూజర్ ఇంటర్‌ఫేస్ లేదా వీక్షణ).

అప్పుడు మాడ్యూల్స్ ఏదో ఒకవిధంగా సంకర్షణ చెందాలని తేలింది, దీని కోసం వారు కంట్రోలర్‌ను జోడిస్తారు, దీని పని మాడ్యూల్స్ యొక్క పరస్పర చర్యను నిర్వహించడం. MVC యొక్క మొబైల్ (క్లాసిక్) వెర్షన్‌లో, వీక్షణ మోడల్ నుండి ఈవెంట్‌లను స్వీకరించడానికి మరియు ప్రదర్శించబడిన డేటాను నిజ సమయంలో మార్చడానికి వీలుగా అబ్జర్వర్ నమూనా జోడించబడింది.

సిస్టమ్ యొక్క మొదటి విభజన ఫలితంగా అతిపెద్ద భాగాలుగా పొందిన సాధారణ ఉన్నత-స్థాయి మాడ్యూల్స్ ఖచ్చితంగా:

• వ్యాపార తర్కం;
• వినియోగ మార్గము;
• డేటాబేస్;
• సందేశ వ్యవస్థ;
• వస్తువు కంటైనర్.

మొదటి విభజన సాధారణంగా మొత్తం అప్లికేషన్‌ను 2-7 (గరిష్టంగా 10 భాగాలు)గా విభజిస్తుంది. మేము దానిని మరిన్ని భాగాలుగా విభజించినట్లయితే, వాటిని సమూహపరచాలనే కోరిక ఉంటుంది మరియు మేము మళ్లీ 2-7 ఉన్నత-స్థాయి మాడ్యూళ్ళను పొందుతాము.

ఫంక్షనల్ కుళ్ళిపోవడం

సిస్టమ్ పరిష్కరించే పనుల ఆధారంగా మాడ్యూల్స్ / సబ్‌సిస్టమ్‌లుగా విభజించడం ఉత్తమం . ప్రధాన విధిని దానిలోని సబ్‌టాస్క్‌లుగా విభజించారు, ఇది ఒకదానికొకటి స్వతంత్రంగా స్వతంత్రంగా పరిష్కరించబడుతుంది/పని చేయబడుతుంది.

ప్రతి మాడ్యూల్ కొన్ని సబ్‌టాస్క్‌ను పరిష్కరించడానికి మరియు దాని సంబంధిత పనితీరును నిర్వహించడానికి బాధ్యత వహించాలి . ఫంక్షనల్ ప్రయోజనంతో పాటు, మాడ్యూల్ దాని పనితీరును నిర్వహించడానికి అవసరమైన డేటా సమితి ద్వారా కూడా వర్గీకరించబడుతుంది, అంటే:

మాడ్యూల్ = ఫంక్షన్ + దీన్ని అమలు చేయడానికి అవసరమైన డేటా.

మాడ్యూల్స్‌లో కుళ్ళిపోవడం సరిగ్గా జరిగితే, ఇతర మాడ్యూల్స్‌తో పరస్పర చర్య (ఇతర ఫంక్షన్‌లకు బాధ్యత వహించేది) తక్కువగా ఉంటుంది. ఇది కావచ్చు, కానీ దాని లేకపోవడం మీ మాడ్యూల్‌కు కీలకం కాకూడదు.

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

అందువల్ల, సమర్థవంతమైన కుళ్ళిపోవడం అనేది మొదటగా, సిస్టమ్ ఫంక్షన్ల విశ్లేషణ మరియు ఈ విధులను నిర్వహించడానికి అవసరమైన డేటాపై ఆధారపడి ఉంటుంది. ఈ సందర్భంలో విధులు తరగతి విధులు మరియు మాడ్యూల్స్ కావు, ఎందుకంటే అవి వస్తువులు కావు. మీరు మాడ్యూల్‌లో రెండు తరగతులను మాత్రమే కలిగి ఉన్నట్లయితే, మీరు దానిని అతిగా చేసారు.

బలమైన మరియు బలహీనమైన కనెక్టివిటీ

మాడ్యులరైజేషన్తో అతిగా చేయకూడదనేది చాలా ముఖ్యం. మీరు ఒక అనుభవశూన్యుడు ఒక మోనోలిథిక్ స్ప్రింగ్ అప్లికేషన్‌ను ఇచ్చి, దానిని మాడ్యూల్స్‌గా విభజించమని అడిగితే, అతను ప్రతి స్ప్రింగ్ బీన్‌ను ప్రత్యేక మాడ్యూల్‌లోకి తీసుకుంటాడు మరియు అతని పని పూర్తయినట్లు భావిస్తాడు. కానీ అది కాదు.

కుళ్ళిపోయే నాణ్యతకు ప్రధాన ప్రమాణం ఏమిటంటే, మాడ్యూల్స్ తమ పనులను పరిష్కరించడంలో ఎలా దృష్టి సారిస్తాయి మరియు స్వతంత్రంగా ఉంటాయి.

ఇది సాధారణంగా ఈ క్రింది విధంగా రూపొందించబడింది: "కుళ్ళిన ఫలితంగా పొందిన మాడ్యూల్స్ అంతర్గతంగా గరిష్టంగా సంయోగం చేయబడాలి (అధిక అంతర్గత సంశ్లేషణ) మరియు ఒకదానికొకటి కనిష్టంగా పరస్పరం అనుసంధానించబడి ఉండాలి (తక్కువ బాహ్య కలపడం)."

మాడ్యూల్‌లోని అధిక సంశ్లేషణ, అధిక సంశ్లేషణ లేదా "సంయోగం", మాడ్యూల్ ఒక ఇరుకైన సమస్యను పరిష్కరించడంపై దృష్టి కేంద్రీకరించిందని మరియు భిన్నమైన విధులు లేదా సంబంధం లేని బాధ్యతలను నిర్వర్తించడంలో నిమగ్నమై లేదని సూచిస్తుంది.

సంయోగం అనేది మాడ్యూల్ ద్వారా నిర్వహించబడే పనులు ఒకదానికొకటి సంబంధించిన స్థాయిని వర్గీకరిస్తుంది.

అధిక సమన్వయం యొక్క పర్యవసానంగా ఒకే బాధ్యత సూత్రం - ఐదు SOLID సూత్రాలలో మొదటిది , దీని ప్రకారం ఏదైనా వస్తువు / మాడ్యూల్ ఒకే బాధ్యతను కలిగి ఉండాలి మరియు దానిని మార్చడానికి ఒకటి కంటే ఎక్కువ కారణాలు ఉండకూడదు.

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

ప్రతి మాడ్యూల్ ఇతర మాడ్యూల్ ఎలా పని చేస్తుందో, అది ఏ భాషలో వ్రాయబడిందో మరియు అది ఎలా పని చేస్తుందో తెలుసుకోవలసిన అవసరం లేదు. తరచుగా, అటువంటి మాడ్యూల్స్ యొక్క పరస్పర చర్యను నిర్వహించడానికి, ఒక నిర్దిష్ట కంటైనర్ ఉపయోగించబడుతుంది, దీనిలో ఈ మాడ్యూల్స్ లోడ్ చేయబడతాయి.

సరైన డిజైన్‌తో, మీరు ఒక మాడ్యూల్‌ని మార్చినట్లయితే, మీరు ఇతరులను సవరించాల్సిన అవసరం ఉండదు లేదా ఈ మార్పులు తక్కువగా ఉంటాయి. కప్లింగ్ ఎంత వదులుగా ఉంటే, ప్రోగ్రామ్‌ను వ్రాయడం/అర్థం చేసుకోవడం/పొడగించడం/రిపేర్ చేయడం అంత సులభం.

బాగా రూపొందించిన మాడ్యూల్స్ క్రింది లక్షణాలను కలిగి ఉండాలని నమ్ముతారు:

• ఫంక్షనల్ సమగ్రత మరియు సంపూర్ణత - ప్రతి మాడ్యూల్ ఒక ఫంక్షన్‌ను అమలు చేస్తుంది, కానీ దానిని బాగా మరియు పూర్తిగా అమలు చేస్తుంది, మాడ్యూల్ స్వతంత్రంగా దాని పనితీరును అమలు చేయడానికి పూర్తి కార్యకలాపాలను నిర్వహిస్తుంది.
• ఒక ఇన్‌పుట్ మరియు ఒక అవుట్‌పుట్ - ఇన్‌పుట్ వద్ద, ప్రోగ్రామ్ మాడ్యూల్ నిర్దిష్ట ప్రారంభ డేటా సెట్‌ను అందుకుంటుంది, అర్ధవంతమైన ప్రాసెసింగ్‌ను నిర్వహిస్తుంది మరియు ఫలిత డేటా యొక్క ఒక సెట్‌ను తిరిగి ఇస్తుంది, అంటే ప్రామాణిక IPO సూత్రం అమలు చేయబడుతుంది - ఇన్‌పుట్ -\u003e ప్రక్రియ -\u003e అవుట్పుట్.
• తార్కిక స్వాతంత్ర్యం - ప్రోగ్రామ్ మాడ్యూల్ యొక్క పని ఫలితం ప్రారంభ డేటాపై మాత్రమే ఆధారపడి ఉంటుంది, కానీ ఇతర మాడ్యూళ్ల పనిపై ఆధారపడి ఉండదు.
• ఇతర మాడ్యూల్స్‌తో బలహీనమైన సమాచార లింక్‌లు - వీలైతే మాడ్యూళ్ల మధ్య సమాచార మార్పిడిని తగ్గించాలి.

మాడ్యూల్స్ యొక్క కనెక్టివిటీని మరింత ఎలా తగ్గించాలో ఒక అనుభవశూన్యుడు అర్థం చేసుకోవడం చాలా కష్టం. పాక్షికంగా ఈ జ్ఞానం అనుభవంతో వస్తుంది, పాక్షికంగా - స్మార్ట్ పుస్తకాలు చదివిన తర్వాత. కానీ ఇప్పటికే ఉన్న అప్లికేషన్ల నిర్మాణాలను విశ్లేషించడం ఉత్తమం.

వారసత్వానికి బదులుగా కూర్పు

సమర్థ కుళ్ళిపోవడం అనేది ఒక రకమైన కళ మరియు చాలా మంది ప్రోగ్రామర్లకు కష్టమైన పని. ఇక్కడ సరళత మోసపూరితమైనది మరియు తప్పులు ఖరీదైనవి.

అంకితమైన మాడ్యూల్స్ ఒకదానికొకటి బలంగా జతచేయబడతాయి మరియు అవి స్వతంత్రంగా అభివృద్ధి చేయబడవు. లేదా వాటిలో ప్రతి ఒక్కరు ఏ పనికి బాధ్యత వహిస్తారో స్పష్టంగా లేదు. మీరు ఇలాంటి సమస్యను ఎదుర్కొంటే, మాడ్యూల్స్‌లో విభజన తప్పుగా జరిగింది.

ప్రతి మాడ్యూల్ ఏ పాత్ర పోషిస్తుందో ఎల్లప్పుడూ స్పష్టంగా ఉండాలి . మాడ్యూల్‌లు స్వతంత్ర మరియు విలువైన సబ్‌ట్రౌటీన్‌లైతే, మిగిలిన అప్లికేషన్‌ల నుండి వేరుచేయబడి (కాబట్టి తిరిగి ఉపయోగించుకోవచ్చు) కుళ్ళిపోవడం సరిగ్గా జరుగుతుందనే అత్యంత విశ్వసనీయ ప్రమాణం.

వ్యవస్థను విచ్ఛిన్నం చేసేటప్పుడు, మీరే ప్రశ్నలను అడగడం ద్వారా దాని నాణ్యతను తనిఖీ చేయడం మంచిది: "ప్రతి మాడ్యూల్ ఏ పనిని నిర్వహిస్తుంది?", "మాడ్యూల్స్ పరీక్షించడం ఎంత సులభం?", "మాడ్యూల్‌లను వాటి స్వంతంగా ఉపయోగించడం సాధ్యమేనా? లేదా మరొక వాతావరణంలో?" ఇతరులను ప్రభావితం చేయాలా?"

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

కాకపోతే ఇక్కడ కూడా అన్నీ పోలేదు. ఉపవ్యవస్థల మధ్య లింక్‌లను మరింత తగ్గించడానికి మరియు బలహీనపరిచేందుకు మిమ్మల్ని అనుమతించే అనేక ప్రత్యేక పద్ధతులు మరియు నమూనాలు ఉన్నాయి. ఉదాహరణకు, MVC విషయంలో, ఈ ప్రయోజనం కోసం అబ్జర్వర్ నమూనా ఉపయోగించబడింది, కానీ ఇతర పరిష్కారాలు సాధ్యమే.

డీకప్లింగ్ కోసం సాంకేతికతలు ప్రధాన "ఆర్కిటెక్ట్ టూల్‌కిట్" అని చెప్పవచ్చు. మేము అన్ని ఉపవ్యవస్థల గురించి మాట్లాడుతున్నామని అర్థం చేసుకోవడం మాత్రమే అవసరం మరియు సోపానక్రమం యొక్క అన్ని స్థాయిలలో కనెక్షన్ బలహీనపడటం అవసరం , అంటే, తరగతుల మధ్య మాత్రమే కాకుండా, ప్రతి క్రమానుగత స్థాయిలో మాడ్యూళ్ల మధ్య కూడా.