ഉപേക്ഷിക്കപ്പെട്ട ഓരോ റെപ്പോസിറ്ററിയും ഒരിക്കൽ രാത്രി 2 മണിയിലെ ഒരു ആവേശമായിരുന്നു. ആ താളം നിങ്ങൾക്ക് അറിയാം. അർദ്ധരാത്രിയോടെയാണ് ആ ആശയം കടന്നുവരുന്നത്. കാപ്പി തണുക്കുന്നതിന് മുമ്പ് തന്നെ നിങ്ങൾ റെപ്പോസിറ്ററിയുടെ അടിത്തറ പാകുന്നു. ഒടുവിൽ അത് വിജയിച്ചു എന്ന് ഉറപ്പുള്ള ഒരാളുടെ അതിശക്തമായ ഊർജ്ജത്തോടെ പതിനൊന്ന് ദിവസം നിങ്ങൾ കോഡ് പുഷ് ചെയ്യുന്നു. പിന്നെ ആ സ്പ്രിന്റ് അവസാനിക്കുന്നു. അല്ലെങ്കിൽ ബോയിലർ കേടാകുന്നു. അല്ലെങ്കിൽ ഒരു ചൊവ്വാഴ്ച വൈകുന്നേരം നിങ്ങൾ കോഡ് തുറക്കുമ്പോൾ ആ താൽപ്പര്യം അപ്രത്യക്ഷമാകുന്നു.

മിക്ക ഡെവലപ്പർമാരും ഈ ഭാരം ചുമക്കുന്നുണ്ട്. ഇത് പൂർണ്ണമായ ഒരു പശ്ചാത്താപമല്ല, മറിച്ച് "എന്താകില്ലായിരുന്നു" എന്നതിനെക്കുറിച്ചുള്ള ഒരു നിശബ്ദമായ ചിന്തയാണ്. നിങ്ങളുടെ GitHub പ്രൊഫൈൽ നല്ല ഉദ്ദേശ്യങ്ങളുടെ ഒരു ശേഖരമായി മാറുന്നു. Side Project Cemetery-യുടെ സ്രഷ്ടാവ് ഇതിനെ നേരിട്ട് അഭിമുഖീകരിക്കുന്ന ഒന്ന് നിർമ്മിച്ചു. അവരുടെ ടൂൾ നിങ്ങളുടെ പബ്ലിക് പ്രൊഫൈലിനെ ഒരു നിലാവുള്ള ശ്മശാനമാക്കി മാറ്റുന്നു; അവിടെ ഓരോ പഴയ റെപ്പോസിറ്ററിക്കും ഒരു ശവകുടീരവും, മരിച്ച തീയതിയും, ഇടയ്ക്കിടെ ഒരു തമാശയും ലഭിക്കുന്നു.

ശ്മശാനം വളരുന്നു

സാധാരണ കാരണങ്ങളാലാണ് സൈഡ് പ്രോജക്റ്റുകൾ മരിക്കുന്നത്. നിങ്ങൾക്ക് ഒരു പുതിയ ഫ്രെയിംവർക്ക് പഠിക്കണമായിരുന്നു, അതിനാൽ നിങ്ങൾ ഒരു CLI ടൂൾ നിർമ്മിച്ചു. ഒരു സ്പ്രെഡ്ഷീറ്റ് ഓട്ടോമേറ്റ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിച്ചു, അതിനാൽ ഒരു Python wrapper എഴുതി. നിങ്ങളുടെ പ്രശ്നം പരിഹരിക്കാൻ പ്രോട്ടോടൈപ്പ് മതിയാകുമായിരുന്നു, അത്രമാത്രം. അവിടെ കാത്തുനിൽക്കുന്ന ഉപയോക്താക്കളോ, നിശ്ചിത സമയപരിധിയോ, സ്റ്റാറ്റസ് ചോദിക്കുന്ന മാനേജരോ ഉണ്ടായിരുന്നില്ല. പുറത്തുനിന്നുള്ള സമ്മർദ്ദമില്ലാതെ, താൽപ്പര്യം മാത്രമാണ് പ്രോജക്റ്റിനെ മുന്നോട്ട് കൊണ്ടുപോകേണ്ടത്. താൽപ്പര്യം കുറയുമ്പോൾ പ്രോജക്റ്റ് നിശ്ചലമാകുന്നു.

ഒരു സാധാരണ ഡെവലപ്പറുടെ GitHub സന്ദർശിച്ചാൽ നിങ്ങൾക്ക് ആ പാറ്റേൺ കാണാം. ഒരു റെപ്പോസിറ്ററിക്കായി Rust നിറത്തിലുള്ള contribution graph. "TODO: write tests" എന്ന് അവസാനിക്കുന്ന ഒരു README. ആറ് മാസം മുമ്പ് പെട്ടെന്ന് നിലച്ചുപോയ ഒരു commit history. നാണക്കേടുണ്ടാക്കുന്ന ഓർമ്മപ്പലകകളെപ്പോലെയാണ് നമ്മൾ ഈ റെപ്പോസിറ്ററികളോട് പെരുമാറുന്നത്. അപൂർണ്ണമായ കോഡ് ഒളിച്ചുവെക്കേണ്ട ഒന്നാണെന്ന പോലെ നമ്മൾ അവ വേഗത്തിൽ സ്ക്രോൾ ചെയ്ത് കടന്നുപോകുന്നു. Side Project Cemetery ഇതിന് വിപരീതമാണ്. അത് പറയുന്നു: അവയെ ശരിയായി അടക്കം ചെയ്യുക. അവയെ അംഗീകരിക്കുക. എന്നിട്ട്, നിങ്ങൾക്ക് വേണമെങ്കിൽ, അവയിൽ ഒന്നിനെ തിരികെ കൊണ്ടുവരിക.

ശ്മശാനം എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഇതിന്റെ ഇന്റർഫേസ് ലളിതവും വ്യക്തവുമാണ്. നിങ്ങൾ ഏതെങ്കിലും GitHub യൂസർനെയിം ടൈപ്പ് ചെയ്യുന്നു. ആപ്പ് GitHub REST API ഉപയോഗിച്ച് എല്ലാ പബ്ലിക് റെപ്പോസിറ്ററികളും എടുക്കുകയും കഴിഞ്ഞ നൂറ്റി എൺപത് ദിവസമായി പുഷ് ചെയ്യാത്തവയെ മാത്രം തിരഞ്ഞെടുക്കുകയും ചെയ്യുന്നു. ഓരോ ഫലവും ഒരു ശവകുടീരമായി മാറുന്നു. നിങ്ങൾക്ക് അതിന്റെ ജനന വർഷവും മരണ വർഷവും, റെപ്പോസിറ്ററിലെ വിവരങ്ങളിൽ നിന്ന് തയ്യാറാക്കിയ ഒരു epitaph-ഉം കാണാം.

ചില epitaph-കൾ ലളിതമാണ്:

  • JavaScript-ൽ എഴുതപ്പെട്ടത്. Callback exhaustion കാരണം മരിച്ചു.

മറ്റുള്ളവ ചരിത്രത്തെ കുറച്ചുകൂടി രസകരമായി അവതരിപ്പിക്കുന്നു:

  • മരിച്ചിട്ടില്ല. 2025 മുതൽ വളരെ ഗൗരവമായി നിർത്തിവെച്ചിരിക്കുകയാണ്.

നിങ്ങൾക്ക് കൂടുതൽ വ്യക്തിത്വം വേണമെന്നുണ്ടെങ്കിൽ, ഓപ്ഷണലായി Gemini integration ഉപയോഗിക്കാം. AI റെപ്പോസിറ്ററിലെ ഭാഷയും സന്ദർഭവും വായിച്ച്, വെറുമൊരു ടെംപ്ലേറ്റ് പോലെയല്ലാതെ പ്രത്യേകമായ epitaph-കൾ തയ്യാറാക്കുന്നു. കൂടാതെ, ആദരാഞ്ജലി (eulogy) ഉച്ചത്തിൽ വായിക്കാൻ ElevenLabs integration-ഉം ലഭ്യമാണ്. നിങ്ങളുടെ ഉപേക്ഷിക്കപ്പെട്ട ഒരു API wrapper ഗൗരവമുള്ള ഒരു ശബ്ദത്തിൽ വിവരിക്കുന്നത് കേൾക്കുന്നത് വരെ ഇതൊരു വെറും തമാശയായി നിങ്ങൾക്ക് തോന്നാം. എന്നാൽ ആ നിമിഷം, ആ വിഡ്ഢിത്തം നിങ്ങളുടെ കുറ്റബോധത്തെ ഇല്ലാതാക്കുന്നു; ആ കുറ്റബോധമായിരുന്നു പ്രോജക്റ്റ് അടക്കം ചെയ്തു വെച്ചിരുന്നത്.

Rekindle: അമിതഭാരം ഒഴിവാക്കാൻ ഒരു ബട്ടൺ

ശ്മശാനം എന്നത് പകുതി കാര്യം മാത്രമാണ്. യഥാർത്ഥ ഫീച്ചർ ഓരോ ശവകുടീരത്തിന് താഴെയും ഒളിഞ്ഞിരിപ്പുണ്ട്: ഒരു Rekindle ബട്ടൺ. അതിൽ ക്ലിക്ക് ചെയ്താൽ ആപ്പ് നിങ്ങളുടെ README വായിക്കും. പ്രോജക്റ്റിന്റെ ലക്ഷ്യത്തെക്കുറിച്ച് നിങ്ങൾ എന്താണോ എഴുതിയിരിക്കുന്നത് അത് വിശകലനം ചെയ്യുകയും, നിലവിലുള്ള കോഡുമായി താരതമ്യം ചെയ്യുകയും, നിങ്ങൾ എന്തുകൊണ്ടാണ് അത് തുടങ്ങിയതെന്ന് ഓർമ്മിപ്പിക്കുന്ന ഒരു ചെറിയ pitch എഴുതുകയും ചെയ്യുന്നു. ശേഷം, ഇന്ന് രാത്രി നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന ഒരു ചെറിയ പ്രായോഗിക കാര്യം കൂടി അത് നിർദ്ദേശിക്കുന്നു. ഇതൊരു റോഡ്മാപ്പല്ല, ഒരു refactor പ്ലാനുമല്ല. വെറുമൊരു ടാസ്ക് മാത്രം. അഞ്ച് മിനിറ്റ് ജോലി.

പഴയൊരു പ്രോജക്റ്റിലേക്ക് മടങ്ങുന്നതിലെ ഏറ്റവും പ്രയാസകരമായ കാര്യം കോഡിംഗ് അല്ല എന്നതാണ് ഇതിന്റെ പ്രസക്തി. നിങ്ങൾ എവിടെയായിരുന്നു എന്ന് ഓർത്തെടുക്കുന്നതും, നിർത്തിപ്പോയതിൽ സ്വയം ക്ഷമിക്കുന്നതുമാണ് പ്രയാസം. മരിച്ചുപോയ ഒരു പ്രോജക്റ്റ് വളരെ വലുതായി തോന്നും. അതിന്റെ ആർക്കിടെക്ചർ വീണ്ടും മനസ്സിലാക്കാൻ തന്നെ മൂന്ന് മണിക്കൂർ വേണമെന്ന് നിങ്ങൾ കരുതും. Rekindle ബട്ടൺ ആ ഭയത്തെ ഒരു ചെറിയ todo ആയി ചുരുക്കുന്നു. നിങ്ങളുടെ അടുത്ത commit വെറും അഞ്ച് മിനിറ്റ് അകലെയാണെന്ന് തോന്നിപ്പിക്കുക എന്നതാണ് ഇതിന്റെ ലക്ഷ്യം, കാരണം ഒരിക്കൽ ചരിത്രത്തിൽ ഒരു ചെറിയ diff വന്നാൽ പിന്നെ ആ വേഗത (momentum) തനിയെ തിരിച്ചുവരും.

എന്തുകൊണ്ട് ഇത്ര ലളിതമായ സ്റ്റാക്ക് ഉപയോഗിക്കുന്നു

സാങ്കേതികമായി പറഞ്ഞാൽ, ഈ പ്രോജക്റ്റ് അത് പ്രസംഗിക്കുന്നത് പോലെ തന്നെ പ്രവർത്തിക്കുന്നു. ഇത് vanilla HTML, CSS, JavaScript എന്നിവ ഉപയോഗിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ഇത് GitHub REST API ഉപയോഗിക്കുന്നു. ഇതിൽ സെർവറുകളോ, ബിൽഡ് സ്റ്റെപ്പുകളോ, പരിപാലിക്കേണ്ട പുതിയ ഫ്രെയിംവർക്കുകളോ ഇല്ല. നിങ്ങൾക്ക് ഇത് GitHub Pages-ൽ ഹോസ്റ്റ് ചെയ്ത് മാറ്റിവെക്കാം.

ആ മിനിമലിസം ഒരു പ്രത്യേകതയാണ്, അലസതയല്ല. പഴയ കോഡ് പുനരുജ്ജീവിപ്പിക്കുന്ന ഒരു ടൂൾ തന്നെ ദുർബലമായ ഒരു dependency tree-യെ ആശ്രയിക്കരുത്. സ്രഷ്ടാവ് Side Project Cemetery ആറുമാസത്തേക്ക് ഉപേക്ഷിച്ചാൽ പോലും, ആ ശ്മശാനം അതിന്റെ തന്നെ മറ്റൊരു താമസക്കാരനായി മാറില്ല. കോഡ് എളുപ്പത്തിൽ വായിക്കാൻ സാധിക്കും. അപ്‌ഡേറ്റ് ചെയ്യാൻ webpack കോൺഫിഗറുകളോ പാച്ച് ചെയ്യാൻ Docker ഇമേജുകളോ ഇല്ല. ടൂളിംഗിലെ മിതത്വത്തിനായുള്ള ഒരു നിശബ്ദമായ വാദമാണിത്: ചിലപ്പോൾ ഒരു സ്റ്റാറ്റിക് സൈറ്റും ഒരു API കീയും മാത്രം മതിയാകും.

ബട്ടൺ യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുമ്പോൾ

The builder admits that their own dead projects called them out during development. One in particular had been a single-night obsession, written in a blur of excitement and then forgotten. They used the Rekindle button on it. The app read the README, remembered the premise, and handed back a real task to finish. It worked. They shipped the missing piece that same week.

This is the core argument of the tool. Passion does not die. It naps. Most abandoned repositories are not failures of engineering. They are failures of context. You lost the thread because the thread was only living in your head, and your head moved on to other threads. Side Project Cemetery externalizes that context. It reads the README so you do not have to reconstruct your past self from scratch.

The real metric is not how many repos you resurrect. It is how many you stop feeling weird about. The cemetery gives them a place to rest until you are ready. And when you are ready, it hands you a shovel and a single instruction: start here.

Stop letting your ideas stay buried.

Visit the cemetery at https://pyaroslav.github.io/side-project-cemetery/, and read the full build story on Dev.to here.