మొదటి రోజే 'సీమ్' (Seam) నిర్మించండి
అధిక పరిమాణంలో డేటాను (high-volume data) నిర్వహించే ప్లాట్ఫారమ్ను నిర్మించేటప్పుడు ఒక నిర్ణయం తీసుకోవాల్సి ఉంటుంది.
దీర్ఘకాలిక నిల్వ కోసం మీకు వేగవంతమైన డేటాబేస్ అవసరం. కానీ మొదటి రోజే ఒక సంక్లిష్టమైన వ్యవస్థను ఏర్పాటు చేయడం కష్టం. మీ డేటా నమూనాలు (data patterns) ఎలా ఉంటాయో కూడా మీకు ఇంకా తెలియకపోవచ్చు. అటువంటి సమయంలో, మీరు ఇప్పటికే ఉపయోగిస్తున్న ఒక సాధారణ రిలేషనల్ డేటాబేస్ను ఎంచుకోవడం సురక్షితమైన పద్ధతి.
అయితే, మీ కోడ్ను నేరుగా ఆ మొదటి డేటాబేస్తో ముడిపెట్టడమే పొరపాటు. మీ యాప్లోని ప్రతి భాగం నేరుగా డేటాబేస్ను పిలిస్తే (calls), మీరు ఒక ఉచ్చును సృష్టించినట్లవుతుంది. భవిష్యత్తులో మెరుగైన డేటాబేస్కు మారాలంటే, మీరు భారీ స్థాయిలో కోడ్ను మార్చాల్సి (massive refactor) ఉంటుంది.
సరైన పద్ధతి ఏమిటంటే, ఒక 'సీమ్' (seam) నిర్మించడం.
సీమ్ అనేది ఒక ఒప్పందం (contract) వంటిది. అది వ్యవస్థ ఏమి చేస్తుందో నిర్వచిస్తుంది కానీ, అది ఎలా చేస్తుందో చెప్పదు.
- ఆ పని కోసం ఒక ఇంటర్ఫేస్ (interface) సృష్టించండి.
- మీ ప్రస్తుత డేటాబేస్ను ఉపయోగించి ఒక ప్రాథమిక డ్రైవర్ను (driver) వ్రాయండి.
- ఆ డ్రైవర్ను ఇంటర్ఫేస్కు అనుసంధానించండి (bind).
మీ యాప్లోని మిగిలిన అన్ని భాగాలు కేవలం ఇంటర్ఫేస్తో మాత్రమే మాట్లాడుతాయి. బ్యాక్గ్రౌండ్లో ఏ డేటాబేస్ నడుస్తుందో ఎవరికీ తెలియదు.
మీ డేటా పెరిగి, మీకు వేగవంతమైన వ్యవస్థ అవసరమైనప్పుడు, ఆ పని చాలా సులభం. మీరు ఒక కొత్త డ్రైవర్ను వ్రాసి, కేవలం ఒక లైన్ కోడ్ను మార్చి, దానిని విడుదల చేస్తే సరిపోతుంది. దీనివల్ల డ్యాష్బోర్డ్లు పాడవవు, పైప్లైన్లు ఆగవు.
కొందరు దీనిని 'ప్రీమెచ్యూర్ అబ్స్ట్రాక్షన్' (premature abstraction) అని పిలుస్తారు. మీకు ఇది ఇంకా అవసరం లేదని వారు అంటారు.
నేను దీనితో విభేదిస్తున్నాను. ఒక ఇంటర్ఫేస్ కోసం మీకు కేవలం ఒక అదనపు ఫైల్ మాత్రమే అవసరమవుతుంది. దానిని వదిలేస్తే, ఆ ఖర్చును భవిష్యత్తుకు వాయిదా వేసినట్లు అవుతుంది. మీరు చివరికి మార్పు చేయాల్సి వచ్చినప్పుడు, ఒత్తిడిలో వందలాది ఫైళ్లను సరిచేయాల్సి వస్తుంది. ఇంటర్ఫేస్ అనేది తక్కువ ఖర్చుతో కూడిన భద్రత (cheap insurance) వంటిది.
మీ సీమ్లను మరింత బలంగా మార్చుకోవడానికి ఈ మూడు అలవాట్లను పాటించండి:
డ్యూయల్ ఐడెంటిఫైయర్లను (dual identifiers) ఉపయోగించండి. అంతర్గత డేటాబేస్ జాయిన్ల (internal database joins) కోసం వేగవంతమైన ఇంటిజర్లను ఉపయోగించండి. మీ సిస్టమ్ నుండి బయటకు వెళ్లే దేనికైనా UUIDలను ఉపయోగించండి. ఇది మీ డేటాను సురక్షితంగా ఉంచుతుంది మరియు జాయిన్లను వేగవంతం చేస్తుంది.
ఉమ్మడి పదజాలం కోసం Enums ఉపయోగించండి. స్టేటస్లు లేదా తీవ్రత (severities) కోసం యాదృచ్ఛిక స్ట్రింగ్లను (random strings) ఉపయోగించకండి. మీ యాప్లోని ప్రతి భాగం ఒకే భాషలో మాట్లాడేలా ఒకే ఒక Enumను ఉపయోగించండి.
డేటా కోసం వెర్షనల్ ఎన్వలప్లను (versioned envelopes) ఉపయోగించండి. మీ సిస్టమ్ అనేక వనరుల నుండి డేటాను పొందుతుంటే, ఒక కచ్చితమైన స్కీమాను (strict schema) ఉపయోగించండి. కొత్త ఫీల్డ్లను మాత్రమే జోడించండి. కొత్త వెర్షన్ లేకుండా వాటిని ఎప్పుడూ తొలగించవద్దు లేదా పేరు మార్చవద్దు. ఇది మీరు వ్యవస్థను మెరుగుపరుస్తున్నప్పుడు పాత క్లయింట్లు కూడా పని చేసేలా చేస్తుంది.
సరిహద్దును (boundary) గుర్తించండి. దానికి ఒక ఒప్పందం (contract) పేరు పెట్టండి. దానిని ఒక సరళమైన ఇంప్లిమెంటేషన్తో (implementation) నింపండి.
ఒప్పందం అనేది మీ వాగ్దానం. డ్రైవర్ అనేది ఆ వాగ్దానాన్ని ఈరోజు మీరు నెరవేర్చే విధానం మాత్రమే.
Source: https://dev.to/nasrulhazim/build-the-seam-on-day-one-the-second-driver-on-day-ninety-26b