ট্রানজিস্টর থেকে অ্যাপ — বিমূর্ততার স্তর

১ · শতকোটি সুইচ একসাথে ভাবা অসম্ভব — বিমূর্ততা আর ইন্টারফেস

আপনার ফোনে WhatsApp খুলে “কেমন আছো?” লিখে “Send” চাপলেন। এক সেকেন্ডও লাগল না। অথচ এই এক চাপের পেছনে ফোনের চিপের ভেতরে কয়েকশো কোটি ট্রানজিস্টর লাখ লাখ বার চালু-বন্ধ হয়েছে। যে প্রোগ্রামার “Send” বোতামটি বানিয়েছেন, তিনি কি এই ট্রানজিস্টরগুলোর কথা ভেবে কোড লিখেছেন? একেবারেই না। আর যে প্রকৌশলী ফোনের চিপের ট্রানজিস্টর সাজিয়েছেন, তিনিও WhatsApp-এর কথা কখনো ভাবেননি।

দুজনেই কাজ করতে পেরেছেন, কারণ কম্পিউটার তৈরি হয় তলায় তলায়, একটি বহুতল ভবনের মতো। প্রতিটি তলা নিচের তলার এলোমেলো, জটিল খুঁটিনাটি লুকিয়ে রাখে, আর ওপরের তলাকে দেয় একটি সহজ, পরিষ্কার “ভাষা”। এই লুকিয়ে রাখার কৌশলের নাম বিমূর্ততা (abstraction). আর দুই তলার মাঝে যে নির্দিষ্ট নিয়ম বা “দরজা” দিয়ে কথা হয়, তাকে বলে ইন্টারফেস (interface).

দুটি দৈনন্দিন উপমা

কম্পিউটারেও ঠিক তাই। “ক” অক্ষরটি পর্দায় দেখানোর সময় অ্যাপ শুধু বলে “এই লেখাটি দেখাও”; কোন পিক্সেল কোন রঙে জ্বলবে, সেটি নিচের তলার দায়িত্ব। পর্ব ২০-এ আপনি লজিক গেটকে একটি “কালো বাক্স” ধরে কাজ করেছেন — ভেতরে কোন ট্রানজিস্টর কোথায়, তা না ভেবেই। পর্ব ২১–২২-এ অ্যাডার বানানোর সময়ও একেকটি গেট নয়, ভেবেছেন “অ্যাডার” নামের বড় বাক্সের কথা। আপনি না জেনেই বিমূর্ততা ব্যবহার করছিলেন। এই পর্বে পুরো ভবনটি নিচ থেকে ওপর পর্যন্ত একবার ঘুরে দেখবেন।

কেন স্তর ছাড়া উপায় নেই

একটু হিসাব করুন। ধরুন সেকেন্ডে একটি করে, দিনরাত না থেমে গুনছেন। একটি ল্যাপটপ চিপের ১,০০০ কোটি ট্রানজিস্টর গুনতেই লাগবে তিনশো বছরের বেশি — নকশা তো দূরের কথা। মানুষের মাথা একসাথে মোটামুটি কয়েকটি জিনিস ধরে রাখতে পারে। তাই একমাত্র উপায়: অল্প কয়েকটি জিনিস দিয়ে একটি বড় জিনিস বানানো, সেটির একটি নাম দেওয়া, তারপর সেই নামকে আবার একটি “ছোট” জিনিস ধরে পরের তলা বানানো। ৪টি ট্রানজিস্টর = একটি NAND গেট; কয়েকটি গেট = একটি full adder; ৩২টি full adder = একটি 32-bit অ্যাডার; অ্যাডার আর আরও কিছু = ALU — এভাবে।

২ · স্তরের মই — ইলেকট্রন থেকে ব্যবহারকারী পর্যন্ত

নিচের টেবিলটি পুরো পর্বের মানচিত্র। একেবারে নিচে পদার্থবিজ্ঞান, একেবারে ওপরে আপনি। প্রতিটি সারিতে দেখুন — সেই তলার মানুষ কী নিয়ে ভাবেন, আর ওপরের তলাকে কী “ভাষা” দেন। এই কোর্সের কোন পর্বে কোন তলা বিস্তারিত পাবেন, তাও দেওয়া আছে।

খেয়াল করুন, প্রতিটি তলার “ভাষা” আগেরটির চেয়ে মানুষের কাছাকাছি। নিচে আছে ভোল্টেজ, মাঝে 0/1, তারপর ADD, তারপর a = b + c, তারপর “Send” বোতাম। ওপরে কাজ বলা সহজ; নিচে যন্ত্রের ওপর নিয়ন্ত্রণ বেশি।

একটি “ক”-এর যাত্রা — ওপর থেকে নিচে, তারপর আবার ওপরে

এবার একটি সত্যিকারের ঘটনা ধরে মইটি বেয়ে নামুন। আপনি অভ্র (phonetic) চালু রেখে কিবোর্ডে k চাপলেন, আর নোটপ্যাডে “ক” দেখা গেল। নিচের ডায়াগ্রামে “পরে” চাপুন, প্রতিটি তলায় কী ঘটে দেখুন। (বিভিন্ন OS-এ ধাপগুলো একটু আলাদা, স্তরগুলো একই।)

এই যাত্রার সবচেয়ে গুরুত্বপূর্ণ শিক্ষা হলো “যা সে জানে না” সারিটি। প্রতিটি তলা ইচ্ছা করেই অনেক কিছু জানে না — আর ঠিক সেই না-জানার কারণেই প্রতিটি তলা আলাদাভাবে বানানো, পরীক্ষা করা আর বদলানো যায়।

৩ · নিচের তলা — ট্রানজিস্টর থেকে গেট, গেট থেকে অ্যাডার

মইয়ের একেবারে নিচে সেমিকন্ডাক্টর সিলিকন। বিশুদ্ধ সিলিকন বিদ্যুৎ খুব একটা চালায় না, আবার পুরোপুরি আটকায়ও না। সামান্য অন্য পরমাণু মিশিয়ে (doping) আর বাইরে থেকে ভোল্টেজ দিয়ে এর বিদ্যুৎ চালানোর ক্ষমতা নিয়ন্ত্রণ করা যায়।

MOSFET — একটি সরল ছবি

আজকের প্রায় সব চিপে যে ট্রানজিস্টর থাকে, তার নাম MOSFET. সহজ করে ভাবুন: সিলিকনের ওপর দুটি প্রান্ত — source (যেখান থেকে ইলেকট্রন আসে) আর drain (যেখানে যায়)। মাঝখানে একটি সরু পথ, যার নাম channel. পথের ঠিক ওপরে, খুব পাতলা একটি অন্তরক (insulator) স্তরের ওপারে বসে থাকে তৃতীয় প্রান্ত — gate. gate-এ উপযুক্ত ভোল্টেজ দিলে তার বৈদ্যুতিক টানে নিচে ইলেকট্রনের একটি সরু পথ তৈরি হয় — channel খুলে যায়, বিদ্যুৎ চলে। ভোল্টেজ সরালে পথ মিলিয়ে যায় — সুইচ বন্ধ।

MOSFET দুই রকম: nMOS (gate-এ 1 দিলে চালু) আর pMOS (gate-এ 0 দিলে চালু)। এই দুটিকে জোড়ায় জোড়ায় বসানোর পদ্ধতির নাম CMOS — পর্ব ২০-এ নামটি শুনেছেন। নিচের stepper-এ দেখুন, একটি সুইচ থেকে কীভাবে ধাপে ধাপে যোগ করার যন্ত্র তৈরি হয়। প্রতিটি ধাপে আগের ধাপের জিনিসটিকে একটি “বাক্স” ধরে নতুন বাক্স বানানো হচ্ছে — এটাই বিমূর্ততার আসল চেহারা।

  gate = 0 V   →  channel নেই   →  source ✕ drain   (OFF = 0)
  gate = 1 V   →  channel তৈরি  →  source ━ drain   (ON = 1)

        VDD (1)
         │
   A ──[pMOS]   A = 0 হলে চালু → Y কে 1-এ টানে
         ├──── Y = A′
   A ──[nMOS]   A = 1 হলে চালু → Y কে 0-তে টানে
         │
        GND (0)

  ওপরে: ২টি pMOS পাশাপাশি  (A বা B যেকোনো একটি 0 → Y = 1)
  নিচে: ২টি nMOS পরপর      (A আর B দুটোই 1 → Y = 0)

  A B │ Y = (A·B)′
  0 0 │ 1
  0 1 │ 1
  1 0 │ 1
  1 1 │ 0

  ইনপুট: A, B, Cin   →   আউটপুট: Sum, Cout
  Sum  = A ⊕ B ⊕ Cin
  Cout = A·B + Cin·(A ⊕ B)

  এখন আর ট্রানজিস্টর নয়, ভাবছি “এক bit যোগ”।

  [FA]←[FA]←[FA]← … ←[FA]   ৩২টি full adder, carry ডান থেকে বাঁয়ে
   │    │    │         │
  S31  S30  S29  …    S0

  ALU-কে বলা হয়: “ADD”  — কোন গেট কোথায়, কেউ আর ভাবে না

প্রতিটি ধাপে সংখ্যা বেড়েছে কয়েক গুণ, কিন্তু মাথায় রাখার জিনিস একই — একটি বাক্স, তার ইনপুট আর আউটপুট। এভাবে মাত্র কয়েক ধাপে ১ থেকে হাজারে পৌঁছানো গেল; আরও কয়েক ধাপে পৌঁছানো যায় শতকোটিতে। রেজিস্টার আর মেমরিও একইভাবে তৈরি — পর্ব ২২-এর ফ্লিপ-ফ্লপ জুড়ে জুড়ে।

৪ · হার্ডওয়্যার-সফটওয়্যারের চুক্তি — ISA, machine code আর assembly

ALU, রেজিস্টার, control unit, cache — এগুলো কীভাবে সাজানো, কয়টি কাজ একসাথে চলে, কোন পথে ডেটা যায় — এই নকশাকে বলে মাইক্রোআর্কিটেকচার. Intel-এর একটি নতুন প্রজন্মের চিপ আর আগের প্রজন্মের চিপের মাইক্রোআর্কিটেকচার অনেকটাই আলাদা। তবুও দুটিতেই আপনার পুরোনো Windows প্রোগ্রাম চলে। কেন? কারণ মাইক্রোআর্কিটেকচারের ঠিক ওপরে আছে একটি চুক্তি, যা বদলায়নি।

সেই চুক্তির নাম ISA — Instruction Set Architecture. ISA বলে দেয়: CPU কোন কোন নির্দেশ বোঝে (যোগ, বিয়োগ, মেমরি থেকে পড়া, লাফ দেওয়া…), কয়টি রেজিস্টার আছে আর তাদের নাম কী, আর প্রতিটি নির্দেশ কীভাবে 0/1-এ লেখা হবে। 0/1-এ লেখা এই নির্দেশগুলোই machine language বা machine code. প্রতিটি নির্দেশের প্রথম অংশে থাকে কোন কাজ — opcode; বাকিটা বলে কোন রেজিস্টার বা কোন সংখ্যার ওপর কাজ।

আজকের তিন বড় ISA

এক ISA-র machine code অন্য ISA-র CPU বোঝে না — ঠিক যেমন বাংলায় লেখা চিঠি শুধু চীনা ভাষা জানা কেউ পড়তে পারেন না। এজন্যই Windows-এর একটি সাধারণ .exe ফাইল সরাসরি ফোনে চলে না।

Assembly — machine code-এর মানুষ-পড়া রূপ

00000001 11011000 দেখে কিছু বোঝা কঠিন। তাই প্রতিটি নির্দেশের একটি ছোট নাম দেওয়া হয় — ADD, MOV, JMP — আর রেজিস্টারের নাম লেখা হয় অক্ষরে। এই রূপের নাম assembly language. machine code আর assembly-র মধ্যে প্রায় এক-এক সম্পর্ক: একটি assembly লাইন = একটি machine নির্দেশ। assembly থেকে machine code বানায় assembler নামের প্রোগ্রাম। আর C, Python-এর মতো high-level language-এর একটি লাইন থেকে অনেকগুলো machine নির্দেশ তৈরি হতে পারে — সেই অনুবাদ করে compiler বা interpreter (পর্ব ৩৮)।

নিচের stepper-এ একটি C লাইন a = b + c; মই বেয়ে নিচে নামবে। ধরা যাক b = 5 আর c = 3. assembly আর machine code x86-64-এর ধাঁচে দেখানো হয়েছে; বোঝানোর জন্য সরল করা (illustrative) — আসল compiler-এর আউটপুট সেটিং অনুযায়ী একটু আলাদা হতে পারে।

int a, b = 5, c = 3;
a = b + c;       // কোন রেজিস্টার, কোন bit — কিছুই বলতে হয় না

mov  eax, [b]     ; মেমরি থেকে b → রেজিস্টার eax
mov  ebx, [c]     ; মেমরি থেকে c → রেজিস্টার ebx
add  eax, ebx     ; eax = eax + ebx
mov  [a], eax     ; ফল মেমরিতে a-এর জায়গায়

hex :  01        D8
bit :  00000001  11 011 000
       opcode    │  │   └ eax (000) — গন্তব্য
                 │  └ ebx (011) — উৎস
                 └ 11 = দুটিই রেজিস্টার

opcode 01  →  “ALU: যোগ করো”
011        →  রেজিস্টার ebx-এর তার খোলো
000        →  রেজিস্টার eax-এর তার খোলো, ফলও eax-এ
এই সংকেতগুলো আসলে কয়েকটি তারে 0/1 — মাল্টিপ্লেক্সার আর ডিকোডার (পর্ব ২১) দিয়ে।

  carry:  1 1 1 0
     b :  0 1 0 1    (5)
   + c :  0 0 1 1    (3)
  ─────────────────
     a :  1 0 0 0    (8)

নিজে চালিয়ে দেখুন — মই বেয়ে নামার ছোট সিমুলেশন

নিচের কোডটি একটি খেলনা কম্পিউটারের মতো একই যাত্রা দেখায়: sum = 5 + 3 → কাল্পনিক ছোট ISA-র assembly → ৮-bit machine code → full adder দিয়ে bit ধরে ধরে যোগ। কাল্পনিক ISA-তে opcode মাত্র ২ bit: MOV = 01, ADD = 10. “Run” চাপুন।

const bits = (n) => n.toString(2).padStart(4, '0');      // সংখ্যা → 4-bit
console.log('1) High-level : sum = 5 + 3');
console.log('2) Assembly   : MOV R1,5 | MOV R2,3 | ADD R0,R1,R2');
const OP = { MOV: '01', ADD: '10' };                       // খেলনা ISA-র opcode
const code = [OP.MOV + '01' + bits(5), OP.MOV + '10' + bits(3), OP.ADD + '00' + '01' + '10'];
console.log('3) Machine    : ' + code.join(' '));
const XOR = (a, b) => a ^ b, AND = (a, b) => a & b, OR = (a, b) => a | b;  // গেট
function fullAdder(a, b, cin) {                            // গেট দিয়ে ১ bit যোগ
  const s1 = XOR(a, b);
  return { sum: XOR(s1, cin), cout: OR(AND(a, b), AND(s1, cin)) };
}
const A = bits(5).split('').map(Number).reverse();         // ডান দিকের bit আগে
const B = bits(3).split('').map(Number).reverse();
let carry = 0;
const out = [];
for (let i = 0; i < 4; i++) {                              // ripple carry
  const r = fullAdder(A[i], B[i], carry);
  console.log(`4) bit ${i}: ${A[i]} + ${B[i]} + carry ${carry} -> sum ${r.sum}, carry ${r.cout}`);
  out.unshift(r.sum);
  carry = r.cout;
}
console.log('5) Result     : ' + out.join('') + ' = ' + parseInt(out.join(''), 2));

সীমানা ঝাপসা যেখানে — firmware আর microcode

হার্ডওয়্যার আর সফটওয়্যারের সীমানা যতটা পরিষ্কার মনে হয়, ততটা নয়। দুটি উদাহরণ:

• Firmware — যন্ত্রের ভেতরে স্থায়ীভাবে বসানো সফটওয়্যার: মাদারবোর্ডের UEFI, প্রিন্টার বা রাউটারের ভেতরের প্রোগ্রাম, SSD-র নিয়ন্ত্রক। এটি সফটওয়্যার (আপডেট করা যায়), কিন্তু ব্যবহারকারীর চোখে হার্ডওয়্যারের অংশ। কম্পিউটার চালু হওয়ার সময় firmware কী করে, তা পর্ব ২৭-এ।
• Microcode — CPU-র ভেতরের একটি গোপন তলা। x86-এর কিছু জটিল নির্দেশ CPU সরাসরি গেটে চালায় না; ভেতরে সেগুলোকে আরও ছোট ছোট ধাপে ভেঙে নেয়, আর সেই ভাঙার নিয়মের একটি অংশ লেখা থাকে microcode-এ। এর সুবিধা: চিপ বাজারে যাওয়ার পরও কোনো ত্রুটি ধরা পড়লে অনেক সময় microcode আপডেট দিয়ে ঠিক করা যায় — Windows বা BIOS আপডেটের সাথে চুপচাপ এমন আপডেট আসে। অর্থাৎ ISA-র নিচেও আরেকটি “সফটওয়্যার” আছে!

৫ · সফটওয়্যারের তলাগুলো — OS, ভাষা, লাইব্রেরি আর virtual machine

ISA-র ওপরে শুরু সফটওয়্যারের জগৎ, আর সেখানেও তলার পর তলা।

অপারেটিং সিস্টেম সবচেয়ে বড় বিমূর্ততার কারখানা। স্টোরেজে (HDD বা SSD) আসলে আছে লাখ লাখ “block” (চুম্বকীয় বা flash ঘর); OS আপনাকে দেখায় “ফাইল” আর “ফোল্ডার”। CPU আসলে একটি সময়ে একটি (বা প্রতিটি core-এ একটি) কাজ করে; OS দেখায় যেন একসাথে বিশটি অ্যাপ চলছে। RAM সীমিত; OS প্রতিটি প্রোগ্রামকে দেখায় যেন তার নিজের বিশাল মেমরি আছে (virtual memory, পর্ব ২৫)। ভেতরের গল্প পর্ব ২৬-এ।

প্রোগ্রামিং ভাষা আরেক তলা ওপরে। C-তে রেজিস্টারের কথা ভাবতে হয় না; Python-এ মেমরি ফেরত দেওয়ার কথাও না। compiler পুরো প্রোগ্রাম আগেই machine code-এ অনুবাদ করে; interpreter চালানোর সময় লাইন ধরে ধরে পড়ে চালায় (পর্ব ৩৮)।

লাইব্রেরি আর framework তার ওপরে। একটি বাজার-সদাইয়ের অ্যাপ ছবি, মানচিত্র, পেমেন্ট, নোটিফিকেশন — প্রায় কিছুই শূন্য থেকে লেখে না। রেডিমেড library আর framework ব্যবহার করে, আর অন্য সেবার সাথে কথা বলে সেই সেবার API দিয়ে — API হলো সফটওয়্যারের জগতের ইন্টারফেস: “এই নামে, এই তথ্য দিয়ে ডাকলে, এই উত্তর পাবেন।”

শিক্ষা: ইন্টারফেস ঠিক থাকলে ওপরের তলা বুঝতেই পারে না নিচে আসল যন্ত্র, না সফটওয়্যারের নকল।

৬ · স্তর কেন এত কাজের — আর কোথায় ফাঁস হয়

তিনটি বড় সুবিধা

1. বিশেষজ্ঞতা (specialization): চিপের পদার্থবিদ, CPU-নকশাকারী, OS প্রোগ্রামার, অ্যাপ ডেভেলপার, UI ডিজাইনার — প্রত্যেকে নিজের তলায় গভীর দক্ষ হতে পারেন। কাউকে সব জানতে হয় না।
2. বহনযোগ্যতা (portability): একই WhatsApp কোড থেকে Android ফোন, iPhone আর Windows-এর অ্যাপ তৈরি হয়, যদিও নিচের চিপ আর OS আলাদা। ওপরের তলা লেখা হয় নিচের ইন্টারফেস ধরে, নির্দিষ্ট যন্ত্র ধরে নয়।
3. একটি তলা বদলানো, বাকিগুলো অক্ষত: HDD থেকে SSD-তে গেলে আপনার Word ফাইল একই থাকে — OS-এর ফাইল-তলা নিচের পরিবর্তন সামলে নেয়। নতুন প্রজন্মের CPU এলে পুরোনো প্রোগ্রাম চলে — ISA একই আছে বলে। একে বলে modularity.

কিন্তু স্তর “ফাঁস” হয়

২০০২ সালে সফটওয়্যার-লেখক Joel Spolsky একটি বিখ্যাত পর্যবেক্ষণ লেখেন: যেকোনো অ-তুচ্ছ বিমূর্ততা কোনো না কোনো মাত্রায় ফাঁস হয় — তিনি এর নাম দেন “Law of Leaky Abstractions”. অর্থাৎ নিচের তলার কিছু বৈশিষ্ট্য মাঝে মাঝে ওপরে উঁকি দেয়, আর তখন নিচের তলা না বুঝলে সমস্যা ধরা যায় না। কয়েকটি উদাহরণ:

• গতি: প্রোগ্রামিং ভাষায় একটি বড় টেবিল সারি ধরে পড়া আর কলাম ধরে পড়া — দুটোই “একই কাজ”। কিন্তু cache কীভাবে কাজ করে (পর্ব ২৫), তার কারণে একটি অন্যটির চেয়ে কয়েক গুণ ধীর হতে পারে। ভাষার তলা cache লুকাতে চেয়েছিল, পারেনি।
• সংখ্যার সীমা: গণিতে 7 + 9 = 16. কিন্তু 4-bit অ্যাডারে উত্তর আসে 0000, বাড়তি একটি carry বাইরে পড়ে যায় — overflow (পর্ব ১৭)। অনেক বড় বাগ ঠিক এই ফাঁস থেকে।
• নিরাপত্তা: সবচেয়ে নাটকীয় ফাঁস, নিচের বক্সে।

সমস্যা কোন তলায়? — একটি চিন্তার অভ্যাস

স্তরগুলো চেনার সবচেয়ে বড় ব্যবহারিক লাভ — কোনো সমস্যা দেখলে আপনি জিজ্ঞেস করতে পারেন, “এটি কোন তলার সমস্যা?” তাহলে ঠিক জায়গায় খোঁজা যায় (পর্ব ৪৯-এ এই পদ্ধতি বিস্তারিত)।

৭ · চিপ যেভাবে তৈরি হয় — বালি থেকে শতকোটি ট্রানজিস্টর

এতক্ষণ যে ট্রানজিস্টরের কথা বললাম, সেগুলো এত ছোট যে একটি চুলের প্রস্থে কয়েক হাজার পাশাপাশি আঁটে। এত ছোট জিনিস হাতে বসানো অসম্ভব — চিপ তৈরি হয় অনেকটা ছবি ছাপার মতো করে, আলো দিয়ে নকশা “প্রিন্ট” করে। কারখানাগুলোকে বলে fab বা foundry. আজ সবচেয়ে উন্নত চিপ বানাতে পারে হাতে গোনা কয়েকটি কোম্পানি — তাইওয়ানের TSMC, দক্ষিণ কোরিয়ার Samsung আর যুক্তরাষ্ট্রের Intel প্রধান। Apple, Qualcomm, NVIDIA-র মতো অনেক কোম্পানি নকশা করে, বানায় TSMC-র মতো foundry-তে।

“3 ন্যানোমিটার” মানে কী — নামের বিভ্রান্তি

খবরে শোনেন “৩ ন্যানোমিটারের চিপ”। একে বলে process node — চিপ তৈরির একটি প্রজন্মের নাম। কয়েক দশক আগে এই সংখ্যা সত্যিই ট্রানজিস্টরের একটি মাপের (gate-এর দৈর্ঘ্য) কাছাকাছি ছিল। কিন্তু প্রায় ২০১০-এর দশক থেকে এটি মূলত একটি বাজারজাত নাম (marketing name): “3 nm” চিপের কোনো গুরুত্বপূর্ণ অংশই আক্ষরিক অর্থে ৩ ন্যানোমিটার নয়; ট্রানজিস্টরগুলোর মাঝের দূরত্ব এখনো কয়েক দশক ন্যানোমিটার। এক কোম্পানির “৩” অন্য কোম্পানির “৩”-এর সমান ঘন নাও হতে পারে। তবে প্রবণতা সত্য: প্রতিটি নতুন node-এ একই জায়গায় আরও বেশি ট্রানজিস্টর আঁটে। TSMC আর Samsung ২০২২ সাল থেকে “3 nm” শ্রেণির চিপ ব্যাপকভাবে বানাতে শুরু করে।

কত ট্রানজিস্টর?

পঞ্চাশ বছরে প্রায় এক কোটি গুণ বৃদ্ধি — Moore’s law (পর্ব ২)-এর ফল। আর এই বিপুল সংখ্যা সামলানো সম্ভব হয়েছে একটিমাত্র কারণে: কোনো প্রকৌশলী একা ট্রানজিস্টর আঁকেন না। তাঁরা লেখেন উচ্চস্তরের হার্ডওয়্যার-বর্ণনা ভাষায় (Verilog, VHDL), আর সফটওয়্যার-টুল সেটিকে গেট আর তারপর ট্রানজিস্টরের নকশায় নামিয়ে আনে — হার্ডওয়্যার বানাতেও সেই একই বিমূর্ততার মই।

৮ · AI-এর যুগে — সবচেয়ে নতুন স্তর: সাধারণ ভাষা থেকে কোড

মইয়ের ইতিহাস দেখুন: প্রথমে প্রোগ্রামাররা সরাসরি 0/1 লিখতেন; তারপর এল assembly; তারপর C-র মতো ভাষা, যাতে আর রেজিস্টারের কথা ভাবতে হয় না; তারপর Python আর বিশাল লাইব্রেরি। আজ AI কোডিং টুল নতুন একটি তলা যোগ করেছে: আপনি বাংলা বা ইংরেজিতে বলেন “একটি ফর্ম বানাও, যেটি মোবাইল নম্বর যাচাই করবে”, আর AI কোড লিখে দেয়। এটি সত্যিই শক্তিশালী — কিন্তু এটিও একটি বিমূর্ততা, আর সব বিমূর্ততার মতো এটিও ফাঁস হয়।

অর্থাৎ AI-এর তলা ব্যবহার করতে হলে আপনার মাথায় নিচের তলাগুলোর একটি মোটামুটি ছবি থাকতে হবে। নিচের prompt-টি AI-কে শুধু উত্তর নয়, তলা ধরে ব্যাখ্যা দিতে বাধ্য করে:

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• assembly বা machine code কোন ISA-র, উত্তরে তা লেখা আছে; x86 আর ARM-এর নির্দেশ মিশিয়ে ফেলেনি
• ছোট উদাহরণ নিজে হাতে (বা ওপরের সিমুলেশনের মতো কোড চালিয়ে) মিলিয়ে দেখেছি — যেমন বাইনারি যোগের carry
• Compiler Explorer (godbolt.org)-এর মতো টুলে আসল compiler-এর assembly দেখে মিলিয়েছি
• সাল, সংখ্যা আর কোম্পানির দাবি নির্ভরযোগ্য উৎসে (নির্মাতার ওয়েবসাইট, পাঠ্যবই) যাচাই করেছি
• AI-এর লেখা কোড বড় ইনপুট, বাংলা লেখা আর সীমার কাছাকাছি সংখ্যা দিয়ে পরীক্ষা করেছি — যেখানে তলা ফাঁস হয়