সরাসরি পর্বে যান
পর্ব ০২ · ৮৬-এর মধ্যে · মডিউল ১

প্রোগ্রামিং ভাষার ইতিহাস আর পরিবার — FORTRAN থেকে Rust

History and Families of Programming Languages — Machine Code, FORTRAN, LISP, ALGOL, Simula, C, ML and the Modern Wave up to Rust

Taught in Bangla, this lesson traces the climb from machine code and assembly to high-level languages: FORTRAN, COBOL, LISP and ALGOL 60, the 1967–1975 burst of Simula 67, Smalltalk, C, Prolog, ML and Scheme, and the modern wave up to Rust. Steppers compare a FORTRAN-style DO loop with Python's for, walk a BNF leftmost derivation and follow closures from LISP to JavaScript. In-page Python builds a language timeline, and one bazar calculation runs in C, Java, JavaScript and Python, giving 996, 5000, 3.

এই পর্বে যা শিখবেন

  • Machine code, assembly আর high-level ভাষার পার্থক্য, আর “ভাষার প্রজন্ম” কথাটির সীমা
  • FORTRAN, COBOL, LISP, ALGOL 60, Simula 67, Smalltalk, C, Prolog, ML, Scheme থেকে Rust পর্যন্ত সাল আর স্রষ্টা, যাচাই করা বা সাবধানে লেখা
  • BNF কীভাবে একটি ভাষার ব্যাকরণ লেখার মান হয়ে উঠল, আর একটি derivation ধাপে ধাপে করা
  • Closure, GC, OOP, type inference আর generics কোন ভাষা থেকে কোন ভাষায় গেছে, তা ভাষার পরিবার-গাছে খুঁজে পাওয়া
  • কেন কিছু ভাষা টিকে থাকে আর কিছু হারায়, আর Haat-এর নকশার প্রতিটি অংশের পূর্বপুরুষ চেনা

১ · ইতিহাস কেন — একই হিসাব, অনেক ভাষা

বাজারঘর নামের অনলাইন দোকানের একটি ছোট নিয়ম দিয়ে শুরু করা যাক: অর্ডারের দাম ১০০০ টাকা বা তার বেশি হলে ১০% ছাড়, আর ছাড়ের পরে মোট ১০০০ টাকার কম হলে ৬০ টাকা delivery charge. এই কোর্সের নিজস্ব শেখার ভাষা Haat-এ নিয়মটি দেখতে এরকম (পুরো ভাষার পরিচয় পর্ব ০১-এ আর পর্ব ৪৫-এ):

fn price(qty: Int, unit: Int) -> Int {
    let p = qty * unit;
    if p >= 1000 { return p - p / 10; }
    return p;
}

এই পাঁচ লাইনের প্রায় প্রতিটি চিহ্নের একটি ইতিহাস আছে। fn আর -> দিয়ে function-এর type লেখার রীতি ML-পরিবার থেকে এসে Rust-এ জনপ্রিয় হয়েছে। কোঁকড়া বন্ধনী { } দিয়ে block আর /-এর পূর্ণসংখ্যা-ভাগ C থেকে। let শব্দটি গণিত আর ML থেকে। “একটি block নতুন scope বানায়” ধারণাটি ALGOL 60-এর। আর function-কে সাধারণ মানের মতো ব্যবহার করা, ভেতরের function বাইরের variable মনে রাখা (closure) — এর শিকড় LISP, Landin আর Scheme-এ। অর্থাৎ নতুন একটি ভাষা আসলে পুরোনো সিদ্ধান্তের একটি বাছাই করা সংকলন।

পারিবারিক বংশলতিকার কথা ভাবুন। দাদির হাতের রান্নার রেসিপি মায়ের হাতে কিছুটা বদলেছে, আপনার হাতে আরও একটু; কিন্তু মশলার মূল অনুপাত চিনলেই বোঝা যায় কোন পরিবারের রান্না। প্রোগ্রামিং ভাষাও তাই। Java-র কোড দেখলে C-এর বন্ধনী আর Simula-র class চোখে পড়ে, JavaScript-এর ভেতরে Scheme-এর closure লুকিয়ে আছে। বংশলতিকা জানলে নতুন ভাষা শেখা দ্রুত হয়, কারণ আপনি জানেন কোন অংশ “পরিচিত আত্মীয়”, আর কোন অংশ সত্যিই নতুন।

ইতিহাস জানার তিনটি ব্যবহারিক লাভ আছে। প্রথমত, কোনো ভাষার অদ্ভুত নিয়ম (যেমন C-তে = আর ==, বা JavaScript-এর নাম) প্রায়ই ইতিহাস দিয়ে ব্যাখ্যা হয়, যুক্তি দিয়ে নয়। দ্বিতীয়ত, compiler-এর বেশির ভাগ কৌশল (parsing, optimization, register allocation, garbage collection) একটি নির্দিষ্ট ভাষার সমস্যা মেটাতে জন্মেছিল; সমস্যাটি চিনলে কৌশলটি বোঝা সহজ। তৃতীয়ত, বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর লিখিত পরীক্ষায় “কোন ভাষা প্রথম কী আনল” ধরনের প্রশ্ন বারবার আসে — এবং সেখানে ভুল সাল বা ভুল স্রষ্টা লেখা সহজ।

ইতিহাসে সাল নিয়ে মতভেদ স্বাভাবিক: একটি ভাষার “জন্ম” বলতে কেউ নকশা শুরুর বছর ধরেন, কেউ প্রথম প্রকাশিত রিপোর্ট, কেউ প্রথম কাজ করা compiler, কেউ version 1.0. এই পর্বে প্রতিটি সালের পাশে সেটি কোন ঘটনার সাল, তা বলার চেষ্টা করা হয়েছে; যেখানে উৎসগুলো মেলে না, সেখানে “সাধারণত বলা হয়” লেখা আছে। কোনো জনপ্রিয়তার তালিকা বা ব্যবহারকারীর সংখ্যা এখানে নেই — সেসব সংখ্যা উৎসভেদে খুব আলাদা আর দ্রুত বদলায়।

২ · Machine code থেকে FORTRAN — প্রথম বড় লাফ

প্রথম দিকের electronic কম্পিউটারে প্রোগ্রাম মানে ছিল সংখ্যার সারি: প্রতিটি নির্দেশ একটি opcode সংখ্যা আর একটি memory ঠিকানা। একে বলে machine code. একটি ঠিকানা ভুল হলে পুরো প্রোগ্রাম নষ্ট, আর মাঝখানে একটি নির্দেশ যোগ করলে পরের সব ঠিকানা হাতে বদলাতে হতো। ১৯৪০-এর দশকের শেষ আর ১৯৫০-এর দশকের শুরুতে সংখ্যার বদলে ছোট নাম (ADD, LOAD) আর প্রতীকী ঠিকানা লেখার ব্যবস্থা আসে — assembly language, আর তাকে machine code-এ বদলানোর প্রোগ্রাম assembler. Assembly এখনো যন্ত্রের সঙ্গে এক-এক সম্পর্কে বাঁধা: প্রতিটি লাইন সাধারণত একটি নির্দেশ, আর প্রতিটি CPU পরিবারের assembly আলাদা। (RISC-V assembly বিস্তারিত দেখতে Computer Architecture কোর্স।)

পরের লাফটি ছিল এমন ভাষা, যেখানে একটি লাইনে একটি গাণিতিক সূত্র লেখা যায়, আর একটি প্রোগ্রাম সেটিকে অনেকগুলো নির্দেশে অনুবাদ করে। এই অনুবাদক-প্রোগ্রামই compiler. Grace Hopper-এর দল ১৯৫২ সালের দিকে A-0 নামের একটি system বানায়, যাকে প্রায়ই প্রথম দিকের compiler বলা হয়; Manchester-এ Alick Glennie-এর Autocode-ও (১৯৫২) এই দাবিদার। “প্রথম compiler” খেতাবটি তাই সংজ্ঞার ওপর নির্ভর করে — এখানে কোনো একটিকে চূড়ান্ত বলা হচ্ছে না।

FORTRAN (১৯৫৭) — compiler কি হাতে লেখা কোডের সমান হতে পারে?

IBM-এ John Backus-এর নেতৃত্বে একটি ছোট দল ১৯৫৪ সালের দিকে FORTRAN (FORmula TRANslation) নিয়ে কাজ শুরু করে। প্রথম manual ১৯৫৬ সালের অক্টোবরে, আর IBM 704-এর জন্য প্রথম compiler গ্রাহকের কাছে পৌঁছায় ১৯৫৭ সালের এপ্রিলে। দলটির সবচেয়ে বড় চ্যালেঞ্জ ভাষার নকশা ছিল না, ছিল আস্থা: সেকালের অভিজ্ঞ প্রোগ্রামাররা বিশ্বাস করতেন, যন্ত্রের বানানো কোড হাতে লেখা assembly-র চেয়ে অনেক ধীর হবে। তাই প্রথম FORTRAN compiler-এর বড় অংশ ছিল optimization: loop-এর ভেতরের ঠিকানা-হিসাব, register-এর ব্যবহার। Backus পরে লিখেছেন, দক্ষতা প্রমাণ করাই ছিল প্রকল্পের মূল লক্ষ্য। এই “compiler দ্রুত কোড দিতে পারে” প্রমাণটিই high-level ভাষাকে ব্যবহারিক করে তোলে, আর M11–M12-এর optimization আর code generation-এর ইতিহাস এখান থেকেই শুরু।

FORTRAN-এর loop দেখতে আজকের চোখে অদ্ভুত। DO 10 I = 1, 3 মানে “I-কে 1 থেকে 3 পর্যন্ত বাড়িয়ে, 10 নম্বর লেবেলের লাইন পর্যন্ত বারবার চালাও।” Block বলে কিছু নেই; loop-এর শেষ চেনা যায় একটি সংখ্যা-লেবেল দিয়ে। নিচে একই হিসাব (তিনটি অর্ডারে পরিমাণ 2, 1, 3, প্রতিটির একক দাম 100 টাকা) FORTRAN 77 ধাঁচে আর Python 3-এ, ধাপে ধাপে:

1C     FORTRAN 77 style2      ITOTAL = 03      DO 10 I = 1, 34        ITOTAL = ITOTAL + IQ(I)*1005   10 CONTINUE6      PRINT *, ITOTAL7# Python 38total = 09for q in qty:10    total += q * 10011print(total)
মান (IQ = qty = 2, 1, 3)
ITOTAL
I
total
q
  1. শুরু। লাইন ২-এ ITOTAL 0 হলো। FORTRAN-এ I দিয়ে শুরু হওয়া নামগুলো (I থেকে N) নিজে থেকেই পূর্ণসংখ্যা — আলাদা ঘোষণা লাগে না। এই “নামের প্রথম অক্ষরে type” নিয়মটি পরের ভাষাগুলো বাদ দিয়েছে।
  2. DO loop শুরু। I = 1. লাইন ৫-এর লেবেল 10 পর্যন্ত অংশটিই loop-এর দেহ; কোনো বন্ধনী নেই।
  3. প্রথম অর্ডার। IQ(1) = 2, তাই ITOTAL = 0 + 2 × 100 = 200.
  4. CONTINUE পেরিয়ে আবার লাইন ৩। I বেড়ে 2. ১৯৫০-এর দশকের প্রোগ্রামাররা ঠিক এই ধরনের loop দ্রুত চালানোর জন্যই FORTRAN compiler-এর optimization-এর ওপর ভরসা করতেন।
  5. দ্বিতীয় অর্ডার। IQ(2) = 1, তাই ITOTAL = 200 + 100 = 300.
  6. I = 3. শেষবারের মতো loop-এর দেহে ঢোকা।
  7. তৃতীয় অর্ডার। IQ(3) = 3, তাই ITOTAL = 300 + 300 = 600. এরপর গোনা শেষ, loop থেকে বেরোনো।
  8. ফল ছাপা। PRINT * লেখে 600. (Loop শেষে I-এর মান কী থাকে, তা ভাষাভেদে আলাদা নিয়ম; এখানে শুধু “শেষ” দেখানো হলো।)
  9. এবার Python 3. total = 0. পার্থক্য খেয়াল করুন: এখানে কোনো সূচক (index) নেই; loop সরাসরি তালিকার প্রতিটি মান নেয়।
  10. q = 2. Loop-এর দেহ চেনা যায় indentation (লাইনের শুরুর ফাঁকা) দিয়ে। total = 200.
  11. q = 1. total = 300.
  12. q = 3. total = 600. তালিকা শেষ, loop শেষ।
  13. একই ফল। দুই প্রোগ্রামই 600 ছাপে। ষাট বছরের ব্যবধানে বদলেছে loop-এর সীমা চেনার উপায় (লেবেল → indentation), type ঠিক করার উপায় (নামের প্রথম অক্ষর → মান দেখে), আর সূচক-গোনা থেকে সরাসরি মানের ওপর চলা। হিসাবের যুক্তি একই আছে।

COBOL (১৯৫৯) — ব্যবসার জন্য ইংরেজির মতো ভাষা

FORTRAN বিজ্ঞান আর প্রকৌশলের হিসাবের জন্য। ব্যবসার হিসাবের (বেতন, হিসাবের খাতা, বিল) জন্য আলাদা চাহিদা ছিল: বড় রেকর্ড, দশমিক টাকার হিসাব আর এমন লেখা যা ম্যানেজারও পড়তে পারেন। ১৯৫৯ সালের মে মাসে যুক্তরাষ্ট্রের Pentagon-এ একটি সভা থেকে CODASYL নামের কমিটি গঠিত হয়, আর সেই বছরের ডিসেম্বরে COBOL-এর প্রথম specification প্রকাশিত হয়। Grace Hopper-এর আগের ভাষা FLOW-MATIC এর ওপর সবচেয়ে বড় প্রভাব রেখেছিল বলে ধরা হয়; তবে COBOL-এর “স্রষ্টা” হিসেবে Hopper-কে বলা ঠিক কি না, তা নিয়ে ইতিহাসবিদদের মতভেদ আছে, কারণ এটি ছিল কমিটির কাজ। COBOL দেখিয়েছিল যে একটি ভাষা কোনো একটি কোম্পানির যন্ত্রে বাঁধা না থেকে বহু নির্মাতার যন্ত্রে চলতে পারে।

৩ · LISP আর ALGOL — দুই বীজ যা থেকে প্রায় সব গাছ

LISP (১৯৫৮–১৯৬০) — list, recursion আর garbage collection

MIT-তে John McCarthy ১৯৫৮ সালে LISP (LISt Processing) নকশা শুরু করেন; তাঁর বিখ্যাত প্রবন্ধ “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I” প্রকাশিত হয় ১৯৬০ সালে Communications of the ACM-এ। LISP তিনটি ধারণা প্রোগ্রামিংয়ের মূলধারায় আনে, যা আজও প্রতিটি আধুনিক ভাষায় আছে:

  • Recursion স্বাভাবিক ব্যবহার: function নিজেকে ডেকে সমস্যার ছোট রূপ সমাধান করবে — FORTRAN-এর প্রথম রূপে এটি ছিল না।
  • স্বয়ংক্রিয় memory ফেরত: list-এর ঘর যখন আর কোনো পথে পৌঁছানো যায় না, তখন একটি প্রক্রিয়া নিজেই তা খুঁজে আবার ব্যবহারের জন্য ফেরত আনে। McCarthy-র ১৯৬০ সালের প্রবন্ধকেই সাধারণত garbage collection-এর প্রথম প্রকাশিত বর্ণনা ধরা হয়; একই বছর George Collins reference counting-এর ধারণা প্রকাশ করেন। (বাস্তবায়ন পর্ব ৭৫-এ।)
  • Program নিজেই data: LISP-এর কোড আর list একই গঠনে লেখা, আর eval নামের একটি ছোট function-ই পুরো ভাষার interpreter. এটি প্রথম interpreter-গুলোর একটি, আর metaprogramming-এর (পর্ব ৭৮) শুরু।

LISP-এর গাণিতিক ভিত্তি ছিল Alonzo Church-এর lambda calculus (১৯৩০-এর দশক), যদিও McCarthy নিজে বলেছেন যে তিনি তত্ত্বটি পুরোপুরি মেনে চলেননি। Lambda calculus একটি গণনার মডেল হিসেবে গণনার তত্ত্ব কোর্সের পর্ব ৪৯-এ আছে; প্রোগ্রামিং ভাষার ভিত্তি হিসেবে আসবে পর্ব ৪৩-এ।

ALGOL 58/60 — ভাষাকে কাগজে নিখুঁত করে লেখা

ইউরোপ আর আমেরিকার বিশেষজ্ঞদের একটি আন্তর্জাতিক কমিটি একটি সাধারণ, যন্ত্র-নিরপেক্ষ বৈজ্ঞানিক ভাষা চাইছিল। প্রথম খসড়া IAL, পরে নাম ALGOL 58. তার জন্য John Backus ১৯৫৯ সালে syntax লেখার একটি নতুন রীতি প্রস্তাব করেন। ১৯৬০ সালের ALGOL 60 report-এ Peter Naur (সম্পাদক) সেই রীতি সামান্য বদলে (::= আর | চিহ্ন) পুরো ভাষার ব্যাকরণ লেখেন। এটিই BNF: প্রথমে “Backus Normal Form” নামে পরিচিত, ১৯৬৪ সালে Donald Knuth Communications of the ACM-এ একটি চিঠিতে প্রস্তাব করেন নামটি হোক “Backus–Naur Form”, কারণ এটি আসলে কোনো “normal form” নয় আর Naur-এর অবদানও স্বীকার করা উচিত। সেই নামই টিকে গেছে।

BNF-এর প্রভাব বিশাল: এর পর থেকে প্রায় প্রতিটি ভাষার standard তার syntax একটি grammar দিয়ে লেখে, আর parser-generator tool সরাসরি সেই grammar পড়ে parser বানায়। Grammar-এর তত্ত্ব (context-free grammar, derivation, ambiguity) গণনার তত্ত্ব কোর্সের পর্ব ২৫ থেকে শেখানো হয়েছে; এখানে শুধু দেখা যাক একটি ALGOL-ধাঁচের grammar কীভাবে 2 + 3 * 4-কে জন্ম দেয়, আর কেন গুণ আগে হয়:

1<expr>   ::= <expr> + <term> | <term>2<term>   ::= <term> * <factor> | <factor>3<factor> ::= <digit> | ( <expr> )4<digit>  ::= 0 | 1 | 2 | ... | 9
বাক্যের বর্তমান রূপ (sentential form)
রূপ
ধাপ
  1. শুরুর চিহ্ন। কোণ-বন্ধনীর নাম (⟨expr⟩) মানে “এখনো ভাঙা হয়নি এমন একটি অংশ” — nonterminal. লক্ষ্য: বারবার বাঁদিকের প্রথম nonterminal-কে একটি নিয়ম দিয়ে বদলে শেষে শুধু 2 + 3 * 4 পাওয়া।
  2. নিয়ম ১, প্রথম বিকল্প। ⟨expr⟩ → ⟨expr⟩ + ⟨term⟩. শেষ পর্যন্ত যোগটিই হবে গাছের মূল, অর্থাৎ সবার শেষে হিসাব হবে।
  3. নিয়ম ১, দ্বিতীয় বিকল্প। বাঁদিকের ⟨expr⟩ → ⟨term⟩, কারণ যোগের বাঁ পাশে আর কোনো যোগ নেই।
  4. নিয়ম ২। ⟨term⟩ → ⟨factor⟩: বাঁ পাশের অংশে গুণও নেই।
  5. নিয়ম ৩। ⟨factor⟩ → ⟨digit⟩.
  6. নিয়ম ৪। ⟨digit⟩ → 2. বাঁ পাশ শেষ; এবার ডান পাশের ⟨term⟩ বাঁদিকের প্রথম nonterminal.
  7. নিয়ম ২, প্রথম বিকল্প। ⟨term⟩ → ⟨term⟩ * ⟨factor⟩. গুণটি ⟨term⟩-এর ভেতরে বসল, অর্থাৎ যোগের একটি অংশ হয়ে — তাই গুণ আগে হিসাব হবে। Precedence এভাবেই grammar-এর স্তরে লেখা থাকে।
  8. নিয়ম ২, দ্বিতীয় বিকল্প। ⟨term⟩ → ⟨factor⟩.
  9. নিয়ম ৩। ⟨factor⟩ → ⟨digit⟩.
  10. নিয়ম ৪। ⟨digit⟩ → 3.
  11. নিয়ম ৩। শেষ ⟨factor⟩ → ⟨digit⟩.
  12. নিয়ম ৪, শেষ। ⟨digit⟩ → 4. মোট ১১টি প্রতিস্থাপনে পুরো বাক্য পাওয়া গেল, আর কোনো nonterminal বাকি নেই। এই একই ধাপগুলো উল্টো দিক থেকে করে parser একটি parse tree বানায় — Haat-এর parser পর্ব ৪৭–৪৮-এ ঠিক এই স্তরভাগ মেনে লেখা হবে।

ALGOL 60-এর আরও কয়েকটি ধারণা আজ এত স্বাভাবিক যে আমরা ভুলে যাই এগুলো একসময় নতুন ছিল: begin … end দিয়ে block structure, ভেতরের block-এ নতুন নাম ঘোষণা করা আর কোড কোথায় লেখা আছে তা দেখে নামের অর্থ ঠিক করা (lexical scope), recursive procedure আর call-by-name নামের এক বিশেষ parameter-পাঠানোর নিয়ম (পর্ব ২৯)। ALGOL 60 বাণিজ্যিকভাবে খুব বেশি ব্যবহৃত হয়নি, কিন্তু Pascal, C, Simula, Scheme আর পরে Java — সবাই এর বংশধর। এজন্য এই পরিবারকে প্রায়ই “ALGOL-পরিবার” বলা হয়।

BNF-এর আগেও ব্যাকরণ নিয়মে লেখার ঐতিহ্য ছিল: ভাষাবিজ্ঞানী Noam Chomsky ১৯৫০-এর দশকের মাঝামাঝি phrase-structure grammar নিয়ে লেখেন, আর কেউ কেউ প্রাচীন ভারতের পাণিনির সংস্কৃত ব্যাকরণকেও এর দূরবর্তী পূর্বসূরি হিসেবে উল্লেখ করেন। Backus নিজে Emil Post-এর production system-এর প্রভাবের কথা বলেছেন বলে উল্লেখ পাওয়া যায়। কে কার কাজ কতটা জানতেন, সে বিষয়ে উৎসগুলো পুরোপুরি একমত নয়।

৪ · ১৯৬৭–১৯৭৫ — আজকের paradigm-গুলোর জন্ম

ষাটের দশকের শেষ থেকে সত্তরের মাঝামাঝি — মাত্র আট-নয় বছরে — এমন কয়েকটি ভাষা আসে, যারা আজকের প্রায় সব programming paradigm-এর (প্রোগ্রাম সাজানোর মৌলিক ধরন) শিকড়। প্রতিটি paradigm-এর বিস্তারিত মডিউল ২-এ (পর্ব ০৭–১৩); এখানে শুধু কে, কখন আর কী আনল।

Simula 67 — class আর object

নরওয়ের Norwegian Computing Center-এ Ole-Johan Dahl আর Kristen Nygaard simulation লেখার জন্য ALGOL 60-কে বাড়িয়ে Simula বানান। Simula 67 আনে class, object, subclass (inheritance) আর virtual procedure — অর্থাৎ dynamic dispatch. এই কাজের জন্য দুজনে ২০০১ সালের Turing Award পান।

পরবর্তী: Smalltalk, C++, Java

Smalltalk (১৯৭২–১৯৮০) — সব কিছুই object

Xerox PARC-এ Alan Kay-এর দল (Dan Ingalls, Adele Goldberg প্রমুখ) Smalltalk-72 থেকে Smalltalk-80 পর্যন্ত কয়েকটি রূপ বানায়। এখানে সংখ্যা থেকে class পর্যন্ত সবই object, আর কাজ হয় object-কে message পাঠিয়ে। “Object-oriented” কথাটি Kay-এর বলে সাধারণত উল্লেখ করা হয়। OOP-এর আজকের ধারণার অনেকটাই এখান থেকে।

পরবর্তী: Objective-C, Ruby, Java-র VM ভাবনা

C (১৯৭২) — যন্ত্রের কাছাকাছি, তবু বহনযোগ্য

Bell Labs-এ Dennis Ritchie, Ken Thompson-এর B ভাষা (যা Martin Richards-এর BCPL থেকে) থেকে C বানান, মূলত Unix লেখার জন্য; ১৯৭৩ সালে Unix-এর kernel-এর বড় অংশ C-তে নতুন করে লেখা হয়। C pointer, struct আর সরাসরি memory-তে হাত দেওয়ার ক্ষমতা দেয়, কিন্তু ALGOL-এর block-গঠন রাখে। আজকের বেশির ভাগ operating system আর অনেক ভাষার runtime C বা C++-এ লেখা।

পরবর্তী: C++, Objective-C, Java, Go

Prolog (১৯৭২) — কী চাই বলুন, কীভাবে নয়

মার্সেইতে Alain Colmerauer আর Philippe Roussel Prolog বানান; Edinburgh-এর Robert Kowalski-র “logic-কে program হিসেবে পড়া” ব্যাখ্যা এর তাত্ত্বিক ভিত্তি। প্রোগ্রাম হলো তথ্য আর নিয়মের তালিকা; উত্তর খোঁজে unification আর backtracking (পর্ব ১০)। এটি logic programming-এর প্রধান ভাষা।

পরবর্তী: Datalog, constraint logic programming

ML (১৯৭৩) — নিজে থেকে type বের করা

Edinburgh-এ Robin Milner LCF নামের theorem prover-এর “meta language” হিসেবে ML বানান। ML প্রতিটি expression-এর type নিজেই বের করে (type inference), আর একই function বিভিন্ন type-এ কাজ করতে পারে। পেছনের algorithm-এর নাম Hindley–Milner: Roger Hindley (১৯৬৯), Milner (১৯৭৮), আর Luis Damas-এর সঙ্গে Milner-এর প্রমাণ (১৯৮২)। পর্ব ৩৫-এ Haat-এর জন্য এটি বানানো হবে।

পরবর্তী: Standard ML, OCaml, Haskell, F#, Rust

Scheme (১৯৭৫) — ছোট LISP, lexical closure

MIT-তে Gerald Jay Sussman আর Guy L. Steele Jr. একটি ছোট LISP বানান, যেখানে ALGOL-এর মতো lexical scope; এটিকে সাধারণত lexical scope-ওয়ালা প্রথম LISP dialect বলা হয়। Function পুরোপুরি first-class মান, আর tail call-এ stack বাড়ে না (পর্ব ৩২)। শিক্ষায় আর ভাষা-গবেষণায় এর প্রভাব খুব বড়।

পরবর্তী: JavaScript-এর function, Racket

খেয়াল করুন, এই ছয়টি ভাষা ছয়টি আলাদা প্রশ্নের উত্তর: কীভাবে বাস্তব জগৎকে মডেল করব (Simula, Smalltalk), কীভাবে operating system বহনযোগ্যভাবে লিখব (C), কীভাবে যুক্তি দিয়ে প্রশ্নের উত্তর খুঁজব (Prolog), কীভাবে type লিখে না দিয়েও নিরাপদ থাকব (ML), আর কীভাবে খুব ছোট একটি ভাষায় সব প্রকাশ করব (Scheme). নকশার এই লক্ষ্য আর আপস নিয়ে পুরো আলোচনা পর্ব ০৬-এ।

“প্রজন্ম” কথাটি

বইয়ে প্রায়ই পাঁচ প্রজন্মের কথা থাকে: 1GL machine code, 2GL assembly, 3GL FORTRAN, C, Java-র মতো সাধারণ high-level ভাষা, 4GL SQL বা report-generator-এর মতো নির্দিষ্ট কাজের ভাষা, আর 5GL — যা প্রায়ই Prolog-এর মতো logic ভাষা আর ১৯৮০-এর দশকের জাপানের Fifth Generation Computer প্রকল্পের সঙ্গে যুক্ত করা হয়। প্রথম তিনটির সীমারেখা পরিষ্কার; ৪ আর ৫ নিয়ে বই আর বিক্রেতারা নানা অর্থ ব্যবহার করেছেন। তাই পরীক্ষায় লিখলে সংজ্ঞাসহ লিখুন, আর মনে রাখুন এটি ইতিহাস বোঝার একটি মোটা দাগের ভাগ, কঠোর বিজ্ঞান নয়।

৫ · ভাষার পরিবার-গাছ — কে কার কাছ থেকে কী নিল

নিচের ছবিতে ১৯টি ভাষা চারটি দলে সাজানো। প্রতিটি দল একটি মোটা দাগের পরিবার: Imperative (ধাপে ধাপে নির্দেশ আর বদলানো যায় এমন variable), Object (class আর object), Functional (function আর মান), আর Script, Logic (সহজে লেখা আর চালানোর ভাষা এবং logic programming). প্রতিটি বাক্সে ভাষার নাম, সাল, আর “←” চিহ্নের পরে সেই ভাষার এক বা দুটি প্রধান পূর্বসূরি। আসল প্রভাবের জাল এর চেয়ে অনেক ঘন — এটি পড়ার সুবিধার জন্য সরলীকৃত।

প্রোগ্রামিং ভাষার পরিবার — চার ধারায়

প্রতিটি দলে বাঁ থেকে ডানে, ওপর থেকে নিচে সময়ের ক্রম; ← মানে “প্রধান প্রভাব এসেছে যার কাছ থেকে”

Family tree of programming languages in four groups: imperative, object-oriented, functional, scripting and logic Imperative FORTRAN 1957 ALGOL 60 1960 ← FORTRAN C 1972 ← ALGOL Go 2009 ← C Rust 1.0 2015 ← C++, ML Object Simula 67 1967 ← ALGOL Smalltalk 1972 ← Simula C++ 1985 ← C, Simula Java 1995 ← C++ C# 2000 ← Java Functional LISP 1958 ML 1973 ← LISP Scheme 1975 ← LISP Haskell 1990 ← ML Script, Logic COBOL 1959 Prolog 1972 logic Python 1991 ← ABC, C JavaScript 1995 ← Scheme TypeScript 2012 ← JS
ছবি ২.১ — অনেক ভাষা একাধিক দলে বসতে পারে (C++, Python, Rust আর JavaScript আসলে একাধিক paradigm মেশায়); এখানে প্রতিটি ভাষা একটি প্রধান পরিচয়ে বসানো। সাল সাধারণত উল্লেখিত প্রথম প্রকাশ বা রিপোর্টের বছর।

ছবিটি একটি data table থেকে বানানো যায়, আর সেই table দিয়ে প্রশ্নও করা যায়: “Rust-এর পূর্বপুরুষ কারা?” এটি আসলে একটি graph-এ পেছনের দিকে breadth-first search. নিচের Python কোড ব্রাউজারেই চলে (Pyodide-এ সত্যিকারের CPython). প্রভাবের তালিকা ইচ্ছা করে ছোট আর সরলীকৃত রাখা হয়েছে:

# (year, language, people, influenced by) — simplified, dates as usually cited
LANGS = [
    (1957, "FORTRAN", "Backus (IBM)", []),
    (1958, "LISP", "McCarthy", []),
    (1959, "COBOL", "CODASYL", []),
    (1960, "ALGOL 60", "Naur (ed.)", ["FORTRAN"]),
    (1967, "Simula 67", "Dahl, Nygaard", ["ALGOL 60"]),
    (1972, "C", "Ritchie", ["ALGOL 60"]),
    (1972, "Smalltalk", "Kay (PARC)", ["Simula 67", "LISP"]),
    (1972, "Prolog", "Colmerauer", []),
    (1973, "ML", "Milner", ["LISP"]),
    (1975, "Scheme", "Sussman, Steele", ["LISP", "ALGOL 60"]),
    (1985, "C++", "Stroustrup", ["C", "Simula 67"]),
    (1990, "Haskell", "committee", ["ML"]),
    (1991, "Python", "van Rossum", ["C", "Haskell"]),
    (1995, "Java", "Gosling (Sun)", ["C++", "Smalltalk"]),
    (1995, "JavaScript", "Eich", ["Scheme", "Java"]),
    (2000, "C#", "Hejlsberg", ["Java", "C++"]),
    (2009, "Go", "Griesemer, Pike, Thompson", ["C"]),
    (2015, "Rust 1.0", "Mozilla", ["C++", "ML", "Haskell"]),
]
by_name = {name: infl for _, name, _, infl in LANGS}
for decade in sorted({y // 10 * 10 for y, *_ in LANGS}):
    row = [f"{n} ({y})" for y, n, _, _ in LANGS if y // 10 * 10 == decade]
    print(f"{decade}s: " + ", ".join(row))
def ancestors(lang):                # walk "influenced by" edges back in time
    seen, todo = [], [lang]
    while todo:
        for parent in by_name[todo.pop(0)]:
            if parent not in seen:
                seen.append(parent); todo.append(parent)
    return seen
print("Rust 1.0 <-", ", ".join(ancestors("Rust 1.0")))
print("JavaScript <-", ", ".join(ancestors("JavaScript")))

আসল আউটপুট (ব্রাউজারের Python; একই কোড Python 3.14.4-এও হুবহু একই ফল দিয়েছে):

1950s: FORTRAN (1957), LISP (1958), COBOL (1959)
1960s: ALGOL 60 (1960), Simula 67 (1967)
1970s: C (1972), Smalltalk (1972), Prolog (1972), ML (1973), Scheme (1975)
1980s: C++ (1985)
1990s: Haskell (1990), Python (1991), Java (1995), JavaScript (1995)
2000s: C# (2000), Go (2009)
2010s: Rust 1.0 (2015)
Rust 1.0 <- C++, ML, Haskell, C, Simula 67, LISP, ALGOL 60, FORTRAN
JavaScript <- Scheme, Java, LISP, ALGOL 60, C++, Smalltalk, FORTRAN, C, Simula 67

প্রথম সাত লাইন দশক ধরে ভাগ: ১৯৭০-এর দশকের সারিটি সবচেয়ে ভরা, যা অংশ ৪-এর “বিস্ফোরণ”-এর কথা মেলায়। শেষ দুই লাইনে ancestors একটি queue দিয়ে “influenced by” তীর ধরে পেছনে হাঁটে; কাছের পূর্বসূরি আগে আসে (C++, ML, Haskell), দূরের পরে (ALGOL 60, FORTRAN). খেয়াল করুন, এই সরলীকৃত table-এও Rust আর JavaScript দুজনেরই শিকড়ে LISP আর ALGOL 60 দুটোই আছে — অংশ ৩-এর “দুই বীজ” কথাটির এটিই অর্থ। Prolog আর COBOL-এর তালিকা খালি, কারণ তাদের প্রধান পূর্বসূরি (যেমন FLOW-MATIC) table-এ রাখা হয়নি; table যত ছোট, উত্তর তত অসম্পূর্ণ — যেকোনো “ভাষার বংশলতিকা” পড়ার সময় এই সীমা মনে রাখবেন।

৬ · যে ধারণাগুলো ভ্রমণ করেছে

ভাষা আসে-যায়, কিন্তু ভালো ধারণা এক ভাষা থেকে আরেক ভাষায় চলে যায় — প্রায়ই কয়েক দশক দেরিতে। এই দেরির কারণ সাধারণত দুটি: ধারণাটির বাস্তবায়ন দ্রুত করার কৌশল (compiler-এর কাজ) তখনো তৈরি হয়নি, অথবা জনপ্রিয় ভাষাগুলো পুরোনো কোড না ভেঙে নতুন জিনিস যোগ করার পথ খুঁজছিল।

ধারণাযেখানে জন্ম (মোটামুটি)মূলধারায় পৌঁছানোএই কোর্সে
Garbage collectionLISP, McCarthy ১৯৬০Smalltalk, ML; পরে Java (১৯৯৫), JavaScript, Python, C#, Goপর্ব ৭৫
Class, object, inheritanceSimula 67Smalltalk, C++ (১৯৮৫), Java, C#, Pythonপর্ব ০৮
Lexical scope আর blockALGOL 60Pascal, C, Scheme; আজ প্রায় সব ভাষাপর্ব ১৫
ClosureLandin ১৯৬৪ (নাম), Scheme ১৯৭৫JavaScript (১৯৯৫), C# 3.0 (২০০৭), C++11 (২০১১), Java 8 (২০১৪)পর্ব ১৭, ৫৭
Type inferenceML ১৯৭৩ (Hindley–Milner)Haskell, OCaml, Rust; local রূপে C++11 auto, Java 10 var, Kotlin, Swift, TypeScriptপর্ব ৩৫
Generics (type parameter)ML-এর polymorphism, CLU (১৯৭০-এর দশক)Ada, C++ template, Java 5 (২০০৪), C# 2.0 (২০০৫), Go 1.18 (২০২২)পর্ব ৩৬, ৩৭
Bytecode আর virtual machineBCPL-এর O-code, Pascal-এর p-code (১৯৭০-এর দশক)Smalltalk-80, Java-র JVM, CPython, .NETপর্ব ৫৮–৬০

সবচেয়ে সুন্দর উদাহরণ সম্ভবত closure. নিচে একটি ছোট function — “n যোগ করার যন্ত্র বানাও” — কয়েকটি ভাষার রূপে, আর প্রতিটি ধাপে ধারণাটির কী বদলাল। কোডগুলো উদাহরণ, এই পাতায় চালানো হয়নি (JavaScript-এর রূপটি নিচে অংশ ৭-এ সত্যিই চালানো হবে)।

  1. LISP১৯৬০dynamic scope
  2. Landin১৯৬৪নাম: closure
  3. ML১৯৭৩lexical, typed
  4. Scheme১৯৭৫lexical LISP
  5. JavaScript১৯৯৫প্রতিদিনের কাজে
  6. C++/Java২০১১/১৪lambda
Lisp (dynamic scope)উদাহরণ, চালানো হয়নি
(defun make-adder (n)
  (lambda (x) (+ x n)))
(funcall (make-adder 10) 5)
; dynamic scope-এ n খোঁজা হয় ডাকার জায়গায়,
; যেখানে n-এর binding আর নেই
Landin-এর ধারণাfunction + environment
closure = ( λx. x + n ,  { n ↦ 10 } )
          কোড অংশ        পরিবেশ অংশ
(closure 5)  ⇒  5 + 10  ⇒  15
Standard MLউদাহরণ, চালানো হয়নি
fun makeAdder n = fn x => x + n
val add10 = makeAdder 10
val r = add10 5      (* r = 15 *)
(* type নিজে থেকে: int -> int -> int *)
Schemeউদাহরণ, চালানো হয়নি
(define (make-adder n)
  (lambda (x) (+ x n)))
((make-adder 10) 5)   ; => 15
JavaScript১৯৯৫-এর ধাঁচ
function makeAdder(n) {
  return function (x) { return x + n; };
}
makeAdder(10)(5)   // 15
C++11 আর Java 8উদাহরণ, চালানো হয়নি
// C++11: [n] = n-এর কপি ধরে রাখা
auto add10 = [n](int x) { return x + n; };
// Java 8: n effectively final হতে হবে
IntUnaryOperator add10 = x -> x + n;
  1. LISP, ১৯৬০ — সমস্যার জন্ম। প্রথম দিকের LISP বাস্তবায়নে free variable (যেমন n) খোঁজা হতো ডাকার মুহূর্তের পরিবেশে — dynamic scope. ফলে function অন্য জায়গায় পাঠালে সে ভুল n দেখতে পারত। এই সমস্যার নাম funarg problem; LISP-এ একে সামলাতে FUNCTION নামের বিশেষ ব্যবস্থা ছিল।
  2. Landin, ১৯৬৪ — নাম আর সংজ্ঞা। Peter Landin তাঁর SECD machine-এর প্রবন্ধে (“The Mechanical Evaluation of Expressions”) একটি function-কে দুই অংশের জোড়া হিসেবে দেখান: কোড আর তৈরির সময়ের পরিবেশ। এই জোড়ার নামই তিনি দেন closure. সমাধানটি এক লাইনে: function-এর সঙ্গে তার জন্মস্থানের পরিবেশ বেঁধে রাখা।
  3. ML, ১৯৭৩ — lexical আর typed. ML শুরু থেকেই lexical scope আর first-class function নিয়ে আসে, আর type inference closure-এরও type বের করে: makeAdder নেয় একটি int, ফেরত দেয় “int থেকে int” function.
  4. Scheme, ১৯৭৫ — LISP পরিবার lexical হলো। Sussman আর Steele LISP-এর ধাঁচ রেখে ALGOL-এর lexical scope নেন। এবার (make-adder 10) থেকে ফেরা function চিরকাল n = 10 মনে রাখে। Landin-এর “closure” শব্দটি এখান থেকেই ব্যাপক হয়। পরে Common Lisp (১৯৮৪)-ও lexical scope-কে মূল নিয়ম করে।
  5. JavaScript, ১৯৯৫ — closure সবার হাতে। Brendan Eich Netscape-এ JavaScript বানানোর সময় Scheme-ধাঁচের first-class function আর Java-ধাঁচের syntax মেশান। ফলে event handler, callback আর module pattern — ওয়েবের প্রতিদিনের কোড closure-এর ওপর দাঁড়িয়ে গেল। বিস্তারিত JavaScript কোর্সের পর্ব ২২-এ।
  6. C++11 আর Java 8 — দেরিতে আসা, নিজের মতো করে। দুই ভাষাতেই closure এসেছে বহু বছর পরে, আর নিজস্ব নিয়ম নিয়ে: C++-এ capture list দিয়ে কপি ([n]) না reference ([&n]) তা লিখে দিতে হয়; Java-তে ধরা variable “effectively final” হতে হয়, অর্থাৎ মান কার্যত কপি হয়। Haat-এর নিয়ম Scheme আর JavaScript-এর মতো: closure variable-কে reference হিসেবে ধরে, তাই পরের পরিবর্তনও দেখে (পর্ব ১৭, ৫৭)।

৭ · ১৯৮৫–২০১৫ — আধুনিক ঢেউ, আর একই হিসাব চার ভাষায়

সত্তরের দশকের ধারণাগুলো আশির দশক থেকে বড় শিল্প-ভাষায় মিশতে শুরু করে। প্রধান কয়েকটি মাইলফলক (সাল সাধারণত উল্লেখিত প্রকাশের বছর):

সালভাষাযাঁর বা যাদেরমূল অবদান
১৯৮৫C++Bjarne Stroustrup, Bell LabsC-এর ওপর Simula-র class; ১৯৭৯-এর “C with Classes” থেকে, ১৯৮৩-তে নাম C++, ১৯৮৫-তে বাণিজ্যিক প্রকাশ
১৯৯০Haskellএকটি কমিটি (১৯৮৭-তে গঠিত)Lazy, pure functional ভাষার একটি খোলা standard; type class
১৯৯১PythonGuido van Rossum, CWI১৯৯১-এর ফেব্রুয়ারিতে 0.9.0 প্রকাশ; ABC ভাষার প্রভাব, indentation দিয়ে block
১৯৯৫JavaJames Gosling-এর দল, SunBytecode আর JVM, GC, “একবার লিখে বহু যন্ত্রে চালানো”
১৯৯৫JavaScriptBrendan Eich, NetscapeBrowser-এর ভাষা; Scheme-এর function, Self-এর prototype, Java-র syntax
২০০০C#Anders Hejlsberg-এর দল, Microsoft২০০০ সালে ঘোষণা, ২০০২-এ .NET-এর সঙ্গে 1.0
২০০৯GoRobert Griesemer, Rob Pike, Ken Thompson, Googleসরল syntax, goroutine আর channel (CSP-এর ধারণা), দ্রুত compile; 1.0 ২০১২
২০১১–১৬KotlinJetBrains২০১১-তে ঘোষণা, ২০১৬-তে 1.0; JVM-এ চলে, null-নিরাপদ type
২০১২TypeScriptMicrosoft (Hejlsberg)JavaScript-এর ওপর static type; JavaScript-এ রূপান্তরিত হয় (transpiler)
২০১৪SwiftAppleObjective-C-এর উত্তরসূরি; type inference, optional
২০১৫Rust 1.0Graydon Hoare-এর শুরু করা, Mozilla-র সমর্থিতGC ছাড়া memory safety: ownership আর borrow checking (পর্ব ৭৬)

দুটি প্রচলিত ভুল ধারণা। এক, “Java interpreted ভাষা”: javac source-কে bytecode-এ compile করে; JVM শুরুতে bytecode interpret করে, কিন্তু বেশি চলা অংশকে চলার সময় machine code-এ compile করে (JIT). তাই “শুধু interpreted” বলা ভুল — বিস্তারিত পর্ব ০৪ আর Java কোর্সের পর্ব ০৫-এ। দুই, “JavaScript হলো Java-র ছোট ভাই”: নাম ছাড়া দুই ভাষার নকশায় মিল খুব কম; প্রথমে নাম ছিল Mocha, পরে LiveScript, আর ১৯৯৫ সালের শেষে নামটি JavaScript রাখা হয়, যাকে সাধারণত সেই সময়ের Java-র জনপ্রিয়তার সঙ্গে মিলিয়ে বিপণনের সিদ্ধান্ত বলা হয়।

এবার অংশ ১-এর বাজারঘর-হিসাবটি পুরো bazar.haat-এর মতো করে চারটি ভাষায় চালানো যাক। Haat-এর নিয়মে উত্তর হওয়ার কথা 996, 5000, 3 (২ পিস × ৫২০ টাকা = ১০৪০; ১০% ছাড়ে ৯৩৬; ১০০০-এর কম বলে ৬০ টাকা delivery; তারপর ১২৫০ করে যোগ করে ৫০০০ ছোঁয়া পর্যন্ত গোনা)। প্রথমে C, যা Wandbox সার্ভারের আসল compiler-এ চলবে:

#include <stdio.h>

long price(long qty, long unit) {
    long p = qty * unit;
    if (p >= 1000) return p - p / 10;
    return p;
}

long delivery(long total) {
    if (total >= 1000) return 0; else return 60;
}

int main(void) {
    long first = price(2, 520) + delivery(price(2, 520));
    printf("%ld\n", first);
    long total = 0, rounds = 0;
    while (total < 5000) { total = total + 1250; rounds = rounds + 1; }
    printf("%ld\n", total);
    printf("%ld\n", rounds - 1);
    return 0;
}

আসল আউটপুট (Zig 0.17.1-এর সঙ্গে আসা Clang দিয়ে -Wall -Wextra-সহ compile করে সত্যিকারের run; কোনো warning আসেনি):

996
5000
3

C-এর সংস্করণটি প্রায় হুবহু Haat: function-এ type লেখা, { } দিয়ে block, while. পার্থক্য দুটি: C-তে type নামের আগে বসে (long p), Haat-এ পরে (p: Int, ML আর Pascal-এর রীতি); আর C-তে if-এর শর্তে বন্ধনী লাগে। / দুই ভাষাতেই শূন্যের দিকে কেটে পূর্ণসংখ্যা দেয় (C99 থেকে এটি standard-এ নির্দিষ্ট), তাই 1040 / 10 = 104. Haat-এর Int 64-bit; এখানে long ব্যবহার করা হয়েছে, যা অনেক Linux system-এ 64-bit, কিন্তু Windows-এ সাধারণত 32-bit — এই ছোট হিসাবে তাতে কিছু বদলায় না।

একই হিসাব Java-তে (Wandbox-এর আসল JDK-তে চলে):

class Bazar {
    static long price(long qty, long unit) {
        long p = qty * unit;
        if (p >= 1000) return p - p / 10;
        return p;
    }

    static long delivery(long total) {
        return total >= 1000 ? 0 : 60;
    }

    public static void main(String[] args) {
        long first = price(2, 520) + delivery(price(2, 520));
        System.out.println(first);
        long total = 0, rounds = 0;
        while (total < 5000) { total = total + 1250; rounds = rounds + 1; }
        System.out.println(total);
        System.out.println(rounds - 1);
    }
}

আসল আউটপুট (Wandbox-এর JDK 21-এ চালিয়ে; C সংস্করণের হুবহু একই হিসাব):

996
5000
3

Java-র কোড C-এর প্রায় কপি — এটি ইচ্ছাকৃত: C আর C++ প্রোগ্রামারদের কাছে পরিচিত লাগার জন্য Java-র syntax C-পরিবারের। তফাত ভেতরে: সব function-কে একটি class-এর ভেতরে থাকতে হয় (Simula-Smalltalk-এর উত্তরাধিকার), আর Java-তে long সব যন্ত্রে ঠিক 64-bit, যা ভাষার specification-এ লেখা আছে। এই হিসাব javac প্রথমে bytecode-এ, তারপর JVM চালায়।

এবার JavaScript, সরাসরি আপনার ব্রাউজারে; শেষে অংশ ৬-এর closure-টিও সত্যিই চালানো হলো:

function price(qty, unit) {
  const p = qty * unit;
  if (p >= 1000) return p - Math.trunc(p / 10); // JS has no integer type
  return p;
}
function delivery(total) {
  return total >= 1000 ? 0 : 60;
}
const first = price(2, 520) + delivery(price(2, 520));
console.log(first);
let total = 0, rounds = 0;
while (total < 5000) { total = total + 1250; rounds = rounds + 1; }
console.log(total);
console.log(rounds - 1);
// a closure: the idea Landin named in 1964 and Scheme made everyday
function makeDiscount(percent) {
  return (amount) => amount - Math.trunc(amount * percent / 100);
}
const eid = makeDiscount(10);
console.log(eid(1040), typeof eid);

আসল আউটপুট:

996
5000
3
936 function

প্রথম তিন লাইন আগের মতোই। কিন্তু একটি সূক্ষ্ম পার্থক্য আছে: JavaScript-এর সাধারণ সংখ্যা হলো 64-bit floating-point (IEEE 754); আলাদা integer type নেই (খুব বড় পূর্ণসংখ্যার জন্য BigInt আলাদা জিনিস)। তাই 1040 / 10 হতো 104 ঠিকই, কিন্তু 1045 / 10 হতো 104.5 — Haat-এর পূর্ণসংখ্যা-ভাগ পেতে Math.trunc লাগে। শেষ লাইনে makeDiscount(10) একটি function ফেরত দিয়েছে (typeof বলছে function), যা percent = 10 মনে রেখেছে, আর 1040 থেকে 936 দিয়েছে — এটিই closure. Arrow function (=>) এসেছে ECMAScript 2015-এ; ১৯৯৫-এর JavaScript-এ একই কাজ function দিয়ে লেখা হতো।

সবশেষে Python. এটি ব্রাউজারে না চালিয়ে নিজের কম্পিউটারে সত্যিকারের run করা হয়েছে (CPython 3.14.4):

def price(qty: int, unit: int) -> int:
    p = qty * unit
    if p >= 1000:
        return p - p // 10      # p > 0 here, so // matches Haat's /
    return p

def delivery(total: int) -> int:
    return 0 if total >= 1000 else 60

first = price(2, 520) + delivery(price(2, 520))
print(first)
total, rounds = 0, 0
while total < 5000:
    total += 1250
    rounds += 1
print(total)
print(rounds - 1)

সত্যিকারের run (Python 3.14.4, Windows):

$ python bazar.py
996
5000
3

চার ভাষা, একই ফল। Python-এ block চেনা যায় indentation দিয়ে, আর type লেখা ঐচ্ছিক “hint” — CPython চালানোর সময় এগুলো যাচাই করে না। আরেকটি সূক্ষ্ম কথা: Python-এর // নিচের দিকে (floor) কাটে, Haat আর C-এর / শূন্যের দিকে। ধনাত্মক সংখ্যায় দুটো একই, কিন্তু -7 // 2 Python-এ -4, আর C-তে -7 / 2 হয় -3. এই ধরনের পার্থক্যই পর্ব ০৩-এর বিষয়: একই চেহারার syntax, আলাদা অর্থ।

৮ · কেন কিছু ভাষা টিকে থাকে, কিছু হারিয়ে যায়

ALGOL 60 নকশায় অসাধারণ ছিল, তবু আজ কেউ এতে নতুন সফটওয়্যার লেখেন না। COBOL নিয়ে বহু দশক ধরে সমালোচনা, তবু অনেক ব্যাংক আর সরকারি প্রতিষ্ঠানের পুরোনো system-এ এখনো COBOL কোড চলে বলে ব্যাপকভাবে জানা যায়। কেন? ইতিহাস থেকে কয়েকটি কারণ বারবার ফিরে আসে:

  • একটি বড় platform-এর সঙ্গে জন্ম: C এসেছিল Unix-এর সঙ্গে, JavaScript ছিল browser-এর একমাত্র ভাষা, Objective-C আর পরে Swift Apple-এর যন্ত্রের সঙ্গে, Kotlin-কে ২০১৭ সালে Google Android-এর জন্য আনুষ্ঠানিক সমর্থন দেয়। যে ভাষা একটি জনপ্রিয় platform-এর “দরজা”, সেটি নকশার দুর্বলতা সত্ত্বেও ছড়ায়।
  • Library আর tool-এর ভান্ডার (ecosystem): একটি ভাষা শেখার পরে মানুষ থাকে কারণ তার package, framework, debugger আর উত্তর-খোঁজার জায়গা আছে। নতুন ভাষাকে শুধু ভালো হলেই চলে না, এই ভান্ডারও গড়তে হয় — তাই অনেক নতুন ভাষা পুরোনো ভাষার library সরাসরি ব্যবহারের পথ রাখে (Kotlin থেকে Java, TypeScript থেকে JavaScript, C++ থেকে C).
  • পুরোনো কোড চালানোর নিশ্চয়তা (backward compatibility): C-এর standard কমিটি আর Java বহু দশক ধরে পুরোনো কোড না ভাঙার চেষ্টা করেছে। উল্টো দিকে, Python 3 (২০০৮) ইচ্ছা করে কিছু পুরোনো নিয়ম ভেঙেছিল (যেমন print statement থেকে function); পুরো জগৎকে নতুন সংস্করণে আনতে প্রায় এক যুগ লেগেছে, আর Python 2-এর আনুষ্ঠানিক সমর্থন শেষ হয় ২০২০ সালের ১ জানুয়ারি।
  • মানুষ আর শিক্ষা: যে ভাষা বিশ্ববিদ্যালয়ে পড়ানো হয়, বই আর কোর্স থাকে, সমাজ সাহায্য করে — সেটি নতুন প্রজন্মের হাতে পৌঁছায়। Pascal দীর্ঘদিন শিক্ষার ভাষা ছিল মূলত এ কারণে।
  • বাস্তবায়নের গুণমান: ভালো compiler আর দ্রুত runtime ছাড়া ভালো নকশাও টেকে না। FORTRAN-এর সাফল্যের বড় অংশ ছিল তার optimizing compiler; Java-র গতির অভিযোগ কমে JIT আসার পরে।

আর একটি ভাষা “মরে” গেলেও তার ধারণা প্রায়ই বেঁচে থাকে। ALGOL 60-এর block আর lexical scope আজ প্রায় সব ভাষায়; Simula আজ খুব কম ব্যবহৃত, কিন্তু প্রতিটি class শব্দ তার উত্তরাধিকার। অর্থাৎ ইতিহাসে বিজয় দুই রকম: ভাষা হিসেবে টিকে থাকা, আর ধারণা হিসেবে টিকে থাকা।

Haat-এর বংশলতিকা

এই কোর্সে আপনি যে ভাষা বানাবেন, তার প্রতিটি সিদ্ধান্তের একটি পূর্বপুরুষ আছে। নকশার কারণগুলো পর্ব ০৬-এ বিস্তারিত; এখানে শুধু বংশ:

Haat-এর বৈশিষ্ট্যযে ভাষা বা ধারণা থেকে
{ } block, if/while, / আর %-এর C-নিয়মC (আর তার আগে ALGOL-এর block)
Block নতুন scope বানায়, lexical scopeALGOL 60
let (বদলানো যায় না) আর var (বদলানো যায়) আলাদাML-এর let; Swift আর Kotlin-এর let/var বা val/var ভাগ
fn name(p: T) -> R, নামের পরে typePascal আর ML-এর রীতি, Rust-এর বানান
Function first-class, closure reference-এ ধরেLISP → Scheme → JavaScript
Implicit type conversion নেইML-পরিবারের কঠোর type
&& আর || short-circuitC (ALGOL-পরিবারে আগে থেকে আলোচিত ধারণা)

আরও গভীরে: “প্রথম high-level ভাষা”-র আরেক দাবিদার Konrad Zuse-এর Plankalkül, যার নকশা ১৯৪০-এর দশকে, কিন্তু পূর্ণ প্রকাশ ১৯৭২ সালে আর বাস্তবায়ন আরও পরে — তাই এর প্রভাব সীমিত ছিল বলে ধরা হয়। Rust-এর ownership-এর পেছনে গবেষণার দীর্ঘ ইতিহাস আছে: linear type-এর তত্ত্ব আর Cyclone-এর মতো গবেষণা-ভাষার region-ভিত্তিক memory ব্যবস্থাপনাকে প্রায়ই এর পূর্বসূরি বলা হয়। ভাষার ইতিহাস নিয়ে প্রাথমিক উৎস চাইলে ACM-এর HOPL (History of Programming Languages) সম্মেলনের প্রবন্ধগুলো পড়ার মতো — সেখানে ভাষার স্রষ্টারা নিজেরাই ইতিহাস লিখেছেন।

পরীক্ষা ও ইন্টারভিউতে:

  • প্রথম ব্যাপকভাবে ব্যবহৃত high-level ভাষা কোনটি? — FORTRAN; IBM-এ John Backus-এর দল, প্রথম compiler ১৯৫৭.
  • BNF কী, আর প্রথম কোথায় পুরো ভাষার জন্য ব্যবহৃত? — Context-free grammar লেখার রীতি; ALGOL 60 report (Backus-এর প্রস্তাব, Naur-এর সম্পাদনা)।
  • Object-oriented programming-এর প্রথম ভাষা? — Simula 67 (Dahl ও Nygaard); “সব কিছু object” ধারণা Smalltalk-এ।
  • Garbage collection প্রথম কোন ভাষায়? — LISP (McCarthy, ১৯৬০ সালের প্রবন্ধ)।
  • Type inference-এর ক্লাসিক algorithm আর ভাষা? — Hindley–Milner; ML (১৯৭৩)।

৯ · AI-এর যুগে ভাষার ইতিহাস

AI assistant ইতিহাসের প্রশ্নে খুব আত্মবিশ্বাসী আর সাবলীল উত্তর দেয় — আর ঠিক সে কারণেই ভুল ধরা কঠিন। ভাষার ইতিহাস আর ভাষা-তুলনায় বারবার দেখা ভুলগুলো:

AI-এর ভুলকীভাবে ধরবেন
ভুল সাল বা স্রষ্টা, বা নকশা শুরু, প্রথম রিপোর্ট আর 1.0 গুলিয়ে ফেলাভাষার নিজের ওয়েবসাইট, standard বা স্রষ্টার HOPL প্রবন্ধে মিলিয়ে দেখা; কোন ঘটনার সাল, তা জিজ্ঞেস করা
এক ভাষার নিয়ম সব ভাষার নিয়ম বলে চালানো (যেমন “integer ভাগ সবসময় নিচের দিকে কাটে”)প্রতিটি ভাষার নির্দিষ্ট version-এ আসল compiler বা interpreter-এ চালানো, যেমন উপরের চার ভাষার run
প্রচলিত মিথ সত্য বলে লেখা (“Java interpreted”, “JavaScript Java-র অংশ”)Specification আর বাস্তবায়নের নথি (JVM-এর JIT, ECMAScript standard) পড়া
অন্য ভাষায় অনুবাদ করা কোড, যার অর্থ চুপচাপ বদলে গেছে (ভাগ, overflow, closure-capture)দুই সংস্করণ একই input-এ চালিয়ে ফল মেলানো (differential test), শূন্য আর ঋণাত্মক সংখ্যাসহ
বানানো উদ্ধৃতি বা নিখুঁত-শোনানো পরিসংখ্যানউৎসের link চাওয়া, আর link খুলে উদ্ধৃতিটি নিজে খোঁজা; না পেলে বাদ দেওয়া

AI-কে ইতিহাসের সহকারী হিসেবে ব্যবহার করার ভালো উপায়: উত্তরের সঙ্গে উৎস আর অনিশ্চয়তা চাওয়া, আর কোড-তুলনায় চালিয়ে দেখার মতো পরীক্ষা চাওয়া।

আমি প্রোগ্রামিং ভাষার ইতিহাস পড়ছি। Closure ধারণাটি LISP থেকে JavaScript পর্যন্ত কীভাবে এলো, একটি সময়রেখা দাও। ১. প্রতিটি ঘটনার সাল দাও, আর বলো সালটি কোন ঘটনার (নকশা শুরু, প্রথম প্রবন্ধ, প্রথম প্রকাশ, না 1.0). ২. প্রতিটি দাবির পাশে একটি প্রাথমিক উৎস দাও (প্রবন্ধ, standard বা ভাষার নিজের নথি); নিশ্চিত না হলে স্পষ্ট করে "অনিশ্চিত" লেখো। ৩. Dynamic scope আর lexical scope-এ একই কোডের ফল কীভাবে আলাদা হয়, একটি ছোট উদাহরণ দিয়ে দেখাও। ৪. C++11, Java 8 আর JavaScript-এ closure variable কপি করে ধরে, না reference করে — প্রতিটির জন্য একটি ছোট program দাও, যা চালালেই পার্থক্য বোঝা যাবে, আর প্রত্যাশিত আউটপুট লেখো। ৫. কোনো জনপ্রিয়তার পরিসংখ্যান দিয়ো না।

(নিজে যাচাই করুন: Landin-এর ১৯৬৪ সালের প্রবন্ধের নাম “The Mechanical Evaluation of Expressions”; Scheme-এর প্রথম রিপোর্ট ১৯৭৫ সালের MIT AI Memo; আর AI যে program-গুলো দেয়, সেগুলো অংশ ৭-এর মতো আসল compiler-এ চালিয়ে প্রত্যাশিত আউটপুটের সঙ্গে মেলান।)

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

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১FORTRAN-এর দল ভাষার সৌন্দর্যের চেয়ে compiler-এর গতিতে বেশি মন দিয়েছিল কেন? সিদ্ধান্তটি কি ঠিক ছিল?

১৯৫০-এর দশকের মাঝামাঝি কম্পিউটার ছিল অত্যন্ত দামি আর বিরল যন্ত্র, আর প্রোগ্রামারের সময়ের চেয়ে যন্ত্রের সময়কে বেশি মূল্যবান ভাবা হতো। অভিজ্ঞ প্রোগ্রামাররা হাতে assembly লিখে প্রতিটি নির্দেশ বাঁচাতেন, আর আগের “automatic programming” system-গুলো ধীর কোড দেওয়ার কারণে সুনাম হারিয়েছিল। Backus আর তাঁর দল বুঝেছিলেন, ভাষাটি যত সুন্দরই হোক, যদি তার বানানো কোড হাতে লেখা কোডের চেয়ে অনেক ধীর হয়, কেউ সেটি ব্যবহার করবে না। তাই প্রথম compiler-এর বড় অংশ গেছে loop-এর ভেতরের সূচক-হিসাব সাজানো আর register-এর বুদ্ধিমান ব্যবহারে। Backus পরে লিখেছেন যে ভাষার নকশা তাঁদের কাছে তুলনামূলক সহজ অংশ ছিল; কঠিন অংশ ছিল দক্ষ কোড।

এর ফল দীর্ঘমেয়াদি। এক, FORTRAN সত্যিই বিজ্ঞান আর প্রকৌশলের হিসাবে ছড়িয়ে পড়ে, আর high-level ভাষা যে ব্যবহারিক, তা প্রতিষ্ঠিত হয়। দুই, compiler optimization একটি আলাদা গবেষণা-ক্ষেত্র হয়ে ওঠে — dataflow analysis, register allocation, loop optimization-এর অনেক শিকড় FORTRAN compiler-গুলোর কাজে (মডিউল ১১–১২)। তিন, আজও বৈজ্ঞানিক গণনার কিছু জায়গায় FORTRAN-এর উত্তরসূরি ব্যবহার হয়, কারণ এর array-কেন্দ্রিক নকশা optimizer-এর জন্য সহজ।

দাম কী দিতে হয়েছিল? প্রথম FORTRAN-এ recursion ছিল না, block বা lexical scope ছিল না, আর অনেক নিয়ম যন্ত্রের সুবিধা দেখে বানানো (যেমন নামের প্রথম অক্ষরে type). ALGOL 60 এই দিকগুলো অনেক পরিষ্কারভাবে ভেবেছিল। তাই “ঠিক ছিল কি না” প্রশ্নের উত্তর সময়ের প্রেক্ষিতে: সেই যুগে গতি না দেখালে high-level ভাষার ধারণাই হয়তো পিছিয়ে যেত।

মূল উপলব্ধি: একটি ভাষার সাফল্য শুধু তার নকশায় নয়, তার বাস্তবায়নের মানে। ভালো compiler ছাড়া ভালো ভাষাও টেকে না — এই কোর্সের অর্ধেক অংশ ঠিক এ কারণেই compiler বানানো নিয়ে।

প্র ০২ALGOL 60 খুব কম ব্যবহৃত হয়েও কেন প্রোগ্রামিং ভাষার ইতিহাসের সবচেয়ে প্রভাবশালী ভাষাগুলোর একটি?

ALGOL 60-এর প্রভাব এসেছে তিনটি পথে। প্রথমত, এটি প্রথম বড় ভাষা যার syntax পুরোপুরি একটি formal grammar (BNF) দিয়ে লেখা। এর ফলে “ভাষার সংজ্ঞা” মানে একটি নিখুঁত দলিল, কোনো একটি compiler-এর আচরণ নয় — এই ধারণা পরে প্রতিটি ভাষা-standard মেনেছে। আর grammar থেকে parser বানানোর গবেষণা (LL, LR parsing) এখান থেকে গতি পায়, যার তত্ত্ব গণনার তত্ত্ব কোর্সে আর প্রয়োগ এই কোর্সের মডিউল ৮-এ।

দ্বিতীয়ত, ALGOL 60 কয়েকটি ধারণাকে একসঙ্গে পরিষ্কারভাবে দাঁড় করায়: nested block, block-এর ভেতরে নতুন নাম, lexical scope, recursive procedure আর stack-ভিত্তিক activation record দিয়ে এগুলোর বাস্তবায়ন। আজ যে “call stack”-কে আমরা স্বাভাবিক ধরি, তার বাস্তবায়নের কৌশল ALGOL compiler-গুলোর প্রয়োজনে বিকশিত হয় (পর্ব ৩০)। Call-by-name-এর মতো পরে-বাদ-পড়া ধারণাও কাজে লেগেছে: এটি thunk আর lazy evaluation-এর চিন্তায় পথ দেখায় (পর্ব ১৯, ২৯)।

তৃতীয়ত, প্রায় সব পরের ভাষার ওপর এর প্রত্যক্ষ প্রভাব: Pascal (Niklaus Wirth, যিনি ALGOL কমিটির কাজে যুক্ত ছিলেন), Simula (ALGOL 60-এর সম্প্রসারণ), BCPL হয়ে C, আর Scheme-এর lexical scope. Tony Hoare-এর একটি বহুল উদ্ধৃত মন্তব্য আছে যে ALGOL 60 “তার পূর্বসূরিদের তো বটেই, প্রায় সব উত্তরসূরির চেয়েও উন্নত” — মন্তব্যটি সাধারণত তাঁর ১৯৭৩ সালের “Hints on Programming Language Design” প্রবন্ধের বলে উল্লেখ করা হয়।

তাহলে কম ব্যবহৃত কেন? এর standard input/output নির্দিষ্ট করেনি, ফলে প্রতিটি বাস্তবায়ন আলাদা; বাণিজ্যিক সমর্থন, বিশেষ করে বড় যন্ত্র-নির্মাতাদের, FORTRAN আর COBOL-এর দিকে ছিল।

মূল উপলব্ধি: প্রভাব আর ব্যবহার এক জিনিস নয়। কিছু ভাষা বেঁচে থাকে নিজের নামে, কিছু বেঁচে থাকে অন্যদের ভেতরে ধারণা হিসেবে — ALGOL 60 দ্বিতীয় ধরনের সবচেয়ে বড় উদাহরণ।

প্র ০৩Garbage collection ১৯৬০ সালে এলেও জনপ্রিয় শিল্প-ভাষায় মূলধারায় আসতে প্রায় তিন দশক লাগল কেন?

McCarthy-র ১৯৬০ সালের প্রবন্ধে LISP-এর জন্য স্বয়ংক্রিয় memory ফেরতের ব্যবস্থা ছিল, আর একই বছর Collins reference counting-এর ধারণা দেন। কিন্তু সেই সময়ের GC সহজ ছিল: memory ফুরোলে পুরো প্রোগ্রাম থামিয়ে সব পৌঁছানো যায় এমন ঘর চিহ্নিত করা, তারপর বাকিগুলো ফেরত নেওয়া। ছোট memory আর ধীর যন্ত্রে এই থামা লক্ষণীয় হতো, আর মোট খরচও বড়। Systems programming-এর ভাষাগুলো (C, পরে C++) তাই ইচ্ছা করে GC রাখেনি — প্রোগ্রামার নিজে malloc/free করবেন, বিনিময়ে পূর্ণ নিয়ন্ত্রণ আর পূর্বানুমেয় গতি।

পরের দশকগুলোতে গবেষণা এই খরচ কমিয়েছে: copying collector (অর্ধেক memory-তে বেঁচে থাকা object কপি করা), generational collection (বেশির ভাগ object অল্প বয়সে মারা যায়, এই পর্যবেক্ষণ কাজে লাগানো), আর incremental ও concurrent collector, যা প্রোগ্রাম পুরো না থামিয়ে কাজ করে। Smalltalk আর ML-এর মতো ভাষা এগুলোর পরীক্ষাগার ছিল। একই সময়ে যন্ত্রের memory আর গতি বহু গুণ বেড়েছে।

১৯৯৫ সালে Java যখন C++-ধাঁচের syntax-সহ কিন্তু GC-সহ আসে, তখন সময় প্রস্তুত ছিল: ইন্টারনেট-যুগের সার্ভার-সফটওয়্যারে memory-ভুল (dangling pointer, double free) থেকে নিরাপত্তা-ঝুঁকি আর বাগ বড় সমস্যা, আর GC-র খরচ সহনীয়। এরপর C#, Python, JavaScript, Go — মূলধারার বেশির ভাগ নতুন ভাষা GC নিয়েছে। ব্যতিক্রম হিসেবে Rust (২০১৫) দেখায় যে compile-time-এর ownership নিয়ম দিয়ে GC ছাড়াও memory safety পাওয়া যায়।

মূল উপলব্ধি: একটি ধারণা মূলধারায় আসে যখন তিনটি জিনিস মেলে: বাস্তবায়নের ভালো কৌশল, যথেষ্ট শক্তিশালী hardware, আর এমন সমস্যা যা ধারণাটিকে জরুরি করে তোলে। পর্ব ৭৫-এ এই collector-গুলো নিজে বানাবেন।

প্র ০৪Python 3 ইচ্ছা করে পুরোনো কোড ভেঙেছিল। Backward compatibility ভাঙা কখন যুক্তিসঙ্গত, আর তার দাম কী?

Python 3.0 প্রকাশিত হয় ২০০৮ সালের ডিসেম্বরে। এর লক্ষ্য ছিল কিছু মৌলিক ভুল ঠিক করা, যা পুরোনো কোড না ভেঙে ঠিক করা সম্ভব ছিল না: লেখা (Unicode text) আর byte-কে পরিষ্কারভাবে আলাদা করা, print-কে statement থেকে সাধারণ function বানানো, আর পূর্ণসংখ্যার ভাগ /-কে সত্যিকারের ভাগ বানানো (7 / 2 হলো 3.5, পূর্ণসংখ্যা-ভাগের জন্য //)। প্রতিটি পরিবর্তন নিজে যুক্তিসঙ্গত, বিশেষ করে বাংলাসহ অ-ইংরেজি লেখার জন্য Unicode পরিবর্তন।

কিন্তু দাম ছিল বড়। লক্ষ লক্ষ লাইনের পুরোনো কোড আর অসংখ্য library-কে নতুন করে লিখতে বা মানিয়ে নিতে হয়েছে। একটি library Python 3-এ না এলে তার ওপর নির্ভর করা প্রকল্পও আসতে পারত না — ecosystem-এর এই জট খুলতে বহু বছর লেগেছে। দুই সংস্করণ একসঙ্গে চালানোর জন্য বিশেষ tool আর কৌশল তৈরি হয়। শেষ পর্যন্ত Python 2-এর আনুষ্ঠানিক সমর্থন শেষ হয় ২০২০ সালের ১ জানুয়ারি — Python 3 আসার এক যুগেরও বেশি পরে।

উল্টো দর্শনের উদাহরণ C আর Java: পুরোনো বৈধ কোড নতুন standard-এও চলবে, এটি প্রায় প্রতিজ্ঞার মতো রক্ষা করা হয়েছে। এর দামও আছে: পুরোনো ভুল নকশা (C-এর অনেক undefined behavior, Java-র generics-এ erasure) চিরকাল বয়ে বেড়াতে হয়। Java 5-এর generics erasure দিয়ে বাস্তবায়িত হয়েছিল মূলত পুরোনো JVM আর পুরোনো library-র সঙ্গে মিল রাখার জন্য (পর্ব ৩৭)। Rust একটি মাঝামাঝি পথ নিয়েছে: “edition” ব্যবস্থা, যেখানে আলাদা edition-এর crate একসঙ্গে link হতে পারে।

কখন ভাঙা যুক্তিসঙ্গত? যখন ভুলটি ভাষার মূলে (যেমন text-এর ধারণা) আর ভবিষ্যতের প্রতিটি ব্যবহারকারীকে ভোগাবে; যখন পরিবর্তনের পথ স্বয়ংক্রিয় tool দিয়ে সহজ করা যায়; আর যখন সমাজ লম্বা অন্তর্বর্তী সময় সহ্য করতে প্রস্তুত।

মূল উপলব্ধি: একটি জনপ্রিয় ভাষার আসল মালিক তার পুরোনো কোড। ভাষা নকশায় প্রতিটি সিদ্ধান্ত তাই প্রায় স্থায়ী — Haat-এর spec-কে এই কোর্সে “স্থির” রাখার কারণও এটাই।

প্র ০৫নতুন ভাষাগুলো কি সত্যিই নতুন ধারণা আনে, না পুরোনো ধারণা নতুন মোড়কে দেয়? Generics-এর ইতিহাস দিয়ে বিচার করুন।

Generics, অর্থাৎ type-কে parameter বানিয়ে একই কোড বহু type-এ ব্যবহার, তার ইতিহাস এই প্রশ্নের চমৎকার উদাহরণ। ML (১৯৭৩) parametric polymorphism আনে: length function যেকোনো type-এর list-এ কাজ করে, আর type inference নিজেই সাধারণ type বের করে। প্রায় একই সময়ে MIT-তে Barbara Liskov-এর CLU ভাষা (১৯৭০-এর দশকের মাঝামাঝি) parameterized type নিয়ে আসে, আর Ada (১৯৮০-এর দশক) “generic” package. C++ template আসে ১৯৮০-এর দশকের শেষে, আর আরও শক্তিশালী হয়ে compile-time-এ গণনার যন্ত্রে পরিণত হয়।

মূলধারার শিল্প-ভাষায় এসেছে অনেক দেরিতে: Java 5 (২০০৪), C# 2.0 (২০০৫), আর Go-তে মাত্র 1.18 (২০২২)। প্রতিটি ভাষা আলাদা বাস্তবায়ন বেছেছে: Java erasure (চলার সময় type-তথ্য মুছে ফেলা), C# runtime-এ আসল type রাখা, C++ আর Rust monomorphization (প্রতিটি type-এর জন্য আলাদা কপি), আর কিছু functional ভাষায় dictionary passing (পর্ব ৩৭)।

তাহলে নতুন কিছু কি নেই? আছে, তবে প্রায়ই ধারণার মূলে নয়, তিনটি জায়গায়: (১) প্রকৌশল — পুরোনো ধারণাকে বড় ecosystem-এ, পুরোনো কোড না ভেঙে আনা (Java-র erasure ঠিক এই সমস্যার সমাধান); (২) সমন্বয় — কয়েকটি পুরোনো ধারণার এমন মিশ্রণ, যা আগে কেউ একসঙ্গে ব্যবহারযোগ্য করেনি (Rust-এ ML-এর type system, C++-এর zero-cost abstraction আর গবেষণা-ভাষার ownership); (৩) মানুষ-কেন্দ্রিক উন্নতি — ভালো error message, package manager, formatter, যা দৈনন্দিন অভিজ্ঞতা বদলে দেয়।

এর একটি ব্যবহারিক শিক্ষা আছে: কোনো “নতুন” বৈশিষ্ট্য দেখলে তার পুরোনো রূপ খুঁজুন। প্রায়ই দেখবেন কোনো গবেষণা-ভাষায় এটি বহু বছর আগে ছিল, আর সেখানকার প্রবন্ধে তার সীমা আর ফাঁদ বিস্তারিত লেখা আছে।

মূল উপলব্ধি: ভাষার উদ্ভাবন মূলত তিন স্তরে — তত্ত্ব, প্রকৌশল আর অভিজ্ঞতা। তত্ত্বের স্তরে নতুনত্ব বিরল; প্রকৌশল আর অভিজ্ঞতার স্তরেই বেশির ভাগ ভাষার আসল অবদান।

অনুশীলন

একটি নকশার কাজ, একটি ভুল খোঁজা, একটি derivation আর একটি আউটপুট অনুমান।

  1. নকশা — Haat-এ FORTRAN-ধাঁচের গোনা loop: Haat v1-এ শুধু while আছে। একটি বর্ধিত রূপ (Haat-এর বর্ধিত রূপ) প্রস্তাব করুন: for i in 1..3 { … }. লিখুন (ক) এর syntax-এর একটি BNF নিয়ম, (খ) এটি কোন while কোডে বদলে দেওয়া যায় (desugaring), আর (গ) i-এর scope আর mutability নিয়ে আপনার সিদ্ধান্ত ও কারণ।

    (ক) <for-stmt> ::= for <ident> in <expr> .. <expr> <block>. এর জন্য lexer-এ নতুন keyword for, in আর নতুন token .. লাগবে — সাবধান: .. এখন একটি token, তাই lexer-এ এটি একটি একক চিহ্ন হিসেবে চিনতে হবে।

    (খ) একটি সম্ভাব্য desugaring (নতুন নাম $i আর $end কল্পিত, ব্যবহারকারী লিখতে পারবেন না):

    {
        var $i = 1;
        let $end = 3;          // সীমা একবারই হিসাব
        while $i <= $end {
            let i = $i;        // দেহের ভেতরে i বদলানো যায় না
            { … দেহ … }
            $i = $i + 1;
        }
    }

    (গ) i শুধু loop-এর দেহে দেখা যাবে (ALGOL-ধাঁচের block scope; FORTRAN-এর মতো loop শেষে মান নিয়ে প্রশ্ন ওঠে না) আর let, যাতে দেহের ভেতরে i = 10; লিখলে type checker error দেয় — এতে loop-গোনা নিয়ে বিভ্রান্তি বন্ধ হয়। প্রতি ঘুরে নতুন let i থাকায় দেহে তৈরি closure প্রতিবার আলাদা i দেখবে — JavaScript-এর for (let …)-এর মতো সিদ্ধান্ত। সীমা একবার হিসাব হয়, তাই দেহে অন্য variable বদলালেও ঘোরার সংখ্যা বদলাবে না। Desugaring নিয়ে পুরো আলোচনা পর্ব ৫৫-এ।

  2. ভুল খুঁজুন: একটি নোটে লেখা আছে — “(১) Java ১৯৯১ সালে Sun প্রকাশ করে আর এটি সম্পূর্ণ interpreted ভাষা। (২) Object-oriented programming-এর প্রথম ভাষা Smalltalk. (৩) BNF প্রথম ব্যবহৃত হয় C ভাষার standard-এ। (৪) LISP-এ garbage collection প্রথম এসেছিল।” কোনগুলো ভুল, আর ঠিক তথ্য কী?

    (১) ভুল, দুই জায়গায়। Java-র কাজ Sun-এ ১৯৯১ সালের দিকে শুরু হয়েছিল (প্রথম নাম Oak), কিন্তু প্রকাশ্যে আসে ১৯৯৫ সালে। আর Java “সম্পূর্ণ interpreted” নয়: javac bytecode-এ compile করে, JVM interpret করে আর গরম অংশ JIT দিয়ে machine code-এ compile করে।

    (২) ভুল। Class, object, inheritance আর virtual procedure প্রথম আসে Simula 67-এ (Dahl ও Nygaard). Smalltalk “সব কিছুই object” আর message passing-এর ধারণাকে পূর্ণ রূপ দেয়।

    (৩) ভুল। BNF প্রথম পুরো একটি ভাষার জন্য ব্যবহৃত হয় ALGOL 60 report-এ (১৯৬০); Backus রীতিটি প্রস্তাব করেন ALGOL 58-এর প্রসঙ্গে। C আসে এক দশকেরও বেশি পরে।

    (৪) ঠিক। McCarthy-র ১৯৬০ সালের LISP প্রবন্ধকে GC-র প্রথম প্রকাশিত বর্ণনা ধরা হয়।

  3. Derivation: অংশ ৩-এর grammar (<expr>, <term>, <factor>, <digit>) দিয়ে (2 + 3) * 4-এর leftmost derivation লিখুন। কয়টি প্রতিস্থাপন লাগে? এই derivation-এ গুণ আর যোগের মধ্যে কোনটি গাছের মূলে?

    Python-এ একটি ছোট parser দিয়ে যাচাই করা ধাপগুলো (E = expr, T = term, F = factor, D = digit):

    <E>
    <T>
    <T> * <F>
    <F> * <F>
    ( <E> ) * <F>
    ( <E> + <T> ) * <F>
    ( <T> + <T> ) * <F>
    ( <F> + <T> ) * <F>
    ( <D> + <T> ) * <F>
    ( 2 + <T> ) * <F>
    ( 2 + <F> ) * <F>
    ( 2 + <D> ) * <F>
    ( 2 + 3 ) * <F>
    ( 2 + 3 ) * <D>
    ( 2 + 3 ) * 4

    মোট ১৪টি প্রতিস্থাপন (১৫টি রূপ)। এবার প্রথম ধাপেই <E> সরাসরি <T> হয়েছে, আর <T> * <F> গাছের মূলের কাছে — অর্থাৎ গুণ শেষে হিসাব হয়। যোগটি বন্ধনীর ভেতর দিয়ে <factor> ::= ( <expr> ) নিয়মে আবার শুরু থেকে এসেছে। এজন্যই বন্ধনী precedence বদলাতে পারে: বন্ধনী একটি পুরো expression-কে সর্বোচ্চ precedence-এর স্তরে (factor) তুলে আনে।

  4. আউটপুট অনুমান করুন (JavaScript, Node 24-এ চালানো):
    function makeCounter() {
      let n = 0;
      return { inc: () => ++n, get: () => n };
    }
    const c = makeCounter();
    c.inc(); c.inc();
    const d = makeCounter();
    d.inc();
    console.log(c.get(), d.get());
    কী ছাপা হবে, আর কেন? Haat-এর closure-নিয়মে একই ধরনের প্রোগ্রাম কি একই আচরণ করবে?

    সত্যিকারের run (Node v24.15.0) ছাপে: 2 1.

    প্রতিবার makeCounter() ডাকলে একটি নতুন পরিবেশ তৈরি হয়, যেখানে আলাদা একটি n. inc আর get দুটি closure একই পরিবেশ ভাগ করে, তাই c.inc() দুবার করলে c.get() দেখে 2. d-এর পরিবেশ আলাদা, তাই 1. এটি Landin-এর সংজ্ঞার সরাসরি প্রয়োগ: closure = কোড + তৈরির সময়ের পরিবেশ, আর সেই পরিবেশ reference হিসেবে ধরা থাকে, কপি হিসেবে নয়। Haat-এর spec বলে closure variable reference দিয়ে ধরে (shared environment), তাই var n রেখে Haat-এ লেখা একই প্রোগ্রামও একই আচরণ করবে। পরিবেশটি heap-এ রাখতে হয়, কারণ makeCounter ফেরার পরেও এটি বেঁচে থাকে — পর্ব ৫৭-এ এর বাস্তবায়ন।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএই ভাষাগুলোকে সাধারণত উল্লেখিত প্রথম প্রকাশের সাল অনুযায়ী পুরোনো থেকে নতুন ক্রমে সাজান (▲▼ চেপে সরান)

  1. FORTRAN — প্রথম compiler
  2. Simula 67 — class আর object
  3. ML — type inference
  4. Java — JVM আর bytecode
  5. Rust 1.0 — ownership

BNF (Backus–Naur Form) প্রথম কোন ভাষার পুরো syntax বর্ণনায় ব্যবহৃত হয়?

  • FORTRAN
  • ALGOL 60
  • C
  • COBOL

Class, object, inheritance আর virtual procedure প্রথম একসঙ্গে কোন ভাষায় আসে?

  • Smalltalk
  • C++
  • Simula 67
  • Java

Garbage collection-এর প্রথম প্রকাশিত বর্ণনা সাধারণত কোন ভাষার কাজের সঙ্গে যুক্ত?

  • LISP
  • Java
  • Smalltalk
  • C

নিচের কোন দাবিটি ঠিক?

  • Java একটি সম্পূর্ণ interpreted ভাষা
  • JavaScript হলো Java-র একটি সরল সংস্করণ
  • Hindley–Milner type inference প্রথম Prolog-এ আসে
  • Block আর lexical scope-এর ধারণা ALGOL 60 থেকে মূলধারায় আসে

এই JavaScript কোড কী ছাপে? function makeAdder(n) { return x => x + n; } const add10 = makeAdder(10); console.log(add10(5));

  • NaN, কারণ makeAdder শেষ হলে n হারিয়ে যায়
  • 15
  • 10
  • Error, কারণ function থেকে function ফেরত দেওয়া যায় না

একটি জনপ্রিয় ভাষা নতুন version-এ পুরোনো কোড ভাঙলে সবচেয়ে বড় বাস্তব সমস্যা কোনটি হয়?

  • নতুন compiler বানানো অসম্ভব হয়ে পড়ে
  • সব প্রোগ্রাম নিজে থেকেই ধীর হয়ে যায়
  • বিদ্যমান কোড আর library-র পুরো ecosystem-কে মানিয়ে নিতে হয়, যাতে বহু বছর লাগতে পারে
  • ভাষাটির grammar আর BNF-এ লেখা যায় না

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Machine code → assembly → high-level: প্রতিটি ধাপে লেখা মানুষের কাছাকাছি আর যন্ত্র থেকে দূরে; মাঝের ফাঁক পূরণ করে assembler আর compiler.
  2. FORTRAN (১৯৫৭) প্রমাণ করে compiler দক্ষ কোড দিতে পারে; LISP আনে recursion, GC আর eval; ALGOL 60 আনে BNF, block আর lexical scope.
  3. ১৯৬৭–১৯৭৫: Simula 67 (OOP), Smalltalk, C, Prolog, ML (type inference), Scheme (lexical closure) — আজকের paradigm-গুলোর শিকড়।
  4. ধারণা ভ্রমণ করে, প্রায়ই কয়েক দশক দেরিতে: GC, closure, type inference আর generics গবেষণা থেকে Java, JavaScript, C#, Go, Rust-এ।
  5. টিকে থাকা নির্ভর করে platform, ecosystem, backward compatibility, শিক্ষা আর বাস্তবায়নের ওপর; আর সাল লেখার সময় বলুন সেটি কোন ঘটনার সাল।

পরের পর্বে: একই -7 / 2 C-তে -3 আর Python-এ -4 — কেন? একটি ভাষার তিন স্তর: syntax (রূপ), semantics (অর্থ) আর pragmatics (ব্যবহারের রীতি), সত্যিকারের run দিয়ে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান