முதல் நாளிலேயே ஒரு இடைவெளியை (Seam) உருவாக்குங்கள்

அதிக அளவிலான தரவுகளுக்கான (high-volume data) ஒரு தளத்தை உருவாக்குவது ஒரு முக்கியமான முடிவை எடுக்கத் தூண்டுகிறது.

நீண்ட கால சேமிப்பிற்கு உங்களுக்கு ஒரு வேகமான தரவுத்தளம் (database) தேவை. ஆனால் முதல் நாளிலேயே ஒரு சிக்கலான அமைப்பை உருவாக்குவது கடினம். உங்கள் தரவு முறைகள் (data patterns) பற்றி உங்களுக்கு இன்னும் தெரியாமல் கூட இருக்கலாம். நீங்கள் ஏற்கனவே பயன்படுத்தும் ஒரு சாதாரண உறவுநிலை தரவுத்தளமே (relational database) பாதுகாப்பான தேர்வாகும்.

உங்கள் குறியீட்டை (code) நேரடியாக அந்த முதல் தரவுத்தளத்துடன் இணைப்பதே தவறு. உங்கள் செயலியின் (app) ஒவ்வொரு பகுதியும் நேரடியாக தரவுத்தளத்தை அழைத்தால், நீங்கள் ஒரு சிக்கலை (trap) உருவாக்குகிறீர்கள். பின்னர் ஒரு சிறந்த தரவுத்தளத்திற்கு மாறுவதற்கு மிகப்பெரிய அளவில் குறியீட்டை மாற்றியமைக்க (massive refactor) வேண்டியிருக்கும்.

சரியான வழி ஒரு இடைவெளியை (seam) உருவாக்குவதாகும்.

ஒரு இடைவெளி (seam) என்பது ஒரு ஒப்பந்தம் போன்றது. ஒரு அமைப்பு என்ன செய்கிறது என்பதை அது எப்படி செய்கிறது என்று சொல்லாமல் வரையறுக்கிறது.

• அந்தப் பணிக்கு ஒரு இடைமுகத்தை (interface) உருவாக்குங்கள்.
• உங்கள் தற்போதைய தரவுத்தளத்தைப் பயன்படுத்தி ஒரு அடிப்படை டிரைவரை (driver) எழுதுங்கள்.
• அந்த டிரைவரை இடைமுகத்துடன் இணையுங்கள்.

உங்கள் செயலியின் மற்ற அனைத்துப் பகுதிகளும் இடைமுகத்துடன் மட்டுமே பேசும். பின்னணியில் எந்த தரவுத்தளம் இயங்குகிறது என்பது யாருக்கும் தெரியாது.

உங்கள் தரவு வளரும்போது மற்றும் உங்களுக்கு ஒரு வேகமான அமைப்பு தேவைப்படும்போது, அந்த வேலை மிகவும் எளிது. நீங்கள் ஒரு புதிய டிரைவரை எழுதி, ஒரு வரியை மட்டும் மாற்றினால் போதும். எந்த டேஷ்போர்டுகளும் (dashboards) உடைந்து போகாது. எந்தத் தரவுப் பாதைகளும் (pipelines) நின்று போகாது.

சிலர் இதை முன்கூட்டியே செய்யும் சுருக்கம் (premature abstraction) என்று அழைக்கிறார்கள். உங்களுக்கு இது இன்னும் தேவையில்லை என்று அவர்கள் கூறுகிறார்கள்.

நான் அதை மறுக்கிறேன். ஒரு இடைமுகத்தை உருவாக்குவது உங்களுக்கு ஒரு கூடுதல் கோப்பை (file) மட்டுமே செலவு செய்யும். அதைத் தவிர்ப்பது அந்தச் செலவை எதிர்காலத்திற்குத் தள்ளிப்போடுவது மட்டுமே. இறுதியில் நீங்கள் மாற்ற வேண்டிய சூழல் வரும்போது, அழுத்தமான நிலையில் நூற்றுக்கணக்கான கோப்புகளை நீங்கள் சரிசெய்ய வேண்டியிருக்கும். ஒரு இடைமுகம் என்பது மலிவான காப்பீடு போன்றது.

உங்கள் இடைவெளிகளை (seams) வலுப்படுத்த இந்த மூன்று பழக்கங்களைப் பயன்படுத்துங்கள்:

• இரட்டை அடையாளங்காட்டிகளைப் (dual identifiers) பயன்படுத்துங்கள். உள் தரவுத்தள இணைப்புகளுக்கு (internal database joins) வேகமான முழு எண்களைப் (integers) பயன்படுத்துங்கள். உங்கள் அமைப்பிலிருந்து வெளியேறும் எதற்கும் UUID-களைப் பயன்படுத்துங்கள். இது உங்கள் தரவை பாதுகாப்பாகவும், இணைப்புகளை வேகமாகவும் வைத்திருக்கும்.

• பொதுவான சொற்களுக்கு Enums-களைப் பயன்படுத்துங்கள். நிலைகள் (statuses) அல்லது தீவிரத்தன்மைக்காக (severities) சீரற்ற சரங்களை (random strings) பயன்படுத்த வேண்டாம். உங்கள் செயலியின் ஒவ்வொரு பகுதியும் ஒரே மொழியில் பேசுவதை உறுதி செய்ய ஒரு ஒற்றை Enum-ஐப் பயன்படுத்துங்கள்.

• தரவுகளுக்கு பதிப்புப்படுத்தப்பட்ட உறைகளை (versioned envelopes) பயன்படுத்துங்கள். உங்கள் அமைப்பு பல ஆதாரங்களில் இருந்து தரவைப் பெறுகையில், ஒரு கண்டிப்பான திட்டவரைபடத்தைப் (strict schema) பயன்படுத்துங்கள். புதிய புலங்களை (fields) மட்டும் சேர்க்கவும். புதிய பதிப்பு இல்லாமல் அவற்றை ஒருபோதும் நீக்கவோ அல்லது மறுபெயரிடவோ வேண்டாம். இது நீங்கள் அமைப்பை மேம்படுத்தும் போது பழைய கிளையண்டுகள் (clients) தொடர்ந்து இயங்குவதை உறுதி செய்யும்.

எல்லையைக் கண்டறியுங்கள். அதை ஒரு ஒப்பந்தத்தின் மூலம் பெயரிடுங்கள். அதை ஒரு எளிய செயலாக்கத்தால் (implementation) நிரப்புங்கள்.

ஒப்பந்தம் என்பது உங்கள் வாக்குறுதி. டிரைவர் என்பது இன்று நீங்கள் அந்த வாக்குறுதியை நிறைவேற்றும் முறை மட்டுமே.

Source: https://dev.to/nasrulhazim/build-the-seam-on-day-one-the-second-driver-on-day-ninety-26b