Bun એ અસુરક્ષિત (Unsafe) AI કોડ શિપ કર્યો
Bun એ તાજેતરમાં તેના કોરને Rust માં ફરીથી લખ્યું છે. તેઓએ પ્રાયોગિક (experimental) મલ્ટીથ્રેડિંગ પણ ઉમેર્યું છે. આ મોટા પગલાં છે. જોકે, આ લક્ષ્યો સુધી પહોંચવા માટે વપરાતી પદ્ધતિ ચિંતાજનક છે.
Bun ટીમે સ્વીકાર્યું છે કે Rust રીરાઈટનો મોટો ભાગ Claude AI એ લખ્યો છે. આ ફેરફારથી કોડબેઝમાં 13,000 થી વધુ unsafe blocks ઉમેરાયા છે. તે કન્કરન્ટ ગાર્બેજ કલેક્ટર (concurrent garbage collector) વગર પણ શિપ કરવામાં આવ્યું છે.
સિસ્ટમ્સ પ્રોગ્રામિંગમાં, unsafe કોડ મેમરી સેફ્ટીને બાયપાસ કરે છે. એક unsafe block એ જોખમ છે. AI દ્વારા લખાયેલા તેર હજાર બ્લોક્સ એ એક મોટી જવાબદારી (liability) છે.
હું ઝડપની જરૂરિયાત સમજું છું. Node.js અને Deno સાથે સ્પર્ધા કરવા માટે નાની ટીમોએ ઝડપથી આગળ વધવું જોઈએ. પરંતુ સાવચેતી વગરની ઝડપ જોખમી છે.
દરેક unsafe block એ માન્ય મેમરી એક્સેસનું વચન છે. જ્યારે AI કોડ લખે છે, ત્યારે તે વચન કોણ આપે છે?
જોખમો સ્પષ્ટ છે:
- AI કોડમાં મેમરી મેનેજમેન્ટ માટે માનવીય તર્કનો અભાવ છે.
- ઉચ્ચ-ઝડપી જનરેશન માટે ઉચ્ચ-ઝડપી રિવ્યુની જરૂર છે.
- કન્કરન્ટ ગાર્બેજ કલેક્ટરનો અભાવ મલ્ટીથ્રેડેડ વર્કલોડ્સને અસ્થિર બનાવે છે.
રનટાઇમ (runtime) એ માત્ર એક સાદી લાઇબ્રેરી નથી. તે તમારા સમગ્ર એપ્લિકેશનનો પાયો છે. તમે વિશ્વાસના આધારે રનટાઇમ પસંદ કરો છો. જ્યારે ઇન્ફ્રાસ્ટ્રક્ચર પ્રાયોગિક લાગે છે, ત્યારે ડેવલપર્સ Node.js જેવા સ્થિર સાધનો તરફ પાછા ફરે છે.
હું દરરોજ AI ટૂલ્સનો ઉપયોગ કરું છું. હું AI કોડ સાથે તે જ રીતે વર્ત કરું છું જે રીતે હું જ્યુનિયર એન્જિનિયરના કોડ સાથે વર્ત કરું છું. તેને તેના પ્રભાવને અનુરૂપ રિવ્યુની જરૂર છે.
રનટાઇમની અંદર મલ્ટીથ્રેડિંગનો પ્રભાવ ઘણો મોટો છે. તેર હજાર unsafe blocks માટે તેર હજાર સારા કારણોની જરૂર છે. તેમને તેર હજાર 'રબર સ્ટેમ્પ' (માત્ર હા માં હા મેળવવી) ની જરૂર નથી.
મહત્વાકાંક્ષી હોવું સારું છે. સિસ્ટમ્સ કોડ સાથે બેદરકાર હોવું એ એક જોખમ છે.
શું તમે તમારા પ્રોડક્શન એપમાં 13,000 AI-જનરેટેડ unsafe blocks ચલાવશો? ઇન્ફ્રાસ્ટ્રક્ચર માટે AI પર વિશ્વાસ કરવાની તમારી મર્યાદા શું છે?
Optional learning community: https://t.me/GyaanSetuAi