സ്റ്റേറ്റ് ടൈപ്പുകളായി, ഒരു ഡിസൈൻ പാറ്റേൺDraft

പ്രോഗ്രാമിംഗ് എന്നത് പൂർണ്ണമായും സ്റ്റേറ്റിനെക്കുറിച്ചാണ്.

കമ്പ്യൂട്ടർ ശാസ്ത്രജ്ഞർ നിങ്ങളോട് പറയും: പ്രോഗ്രാമിംഗ് ഭാഷകൾ എന്നത് ഒരു അമൂർത്ത ട്യൂറിംഗ് മെഷീന്റെ ഡിഎഫ്എ (അല്ലെങ്കിൽ സ്റ്റേറ്റ് മെഷീൻ) നിർവ്വചിക്കാനുള്ള ഒരു മാർഗ്ഗം മാത്രമാണെന്ന്. മറുവശത്ത്, ഹാർഡ്വെയർ എഞ്ചിനീയർമാർ നിങ്ങളോട് പറയും: പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്ന ഭൗതിക വസ്തുവായ സിപിയു, അത് അക്ഷരാർത്ഥത്തിൽ ട്രാൻസിസ്റ്ററുകൾ കൊണ്ട് എൻകോഡ് ചെയ്ത ഒരു സ്റ്റേറ്റ് മെഷീൻ തന്നെയാണ്.

പ്രോഗ്രാമിംഗ് എന്നത് പൂർണ്ണമായും സ്റ്റേറ്റിനെക്കുറിച്ചാണ്.

സിന്റാക്സ് അവഗണിച്ചാൽ, ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയെ മറ്റൊന്നിൽ നിന്ന് വേർതിരിക്കുന്നത് അത് സ്റ്റേറ്റ് എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്നതാണെന്ന് വാദിക്കാം. ഭാഷകൾ സ്റ്റേറ്റ് എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് തരംതിരിക്കാനുള്ള ഒരു മാർഗ്ഗം, അതിൽ എത്രമാത്രം കംപൈൽ-ടൈമിൽ എത്രമാത്രം റൺ-ടൈമിൽ പരിഹരിക്കപ്പെടുന്നു എന്ന് പരിഗണിക്കുക എന്നതാണ്.

ഏറ്റവും ഇടതുവശത്ത് പൈത്തൺ, ലുവ പോലുള്ള പൂർണ്ണമായും ഇന്റർപ്രെറ്റ് ചെയ്യപ്പെടുന്ന ഭാഷകൾ ¹ ആണ്, അവർക്ക് റൺടൈമിൽ എത്തുന്നതുവരെ എന്ത് നിർദ്ദേശങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യണമെന്ന് പോലും അറിയില്ല. മറുവശത്ത്, റസ്റ്റ്, സി++ പോലുള്ള ശക്തമായി ടൈപ്പ് ചെയ്ത, കംപൈൽ ചെയ്യപ്പെടുന്ന ഭാഷകൾ ഉണ്ട്, അവയ്ക്ക് കംപൈൽ ചെയ്യുന്നതിന് മുമ്പ് പ്രോഗ്രാമിനെക്കുറിച്ച് വിപുലമായ വിവരങ്ങൾ ആവശ്യമാണ്.

ഭാഷ സ്പെക്ട്രത്തിൽ എവിടെയായിരുന്നാലും ട്രേഡോഫുകൾ ഉണ്ട്. ടൈപ്പുകൾ, മെമ്മറി, ലൈഫ്റ്റൈം എന്നിവയെക്കുറിച്ച് വിപുലമായ വിവരങ്ങൾ ആവശ്യപ്പെടുന്ന വളരെ കർശനമായ ഭാഷകൾ പലപ്പോഴും നിർമ്മിക്കാനും ഇറ്ററേറ്റ് ചെയ്യാനും ബുദ്ധിമുട്ടുള്ളതാണ്, പക്ഷേ റൺടൈമിൽ വളരെ കാര്യക്ഷമമാണ്. എന്നാൽ മറുവശത്തുള്ള ഭാഷകൾ വിപരീതമാണ്: എന്തെങ്കിലും വേഗത്തിൽ എഴുതാൻ എളുപ്പമുള്ളത്, പക്ഷേ ഗണ്യമായ റൺടൈം ചെലവുമായി വരുന്നു.

ശക്തമായി ടൈപ്പ് ചെയ്ത ഭാഷകൾ നിസ്സംശയമായി തിളങ്ങുന്ന ഒരു മേഖലയുണ്ട്: പിശക് മാനേജ്മെന്റ്. മിക്കവാറും, ഇന്റർപ്രെറ്റ് ചെയ്യപ്പെടുന്ന ഭാഷകളുടെ തത്വശാസ്ത്രം പ്രവർത്തിപ്പിച്ച ശേഷം ഡീബഗ് ചെയ്യുകയും എന്തെങ്കിലും അപ്രതീക്ഷിതമായ എക്സെപ്ഷനുകൾ എറിയപ്പെടുന്നുണ്ടോ എന്ന് നോക്കുകയുമാണ്.

അൽഗോരിതം Y: ഇന്റർപ്രെറ്റ് ചെയ്യപ്പെടുന്ന ഭാഷ ഡീബഗ്ഗിംഗ് (ലഘൂകരിച്ചത്)

1. കോഡ് എഴുതുക
2. കോഡ് പ്രവർത്തിപ്പിക്കുക
3. എങ്കിൽ പിശകൊന്നുമില്ലെങ്കിൽ, ഘട്ടം 6 ലേക്ക് പോകുക
4. പിശക് കൈകാര്യം ചെയ്യുക
5. ഘട്ടം 2 ലേക്ക് പോകുക
6. ഡിപ്ലോയ് ചെയ്യുക

നിങ്ങൾ ഡെവലപ്മെന്റ് സമയത്തെ റൺടൈം പ്രകടനത്തിന് മുകളിൽ വിലമതിക്കുന്നുണ്ടോ, അല്ലെങ്കിൽ തിരിച്ചും, പ്രോഗ്രാമുകൾ ശരിയായതും പിശകുകളോട് ശക്തവുമായിരിക്കണം എന്ന് നമുക്കെല്ലാവർക്കും സമ്മതിക്കാമെന്ന് ഞാൻ കരുതുന്നു.

ഒരു ഡിസൈൻ പാറ്റേൺ നോക്കാം, അത് റൺടൈം ലോജിക്കിനെ വിഭാഗീകരിക്കാനും കംപൈൽ ടൈമിലേക്ക് (അല്ലെങ്കിൽ കോഡ്-എഴുത്ത്-സമയത്തിലേക്ക്, ഒരു ഇന്റർപ്രെറ്റ് ചെയ്യപ്പെടുന്ന ഭാഷ ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ) മാറ്റാനും സഹായിക്കുന്നു. ഫലപ്രദമായി, അത് ഭാഷയുടെ ടൈപ്പ് സിസ്റ്റം ഉപയോഗിച്ച് നിയമവിരുദ്ധമായ ഒബ്ജക്റ്റ് സ്റ്റേറ്റുകൾ തടയുന്ന ഒരു സ്റ്റേറ്റ് പൈപ്പ്ലൈൻ സൃഷ്ടിക്കും. വിഷമിക്കേണ്ട, സ്റ്റാറ്റിക് ടൈപ്പിംഗ് അത്യാവശ്യമല്ല.

ഈ പാറ്റേൺ ഉപയോഗിക്കുന്ന ഒരു റീഫാക്റ്ററിന്റെ ഒരു ഉദാഹരണം നോക്കാം.

ടാസ്ക്

ബോസ് ഞങ്ങളോട് പറയുന്നത്, ഏതെങ്കിലും url ചൂണ്ടിക്കാണിക്കുന്ന ഏത് ഫയലിലും ഒരു നിശ്ചിത അക്ഷരം എത്ര തവണ വരുന്നു എന്ന് കണക്കാക്കുന്ന ഒരു ലൈബ്രറി എഴുതേണ്ടത് അത്യാവശ്യമാണെന്നാണ്. കൂടാതെ, ഞങ്ങളുടെ കോഡ് ഉപയോഗിക്കുന്നയാൾക്ക് ഫയൽ ഏത് സമയത്തും ഡൗൺലോഡ് ചെയ്യാൻ കഴിയണമെന്നും അദ്ദേഹം ആഗ്രഹിക്കുന്നു.

നല്ലത്. കൃത്യമായി അത് ചെയ്യുന്ന ഒരു ക്ലാസ് ഉണ്ടാക്കാം.

class FileDownloadCharCounter:
    def __init__(self, url):
		# ആർഗ്യുമെന്റ് ഇൻസ്റ്റൻസ് വേരിയബിളായി സംരക്ഷിക്കുക
        self.url = url

    def download(self):
		# ഉള്ളടക്കം ഡൗൺലോഡ് ചെയ്ത് പിന്നീടുള്ള ഉപയോഗത്തിനായി സംരക്ഷിക്കുക
        self.downloaded_content = requests.get(self.url).text

    def create_index(self):
		# അക്ഷര എണ്ണം സംഭരിക്കുന്ന ഒരു ഡിക്ഷണറി സൃഷ്ടിക്കുക
        self.index = {}
        for char in self.downloaded_content:
            self.index[char] = self.index.get(char, 0) + 1

    def get_count(self, target_char):
		# ഡിക്ഷണറിയിൽ നിന്ന് എണ്ണം എടുക്കുക
        return self.index.get(target_char, 0)

ഈ വ്യായാമത്തിനായി, requests.get ഒരിക്കലും പരാജയപ്പെടില്ലെന്ന് കരുതുക. ക്ലാസ് പരീക്ഷിക്കാം.

counter = FileDownloadCharCounter(
	"https://world.hey.com/dhh/programming-types-and-mindsets-5b8490bc"
)
counter.download()
counter.create_index()
target = "a"
n = counter.get_count("a")
print(f"{target} appears {n} times")

a appears 477 times

കൊള്ളാം! ഡിപ്ലോയ് ചെയ്യാനുള്ള സമയമായോ? അത്ര വേഗമല്ല… നിങ്ങൾ ശ്രദ്ധാപൂർവ്വം നോക്കിയാൽ, ഞങ്ങൾ അവതരിപ്പിച്ചിട്ടുള്ള കുറച്ച് കൈകാര്യം ചെയ്യപ്പെടാത്ത എക്സെപ്ഷനുകൾ ഉണ്ട്. ഉപയോക്താവ് ഇത് ചെയ്താൽ എന്ത് സംഭവിക്കും?

counter = FileDownloadCharCounter(
	"https://world.hey.com/dhh/programming-types-and-mindsets-5b8490bc"
)
counter.download()
target = "a"
n = counter.get_count("a")

AttributeError: 'FileDownloadCharCounter' object has no attribute 'index'

അയ്യോ. ഉപയോക്താവ് ഇൻഡെക്സ് സൃഷ്ടിക്കാൻ മറന്നാൽ, അവർക്ക് ഒരു AttributeError ലഭിക്കും, അത് വളരെ സഹായകരമല്ല. എന്ത് തെറ്റായി എന്ന് കണ്ടെത്താൻ അവർ ലൈബ്രറി സോഴ്സ് കോഡ് വായിക്കേണ്ടി വരും, അതൊരു മികച്ച ഉപയോക്തൃ അനുഭവമല്ല. ഉപയോക്താവിന് കൈകാര്യം ചെയ്യാനും പരിഹരിക്കാനും കഴിയുന്ന, സ്വയം വിശദീകരിക്കുന്ന ഒരു എക്സെപ്ഷൻ നമുക്ക് സൃഷ്ടിക്കാം:

class IndexNotCreatedException(Exception):
	pass

class FileDownloadCharCounter:
    def __init__(self, url):
		# മറ്റ് കോഡ് ...
        self.index = {}

	# മറ്റ് മെത്തേഡുകൾ ...

    def get_count(self, target_char):
        if len(self.index) == 0:
            raise IndexNotCreatedException
        return self.index[target_char]

ഇപ്പോൾ നമുക്ക് ഒരു നല്ല

File "example.py", line 31, in get_count
    raise IndexNotCreatedException
__main__.IndexNotCreatedException

ലഭിക്കുന്നു, അത് നമുക്ക് ഇങ്ങനെ കൈകാര്യം ചെയ്യാം:

try:
	count = counter.get_count('a')
except IndexNotCreatedException:
	# പുനഃസ്ഥാപിക്കുക
	pass

ഇത് തകരാൻ കഴിയുന്ന മറ്റൊരു വഴി ഉണ്ടോ? അതെ:

counter.create_index()
target = "a"
n = counter.get_count("a")

  File "example.py", line 13, in create_index
    for char in self.downloaded_content:
AttributeError: 'FileDownloadCharCounter' object has no attribute 'downloaded_content'

ലൈബ്രറി ഉപയോക്താവ് ഫയൽ ഡൗൺലോഡ് ചെയ്യാൻ മറന്നാൽ, അത് മറ്റൊരു AttributeError എറിയുന്നു, അത് വളരെ സഹായകരമല്ല. അത് കൈകാര്യം ചെയ്യാം.

class FileNotDownloadedException(Exception):
    pass

class FileDownloadCharCounter:
    def __init__(self, url):
		# ...
        self.downloaded = False

    def download(self):
		# ...
        self.downloaded = True

    def create_index(self):
        if not self.downloaded:
            raise FileNotDownloadedException
		# ...

ഇപ്പോൾ, ഉപയോക്താവിന് മുകളിൽ ചെയ്തതുപോലെ ഈ എക്സെപ്ഷൻ കൈകാര്യം ചെയ്യാനാകും. ഇപ്പോഴും മറ്റൊരു ബഗ് ഉണ്ട്; നിങ്ങൾക്ക് അത് കണ്ടെത്താനാകുമോ? ഉപയോക്താവ് ആകസ്മികമായി ഇത് ചെയ്താൽ എന്ന് കരുതുക.

counter = FileDownloadCharCounter(
	"https://world.hey.com/dhh/programming-types-and-mindsets-5b8490bc"
)
counter.download()
counter.create_index()
# മറ്റ് പ്രധാന കാര്യങ്ങൾ...
counter.create_index()
# കൂടുതൽ പ്രധാന കാര്യങ്ങൾ...
target = "a"
n = counter.get_count("a")
print(f"{target} appears {n} times")

ഇപ്പോൾ നമുക്ക് യഥാർത്ഥ എണ്ണത്തിന്റെ ഇരട്ടി ലഭിക്കുന്നു!

a appears 954 times

കൂടാതെ എക്സെപ്ഷൻ ഇല്ല. അതിനർത്ഥം ഈ ബഗ് അൽഗോരിതം Y കൊണ്ട് പിടികിട്ടിയില്ല എന്നാണ്. വീണ്ടും, ഇത് കൈകാര്യം ചെയ്യാം.

class IndexNotCreatedException(Exception):
    pass

class FileDownloadCharCounter:
	# മെത്തേഡുകൾ...

    def create_index(self):
        if len(self.index) > 0:
            raise IndexAlreadyCreatedException
		# കൂടുതൽ കോഡ്...

ഫൂ! അത് തോന്നുന്നത് സ്റ്റേറ്റ്-ബന്ധപ്പെട്ട എല്ലാ പിശകുകളും ആയിരിക്കാം. ഇതാണ് ഞങ്ങളുടെ അവസാന കോഡ്:

class IndexNotCreatedException(Exception):
    pass

class IndexAlreadyCreatedException(Exception):
    pass

class FileNotDownloadedException(Exception):
    pass

class FileDownloadCharCounter:
    def __init__(self, url):
        self.url = url
        self.index = {}
        self.downloaded = False

    def download(self):
        self.downloaded_content = requests.get(self.url).text
        self.downloaded = True

    def create_index(self):
        if not self.downloaded:
            raise FileNotDownloadedException

        if len(self.index) == 0:
            raise IndexAlreadyCreatedException

        for char in self.downloaded_content:
            self.index[char] = self.index.get(char, 0) + 1

    def get_count(self, target_char):
        if len(self.index) == 0:
            raise IndexNotCreatedException

        return self.index.get(target_char, 0)

എറ്റ് വോയില! ഞങ്ങളുടെ ഒബ്ജക്റ്റ് ഓറിയന്റഡ് കോഡ്… ഭയങ്കരമാണ്. കേവലം കുറച്ച് ലളിതമായ പൈത്തൺ വരികൾ മാത്രമായിരിക്കേണ്ടതിന്, ഞങ്ങൾക്ക് 3 ഇഷ്ടാനുസൃത എക്സെപ്ഷനുകളും ഒന്നും തെറ്റിയില്ലെന്ന് ഉറപ്പുവരുത്തുന്ന ഒരു കൂട്ടം ലോജിക്കും ഉണ്ട്.

കൂടാതെ, സ്റ്റേറ്റ് ട്രാക്ക് ചെയ്യുന്ന 3 ഇൻസ്റ്റൻസ് വേരിയബിളുകൾക്ക് പകരം, 30 ഉണ്ടായിരുന്നെങ്കിൽ, എല്ലാ നിയമവിരുദ്ധ സ്റ്റേറ്റുകളും അറിയുകയോ എണ്ണുകയോ ചെയ്യാൻ പോലും സാധ്യമല്ലായിരിക്കാം, അതിനായി എക്സെപ്ഷനുകൾ എറിയാൻ.

നിർഭാഗ്യവശാൽ, ധാരാളം ഇന്റർപ്രെറ്റഡ് ഭാഷകൾ റോബസ്റ്റ് കോഡ് എഴുതുന്നത് വിരസമാക്കുന്നു. ഇതിനെ നേരിടാൻ സഹായിക്കുന്നതിന്, ഒരു പുതിയ ഡിസൈൻ പാറ്റേൺ അവതരിപ്പിക്കാം, അതിനെ ഞാൻ ടൈപ്പ് പൈപ്പ്ലൈൻ അല്ലെങ്കിൽ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ടൈപ്പ്ലൈൻ എന്ന് വിളിക്കും.

നിലനിൽപ്പ് $implies$ അവസ്ഥ

ഈ ട്രിക്ക് ഉപയോഗിച്ച്, സ്റ്റാറ്റിക്കലി-ടൈപ്പ് ചെയ്ത ഭാഷകളിൽ, അനുവദനീയമല്ലാത്ത അവസ്ഥയുള്ള കോഡ് കംപൈൽ ചെയ്യില്ല. ഡൈനാമിക്കലി ടൈപ്പ് ചെയ്തവയിൽ, നിങ്ങൾക്ക് ഒരു TypeError ലഭിക്കുന്നില്ലെങ്കിൽ, ഒരു ഗ്യാരണ്ടീ ചെയ്ത അനുവദനീയമായ അവസ്ഥ ലഭിക്കും.

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു:

• ഒരു ടൈപ്പ് $T$ ഒരു അവസ്ഥ $Y$ യുമായി ബന്ധിപ്പിക്കുക
• $T$ യുടെ ഒരു ഇൻസ്റ്റൻസ് ഒബ്ജക്റ്റ് $t$ യുടെ നിലനിൽപ്പ് ഞങ്ങൾ $Y$ അവസ്ഥയിലാണെന്ന് ഉറപ്പാക്കുക

അത് അത്ര ലളിതമാണ്. നമുക്ക് ഇപ്പോൾ നമ്മുടെ മുമ്പത്തെ കോഡ് റീഫാക്ടർ ചെയ്യാൻ ശ്രമിക്കാം. നമ്മുടെ പ്രോഗ്രാമിന്റെ സാധുവായ അവസ്ഥകൾ പരിഗണിക്കുക

ഇതൊരു ലളിതമായ ലീനിയർ പൈപ്പ്ലൈൻ ആണെന്ന് വ്യക്തമാണ്. അവസ്ഥ 1 ല് ഒരു URL ഇൻപുട്ട് ആവശ്യമാണ്, അവസ്ഥ 2 ല് അവസ്ഥ 1 ആവശ്യമാണ്, അവസ്ഥ 3 ല് അവസ്ഥ 2 ആവശ്യമാണ്.

$T_n$ എന്നത് അവസ്ഥ $N$ നോട് യോജിക്കുന്ന ടൈപ്പ് ആണെങ്കിൽ, $T_n$ ന്റെ ഒരു ഇൻസ്റ്റൻസ് നിർമ്മിക്കുന്നത് $T\_n-1$ ന്റെ ഒരു ഇൻസ്റ്റൻസ് വഴി മാത്രമേ ആകുയാവൂ. നമുക്ക് അവസ്ഥ 1 ൽ തുടങ്ങാം, അതിന് ഒരു സാധുവായ URL മാത്രമേ ആവശ്യമുള്ളൂ.

class FileURL: # അതായത് T_1
	def __init__(self, url):
		# ഐച്ഛികമായി url സാധുത പരിശോധിക്കുക
		self.url = url

$T_2$ നിർമ്മിക്കുന്നത് $T_1$ ന്റെ ഒരു ഇൻസ്റ്റൻസിൽ നിന്ന് മാത്രമാകണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നതിനാൽ, $T_1$ ലേക്ക് ഒരു മെത്തേഡ് ചേർക്കാം, അത് സാധുവായ അവസ്ഥയിൽ (ഫയൽ ഡൗൺലോഡ് ചെയ്തു) ഒരു $T_2$ നിർമ്മിക്കുന്നു.

class FileURL:
	# മറ്റ് മെത്തേഡുകൾ ...
	def download_file(self, file_url: FileURL) -> DownloadedFile:
		file_contents = requests.get(file_url).text
		return DownloadedFile(file_contents)

class DownloadedFile:
	def __init__(self, file_contents: str):
		self.contents = file_contents

ഞങ്ങൾ $T_3$ നായി ഇത് ആവർത്തിക്കുന്നു, അത് ഒരു ഇൻഡെക്സ് ചെയ്ത ഫയലിനെ പ്രതിനിധീകരിക്കുന്നു

class DownloadedFile:
	# മറ്റ് മെത്തേഡുകൾ ...
	def index_file(self) -> IndexedFile:
		index = {}
		for char in content:
            index[char] = index.get(char, 0) + 1
		return IndexedFile(index)

class IndexedFile:
	def __init__(self, index: dict[str, int]):
		self.index = index

	def get_count(self, target_char):
		return self.index.get(target_char, 0)

ഇപ്പോൾ, ഈ എല്ലാ ക്ലാസുകളും ആശയം പ്രകടിപ്പിക്കുന്നതിന് മാത്രമാണ്. യഥാർത്ഥത്തിൽ ഉപയോക്താവിന് ഒരു ഡൗൺലോഡ് ചെയ്ത-പക്ഷേ-ഇൻഡെക്സ് ചെയ്യാത്ത ഫയലിലേക്കോ അല്ലെങ്കിൽ ഒരു സ്ട്രിംഗ് മാത്രം റാപ്പ് ചെയ്യുന്ന ഒരു URL ക്ലാസിലേക്കോ ആക്സസ് നൽകേണ്ടതില്ല. ഫയൽ ഡിമാൻഡിൽ ഡൗൺലോഡ് ചെയ്യാനും കാരക്ടർ കൗണ്ടുകൾ ലഭിക്കാനും മാത്രമേ അവർക്ക് കഴിയൂ.

അതിനാൽ, ആ അവസ്ഥകളുമായി ബന്ധപ്പെട്ട ടൈപ്പുകൾ നീക്കംചെയ്ത് ലോജിക് ഒരു ട്രാൻസിഷൻ മെത്തേഡിലോ കൺസ്ട്രക്ടറിലോ നിറയ്ക്കാം.

class FileURL:
	def __init__(self, url):
		self.url = url

	# അവസ്ഥ 1 -> 3
	def fetch_index(self) -> CharIndex:
		# അവസ്ഥ 1 -> 2
		content = requests.get(url).text
		# അവസ്ഥ 2 -> 3
		return CharIndex(content)

class CharIndex:
	# അവസ്ഥ 2 -> 3
	def __init__(self, content: str):
		index = {}
		for char in content:
            index[char] = index.get(char, 0) + 1
		self.index = index

	def get_count(self, target_char):
		return self.index.get(target_char, 0)

ഉപയോഗം:

file = FileURL("https://world.hey.com/dhh/programming-types-and-mindsets-5b8490bc")
index = file.fetch_index()
count = index.get_count('a')

ട്രാൻസിഷൻ/കൺസ്ട്രക്ഷൻ ഗ്യാരണ്ടികൾ ഉപയോഗിച്ച് അനുവദനീയമല്ലാത്ത അവസ്ഥ ഇനി ഒരു പ്രശ്നമല്ലെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും.

എന്നിരുന്നാലും, ചില മുന്നറിയിപ്പുകളുണ്ട്. ഈ പാറ്റേൺ ഇനിപ്പറയുന്നവയിൽ മാത്രമേ പ്രവർത്തിക്കൂ

1. അവസ്ഥകൾ കംപൈൽ/കോഡ് എഴുതുന്ന സമയത്ത് അറിയാം (അതായത്, വരി $n$ ലെ ഒബ്ജക്റ്റിന് ഉണ്ടായിരിക്കണം അവസ്ഥ $X$)
2. അത്തരം അവസ്ഥകൾ കുറച്ച് മാത്രമേയുള്ളൂ, കാരണം ഓരോന്നിനും ഒരു പുതിയ ക്ലാസ് സൃഷ്ടിക്കേണ്ടി വന്നേക്കാം

ചില ഗുണങ്ങൾ

ഗാർബേജ് കളക്ട് ചെയ്യപ്പെടുന്ന ഭാഷകളിൽ, ഒരു വലിയ ഗുണം മെമ്മറി കാര്യക്ഷമതയാണ്. നമ്മുടെ ഉദാഹരണത്തിലേക്ക് തിരിച്ചുപോയാൽ, യഥാർത്ഥ ക്ലാസിൽ, ഡൗൺലോഡ് ചെയ്ത ഫയലിന് മുഴുവൻ ഒബ്ജക്റ്റിന്റെയും ലൈഫ്റ്റൈം (ആയുസ്സ്) തന്നെയുണ്ട്. ഇതിനർത്ഥം, ഒബ്ജക്റ്റിലേക്ക് എങ്ങനെയെങ്കിലും ഒരു റഫറൻസ് നിലനിൽക്കുന്നിടത്തോളം, സൈറ്റിന്റെ മുഴുവൻ സ്ട്രിംഗും മെമ്മറിയിൽ സൂക്ഷിച്ചിരിക്കും എന്നാണ്.

counter = FileDownloadCharCounter(...)
counter.download_file()  # സ്ട്രിംഗിനുള്ള സ്ഥലം അനുവദിക്കുന്നു
counter.create_index()   # ഇൻഡെക്സ് ഡിക്റ്റ് അനുവദിക്കുന്നു
counter.get_count('a')

# സ്കോപ്പ് അവസാനിക്കുമ്പോൾ എല്ലാം മോചിപ്പിക്കുന്നു

എന്നാൽ ടാസ്കിൽ നിന്ന് നമുക്കറിയാം, ഇൻഡെക്സ് സൃഷ്ടിച്ച ശേഷം ഫയലിന്റെ ഉള്ളടക്കം ഇനി നമുക്ക് ആവശ്യമില്ല. ടൈപ്പ്ലൈൻ ഡാറ്റ ട്രാൻസ്ഫോർമേഷനെ അടിസ്ഥാനമാക്കിയാണ് നിർമ്മിച്ചിരിക്കുന്നത് എന്നതിനാൽ, ലൈഫ്റ്റൈമുകൾ വ്യക്തമായി നിർവ്വചിച്ചിരിക്കുന്നു. ഒരു ഡാറ്റയുടെ ഭാഗം ഇനി ആവശ്യമില്ലെങ്കിൽ, അത് ജിസിയുടെ സഹായത്തോടെ സുരക്ഷിതമായി നശിപ്പിക്കാവുന്നതാണ്.

file = FileURL(...)
index = file.fetch_index() # സ്ട്രിംഗ് അനുവദിച്ച് ഉടൻ തന്നെ മോചിപ്പിക്കുന്നു
count = index.get_count('a') # ഇൻഡെക്സ് അനുവദിക്കുന്നു
# സ്കോപ്പ് അവസാനിക്കുമ്പോൾ ഇൻഡെക്സ് മോചിപ്പിക്കുന്നു

നാം ഡൗൺലോഡ് ചെയ്ത ഫയൽ നിരവധി ജിബി വലുപ്പമുള്ളതാണെങ്കിലോ, നാം ആയിരക്കണക്കിന് വെബ്സൈറ്റുകൾ ഒരേസമയം സ്ക്രാപ്പ് ചെയ്യുകയാണെങ്കിലോ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

ഉപസംഹാരം

ഈ ലേഖനം ഒരു ലളിതമായ ഡിസൈൻ പാറ്റേൺ വിവരിക്കുന്നു, streamrip v2 എഴുതുമ്പോൾ ഇത് എനിക്ക് ഉപയോഗപ്രദമായി തോന്നി. ഇത് v1-ൽ ഉണ്ടായിരുന്ന വളരെയധികം സാധ്യതയുള്ള സ്റ്റേറ്റ് പിശകുകൾ പരിഹരിക്കുകയും കോഡ്ബേസ് ഗണ്യമായി ലളിതമാക്കുകയും ചെയ്തു. ഈ കൃത്യമായ ആശയം ഞാൻ മുമ്പ് കണ്ടിട്ടില്ലെങ്കിലും, ഇത് ഒരിക്കലും ഒറിജിനൽ അല്ല. ടൈപ്പ്ലൈൻ എന്നത് ചില സൈഡ് ഇഫക്റ്റ് മാനേജ്മെന്റുമായി ഒരു DFA-യെ എൻകോഡ് ചെയ്യുന്നതിനുള്ള ഒരു ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് മാർഗ്ഗം മാത്രമാണ്. അതിനാൽ, DFA-കളിൽ ചെയ്തിട്ടുള്ള എല്ലാ സൈദ്ധാന്തിക പ്രവർത്തനങ്ങളും ഇവിടെ തുല്യമായി ബാധകമാണ്.

ഈ പാറ്റേൺ നിങ്ങൾ എവിടെയെങ്കിലും കണ്ടെത്തിയിട്ടുണ്ടെങ്കിൽ എന്നെ അറിയിക്കുക!