દરેક છોડવામાં આવેલી રિપોઝીટરી ક્યારેક રાત્રે ૨ વાગ્યાનો એક જુનૂન હતી. તમે એ લય જાણો છો. મધ્યરાત્રિની આસપાસ વિચાર આવે છે. તમારી કોફી ઠંડી થાય તે પહેલાં તમે રિપોઝીટરીનું માળખું (scaffold) તૈયાર કરી લો છો. અગિયાર દિવસ સુધી તમે એવી અતિશય ઉર્જા સાથે કોડ પુશ કરો છો જાણે કે તમે આખરે કંઈક મોટું કરી બતાવ્યું હોય. પછી સ્પ્રિન્ટ પૂરી થાય છે. અથવા બોઈલર બગડી જાય છે. અથવા તમે ફક્ત મંગળવારની સાંજે કોડ ખોલો છો અને વિચારનો એ દોર તૂટી ગયો હોય છે.

મોટાભાગના ડેવલપર્સ આ ભાર અનુભવે છે. તે પસ્તાવો નથી, પણ 'જો આમ થયું હોત તો' ની એક શાંત યાદી જેવું છે. તમારી GitHub પ્રોફાઇલ સારા ઈરાદાઓનું આર્કાઈવ બની જાય છે. Side Project Cemetery ના સર્જકર્તાએ આ સમસ્યાનો સીધો સામનો કરવા માટે કંઈક બનાવ્યું છે. તેમનું ટૂલ તમારી પબ્લિક પ્રોફાઇલને એક ચંદ્રપ્રકાશિત કબ્રસ્તાનમાં ફેરવી દે છે જ્યાં દરેક જૂની (stale) રિપોઝીટરીને એક સ્મારક પથ્થર, મૃત્યુની તારીખ અને ક્યારેક એક રમુજ (punchline) મળે છે.

કબ્રસ્તાન વધતું જાય છે

Side projects સામાન્ય કારણોસર મૃત્યુ પામે છે. તમારે નવું ફ્રેમવર્ક શીખવું હતું, તેથી તમે એક CLI tool બનાવ્યું. તમે સ્પ્રેડશીટને ઓટોમેટ કરવા માંગતા હતા, તેથી તમે Python wrapper લખ્યું. પ્રોટોટાઇપ તમારી સમસ્યા ઉકેલવા માટે પૂરતો સારો હતો, અને તે જ અંત હતો. ત્યાં કોઈ વપરાશકર્તા રાહ જોતો નહોતો, કોઈ ડેડલાઇન દબાણ નહોતું, કોઈ મેનેજર સ્ટેટસ અપડેટ માંગતો નહોતો. બાહ્ય દબાણ વગર, માત્ર પ્રેરણાએ જ બધો ભાર ઉપાડવો પડે છે. જ્યારે પ્રેરણા ઓછી થાય છે, ત્યારે પ્રોજેક્ટ સ્થિર થઈ જાય છે.

કોઈ સામાન્ય ડેવલપરના GitHub પર જાઓ અને તમે આ પેટર્ન જોશો. એક રિપોઝીટરી માટે કાટ જેવા રંગનું કન્ટ્રીબ્યુશન ગ્રાફ. એક README જે “TODO: write tests” સાથે સમાપ્ત થાય છે. એક કમિટ હિસ્ટ્રી જે છ મહિના પહેલા જ અટકી ગઈ છે. અમે આ રિપોઝીટરીઓને શરમજનક સ્મૃતિચિહ્નોની જેમ રાખીએ છીએ. અમે ઝડપથી તેને સ્ક્રોલ કરી જઈએ છીએ, જાણે કે અધૂરો કોડ કંઈક છુપાવવા જેવી વસ્તુ હોય. Side Project Cemetery તેનાથી વિપરીત વલણ અપનાવે છે. તે કહે છે: તેમને યોગ્ય રીતે દફનાવો. તેમને સ્વીકારો. પછી, જો તમે ઈચ્છો તો, તેમાંથી એકને ફરી જીવંત કરો.

કબ્રસ્તાન કેવી રીતે કામ કરે છે

ઇન્ટરફેસ સીધું અને સરળ છે. તમે કોઈપણ GitHub યુઝરનેમ ટાઈપ કરો છો. એપ GitHub REST API નો ઉપયોગ કરીને દરેક પબ્લિક રિપોઝીટરી મેળવે છે અને છેલ્લા ૧૮૦ દિવસથી કોઈ પુશ (push) ન થઈ હોય તેવી રિપોઝીટરી ફિલ્ટર કરે છે. દરેક પરિણામ એક કબ્ર બની જાય છે. તમે જન્મનું વર્ષ, મૃત્યુનું વર્ષ અને રિપોઝીટરીની વિગતો પરથી બનેલો શિલાલેખ (epitaph) જોઈ શકો છો.

કેટલાક શિલાલેખ નમ્રતાથી લખાયેલા હોય છે:

  • JavaScript માં લખાયેલું. callback exhaustion થી મૃત્યુ પામ્યું.

અન્ય ઇતિહાસનું વધુ ઉદાર રીતે વર્ણન કરે છે:

  • મૃત નથી. બસ ૨૦૨૫ થી આક્રમક રીતે 'on hold' છે.

જો તમે વધુ પર્સનાલિટી ઈચ્છતા હોવ, તો તમે વૈકલ્પિક Gemini integration ચાલુ કરી શકો છો. AI રિપોઝીટરીની ભાષા અને સંદર્ભ વાંચીને એવા કસ્ટમ શિલાલેખ તૈયાર કરે છે જે ટેમ્પલેટ જેવા લાગવાને બદલે ચોક્કસ લાગે છે. તેમાં એક વૈકલ્પિક ElevenLabs integration પણ છે જે શ્રદ્ધાંજલિ (eulogy) મોટેથી વાંચે છે, જે તમને સાંભળવા સુધી એક નકામી વસ્તુ જેવું લાગે છે, પણ જ્યારે તમે તમારા પોતાના છોડવામાં આવેલા API wrapper ને ગંભીર અવાજમાં વર્ણવતા સાંભળો છો, ત્યારે તે અલગ જ લાગે છે. તે સમયે, અસંગતતા તમારા અપરાધભાવને તોડી નાખે છે, અને વાસ્તવમાં એ અપરાધભાવ જ રિપોઝીટરીને દફનાવી રાખતો હતો.

Rekindle: અતિશય ભાર સામે એક બટન

કબ્રસ્તાન તો માત્ર અડધો જ મુદ્દો છે. સાચું ફીચર દરેક સ્મારક પથ્થરની નીચે છુપાયેલું છે: એક Rekindle બટન. તેના પર ક્લિક કરો, અને એપ તમારું README વાંચશે. તે પ્રોજેક્ટના હેતુ વિશે તમે જે કંઈ પણ લખ્યું હોય તેનું વિશ્લેષણ કરશે, તેને હાલના કોડ સાથે સરખાવશે, અને તમને યાદ અપાવવા માટે એક ટૂંકું પિચ (pitch) લખશે કે તમે આ પ્રોજેક્ટમાં શા માટે રસ લીધો હતો. પછી તે એક નાના, નક્કર પગલા સાથે સમાપ્ત થશે જે તમે આજે રાત્રે લઈ શકો છો. કોઈ રોડમેપ નહીં. કોઈ રિફેક્ટર પ્લાન નહીં. ફક્ત એક કાર્ય. પાંચ મિનિટનું કામ.

આ મહત્વનું છે કારણ કે જૂના પ્રોજેક્ટ પર પાછા ફરવાનો સૌથી મુશ્કેલ ભાગ કોડિંગ નથી. તે તમે ક્યાં હતા તે યાદ રાખવું અને અટકી જવા બદલ તમારી જાતને માફ કરવી છે. લાંબા સમયથી મૃત પ્રોજેક્ટ ખૂબ મોટો લાગે છે. તમે માની લો છો કે આર્કિટેક્ચર ફરીથી સમજવા માટે જ તમારે ત્રણ કલાક જોઈશે. Rekindle બટન તે ધારણાને એક નાની 'todo' માં ફેરવી નાખે છે. ધ્યેય એ છે કે તમારું આગલું commit માત્ર પાંચ મિનિટ દૂર હોય તેવું લાગે, કારણ કે એકવાર હિસ્ટ્રીમાં એક સિંગલ diff આવી જાય, પછી ગતિ (momentum) પાછી આવવા લાગે છે.

સ્ટેક આટલું સરળ કેમ રાખવું

તકનીકી રીતે, આ પ્રોજેક્ટ જે કહે છે તે પોતે કરે છે. તે vanilla HTML, CSS, અને JavaScript સાથે બનાવવામાં આવ્યું છે. તે GitHub REST API નો ઉપયોગ કરે છે. તેમાં કોઈ સર્વર નથી, કોઈ બિલ્ડ સ્ટેપ્સ નથી, અને જાળવણી માટે કોઈ 'framework-of-the-month' નથી. તમે તેને GitHub Pages પર હોસ્ટ કરી શકો છો અને પછી કામ છોડી શકો છો.

તે લઘુત્તમવાદ (minimalism) એ એક ફીચર છે, આળસ નથી. જૂના કોડને પુનર્જીવિત કરવા વિશેના ટૂલને પોતે જ નાજુક ડિપેન્ડન્સી ટ્રી પર આધારિત ન હોવું જોઈએ. જો સર્જક Side Project Cemetery ને છ મહિના માટે છોડી દે, તો આ કબ્રસ્તાન તેના પોતાના કબ્રસ્તાનમાં બીજો રહેવાસી બની જતું નથી. કોડ વાંચવા યોગ્ય રહે છે. અપડેટ કરવા માટે કોઈ webpack configs નથી, પેચ કરવા માટે કોઈ Docker images નથી. તે ટૂલિંગમાં સંયમ માટેનો એક શાંત દલીલ છે: ક્યારેક એક સ્ટેટિક સાઇટ અને એક API key પૂરતા હોય છે.

જ્યારે બટન ખરેખર કામ કરે છે

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.