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

ভাষা নকশার লক্ষ্য আর আপস — readability, safety, performance

Language Design Goals and Trade-offs — Readability, Writability, Reliability, Safety versus Performance

Taught in Bangla, this lesson judges languages by readability, writability, reliability and cost, with simplicity and orthogonality behind them. It asks what INT_MAX + 1 does in C, Java, Python, Rust and Haat; real runs include one C file built three ways with Clang 22.1.8, where -O0 and -O2 differ, plus Java and Python runs. It weighs bounds checks, null, exceptions versus error values, GC, typing and syntax choices, scores a proposed feature in Python, and explains each of Haat's design decisions.

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

  • ভাষা বিচারের মাপকাঠি (readability, writability, reliability, খরচ) আর তাদের পেছনের বৈশিষ্ট্য, যেমন সরলতা আর orthogonality, সংজ্ঞাসহ বলা
  • Integer overflow-এর একই প্রশ্নে C, Java, Python, Rust আর Haat-এর উত্তর আর তার কারণ, সত্যিকারের compiler-এর ফল দিয়ে
  • Bounds check, null, exception, GC, static বনাম dynamic typing আর syntax-এর বাছাইকে আপস হিসেবে বিচার করা
  • একটি নতুন feature প্রস্তাব করলে lexer থেকে VM পর্যন্ত কোথায় কোথায় প্রভাব পড়ে, তা হিসাব করা
  • Haat-এর প্রতিটি নকশা-সিদ্ধান্তের কারণ ব্যাখ্যা করা, আর AI-এর “সব ভাষায় একই নিয়ম” ধরনের দাবি যাচাই করা

১ · ভাষা নকশা মানে আপস — চারটি মাপকাঠি

বাজারঘরের গুদামে দুজন কর্মী ফর্দ লেখেন। রহিম লেখেন “চা৫ চি২ ডা১০”: খুব দ্রুত লেখা যায়, কিন্তু তিনি ছুটিতে গেলে কেউ বুঝতে পারেন না “ডা” ডাল না ডাবের পানি। করিম লেখেন “চা-পাতা: ৫ কেজি; চিনি: ২ কেজি; ডাল (মসুর): ১০ কেজি”। লিখতে সময় বেশি লাগে, কিন্তু যে কেউ পড়ে ভুল ছাড়া মাল আনতে পারেন। কোনটি “ভালো” ফর্দ? উত্তর নির্ভর করে লক্ষ্যের ওপর: একা নিজের জন্য লিখলে রহিমের পদ্ধতি চলে, দশজনের দলে করিমেরটি।

প্রোগ্রামিং ভাষার নকশাকারী ঠিক এই প্রশ্নের মুখোমুখি, শুধু তাঁর “ফর্দ” লাখো মানুষ বছরের পর বছর লিখবেন আর পড়বেন। একটি সিদ্ধান্ত একবার ভাষায় ঢুকলে তা ফেরানো খুব কঠিন, কারণ পুরোনো কোড ভাঙে। তাই নকশা মানে কোনো একটি গুণকে সর্বোচ্চ করা নয়; কয়েকটি গুণের মধ্যে সচেতনভাবে আপস (trade-off) বেছে নেওয়া।

এই আপস নিয়ে কথা বলার জন্য পাঠ্যবইয়ে একটি প্রচলিত কাঠামো আছে; Robert W. Sebesta-র Concepts of Programming Languages বইয়ের তালিকাটি সবচেয়ে বেশি ব্যবহৃত। মাপকাঠি চারটি:

সংজ্ঞা ৬.১ — ভাষা বিচারের চার মাপকাঠি

Readability: লেখা program পড়ে কত সহজে আর নির্ভুলভাবে বোঝা যায়। Writability: একটি নির্দিষ্ট কাজের program কত সহজে লেখা যায়। Reliability: program সব অবস্থায় তার specification মেনে চলে কি না, আর ভুল হলে ভাষা তা কত তাড়াতাড়ি ধরিয়ে দেয়। খরচ (cost): শেখা, লেখা, compile করা, চালানো, রক্ষণাবেক্ষণ আর ভুলের ফলে ক্ষতির মোট দাম।

মাপকাঠিগুলো সরাসরি মাপা যায় না; তারা নির্ভর করে ভাষার কয়েকটি বৈশিষ্ট্যের ওপর। নিচের টেবিলটি সেই প্রচলিত কাঠামো: কোন বৈশিষ্ট্য কোন মাপকাঠিকে প্রভাবিত করে।

বৈশিষ্ট্যReadabilityWritabilityReliability
সরলতা (simplicity)●●●
Orthogonality●●●
Data type (যেমন আলাদা Bool)●●●
Syntax-এর নকশা●●●
Abstraction-এর সুযোগ●●
Expressiveness●●
Type checking●
Exception handling●
Aliasing সীমিত রাখা●

এই চারটির বাইরেও নকশাকারীর হাতে আরও কয়েকটি লক্ষ্য থাকে: গতি (performance), portability (এক যন্ত্রের কোড আরেক যন্ত্রে চলা), backward compatibility (পুরোনো কোড নতুন version-এ চলা), আর বাস্তবায়নের সরলতা (compiler বানানো কত কঠিন)। এসব লক্ষ্য প্রায়ই একে অপরকে টানে। C-র মান নির্ধারণ কমিটির লেখা Rationale দলিলে “C-র আত্মা”র তালিকায় আছে “Trust the programmer” আর “Make it fast, even if it is not guaranteed to be portable”; অর্থাৎ C সচেতনভাবে গতি আর programmer-এর স্বাধীনতাকে নিরাপত্তার ওপরে রেখেছে। Ada (১৯৮০-এর দশক, যুক্তরাষ্ট্রের প্রতিরক্ষা বিভাগের উদ্যোগে) রেখেছে উল্টো দিকে: reliability আগে। দুটোই সচেতন নকশা, কোনোটিই “ভুল” নয়।

২ · সরলতা, orthogonality আর লেখার সুবিধার দাম

সরলতা মানে ভাষায় মৌলিক ধারণা কম, আর একটি কাজ করার পথ কম। C-তে একটি variable-এ ১ যোগ করার চারটি পথ আছে: count = count + 1;, count += 1;, count++; আর ++count;. লেখকের জন্য সুবিধা, কিন্তু পাঠককে চারটিই চিনতে হয়, আর expression-এর ভেতরে count++ আর ++count-এর ফল আলাদা। একে বলে feature multiplicity. Python-এর “Zen” (PEP 20, Tim Peters) বলে, “একটি কাজের একটি, আর পারলে মাত্র একটি, স্পষ্ট পথ থাকা উচিত”; Perl-এর বিখ্যাত মন্ত্র উল্টো, “একাধিক পথ আছে” (TIMTOWTDI). প্রথমটি readability-র দিকে ঝোঁকে, দ্বিতীয়টি writability-র দিকে।

Orthogonality মানে অল্প কয়েকটি মৌলিক ধারণাকে প্রায় যেকোনোভাবে জোড়া লাগানো যায়, আর প্রতিটি জোড়ার অর্থ নিয়ম থেকেই বোঝা যায়, ব্যতিক্রম মুখস্থ করতে হয় না। C-তে একটি function একটি struct ফেরত দিতে পারে, কিন্তু একটি array পারে না; array argument হিসেবে পাঠালে আসলে যায় একটি pointer. এগুলো orthogonality-র ফাঁক: নিয়মের সঙ্গে ব্যতিক্রমও শিখতে হয়। উল্টো দিকে, খুব বেশি orthogonal ভাষাও জটিল হতে পারে, কারণ সব জোড়া বৈধ হলে অদ্ভুত জোড়াও বৈধ; ALGOL 68-কে প্রায়ই এর উদাহরণ হিসেবে ধরা হয়।

লেখার সুবিধা বনাম নিরাপত্তা — assignment কি expression?

C-তে = একটি expression: এর একটি মান আছে (যা বসানো হলো)। এতে খুব সংক্ষেপে লেখা যায়, কিন্তু ==-এর জায়গায় ভুল করে = লিখলেও program compile হয়। নিচের stepper-এ একই প্রশ্নে চারটি ভাষার সিদ্ধান্ত দেখুন; প্রতিটি বার্তা সত্যিকারের run থেকে নেওয়া (Clang 22.1.8, CPython 3.14.4 আর Haat reference বাস্তবায়ন)।

1C:  while ((n = next()) > 0) { … }2C:  if (stock = 0) printf(…);3Py: if x = 0:4Py: if (x := 0):5Haat: if x = 0 { print(x); }
এই ধাপে
সিদ্ধান্ত
মাপকাঠি
  1. লেখার সুবিধা। C-তে assignment-এর একটি মান আছে, তাই একই লাইনে পরের মান নেওয়া আর সেটি পরীক্ষা করা যায়। এই ধাঁচের লুপ C-র প্রোগ্রামারদের খুব প্রিয়; writability বাড়ে।
  2. একই নিয়মের উল্টো পিঠ। if (stock == 0) লিখতে গিয়ে if (stock = 0) লিখলে C এটিকে বৈধ ধরে: stock-এ 0 বসায়, মান 0 মানে মিথ্যা, তাই শাখা চলে না। সত্যিকারের run-এ ছাপা হয়েছে stock = 0: মজুত হিসাবটিই মুছে গেল, কোনো error ছাড়া।
  3. Tool দিয়ে মেরামত। Clang 22.1.8 কোনো flag ছাড়াই warning দিয়েছে আর দুটি সমাধান বলেছে: বন্ধনী দিলে চুপ করবে, অথবা == লিখুন। কিন্তু warning শুধু পরামর্শ; program তবুও তৈরি হয়েছে। ভাষার নিয়ম বদলায়নি, শুধু tool পাহারা দিচ্ছে।
  4. Python-এর সিদ্ধান্ত। Python-এ = একটি statement, expression নয়। তাই শর্তের ভেতরে = লিখলে program চলেই না; CPython 3.14 এমনকি সম্ভাব্য সমাধানও বলে দেয়। Reliability বাড়ল, ভুলটি চালানোর আগেই ধরা পড়ল।
  5. আপসের মাঝামাঝি। Python 3.8 (PEP 572) শর্তের ভেতরে বসানোর সুবিধা ফিরিয়ে আনল, কিন্তু আলাদা চিহ্নে: := (“walrus” operator). লেখার সুবিধা ফিরল, অথচ = আর ==-এর গোলমাল আর ঘটে না, কারণ ইচ্ছা করে আলাদা কিছু লিখতে হয়।
  6. Haat-এর সিদ্ধান্ত। Haat-এ assignment একটি statement (reference-এর README-র সিদ্ধান্ত ৯)। তাই if x = 0 { পড়ে parser শর্ত হিসেবে x পায়, তারপর {-এর জায়গায় = দেখে syntax error দেয়। তার ওপর Haat-এর শর্তকে Bool হতেই হবে, তাই if x { লিখলেও type error. দুই স্তরের পাহারা।

শিক্ষাটি সাধারণ: একটি feature যত বেশি জায়গায় বৈধ, লেখার সুবিধা তত বেশি, কিন্তু ভুলও তত বেশি জায়গায় “বৈধ” হয়ে লুকাতে পারে। নকশাকারী কখনো ভাষার নিয়মেই ভুলটি অসম্ভব করেন (Python, Haat), কখনো সিদ্ধান্তটি tool-এর ওপর ছেড়ে দেন (C-র warning). Syntax আর semantics-এর এই সীমারেখা নিয়ে বিস্তারে আছে পর্ব ০৩-এ (Syntax, semantics আর pragmatics).

৩ · Safety বনাম performance — একটি পূর্ণসংখ্যা সীমা পেরোলে

কম্পিউটারের পূর্ণসংখ্যা সাধারণত নির্দিষ্ট সংখ্যক বিটে রাখা হয়, যেমন ৩২ বা ৬৪ বিট। ঋণাত্মক সংখ্যা রাখার প্রচলিত পদ্ধতি two's complement. ৩২-বিট signed পূর্ণসংখ্যার সবচেয়ে বড় মান 2147483647 (231 − 1). এর সঙ্গে ১ যোগ করলে গাণিতিক উত্তর 2147483648, কিন্তু সেটি ৩২ বিটে ধরে না। একে বলে integer overflow. এখন ভাষাকে একটি সিদ্ধান্ত নিতে হবে: কী হবে? নিচের ছবিতে ছোট করে ৮-বিটে দেখানো হলো; ৩২ বা ৬৪ বিটে আকৃতি একই, শুধু চক্রে বিন্দু বেশি।

ছবি ৬.১ — ৮-বিট signed পূর্ণসংখ্যার চক্র, আর 127 + 1-এ তিন রকম উত্তর

২৫৬টি মান একটি চক্রে বসানো; ১ যোগ মানে ঘড়ির কাঁটার দিকে এক ঘর।

8-bit two's complement wheel: 127 + 1 wraps to -128 in Java and Haat, grows in Python, and is undefined in C 0 64 −64 127 −128 +1 +1 দিক 127 + 1 = কী? wrap, −128: Java, Haat, Rust বড় হয়, 128: Python নিয়ম নেই (UB): C-র signed int
ছবি ৬.১ — two's complement-এ 127-এর বিট 01111111; ১ যোগে বিট হয় 10000000, যা signed হিসেবে পড়লে −128. “Wrap” মানে এই চক্রের নিয়ম মানা। Python চক্রই ব্যবহার করে না, দরকারমতো বিট বাড়ায়। C-র signed int-এ ভাষা কোনো নিয়মই দেয় না। Rust-এর wrap শুধু release build-এ। (Java-র ৮-বিট byte হিসাবের সময় int-এ উঠে যায়; এখানে ৮ বিট শুধু ছবির সুবিধার জন্য।)

চারটি সম্ভাব্য উত্তর আছে, আর বাস্তবের ভাষাগুলো চারটিই বেছে নিয়েছে: (১) wrap করা, অর্থাৎ চক্র মেনে −2147483648-এ যাওয়া; (২) program থামিয়ে error দেওয়া (trap বা panic); (৩) সংখ্যার জন্য বেশি বিট নেওয়া, যাতে overflow আর হয়ই না (arbitrary-precision integer); (৪) কিছুই না বলা, অর্থাৎ undefined behavior. নিচের stepper-এ একই প্রশ্ন ভাষা ধরে ধরে দেখুন। “সত্যিকারের run” লেখা ফলগুলো অংশ ৪-এর run থেকে নেওয়া, Java-র সারি Java 21-এর নিয়ম থেকে প্রত্যাশিত ফল; Rust-এর দুটি সারি Rust-এর documentation অনুযায়ী উদাহরণ, এখানে চালানো হয়নি।

1bits: 0111…1 + 1 (৩২ বিট)2Java: Integer.MAX_VALUE + 13C: big + 1 (Clang -O0)4C: x + 1 > x (Clang -O2)5Rust debug: x + 16Rust release: x + 17Python: (2**31 - 1) + 18Haat: 9223372036854775807 + 1
এই ধাপে
নিয়ম
ফল
  1. যন্ত্রের স্তরে। x86-64 বা RISC-V-এর সাধারণ যোগের নির্দেশ ৩২ বিটের বাইরের অংশ ফেলে দেয়। 0111…1 + 1 = 1000…0, যা two's complement-এ −2147483648. CPU নিজে wrap করে; প্রশ্ন হলো ভাষা এই ফলকে কী বলবে।
  2. Java: নির্ধারিত wrap. Java Language Specification বলে int-এর যোগ two's complement-এ wrap করে। তাই ফল সবসময় −2147483648, প্রতিটি JVM-এ। নিরাপদ? আংশিক: আচরণ নির্ধারিত, কিন্তু ভুল মানটি নীরবে চলতে থাকে।
  3. C: undefined, এই build-এ wrap. C17-এ signed int overflow undefined behavior. Clang 22.1.8-এ -O0 দিয়ে বানানো program যন্ত্রের যোগই করেছে, তাই −2147483648 এল, আর x + 1 > x পরীক্ষাটি 0 দিল। এটি “C-র নিয়ম” নয়, শুধু এই compiler-এর এই build-এর আচরণ।
  4. C: optimizer-এর যুক্তি। একই source -O2-এ: x + 1 > x এখন 1. Optimizer-এর যুক্তি: “signed overflow ঘটতে পারে না (ঘটলে program-টিই অবৈধ), তাই x + 1 সবসময় x-এর চেয়ে বড়”; সে পুরো তুলনা মুছে সরাসরি 1 ফেরত দেয়। একই source, দুই ফল: undefined behavior মানে ঠিক এটাই।
  5. Rust debug: panic. Rust-এ debug build-এ চলার সময় overflow হলে program থামে, বার্তা “attempt to add with overflow”. (Rust ধ্রুবক দেখে compile-এর সময়ই আটকায়, তাই এখানে x একটি চলার সময় আসা মান।) Reliability সর্বোচ্চ, প্রতিটি যোগে একটি পরীক্ষার খরচ।
  6. Rust release: wrap. Release build-এ এই পরীক্ষা ডিফল্টে বন্ধ, আর তখন ফল নির্ধারিত wrap; undefined নয়। দরকার হলে programmer স্পষ্টভাবে checked_add, wrapping_add বা saturating_add লিখে নিজের ইচ্ছা জানান। Rust আপসটি উন্মুক্ত রেখেছে: গতি চাইলে wrap, নিরাপত্তা চাইলে check.
  7. Python: overflow-ই নেই। Python 3-এর int দরকারমতো বড় হয়, তাই উত্তর গাণিতিকভাবে সঠিক 2147483648. দাম: প্রতিটি int একটি heap object, আকার বাড়ে-কমে, আর যোগ একটি সরল CPU নির্দেশ নয়।
  8. Haat: নির্ধারিত ৬৪-বিট wrap. Haat-এর Int ৬৪ বিট, overflow wrap করে (spec v1). Reference-এর interpreter আর VM দুটিই −9223372036854775808 ছাপে। নির্ধারিত বলেই Haat-এর প্রতিটি অনুবাদক একই উত্তর দিতে বাধ্য, যা পর্ব ০৪-এর differential testing-এর ভিত্তি।

৪ · সত্যিকারের run — C, Java আর Python

এবার stepper-এর দাবিগুলো নিজে চালিয়ে দেখুন। প্রথমে C. পাতার “চালান” বোতাম কোডটি একটি online GCC-তে (warning চালু রেখে) চালায়। volatile লেখা হয়েছে যাতে compiler big-এর মান আগে থেকে ধরে নিতে না পারে; next_is_bigger প্রশ্ন করে “x + 1 কি x-এর চেয়ে বড়?”, যা গণিতে সবসময় সত্য।

#include <stdio.h>
#include <limits.h>

int next_is_bigger(int x) {
    return x + 1 > x;          /* overflow when x == INT_MAX: UB */
}

int main(void) {
    volatile int big = INT_MAX;
    unsigned int u = UINT_MAX;
    printf("INT_MAX + 1          = %d\n", big + 1);
    printf("next_is_bigger(MAX)  = %d\n", next_is_bigger(big));
    printf("UINT_MAX + 1         = %u\n", u + 1);
    return 0;
}

আসল আউটপুট, এই কোডই লেখকের যন্ত্রে সত্যিকারের Clang 22.1.8-এ -O0 -fno-sanitize=undefined -Wall -Wextra দিয়ে চালিয়ে (কোনো warning আসেনি):

INT_MAX + 1          = -2147483648
next_is_bigger(MAX)  = 0
UINT_MAX + 1         = 0

প্রথম লাইনে wrap দেখা যাচ্ছে, আর next_is_bigger বলছে “না, বড় নয়”, গণিতের উল্টো। কিন্তু এটি C-র নিয়ম নয়: signed overflow undefined, তাই পাতার “চালান” বোতাম যে online GCC ব্যবহার করে, তার ফল এর সঙ্গে না-ও মেলে, আর দুটিই “সঠিক”। সত্যিই তা-ই হয়েছে: সেই online GCC-তে একই কোড চালিয়ে দ্বিতীয় লাইনে পাওয়া গেছে next_is_bigger(MAX) = 1, বাকি দুই লাইন একই। আপনি নিজে চালিয়ে মিলিয়ে দেখুন। unsigned-এর লাইনটি অবশ্য সব compiler-এ 0 হতে বাধ্য, কারণ unsigned-এর wrap C-তে নির্ধারিত। নিচের run দেখায়, একই compiler-এও flag বদলালে ফল বদলায়।

সত্যিকারের run — একই ফাইল, Clang-এর তিনটি build

নিচের সবকিছু সত্যিকারের run: PyPI-র ziglang 0.17.1 (MIT licence), যার ভেতরে Clang 22.1.8; এখানে zig মানে python -m ziglang. ফাইল উপরের overflow.c-ই।

~/haat $ zig cc -O0 -fno-sanitize=undefined -Wall -Wextra overflow.c -o o0.exe && ./o0.exe
INT_MAX + 1          = -2147483648
next_is_bigger(MAX)  = 0
UINT_MAX + 1         = 0
~/haat $ zig cc -O2 -Wall -Wextra overflow.c -o o2.exe && ./o2.exe
INT_MAX + 1          = -2147483648
next_is_bigger(MAX)  = 1
UINT_MAX + 1         = 0
~/haat $ zig cc -O0 overflow.c -o dbg.exe && ./dbg.exe
thread 30508 panic: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'
~/haat $ zig cc -O2 -fwrapv overflow.c -o wrapv.exe && ./wrapv.exe
INT_MAX + 1          = -2147483648
next_is_bigger(MAX)  = 0
UINT_MAX + 1         = 0

-O2-এ next_is_bigger-এর assembly (x86-64, -S দিয়ে; directive বাদ দিয়ে):

next_is_bigger:
	pushq	%rbp
	movq	%rsp, %rbp
	movl	$1, %eax
	popq	%rbp
	retq

চারটি build, একই source, তিন রকম আচরণ। এক, -O0-এ যোগ আর তুলনা দুটিই আসলে হয়েছে, তাই wrap আর 0. দুই, -O2-এর assembly-তে কোনো যোগ বা তুলনাই নেই: শুধু movl $1, %eax, অর্থাৎ “1 ফেরত দাও”। আর -Wall -Wextra সত্ত্বেও কোনো warning আসেনি; UB-র ওপর ভর করা optimization নীরবে ঘটে। তিন, Zig-এর zig cc -O0-এ (বা কোনো -O না দিলে) sanitizer (UBSan) ডিফল্টে চালু রাখে, তাই overflow-এর মুহূর্তেই program থেমে গেছে; সাধারণ clang বা gcc-তে এটি -fsanitize=undefined দিয়ে চালু করতে হয়। চার, -fwrapv flag Clang আর GCC-কে বলে “signed overflow-কে wrap ধরো”; তখন C-র এই অংশ Java-র মতো নির্ধারিত হয়ে যায়, আর optimizer তুলনাটি আর মুছতে পারে না। unsigned-এর wrap কিন্তু C-তে সবসময় নির্ধারিত (মান 232 দিয়ে ভাগশেষ), তাই তৃতীয় লাইন প্রতিটি build-এ 0.

এবার Java 21. একই program-এ আরও দুটি নিরাপত্তা-পরীক্ষা রাখা হলো, যা অংশ ৫-এ কাজে লাগবে: array-র সীমার বাইরে পড়া আর null-এর ওপর method ডাকা।

class Main {
    public static void main(String[] args) {
        int big = Integer.MAX_VALUE;           // 2147483647
        System.out.println("int  MAX + 1 = " + (big + 1));
        long lbig = Long.MAX_VALUE;
        System.out.println("long MAX + 1 = " + (lbig + 1));
        try {
            System.out.println(Math.addExact(big, 1));
        } catch (ArithmeticException e) {
            System.out.println("addExact: " + e.getMessage());
        }
        int[] cart = {520, 60};                // two items
        try {
            System.out.println(cart[2]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("bounds: " + e.getMessage());
        }
        String coupon = null;
        try {
            System.out.println(coupon.length());
        } catch (NullPointerException e) {
            System.out.println("null: NullPointerException");
        }
    }
}

আসল আউটপুট (পাতার “চালান” বোতামের online runner-এ, Wandbox-এর JDK 21-এ চালিয়ে):

int  MAX + 1 = -2147483648
long MAX + 1 = -9223372036854775808
addExact: integer overflow
bounds: Index 2 out of bounds for length 2
null: NullPointerException

Java-তে উত্তর নির্দিষ্ট: Java Language Specification অনুযায়ী int আর long-এর যোগ two's complement-এ wrap করে, তাই প্রতিটি JVM-এ একই −2147483648 আর −9223372036854775808. নীরব wrap না চাইলে Java একটি স্পষ্ট পথ দেয়: Math.addExact overflow হলে ArithmeticException ছোড়ে, বার্তা “integer overflow”. বাকি দুই লাইন অংশ ৫-এর বিষয়: দুটি জিনিসের ঝুড়িতে index 2 চাইলে JVM পরীক্ষা করে exception দেয়, আর null-এর ওপর method ডাকলে NullPointerException. তিনটি পাহারাই চলার সময়ের, আর তিনটিরই সামান্য খরচ আছে।

শেষে Python, ব্রাউজারের ভেতরে (Pyodide). সঙ্গে Haat-এর wrap নিয়মটিও Python-এ লেখা, ঠিক যেমন reference-এর runtime.py-তে আছে, যাতে দুই নকশা পাশাপাশি দেখা যায়।

import sys
big = 2**63 - 1                     # the largest Haat Int (= C's int64_t max)
print("Python big + 1  =", big + 1)
print("bits needed     =", (big + 1).bit_length())

fact = 1
for i in range(1, 26):
    fact *= i                       # Python ints grow as needed
print("Python 25!      =", fact)

def wrap64(x):                      # Haat's rule (runtime.py): wrap to 64 bits
    return (x + 2**63) % 2**64 - 2**63
print("Haat big + 1    =", wrap64(big + 1))
print("Haat 25!        =", wrap64(fact))

print("size of 1       :", sys.getsizeof(1), "bytes")
print("size of 25!     :", sys.getsizeof(fact), "bytes")
print("size of 10**100 :", sys.getsizeof(10**100), "bytes")

আসল আউটপুট (ব্রাউজারের Python):

Python big + 1  = 9223372036854775808
bits needed     = 64
Python 25!      = 15511210043330985984000000
Haat big + 1    = -9223372036854775808
Haat 25!        = 7034535277573963776
size of 1       : 16 bytes
size of 25!     : 24 bytes
size of 10**100 : 60 bytes

Python-এ 263 − 1 + 1 নির্ভুলভাবে 9223372036854775808, যার জন্য ৬৪ বিট লাগে; signed ৬৪-বিটে এটি আর ধরে না। 25! প্রায় 1.55 × 1025, তবু Python সঠিক মান দেয়। Haat-এর নিয়মে একই হিসাব wrap করে: big + 1 হয় সবচেয়ে ছোট Int, আর 25!-এর জায়গায় আসে 7034535277573963776, যা আসল 25!-এর সঙ্গে কোনো মিলই রাখে না। কোর্সের Haat reference-এ fact(25) চালালে interpreter আর VM দুটিই ঠিক এই 7034535277573963776 ছাপে। শেষ তিন লাইন Python-এর দাম দেখায়: সবচেয়ে ছোট int-ও একটি পুরো object (ব্রাউজারের ৩২-বিট WebAssembly build-এ ১৬ byte; এই লেখকের ল্যাপটপের ৬৪-বিট CPython 3.14.4-এ একই কোড দেয় ২৮, ৩৬ আর ৭২ byte), আর সংখ্যা বড় হলে আকারও বাড়ে; Haat-এর একটি Int বা C-র int64_t সবসময় ৮ byte-এর একটি ঘর। Python-এর সংখ্যা নিয়ে আরও আছে Python কোর্সের পর্ব ০৭-এ (সংখ্যা ও হিসাব).

৫ · সীমা পরীক্ষা, null আর error — নিরাপত্তার দাম কে দেয়

Array-র সীমা

দুটি জিনিসের ঝুড়িতে তৃতীয় জিনিস চাইলে কী হবে? Java প্রতিটি array পড়া-লেখার আগে index পরীক্ষা করে (bounds checking); অংশ ৪-এর run-এ cart[2] একটি exception দিয়েছে, যার বার্তায় index আর দৈর্ঘ্য দুটোই আছে। C কোনো পরীক্ষা করে না: সীমার বাইরে পড়া-লেখা undefined behavior, আর বাস্তবে তা পাশের মেমরির অন্য কিছু পড়ে বা নষ্ট করে। দশকের পর দশক ধরে বহু নিরাপত্তা-ত্রুটির মূলে আছে এই একটি সিদ্ধান্ত; প্রতিরক্ষার দিক থেকে বিস্তারে আছে Cybersecurity কোর্সের পর্ব ৪৭-এ (Memory safety).

পরীক্ষার দাম কত? প্রতিটি index-এ একটি তুলনা আর একটি শাখা। কিন্তু আধুনিক compiler অনেক পরীক্ষা নিজেই মুছে ফেলে, যখন প্রমাণ করতে পারে index সীমার ভেতরেই (যেমন for (i = 0; i < a.length; i++)-এর লুপে)। এই কারণেই Java, C# বা Rust (যেখানে সাধারণ index-এ পরীক্ষা হয়) সাধারণ কাজে খুব ধীর নয়; কত ধীর, তা কাজ আর compiler-এর ওপর নির্ভর করে, আর মাপতে হয় নিজের যন্ত্রে।

Null — “billion-dollar mistake”

Tony Hoare ১৯৬৫ সালে ALGOL W ভাষায় null reference যোগ করেছিলেন: যেকোনো reference “কিছুই না”-ও হতে পারে। ২০০৯ সালের একটি সম্মেলন-বক্তৃতায় তিনি একে নিজের “billion-dollar mistake” বলেন, কারণ তাঁর মতে এরপর কয়েক দশকে এর থেকে অগণিত ভুল আর ক্ষতি হয়েছে (বক্তৃতার ভাষা উৎসভেদে একটু আলাদা উদ্ধৃত হয়)। সমস্যার মূল: type বলে “এটি একটি String”, কিন্তু আসলে তা String বা null; প্রতিটি ব্যবহারে type-এর প্রতিশ্রুতি ভাঙার ঝুঁকি। অংশ ৪-এর Java run-এ coupon.length() ঠিক এই কারণে NullPointerException দিয়েছে, আর তা ধরা পড়েছে শুধু চলার সময়।

আধুনিক উত্তর হলো “না-থাকা”-কে type-এ লিখে রাখা, যাকে বলে option type: Haskell-এর Maybe, ML/OCaml আর Rust-এর Option, Kotlin আর Swift-এর String?. তখন type checker জোর করে: মানটি ব্যবহারের আগে “না-থাকা” ক্ষেত্রটি সামলান। Java 8-এর Optional (Java কোর্সের পর্ব ৩৬) একই ধারণা লাইব্রেরি হিসেবে আনে, কিন্তু ভাষার পুরোনো null থেকেই যায়: backward compatibility-র দাম।

Haat-এ null নেই। প্রতিটি let আর var-এ একটি প্রাথমিক মান বাধ্যতামূলক (let x = e;), আর Int, Bool, Str-এর কোনো “ফাঁকা” মান নেই। তাই NullPointerException-এর মতো ভুল Haat-এ লেখাই যায় না। দাম: “এখনো জানা নেই” ধরনের মান রাখতে হলে Haat v1-এ কোনো সহজ উপায় নেই; algebraic data type এলে (পর্ব ২৪, Haat-এর বর্ধিত রূপ) Option-এর মতো type তৈরি করা যাবে।

Exception বনাম error value

কিছু ব্যর্থ হলে খবরটি কীভাবে ফিরবে? দুটি বড় ধারা। Exception: ব্যর্থতা স্বাভাবিক ফেরত-পথ ছেড়ে ওপরের দিকে লাফ দেয়, যতক্ষণ না কোনো catch ধরে (Java, Python, C++). সুবিধা: সাধারণ পথের কোড পরিষ্কার থাকে। অসুবিধা: কোন লাইন থেকে কোন exception বেরোতে পারে, কোড পড়ে বোঝা কঠিন। Error value: ব্যর্থতা একটি সাধারণ ফেরত মান। C ফেরত দেয় −1 আর errno (উপেক্ষা করা খুব সহজ); Go ফেরত দেয় (value, err) জোড়া, আর প্রচলিত কোডে বারবার if err != nil; Rust ফেরত দেয় Result<T, E>, যা type checker উপেক্ষা করতে দেয় না, আর ? operator লেখার ঝামেলা কমায়।

Haat v1 সরলতম পথ নিয়েছে: runtime error (শূন্য দিয়ে ভাগ, stack overflow, আগে-চালু-না-হওয়া global) program থামিয়ে দেয়, আর ধরার কোনো উপায় নেই। শেখার ভাষার জন্য এটি যথেষ্ট, compiler-ও সরল থাকে। Exception কীভাবে বাস্তবায়িত হয় (stack unwinding), আসবে পর্ব ২৮-এ (Exception handling).

৬ · মেমরি, typing আর syntax — আরও তিনটি বড় বাছাই

মেমরি: হাতে, GC, নাকি ownership

পথউদাহরণলাভদাম
হাতে মেমরিC-র malloc/freeপূর্ণ নিয়ন্ত্রণ, runtime ছোটভুলে না ছাড়া (leak), দুবার ছাড়া, ছাড়ার পর ব্যবহার: সবই programmer-এর দায়
Garbage collectionJava, Python, Go, JavaScriptছাড়ার ভুল প্রায় অসম্ভব, লেখা সহজবাড়তি মেমরি আর CPU, কখন থামবে তার পূর্বানুমান কম
OwnershipRustGC ছাড়াই memory safety, compile-এর সময় যাচাইশেখা কঠিন, কিছু বৈধ program-ও compiler মেনে নেয় না

খেয়াল করুন, তিনটি পথই একই প্রশ্নের তিন উত্তর: “এই মেমরি কখন নিরাপদে ফেরত দেওয়া যায়, সেটি কে প্রমাণ করবে?” Programmer (C), runtime চলার সময় (GC), নাকি compiler চালানোর আগে (Rust). প্রমাণের দায় যত আগে, চলার খরচ তত কম, কিন্তু লেখার কষ্ট তত বেশি। C-র দিক থেকে বিস্তারে আছে C কোর্সের পর্ব ২০-এ; GC-র বাস্তবায়ন আসবে পর্ব ৭৫-এ, আর Rust-এর borrow checker পর্ব ৭৬-এ।

Typing: কখন ধরা পড়বে

Static typing-এ type-এর ভুল চালানোর আগেই ধরা পড়ে (C, Java, Rust, Haat); dynamic typing-এ শুধু সেই লাইন চললে (Python, JavaScript). প্রথমটি reliability আর tool-এর সাহায্য (autocomplete, নিরাপদ নাম বদল) দেয়, দ্বিতীয়টি দ্রুত পরীক্ষামূলক লেখা আর নমনীয়তা। আপসটি এত গুরুত্বপূর্ণ যে দুই দিক থেকেই মাঝামাঝি পথ এসেছে: Python-এ type hint আর mypy (Python কোর্সের পর্ব ৪০), JavaScript-এর ওপর TypeScript, আর উল্টো দিকে Java ও C++-এ local type inference (var, auto), যাতে static ভাষাতেও কম লিখতে হয়। পুরো আলোচনা পর্ব ৩৩-এ (Type system).

Syntax: ফাঁকা জায়গা আর semicolon

Python-এ block বোঝায় indentation; একে বলে significant whitespace. যা দেখতে ভেতরে, তা আসলেই ভেতরে, তাই চোখ আর compiler কখনো দ্বিমত করে না: readability-র বড় জয়। দাম: copy-paste-এ indentation ভাঙলে program-এর অর্থ বদলাতে পারে। JavaScript নিয়েছে উল্টো এক আপস: semicolon না দিলে parser নিজেই কিছু জায়গায় বসিয়ে নেয় (automatic semicolon insertion). লেখা সহজ, কিন্তু নিয়মটি অনেকের অজানা। দুটিরই সত্যিকারের run (CPython 3.14.4 আর Node.js 24.15.0):

~/haat $ cat indent.py
qty = 2
if qty > 1:
print(qty)
~/haat $ python indent.py
  File "indent.py", line 3
    print(qty)
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 2
~/haat $ cat asi.js
function deliveryInfo() {
  return
  { charge: 60 };
}
console.log(deliveryInfo());
~/haat $ node asi.js
undefined

Python-এর ভুলটি চালানোর আগেই ধরা পড়েছে, আর বার্তা স্পষ্ট। JavaScript-এর ঘটনা বেশি বিপজ্জনক: return-এর পরে লাইন ভাঙায় parser সেখানেই একটি semicolon বসিয়েছে, তাই function কিছুই ফেরত দেয়নি (undefined), আর নিচের { charge: 60 } একটি অর্থহীন block হয়ে পড়ে রইল। কোনো error নেই, কোনো warning নেই। Go আরেকটি পথ দেখায়: ভাষাই একটি formatter (gofmt) দিয়ে বিন্যাস ঠিক করে দেয়, ফলে লেখার ধরন নিয়ে তর্ক কমে। Haat নিয়েছে সবচেয়ে কম জাদুর পথ: প্রতিটি statement-এর শেষে ; বাধ্যতামূলক, block-এ { } বাধ্যতামূলক, আর ভুলে গেলে আগের token-এর ঠিক পরে error.

৭ · একটি feature কীভাবে বিচার করবেন

ধরুন বাজারঘরের একজন Haat ব্যবহারকারী অনুরোধ করলেন: “print("total: " + 996); চলুক; Int নিজে থেকেই Str হয়ে যাক।” JavaScript ঠিক এটাই করে, একে বলে implicit conversion (বা coercion). প্রস্তাবটি ছোট দেখায়, কিন্তু একটি ভাষায় কোনো feature একা থাকে না। নিচের stepper-এ প্রস্তাবটি Haat-এর বাস্তবায়নের প্রতিটি অংশ দিয়ে হাঁটিয়ে দেখুন; JavaScript-এর ফলগুলো Node.js 24.15.0-এ সত্যিকারের run.

1print("total: " + 996);2print(1 + 2 + "x");3print("x" + 1 + 2);4print("5" == 5);
এই ধাপে
অংশ
প্রভাব
  1. প্রস্তাব। উদ্দেশ্য সুন্দর: লেখা সহজ, writability বাড়ে। বাজারঘরের রসিদ ছাপাতে বারবার এমন লাইন লাগে।
  2. Lexer আর parser. কোনো নতুন token বা নতুন নিয়ম লাগে না; "total: " + 996 আগের মতোই একটি Binary("+") node. Syntax বদলায় না, বদলায় শুধু অর্থ।
  3. Type checker. আজ নিয়ম: +-এর দুই পাশ Int, Int অথবা Str, Str. নতুন নিয়মে আরও দুটি ক্ষেত্র: Str + Int আর Int + Str, দুটির ফলই Str. Type-এর নিয়ম চারটি হলো, আর প্রতিটি ভবিষ্যৎ type (যেমন Bool) এলে প্রশ্ন উঠবে: এটিও কি রূপান্তর হবে?
  4. দুই back end. Tree-walking interpreter আর VM-এর ADD দুটিকেই চলার সময় ধরন দেখে Int-কে লেখায় বদলাতে হবে, আর দুজনের লেখার রূপ হুবহু এক হতে হবে (ঋণাত্মক সংখ্যা, সবচেয়ে ছোট Int). নইলে differential testing ভাঙবে।
  5. প্রথম চমক। Haat-এর সব binary operator বাঁ দিক থেকে জোড়া বাঁধে। তাই 1 + 2 + "x" মানে (1 + 2) + "x": আগে 3, তারপর লেখা "3x". JavaScript-এ ঠিক এটিই আসে।
  6. দ্বিতীয় চমক। শুধু ক্রম বদলালে "x" + 1 + 2 = ("x" + 1) + 2 = "x1" + 2 = "x12". একই তিনটি জিনিস, দুই রকম উত্তর; পাঠককে associativity মনে রেখে পড়তে হয়। Readability কমল।
  7. Knock-on: সমতা। Str + Int চললে "5" == 5-ও কি সত্য হবে? JavaScript-এর == রূপান্তর করে সত্য বলে, যা বহু ভুলের উৎস; না করলে + আর ==-এর আচরণ অসংগত। যেকোনো উত্তরেই একটি দাম আছে।
  8. সিদ্ধান্ত। Haat v1 প্রস্তাবটি নেয় না: reference বাস্তবায়নে print(1 + 2 + "x"); চালানোর আগেই type error দেয়, আর "total: " + 996-এ দেয় expected Str, found Int. লেখার সামান্য কষ্টের বিনিময়ে সব চমক বাদ।

এই হিসাবকে একটু শৃঙ্খলায় আনা যায়। নিচের Python কোড তিনটি নকশা তুলনা করে: (A) Haat v1-এর মতো বাতিল, (B) JavaScript-এর মতো নিজে থেকে রূপান্তর, (C) শুধু স্পষ্টভাবে লেখা রূপান্তর (যেমন একটি কাল্পনিক str(n); Haat v1-এ এটি নেই)। প্রথম অংশ সত্যিই হিসাব করে দেখায় কোন নকশায় কী আসে। দ্বিতীয় অংশের নম্বর (১ থেকে ৫) লেখকের বিচার, মাপা তথ্য নয়; উদ্দেশ্য দেখানো যে লক্ষ্য বদলালে “সেরা” নকশাও বদলায়।

# Three designs for Haat's "+" when one side is Str and the other Int
def plus(a, b, design):
    if type(a) == type(b):
        return a + b
    if design == "A-reject":                 # Haat v1: no implicit conversion
        raise TypeError(f"type mismatch: {type(a).__name__} + {type(b).__name__}")
    if design == "B-implicit":               # JavaScript-like: Int becomes Str
        return str(a) + str(b)
    raise TypeError("write str(n) explicitly")   # C: explicit conversion only

for d in ["A-reject", "B-implicit", "C-explicit"]:
    out = []
    for e in [(1, 2, "x"), ("x", 1, 2)]:      # left-assoc: (e0 + e1) + e2
        try:
            out.append(repr(plus(plus(e[0], e[1], d), e[2], d)))
        except TypeError:
            out.append("error")
    print(f"{d:11} 1+2+'x' -> {out[0]:6} 'x'+1+2 -> {out[1]}")

# author's judgement, 1 (bad) .. 5 (good) -- not measured data
scores = {"A-reject":   dict(read=4, write=2, safe=5, simple=5),
          "B-implicit": dict(read=2, write=5, safe=2, simple=3),
          "C-explicit": dict(read=5, write=3, safe=5, simple=4)}
profiles = {"teaching": dict(read=.3, write=.1, safe=.4, simple=.2),
            "quick-script": dict(read=.15, write=.6, safe=.15, simple=.1)}
for name, w in profiles.items():
    total = {d: round(sum(s[k] * w[k] for k in w), 2) for d, s in scores.items()}
    best = max(total, key=total.get)
    print(f"{name:12}", total, "->", best)

আসল আউটপুট (ব্রাউজারের Python):

A-reject    1+2+'x' -> error  'x'+1+2 -> error
B-implicit  1+2+'x' -> '3x'   'x'+1+2 -> 'x12'
C-explicit  1+2+'x' -> error  'x'+1+2 -> error
teaching     {'A-reject': 4.4, 'B-implicit': 2.5, 'C-explicit': 4.6} -> C-explicit
quick-script {'A-reject': 3.05, 'B-implicit': 3.9, 'C-explicit': 3.7} -> B-implicit

প্রথম তিন লাইন হিসাব: শুধু নকশা B-তে দুটি expression-এর মান আসে, আর ক্রম বদলালেই উত্তর বদলায় ('3x' বনাম 'x12'), stepper-এর মতোই। A আর C-তে দুটিই error, তবে আলাদা কারণে: A বলে “এ যোগ হয় না”, C বলে “রূপান্তরটি নিজে লিখুন”। শেষ দুই লাইন ওজনের খেলা। শেখার ভাষার ওজনে (reliability আর readability বেশি) C জেতে 4.6 পেয়ে, A ঠিক পেছনে 4.4; দ্রুত script লেখার ওজনে (writability 0.6) জেতে B, 3.9 পেয়ে। নম্বরগুলো নিয়ে তর্ক করা যায়, আর ঠিক সেটিই উদ্দেশ্য: নকশার আলোচনা “কোনটি ভালো” থেকে সরে আসে “কোন লক্ষ্যে, কোন ওজনে, কেন এই নম্বর” প্রশ্নে। Haat v1 আজ A-তে আছে কারণ C-র জন্য একটি built-in function লাগত, যা spec v1-এ নেই; A থেকে C-তে যাওয়া পরে সহজ (নতুন কিছু যোগ), কিন্তু B থেকে ফেরা প্রায় অসম্ভব (পুরোনো কোড ভাঙবে)।

পদ্ধতি ৬.২ — একটি feature বিচারের ধাপ
  1. সমস্যাটি লিখুন: কোন ব্যবহারকারী, কোন কাজ, আজ কী কষ্ট।
  2. মাপকাঠি আর তাদের ওজন ঠিক করুন, ভাষার লক্ষ্য থেকে (শেখার ভাষা, system ভাষা, script ভাষা)।
  3. অন্তত তিনটি বিকল্প নকশা লিখুন, “কিছুই না করা”-সহ।
  4. প্রতিটি বিকল্পের প্রভাব lexer, parser, type checker, প্রতিটি back end আর পুরোনো program-এ হিসাব করুন; অন্য feature-এর সঙ্গে জোড়া লাগিয়ে কোণের উদাহরণ লিখুন।
  5. ছোট prototype বানিয়ে test আর differential test চালান; তারপর সিদ্ধান্ত আর তার কারণ লিখে রাখুন (Python-এর PEP, Rust-এর RFC এই কাজই করে)।

৮ · Haat-এর নকশা কেন এমন

এবার পুরো কোর্সের ভাষা Haat-এর দিকে তাকাই। Haat-এর spec ছোট, কিন্তু প্রতিটি লাইনের পেছনে একটি আপস আছে। Haat-এর লক্ষ্য তিনটি, এই ক্রমে: (১) শেখা আর বাস্তবায়ন সহজ, যাতে কয়েকশো লাইনে পুরো compiler লেখা যায়; (২) অর্থ সম্পূর্ণ নির্ধারিত, যাতে প্রতিটি অনুবাদকের উত্তর মেলানো যায়; (৩) পরিচিত দেখতে, C, Rust আর JavaScript জানা মানুষের চোখে স্বাভাবিক। Reference বাস্তবায়নের README-র “Spec decisions” অংশ যেখানে spec চুপ, সেখানে “সবচেয়ে C-র মতো বা Rust-এর মতো” ব্যাখ্যাটি বেছে নিয়েছে।

সিদ্ধান্তকারণ (কোন মাপকাঠি)দাম
let (বদলায় না) আর var (বদলায়) আলাদাReliability আর readability: পাঠক এক নজরে জানেন কোন নাম বদলাতে পারে; Rust, Swift, Kotlin আর JavaScript-এর const-এর মতো immutability-কে সহজ পথ করা। Parameter আর function-এর নামও বদলানো যায় না।দুটি keyword শিখতে হয়
Function-এর parameter আর return type লিখতেই হবেType checker সরল থাকে (মডিউল ৯-এ আপনি নিজে লিখবেন); function-এর signature নিজেই documentation. let-এর type শুধু ডান পাশ থেকে বের হয়, তাই local inference যথেষ্টএকটু বেশি লেখা; পূর্ণ Hindley–Milner inference পর্ব ৩৫-এ আলাদা করে
কোনো implicit conversion নেইReliability: অংশ ৭-এর চমকগুলো অসম্ভব; Int আর Bool-ও আলাদা, তাই if n { type errorলেখায় একটু কষ্ট
৬৪-বিট Int, overflow wrap; INT_MIN / -1-ও wrapঅর্থ সম্পূর্ণ নির্ধারিত (C-র মতো UB নেই), আর যন্ত্রের একটি নির্দেশে বসে (Python-এর মতো bigint নয়); সব back end-এর উত্তর একভুল মান নীরবে চলে, Rust-এর debug panic-এর মতো পাহারা নেই
/ শূন্যের দিকে কাটে, % ভাজ্যের চিহ্ন নেয়C, Java আর RISC-V-এর div/rem নির্দেশের মতো, তাই code generation সরলPython-এর // আর %-এর সঙ্গে ঋণাত্মকে আলাদা
Comparison শিকলে বাঁধা যায় না (a < b < c syntax error)এই লেখার অর্থ ভাষাভেদে আলাদা (নিচের run দেখুন); আলাদা না করে নিষেধ করাই সবচেয়ে নিরাপদলিখতে হয় a < b && b < c
Assignment আর print statementif (x = 0) ধরনের ভুল অসম্ভব (অংশ ২)C-র এক-লাইনের লুপ লেখা যায় না
প্রতিটি statement-এ ;, প্রতিটি block-এ { }Parser সরল আর নির্ভুল; JavaScript-এর ASI বা ঝুলন্ত else-এর দ্ব্যর্থতা নেইকয়েকটি বাড়তি চিহ্ন
Null নেই; প্রতিটি variable-এ প্রাথমিক মানHoare-এর “billion-dollar mistake” এড়ানো“এখনো অজানা” মান রাখা যায় না
শুধু top-level function hoist হয়; ঘোষণার আগে ব্যবহার errorMutual recursion চলে, কিন্তু নামের অর্থ স্পষ্ট থাকে (JavaScript-এর let-এর মতো)Nested function একে অপরকে আগে ডাকতে পারে না

শিকলে বাঁধা তুলনার উদাহরণটি দেখার মতো, কারণ একই লেখা 1 < 3 < 2 তিনটি ভাষায় তিন রকম অর্থ পায়। সত্যিকারের run (CPython 3.14.4, Node.js 24.15.0, Clang 22.1.8):

~/haat $ python -c "print(1 < 3 < 2, 3 > 2 > 1)"
False True
~/haat $ node -e "console.log(1 < 3 < 2, 3 > 2 > 1)"
true false
~/haat $ zig cc chain.c -o chain.exe
chain.c:3:29: error: chained comparison 'X < Y < Z' does not behave the same as a mathematical expression [-Wparentheses]
~/haat $ zig cc -Wno-error=parentheses chain.c -o chain.exe && ./chain.exe
1 0

Python-এ a < b < c মানে গণিতের মতো a < b and b < c, তাই 1 < 3 < 2 মিথ্যা। JavaScript আর C বাঁ থেকে জোড়া বাঁধে: (1 < 3) সত্য, অর্থাৎ 1, আর 1 < 2 সত্য। উল্টো দিকে 3 > 2 > 1 মানে (3 > 2) > 1, অর্থাৎ 1 > 1, মিথ্যা: গণিতের চোখে সত্য কথা C আর JavaScript-এ মিথ্যা। এই Clang 22.1.8 এটিকে ডিফল্টে error ধরেছে (warning-টি -Wparentheses দলের, কিন্তু এখানে error হিসেবে চালু); জোর করে চালালে 1 0. Haat-এর reference এই লাইনে দেয় comparison operators cannot be chained, ঠিক দ্বিতীয় তুলনার জায়গায়।

Haat-এর অন্য সিদ্ধান্তগুলোর আসল error বার্তা (reference বাস্তবায়ন, python haat.py run; প্রতিটি আলাদা ফাইল, আর ;-এর পরের দুটি ফাঁকা জায়গা মানে ফাইলে নতুন লাইন):

let rate = 10;  rate = 15;             --> 2:1: error: cannot assign to 'rate': it is declared with 'let'
fn twice(x) -> Int { return x * 2; }   --> 1:11: error: expected ':' and a type after parameter 'x'
let n = 5;  if n { print(n); }         --> 2:4: error: type mismatch: expected Bool, found Int
print(price - discount);  (discount: Bool)  --> 3:15: error: type mismatch: expected Int, found Bool
print(9223372036854775807 + 1);        --> -9223372036854775808

আরও গভীরে: ভাষা নকশা নিয়ে দুটি পুরোনো লেখা আজও পড়া হয়। Tony Hoare-এর “Hints on Programming Language Design” (১৯৭৩) সরলতা, নিরাপত্তা আর দ্রুত compile-কে নকশার কেন্দ্রে রাখে, আর বলে ভাষার নকশাকারীর কাজ নতুন feature আবিষ্কার নয়, পরীক্ষিত feature থেকে বাছাই করা। Guy Steele-এর বক্তৃতা “Growing a Language” (OOPSLA ১৯৯৮) দেখায়, একটি ভাষাকে ছোট শুরু করে ব্যবহারকারীর হাতে বাড়তে দেওয়ার উপায় রাখা উচিত। Overflow-এর দিকে আধুনিক কাজ C-কেও বদলাচ্ছে: C23 signed পূর্ণসংখ্যার two's complement রূপ বাধ্যতামূলক করেছে আর ckd_add-এর মতো পরীক্ষিত যোগের function এনেছে, যদিও signed overflow নিজে এখনো undefined.

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • ভাষা বিচারের মাপকাঠি কী কী? Readability, writability, reliability আর cost; এদের পেছনে সরলতা, orthogonality, data type, syntax, type checking, exception handling.
  • Orthogonality কী, উদাহরণ? অল্প মৌলিক ধারণা যেকোনোভাবে জোড়া যায় আর অর্থ নিয়ম থেকে আসে; C-তে function struct ফেরত দিতে পারে, array পারে না, এটি ফাঁক।
  • Readability আর writability কীভাবে বিরোধে যায়? সংক্ষিপ্ত লেখার সুবিধা (C-র = expression, ++) পড়ার আর নিরাপত্তার খরচে আসে।
  • C-তে INT_MAX + 1 কত? নির্দিষ্ট উত্তর নেই, undefined behavior; Java-তে −2147483648, Python-এ 2147483648.
  • Type checking reliability কীভাবে বাড়ায়? ভুল চালানোর আগেই ধরে, আর যত আগে ধরা পড়ে মেরামতের খরচ তত কম।

৯ · AI-এর যুগে ভাষার নকশা বোঝা

ভাষার নকশা নিয়ে AI assistant-এর উত্তর প্রায়ই আত্মবিশ্বাসী আর সাধারণ: “integer overflow হলে মান ঘুরে যায়”, “Python ধীর কারণ interpreted”, “null-এর বদলে Optional ব্যবহার করুন”। প্রতিটি কথা কোনো এক ভাষায় সত্য, আরেক ভাষায় মিথ্যা। এই বিষয়ে AI-এর বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
এক ভাষার নিয়ম সব ভাষায় চাপানো (“overflow-এ wrap হয়”)ভাষা আর version জিজ্ঞেস করা; C, Java, Python, Rust-এ আলাদা আলাদা চালিয়ে দেখা
Undefined behavior-এর একটি নির্দিষ্ট ফলকে “উত্তর” বলাএকই কোড -O0 আর -O2-এ, দুটি compiler-এ চালানো; -fsanitize=undefined দিয়ে চালানো
Overflow-এর পরে পরীক্ষা লিখে দেওয়া (if (a + b < a))-O2-এ compile করে assembly দেখা; যোগের আগে পরীক্ষা করা বা __builtin_add_overflow ব্যবহার
বানানো flag বা নিয়ম (“-fsafe-ints”, “Java-তে overflow exception দেয়”)Compiler-এর documentation আর ভাষার specification খুঁজে দেখা, চালিয়ে দেখা
নকশার প্রশ্নে এক-কথার রায় (“GC সবসময় ধীর”, “static typing সবসময় ভালো”)মাপকাঠি আর ওজন জিজ্ঞেস করা; দাবির পক্ষে মাপা তথ্য চাওয়া
ইতিহাসে ভুল সাল বা ভুল ব্যক্তি (null, ALGOL W, Hoare-এর বক্তৃতা)মূল উৎস বা নির্ভরযোগ্য ইতিহাস মিলিয়ে দেখা, সন্দেহ থাকলে “প্রায়” লেখা

AI-কে ভালোভাবে কাজে লাগানোর উপায়: রায় না চেয়ে আপসের তালিকা, ভাষা ধরে ধরে নিয়ম আর যাচাইয়ের উপায় চাওয়া, তারপর নিজে চালিয়ে মেলানো।

আমি প্রোগ্রামিং ভাষার নকশা শিখছি। Haat নামের একটি ছোট শেখার ভাষায় (৬৪-বিট Int যা overflow-এ wrap করে, কোনো implicit conversion নেই) একটি নতুন feature যোগ করার কথা ভাবছি: x += e. ১. lexer, parser, AST, type checker আর একটি bytecode VM-এ কোথায় কী বদলাতে হবে, তালিকা দাও। ২. অন্তত তিনটি বিকল্প নকশা দাও (কিছুই না করা-সহ), আর readability, writability, reliability আর বাস্তবায়নের খরচে প্রতিটির সুবিধা-অসুবিধা লেখো। ৩. C, Python আর Rust-এ += কীভাবে কাজ করে বললে ভাষা আর version লিখে দাও; নিশ্চিত না হলে বলো। ৪. কোণের উদাহরণ দাও: overflow, let দিয়ে ঘোষিত নাম, function-এর নাম। ৫. কোনো আউটপুট অনুমান করে লিখবে না; কোনটি আমাকে চালিয়ে দেখতে হবে, আলাদা করে বলো।

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

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

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

প্র ০১C কেন signed overflow-কে undefined রাখল, আর আজও কেন রেখে দিয়েছে?

ঐতিহাসিক কারণটি portability. ১৯৭০ আর ১৯৮০-এর দশকে সব কম্পিউটার two's complement ব্যবহার করত না; কিছু যন্ত্র ones' complement বা sign-magnitude ব্যবহার করত, আর কিছু যন্ত্রে overflow হলে hardware নিজেই trap করত। C-কে সব যন্ত্রে দ্রুত চালাতে হলে মান নির্ধারণ কমিটি কোনো একটি আচরণ বাধ্যতামূলক করতে পারত না: wrap বাধ্যতামূলক করলে trap-করা যন্ত্রে প্রতিটি যোগের পরে বাড়তি নির্দেশ লাগত, trap বাধ্যতামূলক করলে বাকি যন্ত্রে। তাই সিদ্ধান্ত: “এমন program-এর কোনো অর্থ নেই”। C-র Rationale দলিলের “Trust the programmer” আর “Make it fast” মন্ত্রের সঙ্গে এটি মেলে।

আজ প্রায় সব যন্ত্রই two's complement, আর C23 সেই রূপ বাধ্যতামূলকও করেছে। তবু overflow undefined রয়ে গেছে, কারণ এর একটি নতুন মূল্য তৈরি হয়েছে: optimization. অংশ ৪-এর run-এ Clang x + 1 > x-কে সরাসরি 1 বানিয়েছে। লুপে এর প্রভাব আরও বড়: for (int i = 0; i < n; i++)-এ compiler ধরে নিতে পারে i কখনো ঘুরে ঋণাত্মক হবে না, তাই লুপ কতবার চলবে হিসাব করা, ৬৪-বিট pointer হিসাবে i-কে চওড়া করা আর vectorization সহজ হয়। Wrap বাধ্যতামূলক হলে এসব যুক্তি দুর্বল হয়ে যায়।

দাম হলো নিরাপত্তা। Programmer-এর লেখা overflow-পরীক্ষাও মুছে যেতে পারে (অনুশীলন ২ দেখুন), আর ভুলটি কোনো warning ছাড়াই থেকে যায়। এজন্য বাস্তবে কয়েকটি স্তরের পাহারা আছে: -fwrapv (wrap বাধ্যতামূলক করে, Linux kernel-এর মতো বড় প্রকল্প এ ধরনের flag ব্যবহার করে বলে জানা যায়), -ftrapv আর UBSan (চলার সময় ধরে), __builtin_add_overflow আর C23-এর ckd_add (স্পষ্ট পরীক্ষা)।

অন্য ভাষার তুলনা শিক্ষণীয়। Java (১৯৯৫) wrap বাধ্যতামূলক করেছে, কারণ তার লক্ষ্য ছিল “একবার লিখুন, সব JVM-এ এক ফল”; Rust (১.০, ২০১৫) debug-এ check, release-এ wrap, আর কখনো UB নয়; Haat নির্ধারিত wrap, যাতে সব back end একই উত্তর দেয়।

মূল উপলব্ধি: একটি নকশা-সিদ্ধান্ত যে কারণে নেওয়া হয়েছিল, সেই কারণ চলে গেলেও সিদ্ধান্ত থেকে যেতে পারে, কারণ ততদিনে তার ওপর নতুন সুবিধা (এখানে optimization) গড়ে উঠেছে।

প্র ০২Null-কে “billion-dollar mistake” বলা হয় কেন, আর option type কি সত্যিই সমস্যার সমাধান?

Tony Hoare ১৯৬৫ সালে ALGOL W-এ reference যোগ করার সময় null রাখেন, কারণ তাঁর ভাষায় এটি বাস্তবায়ন করা খুব সহজ ছিল। ২০০৯ সালের একটি বক্তৃতায় তিনি একে “billion-dollar mistake” বলেন: তাঁর মতে পরের দশকগুলোতে null-এর কারণে অসংখ্য ভুল, নিরাপত্তা-ত্রুটি আর system crash হয়েছে (সংখ্যাটি একটি কথার কথা, মাপা হিসাব নয়)। পরে C, C++, Java, C# প্রায় সব জনপ্রিয় ভাষা এই নকশা নেয়।

সমস্যাটি type system-এর। Java-তে String coupon লিখলে type বলে “এটি একটি String”, কিন্তু আসলে মানটি String অথবা null. অর্থাৎ প্রতিটি reference type-এ একটি লুকানো বাড়তি মান আছে, যা type checker দেখে না। ফলে type-এর প্রতিশ্রুতি “এর ওপর length() ডাকা যাবে” সবসময় সত্য নয়, আর ভুল ধরা পড়ে চলার সময়, প্রায়ই ভুলের জায়গা থেকে অনেক দূরে।

Option type সমস্যাটিকে type-এ তুলে আনে। Rust-এ Option<String> হলো Some(s) অথবা None, আর সাধারণ String-এ None হতেই পারে না। মান ব্যবহারের আগে pattern matching দিয়ে দুটি ক্ষেত্রই সামলাতে হয়; ভুলে গেলে compile error. Kotlin আর Swift একই কাজ করে String? দিয়ে, আর C# 8 nullable reference type-এর পরীক্ষা যোগ করেছে (তবে পুরোনো কোডের জন্য সেটি warning, error নয়)।

কিন্তু এটি জাদু নয়। প্রথমত, “না-থাকা” বাস্তবে থাকেই; option type শুধু তাকে দৃশ্যমান করে, সামলানোর কাজ কমায় না। দ্বিতীয়ত, পালানোর পথ থাকে: Rust-এর unwrap() None-এ panic করে, Kotlin-এর !! exception দেয়; অলস ব্যবহারে পুরোনো সমস্যাই ফেরে, শুধু নাম বদলে। তৃতীয়ত, পুরোনো ভাষায় যোগ করা কঠিন: Java-র Optional নিজেই একটি reference, তাই Optional variable-ও null হতে পারে। চতুর্থত, লেখার কষ্ট বাড়ে, যদিও ?, map, ?.-এর মতো সংক্ষেপ সেটি কমায়।

মূল উপলব্ধি: ভালো নকশা ভুলকে অসম্ভব করে না, ভুলকে দৃশ্যমান আর আগে-ধরা-যায় এমন করে। Null-এর সমস্যা ছিল অদৃশ্যতা; option type তার উত্তর।

প্র ০৩Python-এর indentation-ভিত্তিক syntax কি readability-র জয়, নাকি একটি ঝুঁকি?

Python-এর এই নকশা এসেছে ABC নামের একটি শেখার ভাষা থেকে, যেখানে Guido van Rossum কাজ করেছিলেন বলে তিনি নিজে উল্লেখ করেছেন। মূল যুক্তি: brace-এর ভাষায় programmer যাইহোক indentation দেন, কারণ মানুষ চোখে block দেখে indentation দিয়েই। তাহলে compiler-ও সেটি দেখুক। এতে একটি পুরো শ্রেণির ভুল দূর হয়: যে কোড দেখতে if-এর ভেতরে, কিন্তু brace না থাকায় আসলে বাইরে। C-তে এমন ভুল বাস্তবে নিরাপত্তা-ত্রুটির কারণ হয়েছে, যেমন ২০১৪ সালে Apple-এর TLS কোডের “goto fail” ঘটনা, যেখানে একটি অতিরিক্ত লাইন indentation দেখে if-এর ভেতরে মনে হলেও আসলে সবসময় চলত।

ঝুঁকিও আছে। প্রথমত, ফাঁকা জায়গা অদৃশ্য: tab আর space মেশালে দুই editor-এ দুই রকম দেখায়। Python 3 এ জন্য অসংগত মেশানোকে TabError দিয়ে আটকায়। দ্বিতীয়ত, copy-paste বা email-এ indentation হারালে program-এর অর্থ নীরবে বদলাতে পারে, যেমন একটি লাইন লুপের বাইরে চলে গেলে। তৃতীয়ত, anonymous function বড় করে লেখা কঠিন: Python-এর lambda এক expression-এর বেশি নিতে পারে না, আর এর একটি কারণ হিসেবে প্রায়ই বলা হয়, indentation-এর syntax-এ বহু লাইনের expression বসানো কঠিন।

বিকল্প পথগুলোও আপস। Haskell আর F#-এ indentation ঐচ্ছিক নিয়ম (layout rule), চাইলে brace দেওয়া যায়। Go brace রেখেছে কিন্তু gofmt দিয়ে বিন্যাস একরকম করেছে, আর if-এর শরীরে brace বাধ্যতামূলক করেছে, ঠিক goto fail-এর মতো ভুল আটকাতে। Rust আর Swift-ও if-এ brace বাধ্যতামূলক করেছে। Haat একই পথে: block-এ { } সবসময় লাগে, আর reference-এর fmt command একটি নির্দিষ্ট বিন্যাসে লিখে দেয়।

পরিমাপের প্রশ্নও আছে: কোনটি সত্যিই বেশি পাঠযোগ্য, তা মত নয়, পরীক্ষার বিষয়; programming ভাষার syntax নিয়ে মানুষ-কেন্দ্রিক গবেষণা হয়েছে, কিন্তু এক কথায় চূড়ান্ত রায় দেওয়ার মতো নয়।

মূল উপলব্ধি: ভালো syntax মানুষের চোখ আর compiler-এর বোঝা একই রাখে। Python সেটি করে indentation-কে অর্থ দিয়ে, Go আর Haat করে brace বাধ্যতামূলক আর বিন্যাস যন্ত্রে ঠিক করে।

প্র ০৪Backward compatibility একটি ভাষাকে কীভাবে বাঁচায়, আবার কীভাবে বেঁধে রাখে?

একটি জনপ্রিয় ভাষার আসল সম্পদ তার ভাষা নয়, তাতে লেখা কোটি কোটি লাইনের কোড আর লাইব্রেরি। নতুন version পুরোনো কোড ভাঙলে প্রতিটি দলকে হিসাব করতে হয়: মেরামতের খরচ বনাম নতুন সুবিধা। তাই বেশিরভাগ ভাষা backward compatibility-কে প্রায় পবিত্র ধরে, আর এর দাম পুরোনো ভুলগুলোর সঙ্গে চিরকাল বাস করা।

কয়েকটি বাস্তব উদাহরণ। JavaScript-এ typeof null আজও "object", প্রথম বাস্তবায়নের একটি ভুল, যা ওয়েব ভেঙে যাওয়ার ভয়ে কখনো ঠিক করা হয়নি; ভাষাটির নকশার নীতিই “don't break the web”. Java 5 (২০০৪) generics যোগ করল type erasure দিয়ে: চলার সময় List<String> আর List<Integer> একই class, যাতে পুরোনো JVM আর পুরোনো লাইব্রেরি অপরিবর্তিত চলে; দাম হলো চলার সময় type-এর তথ্য হারানো (পর্ব ৩৭)। C++ বহু বছর ধরে C-র সঙ্গে প্রায়-সামঞ্জস্য রেখেছে, যা তার দ্রুত জনপ্রিয় হওয়ার একটি কারণ, আবার তার জটিলতার একটি বড় উৎসও।

উল্টো উদাহরণ Python 3 (২০০৮)। দলটি ইচ্ছা করে ভাঙল: print statement থেকে function, লেখা আর byte আলাদা type, আর পূর্ণসংখ্যার / এখন সত্যিকারের ভাগ। ফল ভাষার জন্য পরিষ্কার, কিন্তু রূপান্তর এক দশকের বেশি সময় নিল; Python 2.7-এর আনুষ্ঠানিক সমর্থন শেষ হয় ২০২০ সালে। এই অভিজ্ঞতার পর বহু ভাষা আরও সাবধানী পথ নেয়: Rust-এর “edition” (২০১৫, ২০১৮, ২০২১, ২০২৪) একই compiler-এ পুরোনো আর নতুন নিয়মের কোড পাশাপাশি চলতে দেয়, প্রতিটি crate নিজের edition বেছে নেয়।

নকশাকারীর শিক্ষা: প্রথম সংস্করণের সিদ্ধান্ত প্রায় স্থায়ী, তাই সন্দেহ হলে কম দিন, কারণ পরে যোগ করা যায় কিন্তু সরানো কঠিন। অংশ ৭-এর Haat-এর সিদ্ধান্তও এই যুক্তিতে: implicit conversion না দিয়ে শুরু করলে পরে স্পষ্ট conversion যোগ করা সহজ।

মূল উপলব্ধি: Compatibility ভাষার ব্যবহারকারীদের প্রতি একটি প্রতিশ্রুতি; প্রতিটি নতুন feature সেই প্রতিশ্রুতির ভবিষ্যৎ দায় বাড়ায়।

প্র ০৫Haat কেন ৬৪-বিট wrap বেছে নিল, Python-এর মতো বড় সংখ্যা বা Rust-এর debug-এর মতো panic নয়?

তিনটি বিকল্পই সঠিক নকশা হতে পারত, তাই প্রশ্নটি হলো Haat-এর লক্ষ্যের সঙ্গে কোনটি মেলে। Haat-এর প্রথম লক্ষ্য: অর্থ সম্পূর্ণ নির্ধারিত, যাতে tree-walking interpreter, bytecode VM আর পরে RISC-V ও WebAssembly back end একই ইনপুটে একই আউটপুট দেয়। দ্বিতীয়: বাস্তবায়ন সরল, বিশেষ করে code generation. তৃতীয়: পরিচিত।

Bigint (Python-এর পথ): গাণিতিকভাবে সবচেয়ে সৎ। কিন্তু RISC-V back end-এ একটি সাধারণ add নির্দেশের জায়গায় লাগত একটি পূর্ণ বড়-সংখ্যার লাইব্রেরি, heap-এ সংখ্যা রাখা, আর GC-র কাজ বাড়া; পর্ব ৭২-এর back end কয়েক গুণ জটিল হতো। WebAssembly-র i64.add-ও wrap করে, তাই সেখানেও একই সমস্যা। আর একটি Int-এর আকার আর স্থির থাকত না, যা register allocation-কেও জটিল করত।

Panic (Rust debug-এর পথ): reliability-তে সেরা: ভুল মান নীরবে চলে না। দাম: প্রতিটি যোগ, বিয়োগ, গুণের পরে একটি overflow পরীক্ষা আর শাখা; আর কোর্সের প্রতিটি optimization পর্বে (constant folding, strength reduction) মনে রাখতে হতো যে x * 2-কে x + x বা shift-এ বদলানোর সময় panic-এর অবস্থান আর ক্রম ঠিক রাখতে হবে। শেখার জন্য সেটি বাড়তি জটিলতা। তবে এটি একটি বৈধ বিকল্প, আর একটি অনুশীলন হিসেবে চমৎকার।

Wrap (Java আর Haat-এর পথ): নির্ধারিত, তাই differential testing কাজ করে; যন্ত্রের সাধারণ নির্দেশে সরাসরি বসে; Java, Go, WebAssembly-র নিয়মের সঙ্গে মেলে। এমনকি C-তে যা undefined, যেমন INT_MIN / -1, Haat-এ তাও wrap (reference-এর সিদ্ধান্ত ১৩)। দাম স্পষ্ট: অংশ ৪-এ Haat-এর 25! একটি অর্থহীন সংখ্যা দিয়েছে, কোনো সতর্কবার্তা ছাড়া। বাজারঘরের টাকার হিসাবে ৬৪ বিট (প্রায় ৯.২ × ১০১৮) যথেষ্ট বড়, তাই বাস্তব ঝুঁকি কম, কিন্তু শূন্য নয়।

মূল উপলব্ধি: একই প্রশ্নের “সেরা” উত্তর ভাষার লক্ষ্য থেকে আসে। Haat একটি compiler শেখার ভাষা, তাই নির্ধারিত আর সরল অর্থকে সর্বোচ্চ নিরাপত্তার ওপরে রেখেছে, আর সেটি স্পষ্ট করে লিখে রেখেছে।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি আউটপুট সত্যিকারের Python 3.14, Clang 22.1.8 বা Haat reference-এ চালিয়ে মেলানো।

  1. নকশা আর বাস্তবায়ন — x += e;: Haat-এ x += e; (আর -= *= /= %=) যোগ করতে চান। (ক) lexer, parser, AST, type checker আর back end-এ কী বদলাবে? (খ) সবচেয়ে কম কাজে এটি কীভাবে করা যায়? Python-এ AST-স্তরের রূপান্তরটি লিখুন। (গ) মাপকাঠিতে প্রস্তাবটির বিচার করুন।

    (ক) Lexer-এ পাঁচটি নতুন token (+= ইত্যাদি), longest match-এর নিয়মে +-এর আগে মেলাতে হবে। Parser-এ statement-এর নিয়মে নাম, তারপর এই token. Type checker-এ x = x op e-এর নিয়মই: x অবশ্যই var, আর op-এর type-নিয়ম মানতে হবে (+= Str-এও চলবে)। Back end-এ কিছু না, যদি নিচের কৌশল নেওয়া হয়।

    (খ) Desugaring: parser নতুন statement পড়ে সঙ্গে সঙ্গে পুরোনো node-এ বদলে দেয়, তাই বাকি সব অংশ অপরিবর্তিত। Haat-এ assignment-এর লক্ষ্য শুধু একটি নাম, তাই x দুবার পড়লেও কোনো side effect দুবার ঘটে না:

    from dataclasses import dataclass
    @dataclass
    class Var: name: str
    @dataclass
    class Num: value: int
    @dataclass
    class Binary: op: str; left: object; right: object
    @dataclass
    class Assign: name: str; value: object
    
    def desugar_compound(name, op_token, value):     # x op= e  ==>  x = x op e
        return Assign(name, Binary(op_token[0], Var(name), value))
    
    print(desugar_compound("total", "+=", Num(1250)))

    Python 3.14-এ চালানো ফল: Assign(name='total', value=Binary(op='+', left=Var(name='total'), right=Num(value=1250))). এখন বাজারঘরের লুপ total += 1250; লেখা যায়, আর এটি হুবহু total = total + 1250;. Error-এর অবস্থান যেন নতুন লেখার দিকেই দেখায়, তাই node-এ মূল line:col রাখতে হবে।

    (গ) Writability বাড়ে, readability প্রায় একই (পরিচিত চিহ্ন), reliability-তে ক্ষতি নেই কারণ এটি statement, expression নয় (C-র if (x += 1) সম্ভব নয়), আর খরচ খুব কম। একটি সতর্কতা: feature multiplicity বাড়ে, একই কাজের দুটি পথ। তুলনায় x++ যোগ করা বেশি ঝুঁকির, কারণ সেটি expression হলে C-র ++-এর পুরো জটিলতা আসে।

  2. ভুল খুঁজুন: একজন C programmer overflow ধরার জন্য লিখলেন int will_wrap(int a, int b) { return b > 0 && a + b < a; } আর বললেন, “CPU তো wrap করে, তাই overflow হলে a + b ছোট হয়ে যাবে, আর আমি ধরে ফেলব।” a = INT_MAX, b = 1 দিয়ে চালালে কী হতে পারে? ভুলটি কোথায়, আর সঠিক পরীক্ষা কী?

    Clang 22.1.8-এ সত্যিকারের run, পাশে একটি সঠিক সংস্করণ (will_wrap_good, যা যোগের আগে পরীক্ষা করে):

    -O0:  bad  = 1    good = 1
    -O2:  bad  = 0    good = 1
    
    will_wrap_bad at -O2 (x86-64):
    	xorl	%eax, %eax          # return 0
    	retq

    ভুলটি যুক্তিতে: “CPU wrap করে” কথাটি যন্ত্রের, ভাষার নয়। C17-এ signed overflow undefined, তাই optimizer ধরে নেয় a + b কখনো overflow করে না। তাহলে b > 0 হলে a + b > a সবসময়, অর্থাৎ a + b < a সবসময় মিথ্যা; পুরো function হয়ে যায় return 0. -O0-এ পরীক্ষাটি “কাজ করেছে”, যা ভুলটিকে আরও বিপজ্জনক করে: debug build-এর test পাস করবে, release build-এ পাহারা উধাও।

    সঠিক পথ: যোগের আগে পরীক্ষা, b > 0 && a > INT_MAX - b (ঋণাত্মক b-র জন্য b < 0 && a < INT_MIN - b), অথবা GCC/Clang-এর __builtin_add_overflow(a, b, &r), অথবা C23-এর ckd_add. বিকল্প হিসেবে -fwrapv দিয়ে wrap নির্ধারিত করা।

  3. হিসাব করুন: অংশ ৭-এর ওজন-পদ্ধতিতে একটি তৃতীয় লক্ষ্য যোগ করুন, “system ভাষা”: readability 0.2, writability 0.1, reliability 0.3, বাস্তবায়নের সরলতা 0.4. নম্বর একই রেখে A, B, C-র মোট নম্বর হাতে হিসাব করুন। কোন নকশা জেতে? তারপর বলুন, এমন হিসাবের সবচেয়ে বড় দুর্বলতা কী।

    মোট = Σ নম্বর × ওজন।

    • A: 4×0.2 + 2×0.1 + 5×0.3 + 5×0.4 = 0.8 + 0.2 + 1.5 + 2.0 = 4.5
    • B: 2×0.2 + 5×0.1 + 2×0.3 + 3×0.4 = 0.4 + 0.5 + 0.6 + 1.2 = 2.7
    • C: 5×0.2 + 3×0.1 + 5×0.3 + 4×0.4 = 1.0 + 0.3 + 1.5 + 1.6 = 4.4

    A জেতে (4.5), C সামান্য পেছনে (4.4); অংশ ৭-এর কোডে এই profile যোগ করে Python 3.14-এ চালালে একই সংখ্যা আসে: {'A-reject': 4.5, 'B-implicit': 2.7, 'C-explicit': 4.4}. বাস্তবায়নের সরলতার ওজন বেশি হলে “কিছুই না করা” এগিয়ে যায়, যা যুক্তিসংগত।

    সবচেয়ে বড় দুর্বলতা: নম্বরগুলো বিচার, মাপা তথ্য নয়; ০.১ পার্থক্যে রায় দেওয়া অর্থহীন। আর মাপকাঠিগুলো স্বাধীন নয় (readability আর reliability একসঙ্গে ওঠানামা করে), তাই যোগফল একই জিনিস দুবার গুনতে পারে। পদ্ধতিটির আসল মূল্য আলোচনাকে স্পষ্ট করা, সিদ্ধান্ত যন্ত্রের হাতে দেওয়া নয়।

  4. আউটপুট অনুমান করুন: কোর্সের Haat reference দিয়ে চালালে প্রতিটি কী ছাপবে, বা কোন error দেবে (অবস্থানসহ)? (ক) print(1 + 2 + "x"); (খ) var stock = 5; তারপর let low = stock < 10 < 20; (গ) let big = 9223372036854775807; print(big + 1); print(-7 / 2); print(-7 % 2); আর (ঘ) Python 3.14-এ print(-7 // 2, -7 % 2).

    সত্যিকারের run-এর ফল:

    (ক) 1:15: error: type mismatch: expected Int, found Str
    (খ) 2:22: error: comparison operators cannot be chained
    (গ) -9223372036854775808
        -3
        -1
    (ঘ) -4 1

    (ক) বাঁ দিক থেকে: 1 + 2 ঠিক আছে (Int), তারপর +-এর বাঁ পাশ Int, তাই ডান পাশকেও Int হতে হবে (reference-এর সিদ্ধান্ত ১১: বাঁ পাশ ঠিক করে ডান পাশ কী হবে)। "x" শুরু হয়েছে কলাম ১৫-এ। কিছুই ছাপা হয় না, কারণ type checker চালানোর আগেই থামায়। (খ) ভুল ধরা পড়ে দ্বিতীয় <-এ, কলাম ২২. (গ) wrap করে সবচেয়ে ছোট Int; / শূন্যের দিকে কাটে বলে −3; % ভাজ্যের চিহ্ন নেয় বলে −1. (ঘ) Python-এর // নিচের দিকে কাটে (−4), আর % ভাজকের চিহ্ন নেয় (1). একই চেহারার operator, দুই ভাষায় দুই নকশা-সিদ্ধান্ত।

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

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

ক্রমএকটি ভাষায় নতুন feature বিচার করার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. সমস্যা আর ব্যবহারকারী লিখে ফেলা
  2. ভাষার লক্ষ্য থেকে মাপকাঠি আর ওজন ঠিক করা
  3. “কিছুই না করা”-সহ কয়েকটি বিকল্প নকশা লেখা
  4. Lexer থেকে back end আর পুরোনো program পর্যন্ত প্রভাব হিসাব করা
  5. Prototype বানিয়ে test আর differential test চালানো
  6. সিদ্ধান্ত আর কারণ লিখে রাখা

C17-এ int x = INT_MAX; হলে x + 1 > x-এর মান কী?

  • সবসময় 0, কারণ x + 1 wrap করে ঋণাত্মক হয়
  • সবসময় 1, কারণ গণিতে x + 1 > x
  • নির্দিষ্ট মান নেই: signed overflow undefined behavior, তাই compiler আর optimization-ভেদে ফল আলাদা হতে পারে
  • ArithmeticException

একটি ভাষায় একই কাজের অনেকগুলো পথ (যেমন C-তে count = count + 1, count += 1, count++, ++count) থাকলে সাধারণত কোন মাপকাঠি সবচেয়ে বেশি ক্ষতিগ্রস্ত হয়?

  • Writability
  • Readability
  • Compile-এর গতি
  • Portability

Java 21-এ int big = Integer.MAX_VALUE; System.out.println(big + 1); কী ছাপে?

  • 2147483648
  • ArithmeticException: integer overflow
  • ফল JVM-ভেদে আলাদা, কারণ undefined
  • -2147483648

Option type (যেমন Rust-এর Option<T>, Kotlin-এর String?) null-এর সমস্যা কীভাবে কমায়?

  • “মান না-ও থাকতে পারে” কথাটি type-এ লিখে রাখে, তাই ব্যবহারের আগে সেই ক্ষেত্র সামলানো type checker বাধ্য করে
  • “না-থাকা” মানটিকে ভাষা থেকে পুরোপুরি মুছে দেয়
  • চলার সময় প্রতিটি reference পরীক্ষা করে exception দেয়
  • Garbage collection চালু করে

Haat (spec v1)-এ let total = 996; print("total: " + total); চালালে কী হয়?

  • ছাপে total: 996
  • চালানোর আগেই type error: expected Str, found Int
  • চলার সময় runtime error
  • Str-কে Int-এ বদলে যোগ করে

C-তে if (stock = 0) লিখলে কী হয়, আর Python বা Haat এই ভুল কীভাবে আটকায়?

  • C compile error দেয়, তাই কোনো ভাষারই কিছু করার দরকার নেই
  • C stock-কে 0-এর সঙ্গে তুলনা করে
  • C-তে stock-এ 0 বসে আর শর্ত মিথ্যা হয়; Python আর Haat-এ assignment একটি statement, তাই এটি syntax error
  • Python এটিকে নিজে থেকে := বলে ধরে নেয়

শব্দকোষ

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

মনে রাখুন

  1. ভাষা বিচারের চার মাপকাঠি: readability, writability, reliability আর খরচ; এদের পেছনে সরলতা, orthogonality, data type, syntax আর type checking. একটি বাড়ালে আরেকটি প্রায়ই কমে।
  2. Integer overflow-এর চার উত্তর: wrap (Java, Haat, Rust release), trap বা panic (Rust debug), বড় সংখ্যা (Python), আর undefined behavior (C-র signed int), যেখানে একই source -O0 আর -O2-এ আলাদা ফল দেয়।
  3. নিরাপত্তার প্রতিটি পাহারার দাম আছে: bounds check, option type (null-এর বদলে), exception বা error value, GC বা ownership; প্রশ্ন হলো প্রমাণের দায় কে, কখন নেবে।
  4. Syntax-ও নকশা: C-র assignment-expression, Python-এর indentation, JavaScript-এর ASI; নিরাপদ নকশা মানুষের চোখ আর compiler-এর বোঝা এক রাখে।
  5. Haat নির্ধারিত আর সরল অর্থ বেছে নিয়েছে: let/var, annotate করা function type, কোনো implicit conversion বা null নেই, ৬৪-বিট wrap, শিকলহীন comparison, assignment statement.

পরের পর্বে: মডিউল ১ এখানেই শেষ। মডিউল ২-এ programming paradigm শুরু হবে পর্ব ০৭ দিয়ে (Imperative আর procedural programming — state আর command): Haat যে imperative ধাঁচের ভাষা, তার মূল ধারণা state, command আর procedure.

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

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