ഗൂഗിൾ ഡോക്സ് എങ്ങനെയാണ് ഒരേസമയം നടത്തുന്ന എഡിറ്റുകൾ കൈകാര്യം ചെയ്യുന്നത്
ഒരേ സമയം ഒരു ഡോക്യുമെന്റ് എഡിറ്റ് ചെയ്യാൻ ഗൂഗിൾ ഡോക്സ് പലരെയും അനുവദിക്കുന്നു.
ഒരേ സെക്കൻഡിൽ രണ്ട് ആളുകൾ ഒരേ വരി തന്നെ എഡിറ്റ് ചെയ്താൽ എന്ത് സംഭവിക്കും?
ഒരു സാധാരണ സിസ്റ്റം ഡാറ്റ വായിക്കുകയും, മാറ്റം വരുത്തുകയും, സേവ് ചെയ്യുകയും ചെയ്യുന്ന രീതിയിലാണ് പ്രവർത്തിക്കുന്നത്. രണ്ട് ആളുകൾ ഒരേസമയം സേവ് ചെയ്താൽ, രണ്ടാമത്തെ ആൾ ആദ്യത്തെ ആളുടെ മാറ്റങ്ങളെ മായ്ച്ചുകളയുന്നു (overwrites). അങ്ങനെ ആദ്യത്തെ ആളുടെ വർക്ക് നഷ്ടപ്പെടുന്നു.
ഓപ്പറേഷണൽ ട്രാൻസ്ഫോർമേഷൻ (Operational Transformation - OT) ഉപയോഗിച്ചാണ് ഗൂഗിൾ ഡോക്സ് ഇത് ഒഴിവാക്കുന്നത്.
നിങ്ങൾ ടൈപ്പ് ചെയ്യുമ്പോഴെല്ലാം ഇത് മുഴുവൻ ഡോക്യുമെന്റും അയക്കുകയല്ല ചെയ്യുന്നത്. പകരം ചെറിയ ഓപ്പറേഷനുകൾ (operations) മാത്രമാണ് അയക്കുന്നത്.
ഉദാഹരണത്തിന്:
- യൂസർ A 6-ാം സ്ഥാനത്ത് "Beautiful" എന്ന് ചേർക്കുന്നു.
- യൂസർ B 6-ാം സ്ഥാനത്ത് "Amazing" എന്ന് ചേർക്കുന്നു.
സെർവർ ഇവയിൽ മാറ്റം വരുത്താതെ നടപ്പിലാക്കിയാൽ, ഒരു എഡിറ്റ് അപ്രത്യക്ഷമാകും.
പകരം, സെർവർ ഈ ഓപ്പറേഷനുകളെ മാറ്റം വരുത്തുന്നു (transforms).
യൂസർ A ആണ് ആദ്യം ഡോക്യുമെന്റ് അപ്ഡേറ്റ് ചെയ്തതെന്ന് സെർവർ കാണുന്നു. അതോടൊപ്പം ഡോക്യുമെന്റിന്റെ വലിപ്പം കൂടുന്നു. സെർവർ യൂസർ B-യുടെ മാറ്റം പ്രോസസ്സ് ചെയ്യുമ്പോൾ, അതിന്റെ സ്ഥാനം 6-ൽ നിന്ന് 16 ആയി മാറ്റുന്നു.
അന്തിമ ടെക്സ്റ്റ് ഇതായിരിക്കും: Hello Beautiful Amazing World.
രണ്ട് എഡിറ്റുകളും നിലനിൽക്കുന്നു.
ഈ സിസ്റ്റം താഴെ പറയുന്ന സാങ്കേതിക തൂണുകളെ (technical pillars) ആശ്രയിക്കുന്നു:
- നിരന്തരമായ കണക്ഷനായി WebSockets.
- ഏത് എഡിറ്റ് ഏത് വേർഷനിൽ നിന്നാണെന്ന് അറിയാൻ വേർഷൻ ട്രാക്കിംഗ് (Version tracking).
- മാറ്റങ്ങൾ അറിയിക്കാൻ റിയൽ-ടൈം ഇവന്റ് സ്ട്രീമുകൾ (Real-time event streams).
ഗൂഗിൾ ഡോക്സ് ഡോക്യുമെന്റ് ലോക്ക് ചെയ്യുന്നില്ല. ഒരാൾ ടൈപ്പ് ചെയ്യുമ്പോൾ മറ്റുള്ളവർക്ക് ജോലി ചെയ്യാൻ കഴിയാത്ത രീതിയിൽ ലോക്ക് ചെയ്യുന്നത് തടസ്സമുണ്ടാക്കും.
പകരം, ഇത് ഇന്റലിജന്റ് മെർജിംഗ് (intelligent merging) ഉപയോഗിക്കുന്നു.
ഈ സിസ്റ്റം നിങ്ങളുടെ കർസർ പൊസിഷനും (cursor position) മാറ്റം വരുത്തുന്നു. ഒരാൾ നിങ്ങളുടെ മുന്നിൽ ടെക്സ്റ്റ് ചേർക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ സ്ഥാനം നഷ്ടപ്പെടാതിരിക്കാൻ കർസർ മുന്നോട്ട് നീങ്ങുന്നു.
ഗൂഗിൾ ഡോക്സ് OT ഉപയോഗിക്കുമ്പോൾ, Figma പോലുള്ള പുതിയ ടൂളുകൾ Conflict-free Replicated Data Types (CRDT) ആണ് ഉപയോഗിക്കുന്നത്. ഒരു സെൻട്രൽ സെർവർ ഇല്ലാതെ തന്നെ മാറ്റങ്ങൾ യോജിപ്പിക്കാൻ (merge) CRDT-കൾ ഉപയോക്താക്കളെ അനുവദിക്കുന്നു.
നിങ്ങൾ സിസ്റ്റം ഡിസൈൻ (system design) പഠിക്കുകയാണെങ്കിൽ, ഈ കാര്യങ്ങൾ ഓർമ്മിക്കുക:
- കുറഞ്ഞ ലേറ്റൻസിക്ക് (low latency) WebSockets ഉപയോഗിക്കുക.
- കോൺഫ്ലിക്റ്റ് റെസല്യൂഷനായി (conflict resolution) OT അല്ലെങ്കിൽ CRDT ഉപയോഗിക്കുക.
- മാറ്റങ്ങൾ ട്രാക്ക് ചെയ്യാൻ വേർഷൻ നമ്പറുകൾ ഉപയോഗിക്കുക.
- യൂസർ എക്സ്പീരിയൻസ് മെച്ചപ്പെടുത്താൻ കർസറുകൾ സിങ്ക് (sync) ചെയ്യുക.
ഗൂഗിൾ ഡോക്സ് കോൺഫ്ലിക്റ്റുകൾ തടയുന്നില്ല. പകരം, എല്ലാവർക്കും ഒരേ ഫലം ലഭിക്കുന്ന രീതിയിൽ എഡിറ്റുകളെ മാറ്റം വരുത്തിക്കൊണ്ട് അവ പരിഹരിക്കുന്നു.