Bun பாதுகாப்பற்ற AI குறியீட்டை வெளியிட்டது

Bun சமீபத்தில் அதன் மையப்பகுதியை (core) Rust மொழியில் மீண்டும் எழுதியது. அவர்கள் சோதனை முயற்சியாக மல்டித்ரெடிங்கையும் (multithreading) சேர்த்துள்ளனர். இவை பெரிய மாற்றங்கள். இருப்பினும், இந்த இலக்குகளை அடையப் பயன்படுத்தப்பட்ட முறை கவலைக்குரியதாக உள்ளது.

Rust மறுபதிப்பின் பெரும்பகுதியை Claude AI எழுதியதை Bun குழு ஒப்புக்கொண்டது. இந்த மாற்றம் codebase-இல் 13,000-க்கும் மேற்பட்ட unsafe பிளாக்குகளை (unsafe blocks) சேர்த்துள்ளது. மேலும், இது ஒரு concurrent garbage collector இல்லாமலேயே வெளியிடப்பட்டுள்ளது.

Systems programming-இல், unsafe குறியீடு memory safety-யை மீறுகிறது. ஒரு unsafe பிளாக் என்பது ஒரு ஆபத்து. ஒரு AI-யால் உருவாக்கப்பட்ட பதினமூன்றாயிரம் பிளாக்குகள் என்பது ஒரு பெரும் சுமை (liability).

வேகத்தின் அவசியத்தை நான் புரிந்துகொள்கிறேன். Node.js மற்றும் Deno ஆகியவற்றுடன் போட்டியிட சிறிய குழுக்கள் வேகமாகச் செயல்பட வேண்டும். ஆனால் கவனமில்லாத வேகம் ஆபத்தானது.

ஒவ்வொரு unsafe பிளாக்கும் சரியான memory access-ஐ உறுதி செய்யும் ஒரு வாக்குறுதியாகும். ஒரு AI குறியீட்டை எழுதும்போது, அந்த வாக்குறுதியை யார் உறுதிப்படுத்துகிறார்கள்?

அபாயங்கள் தெளிவாக உள்ளன:

  • Memory management-ிற்கான human reasoning AI குறியீட்டில் இல்லை.
  • மிக வேகமாக உருவாக்கப்படும் குறியீடுகளுக்கு, மிக வேகமான ஆய்வும் (review) தேவைப்படுகிறது.
  • ஒரு concurrent garbage collector இல்லாதது, multithreaded workloads-ஐ நிலையற்றதாக மாற்றுகிறது.

ஒரு runtime என்பது வெறும் சாதாரண library அல்ல. அது உங்கள் முழு அப்ளிகேஷனின் அடித்தளம். நீங்கள் நம்பிக்கையின் அடிப்படையில் ஒரு runtime-ஐத் தேர்ந்தெடுக்கிறீர்கள். Infrastructure சோதனை முயற்சியாகத் தோன்றும் போது, டெவலப்பர்கள் Node.js போன்ற நிலையான கருவிகளை நோக்கித் திரும்புகின்றனர்.

நான் தினமும் AI கருவிகளைப் பயன்படுத்துகிறேன். ஒரு ஜூனியர் இன்ஜினியரிடமிருந்து வரும் குறியீட்டை நான் எப்படி நடத்துகிறேனோ, அதேபோலத்தான் AI குறியீட்டையும் நடத்துகிறேன். அதன் தாக்கத்திற்கு ஏற்ப அது முறையான ஆய்வுக்கு உட்படுத்தப்பட வேண்டும்.

ஒரு runtime-க்குள் multithreading-இன் தாக்கம் மிகப்பெரியது. பதினமூன்றாயிரம் unsafe பிளாக்குகளுக்கு பதினமூன்றாயிரம் சரியான காரணங்கள் தேவைப்படுகின்றன. அவற்றுக்குத் தேவைப்படுவது வெறும் இயந்திரத்தனமான ஒப்புதல்கள் (rubber stamps) அல்ல.

லட்சியமாக இருப்பது நல்லது. ஆனால் systems code-இல் கவனக்குறைவாக இருப்பது ஒரு பெரும் சுமை.

உங்கள் production app-இல் AI மூலம் உருவாக்கப்பட்ட 13,000 unsafe பிளாக்குகளை நீங்கள் இயக்குவீர்களா? Infrastructure-க்காக AI-யை நம்புவதில் உங்கள் வரம்பு என்ன?

Source: https://dev.to/adioof/bun-shipped-a-million-lines-of-ai-generated-unsafe-code-thats-not-bold-its-reckless-h3g

Optional learning community: https://t.me/GyaanSetuAi