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

Imperative আর procedural programming — state আর command

Imperative and Procedural Programming — State, Assignment, Control Flow and Procedures

Taught in Bangla, this lesson presents imperative programming as commands that change state, grounded in the von Neumann machine where assignment writes memory and loops jump back. It writes state as a table with rules for assignment and sequencing, traces a Haat program line by line, and covers goto, structured programming, Böhm–Jacopini and Dijkstra, showing how compilers lower loops to jumps. A district order total runs in C and Python, giving 2126, and in-page Python shows side effects and aliasing.

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

  • Imperative আর procedural paradigm-এর মূল উপাদান চেনা: state, assignment, sequencing, শর্ত, loop আর procedure
  • State-কে variable থেকে মানের একটি টেবিল হিসেবে লেখা, আর assignment ও sequencing-এর নিয়ম গাণিতিকভাবে লেখা
  • goto আর structured loop-এর পার্থক্য, Böhm–Jacopini আর Dijkstra-র ইতিহাস, আর compiler কীভাবে loop-কে লাফে নামায়
  • একটি বাস্তব কাজকে procedure-এ ভাগ করা, আর একই কাজ C, Python আর Haat-এ চালিয়ে উত্তর মেলানো
  • Side effect আর aliasing চেনা, আর AI-এর লেখা imperative কোড যাচাই করার উপায়

১ · Imperative মানে: আদেশ দিয়ে state বদলানো

মডিউল ২-এ আমরা প্রোগ্রামিং ভাষার প্রধান “ধাঁচ” একে একে দেখব। এমন একটি মৌলিক ধাঁচকে বলে programming paradigm. পর্ব ০২-এ (প্রোগ্রামিং ভাষার ইতিহাস আর পরিবার) ভাষার পরিবারগুলোর জন্ম দেখেছেন; এবার প্রতিটি পরিবারের ভেতরের চিন্তাটা খুলে দেখার পালা। শুরু করছি সবচেয়ে পুরোনো আর সবচেয়ে পরিচিত ধাঁচ দিয়ে।

মায়ের রান্নার খাতার একটি রেসিপি ভাবুন: “হাঁড়িতে তেল দিন। পেঁয়াজ দিন। বাদামি হলে মসলা দিন। পানি ফুটলে চাল দিন। পানি শুকানো পর্যন্ত নাড়তে থাকুন।” প্রতিটি লাইন একটি আদেশ. প্রতিটি আদেশ হাঁড়ির অবস্থা একটু বদলায়। কোন আদেশ আগে, কোনটি পরে, তা খুব গুরুত্বপূর্ণ: চাল আগে দিয়ে তারপর তেল দিলে অন্য জিনিস তৈরি হবে। আর “শুকানো পর্যন্ত নাড়তে থাকুন” একটি loop. Imperative programming ঠিক এমন রেসিপি লেখা।

এবার নির্দিষ্ট করে বলি। Imperative programming-এ program হলো আদেশের (command, বা statement) একটি ক্রম। “Imperative” শব্দটি ব্যাকরণের: “imperative mood” মানে আদেশসূচক বাক্য, যেমন “দিন”, “লিখুন”। প্রতিটি আদেশ program-এর state বদলায়। State মানে এই মুহূর্তে সব variable-এর মান, আর বড় অর্থে মেমরি, খোলা ফাইল আর পর্দার লেখাও। একটি imperative program-এর অর্থ তাই এক কথায়: “শুরুর state থেকে কোন ধাপে কোন state-এ পৌঁছায়।”

এর পাশে আরেকটি বড় ধাঁচ আছে, declarative programming: সেখানে আপনি বলেন “কী চাই”, “কীভাবে করতে হবে” নয়। SQL-এর SELECT SUM(total) FROM orders WHERE district = 'Dhaka' একটি declarative অনুরোধ; কোন ক্রমে সারি পড়া হবে, কোন index ব্যবহার হবে, তা database নিজে ঠিক করে। Functional programming (পর্ব ০৯) আর logic programming (পর্ব ১০) এই দিকের দুটি বড় পরিবার। Imperative কোডে কিন্তু “কীভাবে” লেখার দায় পুরোটাই আপনার।

Procedural programming হলো imperative ধাঁচের একটি সংগঠিত রূপ: আদেশগুলোকে নাম দেওয়া ছোট ছোট procedure-এ (function, subroutine) ভাগ করা, আর বড় কাজকে সেই procedure-গুলোর ডাক দিয়ে লেখা। FORTRAN, ALGOL, Pascal আর C এই ধাঁচের ক্লাসিক ভাষা। আজকের Python, Java বা JavaScript-ও ভেতরে imperative; তাদের object-oriented আর functional দিকগুলো এই ভিত্তির ওপর বসানো (পর্ব ০৮, ০৯, ১৩)।

উপাদানরেসিপিতেHaat-এযন্ত্রে
Stateহাঁড়ির এখনকার অবস্থাvar আর let-এর মানমেমরি আর register-এর মান
Assignment“লবণ দিন”total = total + 1250;মেমরির ঘরে লেখা (store)
Sequencing (ক্রম)লাইনের পর লাইন; দিয়ে আলাদা statementprogram counter এগোয়
Selection (শর্ত)“বাদামি হলে …”if … elseশর্তসাপেক্ষ লাফ
Iteration (loop)“শুকানো পর্যন্ত নাড়ুন”whileপেছনে লাফ
Procedure“ভাত রান্না” নামে আলাদা রেসিপিfncall আর return, stack frame

এই পর্বের পুরো সময় একটি কাজ আমাদের সঙ্গে থাকবে; মডিউল ২-এর প্রতিটি পর্বে একই কাজ আলাদা ধাঁচে লেখা হবে, যাতে তুলনা সহজ হয়। কাজটি বাজারঘরের: কয়েকটি অর্ডার আছে, প্রতিটি অর্ডারে কয়েকটি লাইন (পণ্য, পরিমাণ, একক দাম)। প্রতিটি লাইনের দাম হিসাব করুন, অর্ডারের মোট ১০০০ টাকা বা বেশি হলে ১০% ছাড় দিন, শুধু একটি জেলার অর্ডার রাখুন, আর সেগুলোর যোগফল বের করুন। আমাদের চারটি অর্ডার:

অর্ডারজেলালাইন (পরিমাণ × একক দাম)মোটছাড়ের পরে
১Dhakarice ২ × ৫২০১০৪০৯৩৬
২Rajshahilentil ৩ × ১২০, oil ১ × ১৮০৫৪০৫৪০
৩Dhakasugar ৪ × ১৫০, tea ২ × ২৫০১১০০৯৯০
৪Dhakasalt ৫ × ৪০২০০২০০

Dhaka-র তিনটি অর্ডার মিলিয়ে ৯৩৬ + ৯৯০ + ২০০ = ২১২৬ টাকা। ছাড় হিসাব হয় Haat-এর নিয়মে, পূর্ণসংখ্যার ভাগে: total - total / 10. অংশ ৬-এ এই উত্তর C আর Python দুই ভাষায় সত্যিই চালিয়ে মেলাব, আর অংশ ৫-এ Haat-এ।

২ · পেছনের যন্ত্র: von Neumann মডেল

Imperative ধাঁচ এত স্বাভাবিক লাগে কেন? কারণ আমাদের কম্পিউটার নিজেই এভাবে কাজ করে। ১৯৪৫ সালে John von Neumann EDVAC নামের একটি কম্পিউটারের নকশা নিয়ে একটি খসড়া প্রতিবেদন (“First Draft of a Report on the EDVAC”) লেখেন। সেখান থেকে যে নকশা ছড়ায়, তাকে বলে von Neumann architecture; যদিও ধারণাগুলোর পেছনে Eckert, Mauchly-সহ পুরো দলের অবদান ছিল, আর নামকরণ নিয়ে ইতিহাসবিদদের মধ্যে বিতর্ক আছে। মূল কথা: নির্দেশ (program) আর ডেটা একই মেমরিতে থাকে, আর CPU একটি একটি করে নির্দেশ এনে চালায়। হার্ডওয়্যারের দিক থেকে পুরো ছবি আছে Computer Architecture কোর্সের পর্ব ০১-এ; এখানে দেখব ভাষার চোখে।

ছবি ৭.১ — von Neumann যন্ত্র আর imperative ভাষার মিল

Program আর data একই মেমরিতে; CPU একবারে একটি নির্দেশ চালায়, আর মাঝের bus দিয়ে একবারে একটি word আসা-যাওয়া করে।

von Neumann machine: CPU with PC, ALU and register above, one memory holding program and data below, connected by a bus CPU PC = 7 ALU 936 + 990 register 1926 bus: একবারে এক word মেমরি — program আর data একসঙ্গে sum = 1926 t = 990 … 6: if t ≥ 1000 {…} 7: sum = sum + t 8: print(sum)
ছবি ৭.১ — program counter (PC) = 7, অর্থাৎ এখন ৭ নম্বর নির্দেশ চলছে। CPU মেমরি থেকে sum (936) আর t (990) পড়ে, ALU যোগ করে, আর ফল 1926 আবার sum-এর ঘরে লেখে। ছবিটি লেখার ঠিক পরের অবস্থা; পরের মুহূর্তে PC হবে 8.

ছবিটি থেকে imperative ভাষার প্রতিটি উপাদানের যান্ত্রিক অর্থ পড়া যায়:

  • Variable = মেমরির একটি নাম দেওয়া ঘর। sum নামটি আসলে একটি ঠিকানার ডাকনাম, যেমন পোস্ট অফিসের ঠিকানায় “করিম সাহেবের বাসা” মানে আসলে একটি নির্দিষ্ট বাড়ি নম্বর।
  • Assignment = সেই ঘরে নতুন মান লেখা। পুরোনো মান মুছে যায়; ঘরটির কোনো স্মৃতি থাকে না।
  • Sequencing = PC-র এক ধাপ এগোনো। “পরের লাইন” কথাটির যান্ত্রিক রূপ।
  • শর্ত আর loop = PC-তে অন্য ঠিকানা বসানো (লাফ)। হার্ডওয়্যারে if আর while বলে কিছু নেই, আছে শুধু শর্তসাপেক্ষ আর শর্তহীন লাফ; assembly-তে তার রূপ দেখতে পারেন Computer Architecture কোর্সের পর্ব ২৯-এ.

এই মিল কাকতালীয় নয়। প্রথম দিকের উচ্চ-স্তরের ভাষাগুলো, বিশেষ করে ১৯৫৭ সালের FORTRAN, তৈরিই হয়েছিল যন্ত্রের এই মডেলকে একটু সহজ ভাষায় লেখার জন্য। তাই imperative কোড compiler-এর পক্ষে যন্ত্রের নির্দেশে নামানো তুলনামূলক সোজা, আর এটিই এই ধাঁচের টিকে থাকার একটি বড় কারণ।

মজার ব্যাপার, এই ধাঁচের সবচেয়ে বিখ্যাত সমালোচক ছিলেন FORTRAN-এর স্রষ্টা নিজেই। John Backus ১৯৭৭ সালে Turing Award বক্তৃতায় (১৯৭৮ সালে Communications of the ACM-এ প্রকাশিত, শিরোনাম “Can Programming Be Liberated from the von Neumann Style?”) বলেন, CPU আর মেমরির মাঝের সরু পথটি একটি “bottleneck”: program একবারে একটি word আনা-নেওয়ায় ব্যস্ত থাকে, আর ভাষাগুলোও প্রোগ্রামারকে সেই একটি-একটি-word-এর চিন্তায় আটকে রাখে। এই ধারণাটির নাম von Neumann bottleneck. Backus বিকল্প হিসেবে FP নামের একটি functional ভাষার প্রস্তাব দেন; সেই গল্প পর্ব ০৯-এ।

৩ · State, assignment আর sequencing — নিয়মে লেখা

এবার state-কে একটু গাণিতিক করে লিখি; পরের অনেক পর্বে (semantics, interpreter, optimization) এই নোটেশন কাজে লাগবে। একটি state σ (গ্রিক অক্ষর “সিগমা”) হলো variable-এর নাম থেকে মানের একটি টেবিল, যেমন σ = {sum ↦ 0, t ↦ 1040}. এখানে “↦” পড়ুন “এর মান”। ⟦e⟧σ লিখলে বোঝায়: state σ-তে expression e-এর মান। যেমন ওপরের σ-তে ⟦t / 10⟧σ = 104.

একটি expression state পড়ে একটি মান দেয়; একটি statement state নিয়ে নতুন একটি state দেয়। এই দুই ভূমিকার পার্থক্যই imperative ভাষার মূল কথা। Haat-এ assignment একটি statement, expression নয় (reference বাস্তবায়নের নকশা-সিদ্ধান্ত ৯): x = e; কোনো মান ফেরত দেয় না, শুধু state বদলায়। C-তে কিন্তু x = 5 নিজেই একটি expression, যার মান 5; তাই C-তে a = b = 5 লেখা যায়, আর if (x = 0)-এর মতো বিখ্যাত ভুলও করা যায় (পর্ব ০৩-এ, Syntax, semantics আর pragmatics, এর আলোচনা আছে)।

সংজ্ঞা ৭.১ — imperative statement-এর অর্থ (state থেকে state)

Assignment: ⟦x = e⟧(σ) = σ[x ↦ ⟦e⟧σ]. এখানে σ[x ↦ v] মানে “σ-এর মতোই একটি টেবিল, শুধু x-এর ঘরে v”.

Sequencing: ⟦S1 S2⟧(σ) = ⟦S2⟧(⟦S1⟧(σ)). আগে S1 চলে, তার ফলের state-এর ওপর S2.

শর্ত: ⟦if b { S }⟧(σ) = ⟦S⟧(σ) যদি ⟦b⟧σ = true, নইলে σ অপরিবর্তিত।

Loop: ⟦while b { S }⟧(σ) = ⟦while b { S }⟧(⟦S⟧(σ)) যদি ⟦b⟧σ = true, নইলে σ. খেয়াল করুন, সংজ্ঞার ডান দিকে আবার while আছে: loop-এর অর্থ নিজের ওপর নির্ভরশীল একটি সমীকরণ। এর সমাধান কীভাবে নিশ্চিত হয়, তা পর্ব ৪১-এ (Denotational semantics) আসবে।

একই নিয়ম inference rule আকারেও লেখা যায়, যেমন পর্ব ০৪-এ T-diagram-এর নিয়ম লিখেছিলাম। ⟨S, σ⟩ ⇓ σ′ পড়ুন: “state σ থেকে statement S চালালে শেষে state σ′ পাওয়া যায়”, আর ⟨e, σ⟩ ⇓ v মানে “σ-তে e-এর মান v”. দাগের ওপরে শর্ত (premise), নিচে সিদ্ধান্ত (conclusion):

⟨e, σ⟩ ⇓ v(Assign)
⟨x = e;, σ⟩ ⇓ σ[x ↦ v]
⟨S1, σ⟩ ⇓ σ′⟨S2, σ′⟩ ⇓ σ″(Seq)
⟨S1 S2, σ⟩ ⇓ σ″

এই পুরো ধারণার পূর্ণ গণিত, small-step আর big-step, আসবে পর্ব ৪০-এ (Operational semantics). আপাতত হাতে-কলমে দেখি। নিচের Haat program-এ অর্ডার ১ আর ৩-এর ছাড়ের পরের দাম যোগ হচ্ছে, কোনো function ছাড়াই। প্রতিটি ধাপে state টেবিলটি দেখুন।

1var sum = 0;2var t = 2 * 520;3if t >= 1000 { t = t - t / 10; }4sum = sum + t;5t = 4 * 150 + 2 * 250;6if t >= 1000 { t = t - t / 10; }7sum = sum + t;8print(sum);
এই ধাপের পরে state σ
sum
t
বদল
  1. নতুন ঘর। var sum = 0; state-এ একটি নতুন variable যোগ করে: σ = {sum ↦ 0}. var মানে পরে বদলানো যাবে।
  2. আরেকটি ঘর। ডান দিকের expression আগে হিসাব হয়: 2 × 520 = 1040. তারপর t-এর ঘর তৈরি হয়: σ = {sum ↦ 0, t ↦ 1040}.
  3. শর্ত সত্য। 1040 ≥ 1000, তাই block-এর ভেতরের assignment চলে। ডান দিকে পুরোনো t পড়া হয়: 1040 − 1040 / 10 = 1040 − 104 = 936. তারপর t-এর ঘরে 936 লেখা হয়; 1040 আর কোথাও নেই।
  4. জমা। sum = sum + t;: ডান দিকের sum (0) আর t (936) পড়া, যোগ 936, তারপর বাঁ দিকের sum-এর ঘরে লেখা। একই নাম দুই দিকে, কিন্তু ভূমিকা আলাদা।
  5. ঘরের পুনর্ব্যবহার। অর্ডার ৩-এর মোট: 600 + 500 = 1100. একই t ঘরে নতুন মান; আগের 936-এর আর দরকার নেই, কারণ সেটি sum-এ জমা হয়ে গেছে।
  6. আবার শর্ত। 1100 ≥ 1000, তাই ছাড়: 1100 − 110 = 990. লাইন ৩ আর ৬ হুবহু এক লেখা, কিন্তু state আলাদা বলে ফলও আলাদা। Imperative কোডে একটি লাইনের অর্থ বুঝতে state জানতে হয়।
  7. দ্বিতীয় জমা। 936 + 990 = 1926 sum-এর ঘরে।
  8. আউটপুট। print(sum); state বদলায় না, শুধু বাইরের দুনিয়ায় (পর্দায়) 1926 লেখে। এটিও এক ধরনের side effect, অংশ ৭-এ আসবে। Haat reference-এর interpreter আর VM দুটিই এই program-এ 1926 ছাপে।

Stepper-এর একটি সূক্ষ্ম বিষয় আলাদা করে বলা দরকার। sum = sum + t-এ বাঁ দিকের sum মানে “ঘরটি” (ঠিকানা), আর ডান দিকের sum মানে “ঘরের ভেতরের মান”। প্রথমটিকে বলে l-value (left value, যেখানে লেখা যায়), দ্বিতীয়টিকে r-value (right value, শুধু মান)। গণিতের x = x + 1 কখনো সত্য নয়, কিন্তু imperative ভাষায় এটি একটি সম্পূর্ণ বৈধ আদেশ, কারণ “=” এখানে সমতা নয়, “লেখো” অর্থে। এজন্য ALGOL আর Pascal assignment-এর জন্য আলাদা চিহ্ন := ব্যবহার করত।

Stepper-এর প্রতিটি ধাপ নিচের কোড দিয়ে মেলানো। এটি সংজ্ঞা ৭.১-এর সরাসরি বাস্তবায়ন, ব্রাউজারের Python-এ (Pyodide). Node-এর নাম Haat reference-এর ast_nodes.py-এর মতো (Num, Var, Binary, Let, Assign, If), তবে ক্ষেত্র কম রাখা হয়েছে। লক্ষ করুন, ex কখনো পুরোনো state বদলায় না; প্রতিবার নতুন টেবিল বানায়, ঠিক σ[x ↦ v]-এর মতো।

from collections import namedtuple as node
Num, Var = node("Num", "value"), node("Var", "name")
Binary = node("Binary", "op left right")
Let = node("Let", "name init")          # var x = e;   (simplified Let)
Assign = node("Assign", "name value")   # x = e;
If = node("If", "cond then")            # if cond { then }
def tdiv(a, b):                         # Haat '/': truncate toward 0
    q = abs(a) // abs(b)
    return q if (a >= 0) == (b >= 0) else -q
OPS = {"+": lambda a, b: a + b, "-": lambda a, b: a - b,
       "*": lambda a, b: a * b, "/": tdiv, ">=": lambda a, b: a >= b}
def ev(e, s):                           # expression: (e, state) -> value
    if isinstance(e, Num): return e.value
    if isinstance(e, Var): return s[e.name]
    return OPS[e.op](ev(e.left, s), ev(e.right, s))
def ex(st, s):                          # command: state -> new state
    if isinstance(st, If):
        for inner in (st.then if ev(st.cond, s) else []):
            s = ex(inner, s)
        return s
    e = st.init if isinstance(st, Let) else st.value
    return {**s, st.name: ev(e, s)}     # s[x := value]; old s untouched
t = Var("t")
disc = Assign("t", Binary("-", t, Binary("/", t, Num(10))))
prog = [Let("sum", Num(0)), Let("t", Binary("*", Num(2), Num(520))),
        If(Binary(">=", t, Num(1000)), [disc]),
        Assign("sum", Binary("+", Var("sum"), t)),
        Assign("t", Binary("+", Binary("*", Num(4), Num(150)),
                                Binary("*", Num(2), Num(250)))),
        If(Binary(">=", t, Num(1000)), [disc]),
        Assign("sum", Binary("+", Var("sum"), t))]
s = {}
for i, st in enumerate(prog, 1):
    s = ex(st, s); print(i, type(st).__name__.ljust(6), s)
print("print(sum) ->", s["sum"])

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

1 Let    {'sum': 0}
2 Let    {'sum': 0, 't': 1040}
3 If     {'sum': 0, 't': 936}
4 Assign {'sum': 936, 't': 936}
5 Assign {'sum': 936, 't': 1100}
6 If     {'sum': 936, 't': 990}
7 Assign {'sum': 1926, 't': 990}
print(sum) -> 1926

প্রতিটি সারি stepper-এর একটি ধাপ: statement-এর ধরন আর তার পরের state. ev হলো ⟦e⟧σ, আর ex হলো ⟦S⟧, যা state নিয়ে নতুন state দেয়। নিচের for loop-টি নিজেই sequencing-এর নিয়ম: আগের statement-এর ফল-state পরের statement-এর ইনপুট। এটি একটি ছোট tree-walking interpreter-এর মূল অংশ; পূর্ণটি (wrap-করা Int, function, scope, runtime error সহ) Haat reference-এর interp.py-তে, আর পর্ব ৫৬-এ সেটি ধাপে ধাপে বানাবেন। এখানে সংখ্যা ছোট, তাই ৬৪-বিট wrap বাদ রাখা হয়েছে। এই কোডে while নেই; অনুশীলন ১-এ আপনি নিজে যোগ করবেন।

দাবি ৭.২ — তৃতীয় variable ছাড়া অদলবদল

Haat-এ a = a + b; b = a - b; a = a - b; চালালে a আর b-এর মান অদলবদল হয়, যেকোনো Int মানের জন্য।

প্রমাণ: শুরুর state σ0 = {a ↦ A, b ↦ B}. সংজ্ঞা ৭.১-এর Assignment আর Sequencing নিয়ম পরপর প্রয়োগ করি; Haat-এর Int ২৬৪ দিয়ে ভাগশেষের হিসাবে wrap করে, তাই সব যোগ-বিয়োগ সেই হিসাবে (mod 264).

  1. σ1 = σ0[a ↦ A + B] = {a ↦ A + B, b ↦ B}.
  2. σ2 = σ1[b ↦ (A + B) − B] = {a ↦ A + B, b ↦ A}.
  3. σ3 = σ2[a ↦ (A + B) − A] = {a ↦ B, b ↦ A}.
  4. mod 264-এর যোগ-বিয়োগও সাধারণ যোগ-বিয়োগের মতো সাজানো আর কাটাকাটি করা যায়, তাই মাঝপথে overflow হলেও ধাপ ২ আর ৩-এর সরলীকরণ ঠিক থাকে। ∎

Haat reference-এ a = 9223372036854775807 (সবচেয়ে বড় Int), b = 1 দিয়ে চালানো হয়েছে: মাঝপথে a হয় −9223372036854775808 (wrap), কিন্তু শেষে a = 1, b = 9223372036854775807. C17-এ int দিয়ে একই কৌশল নিরাপদ নয়: signed overflow সেখানে undefined behavior, তাই প্রমাণের ধাপ ৪-এর ভিত্তিই নেই। একই তিন লাইন, দুই ভাষায় দুই রকম নিশ্চয়তা।

৪ · Control flow: goto থেকে structured programming

কোন statement-এর পর কোনটি চলবে, সেই পুরো ব্যবস্থার নাম control flow. যন্ত্রের স্তরে এর একটিই হাতিয়ার: লাফ। প্রথম দিকের উচ্চ-স্তরের ভাষাগুলোও সেই হাতিয়ার সরাসরি দিত: FORTRAN-এ GO TO 30, BASIC-এ GOTO 100, আর C-তে আজও goto আছে। নিচে একই loop-এর goto রূপ, C-র ধাঁচে লেখা, ধাপে ধাপে চালিয়ে দেখুন। সংখ্যা ছোট রাখতে সীমা ২৫০০ টাকা।

1total = 0; rounds = 0;2top: if (total >= 2500) goto done;3  total = total + 1250;4  rounds = rounds + 1;5  goto top;6done: printf(total, rounds);
এই ধাপের পরে
total
rounds
লাফ
while রূপে
  1. শুরু। দুটি variable-এ 0. Structured রূপে এটি var total = 0; var rounds = 0;
  2. পরীক্ষা। 0 ≥ 2500 মিথ্যা, তাই goto done হয় না; PC স্বাভাবিকভাবে পরের লাইনে যায়। খেয়াল করুন, goto রূপে শর্তটি উল্টো: “শেষ হবে কখন”, আর while-এ লেখা হয় “চলবে কখন” (total < 2500).
  3. শরীর, প্রথমবার। total = 0 + 1250 = 1250.
  4. গোনা। rounds = 1.
  5. পেছনে লাফ। goto top PC-তে লাইন ২-এর ঠিকানা বসায়। Structured রূপে এটি while-এর শরীরের শেষ বন্ধনী: কোনো লেখা নেই, কিন্তু এখানেই লাফ লুকিয়ে আছে।
  6. আবার পরীক্ষা। 1250 ≥ 2500 মিথ্যা, তাই আবার শরীরে।
  7. শরীর, দ্বিতীয়বার। total = 2500.
  8. গোনা। rounds = 2.
  9. আবার পেছনে লাফ। লাইন ২-এ ফেরা।
  10. বেরোনোর লাফ। 2500 ≥ 2500 সত্য, তাই goto done: PC সরাসরি লাইন ৬-এ। while রূপে এটি শর্ত মিথ্যা হয়ে loop থেকে বেরোনো।
  11. আউটপুট। 2500 আর 2. মোট ৩টি লাফ হলো: ২ বার পেছনে, ১ বার বাইরে। এই ছোট program-এ goto পড়া কঠিন নয়; সমস্যা শুরু হয় যখন দশটা label আর বিশটা goto একে অপরকে কাটাকাটি করে।

শেষ ধাপের কথাটিই ১৯৬০-এর দশকের বড় সমস্যা ছিল। বড় program-এ goto যখন যেকোনো জায়গা থেকে যেকোনো জায়গায় লাফ দেয়, তখন control flow-এর ছবি দেখতে হয় এক থালা নুডলসের মতো; এই কোডকে ঠাট্টা করে বলা হয় “spaghetti code”. একটি লাইন পড়ে বোঝা যায় না, এখানে কোন কোন পথ দিয়ে আসা যায়, তাই সেখানে state কী থাকতে পারে, তা-ও বলা যায় না।

দুটি বড় ফল: Böhm–Jacopini আর Dijkstra

১৯৬৬ সালে Corrado Böhm আর Giuseppe Jacopini Communications of the ACM-এ দেখান, যেকোনো flowchart-এর program শুধু তিনটি গঠন দিয়ে লেখা যায়: ক্রম (একটির পর আরেকটি), নির্বাচন (if-else) আর পুনরাবৃত্তি (while). ফলটি সাধারণত Böhm–Jacopini theorem নামে পরিচিত। একটি শর্ত আছে: কখনো কখনো কয়েকটি বাড়তি Boolean variable (flag) লাগে, যেগুলো মনে রাখে “এখন কোন অংশে আছি”। তাই goto সরানো সবসময় সম্ভব, কিন্তু সবসময় সুন্দর নয়।

দুই বছর পরে, ১৯৬৮ সালের মার্চে, Edsger W. Dijkstra একই পত্রিকায় একটি ছোট চিঠি লেখেন, যা “Go To Statement Considered Harmful” শিরোনামে বিখ্যাত। Dijkstra নিজে পরে লিখেছেন, শিরোনামটি তাঁর দেওয়া নয়; পত্রিকার তখনকার সম্পাদক Niklaus Wirth চিঠিটি দ্রুত ছাপতে শিরোনাম বদলে দেন। তাঁর যুক্তি ছিল: program চলার সময় কী ঘটছে, তা আমরা বুঝি লেখার গঠন থেকে; goto সেই গঠন আর চলার পথের মিল ভেঙে দেয়। এর পরের আন্দোলনই structured programming: প্রতিটি গঠনের একটি প্রবেশপথ আর একটি বেরোনোর পথ, যাতে প্রতিটি অংশ আলাদা করে বোঝা আর প্রমাণ করা যায়।

goto কি পুরো মারা গেছে? না। Donald Knuth ১৯৭৪ সালে “Structured Programming with go to Statements” প্রবন্ধে দেখান, কিছু জায়গায় নিয়ন্ত্রিত goto কোডকে সহজ আর দ্রুত করে। আজকের C-তে error হলে খোলা resource বন্ধ করার জন্য একটি “cleanup” label-এ goto একটি প্রচলিত কৌশল, Linux kernel-এর মতো বড় প্রকল্পেও (C কোর্সের পর্ব ৩০, এরর হ্যান্ডলিং)। আধুনিক ভাষাগুলো বরং goto-র “ভদ্র” রূপ দেয়: break, continue, আগেভাগে return আর exception. Java-তে goto একটি reserved keyword, কিন্তু ভাষায় এর কোনো ব্যবহার নেই; Python-এ goto নেই। Haat v1-এ break-ও নেই, শুধু while আর return. পুরো আলোচনা পর্ব ২৭-এ (Control flow — selection, iteration, goto আর structured programming).

সত্যিকারের run — compiler আবার goto-তেই নামায়

একটি মজার উল্টো দিক আছে। প্রোগ্রামারের কাছ থেকে goto সরানো হলো, কিন্তু যন্ত্রে তো লাফ ছাড়া কিছু নেই। তাই compiler-কে প্রতিটি while আবার লাফে নামাতে হয়। নিচে stepper-এর loop-টি Haat-এ লিখে কোর্সের Haat reference বাস্তবায়নের bytecode compiler দিয়ে দেখা হলো (সত্যিকারের run, CPython 3.14.4-এ; haat.py মানে reference-এর command line):

var total = 0;
var rounds = 0;
while total < 2500 {
    total = total + 1250;
    rounds = rounds + 1;
}
print(total);
print(rounds);
~/haat $ python haat.py run loop.haat
2500
2
~/haat $ python haat.py dis loop.haat
== <main> (arity 0, locals 0) ==
   0  CONST          0     ; 0
   1  DEFINE_GLOBAL  0     ; total
   2  CONST          0     ; 0
   3  DEFINE_GLOBAL  1     ; rounds
   4  LOAD_GLOBAL    0     ; total
   5  CONST          1     ; 2500
   6  LT
   7  JUMP_IF_FALSE  17
   8  LOAD_GLOBAL    0     ; total
   9  CONST          2     ; 1250
  10  ADD
  11  STORE_GLOBAL   0     ; total
  12  LOAD_GLOBAL    1     ; rounds
  13  CONST          3     ; 1
  14  ADD
  15  STORE_GLOBAL   1     ; rounds
  16  JUMP           4
  17  LOAD_GLOBAL    0     ; total
  18  PRINT
  19  LOAD_GLOBAL    1     ; rounds
  20  PRINT
  21  CONST          4     ; ()
  22  RETURN

একই loop Python 3.14-এ লিখে CPython-এর নিজের dis দিয়ে দেখা (সত্যিকারের run, CPython 3.14.4; শুরুর RESUME আর দুটি শূন্য বসানোর লাইন বাদ):

def count_rounds(limit):
    total = 0
    rounds = 0
    while total < limit:
        total = total + 1250
        rounds = rounds + 1
    return rounds

  5   L1:     LOAD_FAST_BORROW_LOAD_FAST_BORROW 16 (total, limit)
              COMPARE_OP              18 (bool(<))
              POP_JUMP_IF_FALSE       21 (to L2)
              NOT_TAKEN
  6           LOAD_FAST_BORROW         1 (total)
              LOAD_CONST               1 (1250)
              BINARY_OP                0 (+)
              STORE_FAST               1 (total)
  7           LOAD_FAST_BORROW         2 (rounds)
              LOAD_SMALL_INT           1
              BINARY_OP                0 (+)
              STORE_FAST               2 (rounds)
              JUMP_BACKWARD           26 (to L1)
  8   L2:     LOAD_FAST_BORROW         2 (rounds)
              RETURN_VALUE

দুই তালিকায় একই কাঠামো, stepper-এর goto রূপের সঙ্গে হুবহু মিল। Haat-এ নির্দেশ ৭ JUMP_IF_FALSE 17 হলো “শর্ত মিথ্যা হলে done-এ যাও”, আর নির্দেশ ১৬ JUMP 4 হলো “goto top”. CPython-এ একই জোড়া: POP_JUMP_IF_FALSE … (to L2) আর JUMP_BACKWARD … (to L1). শুধু শর্তের দিক উল্টো: goto রূপে আমরা লিখেছিলাম “total ≥ 2500 হলে বেরোও”, এখানে “total < limit মিথ্যা হলে বেরোও”, যা একই কথা। মাঝের STORE_GLOBAL আর STORE_FAST হলো assignment-এর যান্ত্রিক রূপ: ছবি ৭.১-এর “ঘরে লেখা”। Haat-এ variable দুটি top-level, তাই global ঘর; Python-এ function-এর local ঘর। Bytecode কীভাবে তৈরি হয়, তা পর্ব ৫৮-এ (Bytecode নকশা) বিস্তারে আসবে।

শিক্ষাটি গুরুত্বপূর্ণ: structured programming যন্ত্রের সীমা নয়, মানুষের বোঝার সুবিধার নিয়ম। Compiler-এর ভেতরে loop আবার লাফ আর block-এর graph হয়ে যায়, যার নাম control-flow graph (পর্ব ৬২)। কিন্তু structured উৎস থেকে তৈরি graph-এর একটি বিশেষ সুন্দর আকার থাকে, যা optimizer-এর বিশ্লেষণ সহজ করে।

৫ · Procedure আর procedural decomposition

Structured programming-এর দ্বিতীয় হাতিয়ার procedure. একটি procedure হলো নাম দেওয়া এক টুকরো আদেশ, যা ইনপুট (parameter) নিয়ে কাজ করে আর প্রয়োজনে একটি মান ফেরত দেয়। ইতিহাসে এর জন্ম আরও পুরোনো: ১৯৪০-এর দশকের শেষে আর ১৯৫০-এর শুরুতে কেমব্রিজের EDSAC কম্পিউটারে David Wheeler-রা subroutine-এর একটি লাইব্রেরি গড়ে তোলেন; ফেরার ঠিকানা মনে রাখার তাঁদের কৌশলটি “Wheeler jump” নামে পরিচিত। উচ্চ-স্তরের ভাষায় FORTRAN II (১৯৫৮) SUBROUTINE, FUNCTION আর CALL নিয়ে আসে, আর ALGOL 60 procedure-কে recursive আর block-কাঠামোর অংশ করে।

বিয়েবাড়ির রান্নার প্রধান বাবুর্চি নিজে সব কাজ করেন না। তিনি বলেন: “পোলাও করো, রোস্ট করো, বোরহানি বানাও”, আর প্রতিটি কাজ একজন সহকারী জানেন কীভাবে করতে হয়। প্রধান বাবুর্চির খাতায় শুধু বড় ধাপগুলোর নাম; ভেতরের খুঁটিনাটি সহকারীর খাতায়। Procedure ঠিক এই সহকারী: নাম ধরে ডাকুন, কাজ হয়ে ফল আসবে, ভেতরে কী হলো তা না জানলেও চলে।

বড় কাজকে এভাবে নাম দেওয়া ছোট কাজে ভাঙার পদ্ধতিকে বলে procedural decomposition. Niklaus Wirth ১৯৭১ সালে “Program Development by Stepwise Refinement” প্রবন্ধে এর একটি নিয়মিত পদ্ধতি দেখান, যার নাম stepwise refinement: প্রথমে পুরো কাজ এক লাইনে লিখুন, তারপর প্রতিটি অস্পষ্ট ধাপকে আরও ছোট ধাপে ভাঙুন, যতক্ষণ না প্রতিটি ধাপ সরাসরি কোডে লেখা যায়। বাজারঘরের কাজে:

  1. স্তর ০: “একটি জেলার অর্ডারের ছাড়ের পরের মোট বের করুন।”
  2. স্তর ১: প্রতিটি অর্ডারের জন্য: জেলা মিললে তার মোট যোগ করুন → district_sum.
  3. স্তর ২: একটি অর্ডারের মোট = সব লাইনের দামের যোগ, তারপর ছাড় → order_total, discounted.
  4. স্তর ৩: একটি লাইনের দাম = পরিমাণ × একক দাম → line (বা line_total).

Haat v1-এ এখনো array বা record নেই (এগুলো পর্ব ২২-এ “Haat-এর বর্ধিত রূপ” হিসেবে আসবে)। তাই Haat সংস্করণে চারটি অর্ডার সরাসরি লেখা, আর “জেলা মিললে রাখো” অংশটি একটি ছোট function keep. Procedure-এর ভাগাভাগি তবু একই:

// বাজারঘর: একটি জেলার অর্ডারের মোট (Haat v1-এ array নেই)
fn line(qty: Int, unit: Int) -> Int {
    return qty * unit;
}
fn discounted(total: Int) -> Int {
    if total >= 1000 { return total - total / 10; }
    return total;
}
fn keep(district: Str, wanted: Str, amount: Int) -> Int {
    if district == wanted { return amount; }
    return 0;
}
let wanted = "Dhaka";
var sum = 0;
sum = sum + keep("Dhaka", wanted, discounted(line(2, 520)));
sum = sum + keep("Rajshahi", wanted, discounted(line(3, 120) + line(1, 180)));
sum = sum + keep("Dhaka", wanted, discounted(line(4, 150) + line(2, 250)));
sum = sum + keep("Dhaka", wanted, discounted(line(5, 40)));
print(sum);
~/haat $ python haat.py run orders.haat
2126
~/haat $ python haat.py vm orders.haat
2126

সত্যিকারের run: reference-এর tree-walking interpreter (run) আর bytecode VM (vm) দুটিই 2126 দেয়, অংশ ১-এর হিসাবের সঙ্গে মিলে। Program-এর ওপরের অংশ ঘোষণা (কী কী কাজ জানা আছে), নিচের অংশ আদেশের ক্রম। এখন একটি লাইনের ভেতরে কী ঘটে, ধাপে ধাপে দেখি। Haat-এর নিয়ম: expression বাঁ থেকে ডানে চলে, আর function ডাকার আগে তার সব argument হিসাব হয় (নকশা-সিদ্ধান্ত ১২)।

1fn line(qty: Int, unit: Int) -> Int { return qty * unit; }2fn discounted(total: Int) -> Int {3    if total >= 1000 { return total - total / 10; }4    return total;5}6fn keep(district: Str, wanted: Str, amount: Int) -> Int {7    if district == wanted { return amount; }8    return 0;9}10sum = sum + keep("Dhaka", wanted, discounted(line(2, 520)));
এই ধাপে
call stack
সবার ওপরের frame
ফেরত মান
sum
  1. বাঁ দিক আগে। sum + keep(…)-এর বাঁ operand sum, তাই আগে তার মান 0 পড়া হয়। তারপর callee keep, আর তার প্রথম দুটি argument: “Dhaka” আর wanted-এর মান “Dhaka”. তৃতীয় argument-এর জন্য আগে discounted(…) হিসাব করতে হবে, তার জন্য আবার line(2, 520).
  2. সবচেয়ে ভেতরের ডাক। line ডাকা হলো। Call stack-এ একটি নতুন stack frame ওঠে, যার ভেতরে parameter qty = 2, unit = 520. এরা local variable: বাইরের কেউ এদের দেখে না।
  3. ফিরে আসা। 2 × 520 = 1040 ফেরত; line-এর frame stack থেকে সরে যায়, qty আর unit আর নেই।
  4. পরের স্তর। এবার 1040 নিয়ে discounted ডাকা হলো; নতুন frame-এ total = 1040.
  5. ছাড় দেওয়া। 1040 ≥ 1000, তাই 1040 − 104 = 936 ফেরত। frame সরে যায়।
  6. সবচেয়ে বাইরের ডাক। তিনটি argument তৈরি, তাই এবার keep ডাকা হলো: district = Dhaka, wanted = Dhaka, amount = 936.
  7. জেলা মিলল। দুটি Str সমান, তাই amount, অর্থাৎ 936 ফেরত। Rajshahi-র লাইনে এখানে 0 ফিরত।
  8. যোগ আর লেখা। ধাপ ১-এ পড়া 0-এর সঙ্গে 936 যোগ, আর ফল sum-এর ঘরে। পুরো লাইনে তিনটি procedure ডাকা হলো, কিন্তু main-এর state বদলাল শুধু এই শেষ ধাপে।

Stepper-এর call stack হলো procedure-এর যান্ত্রিক রূপ: প্রতিটি ডাকে একটি frame ওঠে, ফেরার সময় নামে, যে সবশেষে ডাকা হয়েছে সে-ই আগে শেষ হয়। হার্ডওয়্যারের স্তরে এটি কীভাবে register আর মেমরিতে হয়, তা আছে Computer Architecture কোর্সের পর্ব ৩০-এ; compiler কীভাবে frame-এর নকশা করে, তা এই কোর্সের পর্ব ৩০-এ (Subprogram-এর বাস্তবায়ন), আর parameter পাঠানোর নানা নিয়ম পর্ব ২৯-এ।

Procedure দুটি বড় জিনিস দেয়। এক, abstraction: discounted ডাকার সময় আপনাকে মনে রাখতে হয় না ছাড় কীভাবে হিসাব হয়; নিয়ম বদলালে (ধরুন ১০% থেকে ১২%) শুধু একটি জায়গা বদলাবে। দুই, পুনর্ব্যবহার: line ছয়বার ডাকা হয়েছে, কিন্তু লেখা হয়েছে একবার। তৃতীয় একটি সুবিধা পরে বুঝবেন: যে procedure শুধু parameter পড়ে আর একটি মান ফেরত দেয়, বাইরের কিছু বদলায় না, সেটি আলাদা করে পরীক্ষা করা সহজ। আমাদের line, discounted আর keep তিনটিই এমন। শুধু শেষের sum = … লাইনগুলো state বদলায়।

৬ · বাজারঘরের কাজ C আর Python-এ — সত্যিকারের run

এবার পুরো কাজটি দুটি আসল imperative ভাষায়, array আর record সহ। প্রথমে C: অর্ডার আর লাইন হলো struct (C কোর্সের পর্ব ২২), অর্ডারের তালিকা একটি array, আর তিনটি procedure অংশ ৫-এর stepwise refinement-এর তিন স্তর। কোডটি Wandbox সার্ভারের আসল C compiler-এ চলবে:

#include <stdio.h>
#include <string.h>
struct line  { const char *item; long qty, unit; };
struct order { const char *district; int n; struct line lines[2]; };

long line_total(const struct line *ln) { return ln->qty * ln->unit; }

long order_total(const struct order *o) {
    long total = 0;
    for (int i = 0; i < o->n; i++)
        total = total + line_total(&o->lines[i]);
    if (total >= 1000) total = total - total / 10;
    return total;
}

long district_sum(const struct order *orders, int n, const char *wanted) {
    long s = 0;
    for (int i = 0; i < n; i++)
        if (strcmp(orders[i].district, wanted) == 0)
            s = s + order_total(&orders[i]);
    return s;
}

int main(void) {
    struct order orders[] = {
        {"Dhaka", 1, {{"rice", 2, 520}}},
        {"Rajshahi", 2, {{"lentil", 3, 120}, {"oil", 1, 180}}},
        {"Dhaka", 2, {{"sugar", 4, 150}, {"tea", 2, 250}}},
        {"Dhaka", 1, {{"salt", 5, 40}}},
    };
    for (int i = 0; i < 4; i++)
        printf("%s %ld\n", orders[i].district, order_total(&orders[i]));
    printf("Dhaka total: %ld\n", district_sum(orders, 4, "Dhaka"));
    return 0;
}

আসল আউটপুট:

Dhaka 936
Rajshahi 540
Dhaka 990
Dhaka 200
Dhaka total: 2126

প্রতিটি অর্ডারের ছাড়ের পরের মোট অংশ ১-এর টেবিলের সঙ্গে মেলে, আর Dhaka-র যোগফল 2126, Haat-এর মতোই। C-র কোডে imperative ধাঁচ সবচেয়ে খোলা: for loop-এ সূচক i নিজে বাড়াতে হয়, total আর s নামের দুটি “জমার খাতা” ধাপে ধাপে বদলায়। Procedure-গুলো array-র উপাদান পায় pointer দিয়ে (&orders[i]), কপি করে নয়; const লিখে প্রতিশ্রুতি দেওয়া হয়েছে যে procedure সেই অর্ডার বদলাবে না। String তুলনায় == নয়, strcmp লাগে, কারণ C-তে == দুটি pointer-এর ঠিকানা তুলনা করত। lines[2]-এ যে অর্ডারের একটি লাইন, তার দ্বিতীয় ঘর শূন্যে ভরা থাকে, আর n বলে দেয় কয়টি লাইন আসল।

একই কাজ Python-এ, ব্রাউজারে চালানো। Record-এর জন্য dataclass, তালিকার জন্য list. কাঠামো C-র হুবহু অনুবাদ রাখা হয়েছে, যাতে পাশাপাশি পড়া যায়; Python-এর নিজস্ব ছোট রূপ (যেমন sum() আর generator) পর্ব ০৯ আর ১৩-এ।

from dataclasses import dataclass

@dataclass
class Line: item: str; qty: int; unit: int      # unit price in taka

@dataclass
class Order: district: str; lines: list

def line_total(ln):
    return ln.qty * ln.unit

def order_total(order):
    total = 0
    for ln in order.lines:
        total = total + line_total(ln)
    if total >= 1000:
        total = total - total // 10    # amounts are positive here
    return total

def district_sum(orders, wanted):
    s = 0
    for o in orders:
        if o.district == wanted:
            s = s + order_total(o)
    return s

orders = [Order("Dhaka", [Line("rice", 2, 520)]),
          Order("Rajshahi", [Line("lentil", 3, 120), Line("oil", 1, 180)]),
          Order("Dhaka", [Line("sugar", 4, 150), Line("tea", 2, 250)]),
          Order("Dhaka", [Line("salt", 5, 40)])]
for o in orders:
    print(o.district, order_total(o))
print("Dhaka total:", district_sum(orders, "Dhaka"))

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

Dhaka 936
Rajshahi 540
Dhaka 990
Dhaka 200
Dhaka total: 2126

C-র আউটপুটের সঙ্গে প্রতিটি লাইন হুবহু এক: দুটি আলাদা ভাষা, আলাদা বাস্তবায়ন, একই উত্তর। এভাবে মেলানোই differential testing-এর মূল ভাবনা। একটি সূক্ষ্ম পার্থক্য খেয়াল করুন: Python-এ // নিচের দিকে কাটে, C আর Haat-এর / শূন্যের দিকে। এখানে সব টাকার অঙ্ক ধনাত্মক, তাই উত্তর এক (মন্তব্যে সেটিই লেখা); ঋণাত্মক সংখ্যা এলে এই অনুবাদ ভুল হতো, যা পর্ব ০৪-এ (অনুবাদক) ১৮৩টি ইনপুটে পরীক্ষা করে দেখানো হয়েছে।

বিষয়C17Python 3.14Haat v1
Recordstruct@dataclassনেই (পর্ব ২২-এ বর্ধিত রূপ)
তালিকানির্দিষ্ট আকারের arraylist (বাড়ানো যায়)নেই; আলাদা লাইন
Loopfor (i = 0; i < n; i++)for o in orderswhile
পূর্ণসংখ্যার ভাগ/ শূন্যের দিকে// নিচের দিকে/ শূন্যের দিকে
String সমতাstrcmp====
Type পরীক্ষাcompile-এর সময়চলার সময়চালানোর আগে (type checker)
আউটপুট212621262126

৭ · Side effect আর aliasing — প্রথম পরিচয়

Imperative ধাঁচের শক্তি state বদলানো; তার দামও সেখানেই। একটি procedure যদি মান ফেরত দেওয়ার বাইরে আর কিছু বদলায়, যেমন একটি global variable, পাঠানো list, ফাইল বা পর্দা, তাকে বলে side effect. আর একই মেমরির ঘরে যদি দুটি আলাদা নাম দিয়ে পৌঁছানো যায়, তাকে বলে aliasing: একজনের ডাকনাম “বাবু”, অফিসে নাম “রফিক সাহেব”; একজনকে খবর দিলে অন্যজনও জানেন, কারণ মানুষ একই। নিচের কোডে দুটোই দেখুন:

# 1) aliasing: two names, one list in memory
dhaka = [("rice", 2, 520)]
today = dhaka                  # no copy is made
today.append(("salt", 5, 40))
print("dhaka:", dhaka)
print("same object?", today is dhaka)

# 2) a procedure with a side effect on its argument
def add_bag_fee(lines):
    lines.append(("bag", 1, 10))   # changes the caller's list
    return len(lines)

backup = list(dhaka)           # a real copy
print("lines now:", add_bag_fee(dhaka), " backup still:", len(backup))

# 3) a side effect on hidden state: same call, different answer
counter = 0
def next_order_id():
    global counter
    counter = counter + 1
    return counter

print(next_order_id(), next_order_id())
print("difference:", next_order_id() - next_order_id())  # left to right

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

dhaka: [('rice', 2, 520), ('salt', 5, 40)]
same object? True
lines now: 3  backup still: 2
1 2
difference: -1

১. today = dhaka কোনো কপি বানায়নি; দুটি নাম একই list-এর দিকে নির্দেশ করে। তাই today-তে যোগ করা লাইন dhaka-তেও দেখা গেল। Python-এর দিক থেকে এর পুরো গল্প Python কোর্সের পর্ব ১৯-এ. ২. add_bag_fee শুধু একটি সংখ্যা ফেরত দেওয়ার কথা বলে মনে হয়, কিন্তু চুপচাপ ডাকা-পক্ষের list বদলে দেয়; list(dhaka) দিয়ে আসল কপি নেওয়া backup অক্ষত (২টি লাইন)। ৩. next_order_id() একই ভাবে ডাকলেও প্রতিবার আলাদা উত্তর দেয়, কারণ সে লুকানো state (counter) বদলায়। শেষ লাইনে 3 − 4 = −1, কারণ Python 3-এ expression বাঁ থেকে ডানে হিসাব হয়, এটি ভাষার reference-এ লেখা নিয়ম। C-তে কিন্তু f() - f()-এর দুই ডাকের ক্রম নির্ধারিত নয় (unspecified), তাই একই কোড compiler-ভেদে −1 বা 1 দিতে পারে। এই বিষয়টি পর্ব ২৬-এ (Expression আর evaluation order) বিস্তারে আসবে।

Compiler-এর জন্যও aliasing একটি বড় মাথাব্যথা। ধরুন C-তে একটি function দুটি pointer পায়, int *a আর int *b, আর লেখে *a = 1; *b = 2; return *a;. Compiler কি সরাসরি 1 ফেরত দিতে পারে? না, কারণ a আর b একই ঘরের দিকে নির্দেশ করতে পারে, তখন উত্তর 2. প্রমাণ ছাড়া optimizer নিরাপদ পথ নেয়, আর কোড ধীর হয়। এজন্য C99 restrict নামের একটি প্রতিশ্রুতি যোগ করে: প্রোগ্রামার বলে দেন “এই pointer-এর ঘরে অন্য কোনো পথ নেই”. Fortran বহু আগে থেকেই ধরে নেয় যে argument-গুলো একে অপরের alias নয়, আর এটি সংখ্যা-হিসাবের কোডে Fortran-এর গতির একটি প্রচলিত ব্যাখ্যা। Pointer আর alias-এর পূর্ণ আলোচনা পর্ব ২৩-এ (Pointer আর reference).

Haat v1-এ mutable ডেটা-কাঠামো নেই, আর let দিয়ে ঘোষিত নাম বদলানো যায় না। let rate = 10; rate = 15; লিখলে reference বাস্তবায়ন চালানোর আগেই থামে: 2:1: error: cannot assign to 'rate': it is declared with 'let' (সত্যিকারের run). তবে Haat-এও একটি জায়গায় aliasing আছে: closure বাইরের variable-কে reference হিসেবে ধরে, তাই দুটি closure একই var ভাগ করতে পারে। সেই গল্প পর্ব ১৭-এ (Closure).

৮ · Compiler-এর চোখে imperative কোড

এই কোর্সে আপনি যে compiler বানাবেন, তার বড় অংশ আসলে imperative কোড নিয়ে কাজ করার কৌশল। এখানে একটি মানচিত্র, কোন ধারণা কোথায় ফিরে আসবে:

Imperative ধারণাCompiler-এ কী হয়কোথায়
Variable আর stateনাম থেকে ঘর খোঁজা: symbol table, slot, registerপর্ব ১৪, ৫১, ৭০
Assignmentএকই নামে অনেকবার লেখা ভেঙে প্রতিটি মানকে আলাদা নাম দেওয়া: SSA formপর্ব ৬৩
Sequencing, if, whileBasic block আর control-flow graphপর্ব ৬২
LoopLoop-এর বাইরে সরানো, unrollingপর্ব ৬৬
ProcedureActivation record, calling convention, inliningপর্ব ৩০, ৬৭, ৭১
Side effect, aliasingকোন কোড সরানো বা বাদ দেওয়া নিরাপদ, তার বিশ্লেষণপর্ব ৬৪, ৬৫

একটি উদাহরণে দেখা যাক, assignment কেন optimizer-এর কাজ কঠিন করে। অংশ ৩-এর program-এ t নামে চারটি আলাদা মান থাকে (1040, 936, 1100, তারপর 990). “t-এর মান কত?” প্রশ্নের উত্তর নির্ভর করে আপনি কোন লাইনে দাঁড়িয়ে আছেন তার ওপর। SSA form প্রতিটি assignment-কে একটি নতুন নাম দেয়: t1 = 1040, t2 = 936, t3 = 1100, t4 = 990. এখন প্রতিটি নামের মান একটিই, তাই “এই মান কোথা থেকে এল” প্রশ্নের উত্তর সরাসরি পড়া যায়। দুটি পথ যেখানে মেলে (যেমন if-এর পরে, যেখানে ছাড় হতেও পারে, না-ও হতে পারে), সেখানে একটি বিশেষ φ (phi) নির্দেশ বলে কোন পথের মান আসবে। অর্থাৎ compiler নিজের সুবিধার জন্য imperative কোডকে প্রায় “একবার-লেখা” রূপে নিয়ে যায়।

আরেকটি বাস্তব কথা: imperative ভাষা মানেই দ্রুত, এমন নয়। পর্ব ০৪-এ দেখেছেন, একই price(2, 520) Clang build-এর সময়েই 936-এ নামিয়েছে, আর CPython প্রতিবার bytecode চালায়। দুটিই imperative ভাষা; গতির পার্থক্য এসেছে বাস্তবায়ন থেকে, paradigm থেকে নয়।

আরও গভীরে: Andrew Appel ১৯৯৮ সালে “SSA is Functional Programming” নামের একটি ছোট প্রবন্ধে দেখান, SSA রূপের একটি program আসলে nested function দিয়ে লেখা একটি functional program-এর সমান; প্রায় একই সময়ে Richard Kelsey (১৯৯৫) continuation-passing style আর SSA-র মিল দেখান। অর্থাৎ আধুনিক compiler imperative কোডকে ভেতরে প্রায় functional রূপে বিশ্লেষণ করে, আর Backus-এর ১৯৭৭ সালের সমালোচনা এক অর্থে compiler-এর ভেতরেই সত্যি হয়েছে। উল্টো দিকে, functional ভাষার compiler শেষে আবার loop আর assignment-এর machine code লেখে।

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

  • Imperative আর declarative-এর পার্থক্য? Imperative-এ “কীভাবে” (ধাপে ধাপে state বদল), declarative-এ “কী চাই” (যেমন SQL).
  • Procedural programming কী? Imperative কোডকে নাম দেওয়া procedure-এ ভাগ করা; উদাহরণ C, Pascal.
  • Structured programming-এর তিন গঠন? ক্রম, নির্বাচন (if) আর পুনরাবৃত্তি (while); Böhm–Jacopini, ১৯৬৬.
  • Side effect কী, উদাহরণ? ফেরত মানের বাইরে কিছু বদলানো: global variable, পাঠানো list, ফাইল বা পর্দায় লেখা।
  • l-value আর r-value? x = x + 1-এ বাঁ দিকের x একটি ঘর (l-value), ডান দিকের x তার মান (r-value).

৯ · AI-এর যুগে imperative কোড

AI assistant সবচেয়ে বেশি কোড লেখে imperative ধাঁচেই: loop, শর্ত আর জমার variable. দেখতে ঠিক লাগে বলেই এখানে ভুল ধরা কঠিন। এই বিষয়ে বারবার দেখা ভুলগুলো:

AI-এর ভুলকীভাবে ধরবেন
এক ভাষার নিয়ম আরেক ভাষায় চাপানো, যেমন Python-এর // আর C-র /-কে এক ভাবাঋণাত্মক সংখ্যা দিয়ে দুই ভাষায় আসলে চালানো
C-তে evaluation order বা signed overflow-এর ফল “নিশ্চিত” বলে দেওয়াC standard-এর নিয়ম দেখা; unspecified আর undefined behavior চেনা
Loop-এর সীমায় এক-ঘর ভুল (off-by-one), যেমন <= আর <খালি তালিকা, একটি উপাদান আর সীমার ঠিক মান দিয়ে test
“Refactor” করে loop-এর ক্রম বা শর্ত বদলে অর্থ বদলে ফেলাপুরোনো আর নতুন কোড একই ইনপুটে চালিয়ে মেলানো (differential testing)
Function-এর ভেতরে চুপচাপ argument বদলানো (side effect), বা কপি না করে alias রাখাডাকার আগে আর পরে argument-টি ছাপিয়ে দেখা; প্রয়োজনে কপি
Compiler কী করবে তা নিয়ে বানানো দাবি, যেমন “এই loop compiler নিজেই সরিয়ে দেবে”আসল bytecode বা assembly দেখা: dis, -S

AI-কে ভালোভাবে কাজে লাগানোর উপায়: কোড চাওয়ার সময় ভাষা, version আর কোণের ইনপুট বলে দেওয়া, আর state-এর হিসাব ধাপে ধাপে চাওয়া, যাতে আপনি নিজে মেলাতে পারেন।

আমি প্রোগ্রামিং ভাষা শিখছি। নিচের কাজটি C17 আর Python 3.14-এ imperative ধাঁচে লিখে দাও, শুধু standard library দিয়ে: অর্ডারের তালিকা (জেলা, আর প্রতিটি লাইনে পরিমাণ ও একক দাম), প্রতিটি অর্ডারের মোট ১০০০ বা বেশি হলে মোট থেকে মোট/১০ বাদ (পূর্ণসংখ্যার ভাগ, শূন্যের দিকে কাটা), তারপর একটি জেলার অর্ডারের যোগফল। ১. প্রতিটি procedure কী পড়ে আর কী বদলায় (side effect আছে কি না) এক লাইনে লেখো। ২. একটি ছোট উদাহরণে loop-এর প্রতিটি ঘোরার পরে জমার variable-এর মান টেবিলে দেখাও। ৩. খালি তালিকা, ঠিক ১০০০ টাকার অর্ডার আর ঋণাত্মক মোট (ফেরত দেওয়া অর্ডার) দিয়ে test দাও; ঋণাত্মক সংখ্যায় C আর Python-এর ভাগের পার্থক্য কোথায় ধরা পড়বে, বলো। ৪. কোনো আচরণ যদি C-তে unspecified বা undefined হয়, স্পষ্ট করে লেখো। ৫. কোনো আউটপুট অনুমান করে লিখবে না; কোনগুলো আমাকে চালিয়ে দেখতে হবে, আলাদা করে বলো।

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

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

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

প্র ০১Dijkstra-র “Go To Statement Considered Harmful” চিঠিতে আসলে কী বলা হয়েছিল, আর goto কেন আজও কিছু ভাষায় টিকে আছে?

চিঠিটি ছোট, মাত্র দুই পাতার, ১৯৬৮ সালের মার্চে Communications of the ACM-এ ছাপা। Dijkstra-র নিজের দেওয়া নাম ছিল “A Case against the GO TO Statement”; বিখ্যাত শিরোনামটি পত্রিকার তখনকার সম্পাদক Niklaus Wirth দেন, এমনটাই Dijkstra পরে লিখেছেন। তাঁর যুক্তি নৈতিক নয়, বোঝার: আমরা program-এর লেখা পড়ি স্থির কাগজে, কিন্তু program চলে সময়ের মধ্যে। ভালো program-এ লেখার কাঠামো আর চলার পথের মধ্যে সহজ মিল থাকে, যাতে লেখার কোনো বিন্দু দেখে বলা যায় “চলার সময় এখানে কী কী সত্য”. Loop আর procedure-এ এই মিল থাকে: একটি গণনা (কতবার ঘুরেছে) বা call stack দিয়ে অবস্থান বোঝা যায়। অবাধ goto সেই মিল ভেঙে দেয়, কারণ একটি label-এ যেকোনো জায়গা থেকে আসা যায়।

চিঠিটি দুই দিকেই বাড়াবাড়ি তৈরি করেছিল। একদল একে নিষেধাজ্ঞা হিসেবে পড়ল, “… considered harmful” শিরোনামের অনুকরণে শত শত প্রবন্ধ লেখা হলো। ১৯৭৪ সালে Donald Knuth “Structured Programming with go to Statements” প্রবন্ধে ধৈর্য ধরে দেখান, কয়েকটি ক্ষেত্রে (loop-এর মাঝখান থেকে বেরোনো, error হলে একসঙ্গে পরিষ্কার করা) নিয়ন্ত্রিত goto কোডকে সরল আর দ্রুত করে; আসল লক্ষ্য হলো কাঠামো, একটি keyword নিষিদ্ধ করা নয়।

আজকের ভাষাগুলো সেই সমঝোতাই মেনেছে। break, continue, আগেভাগে return, labeled break (Java) আর exception হলো “নিয়ন্ত্রিত goto”: প্রতিটির লক্ষ্য সীমিত আর পূর্বানুমেয়। C-তে goto আছে, কারণ C-তে exception বা destructor নেই, আর error হলে খোলা ফাইল ও মেমরি এক জায়গায় ছাড়ার জন্য cleanup label একটি প্রচলিত কৌশল। Go-তেও goto আছে, তবে variable-এর ঘোষণার ওপর দিয়ে বা block-এর ভেতরে লাফ দেওয়া নিষেধ। Java goto-কে keyword হিসেবে আটকে রেখেছে, কিন্তু কোনো কাজ দেয়নি।

মূল উপলব্ধি: structured programming একটি keyword-এর বিরুদ্ধে নয়, লেখা আর চলার পথের মিল রক্ষার পক্ষে। যে লাফ সেই মিল রাখে (break, return, cleanup), তা গ্রহণযোগ্য; যে লাফ ভাঙে, তা-ই spaghetti.

প্র ০২FORTRAN-এর স্রষ্টা John Backus কেন নিজেই von Neumann ধাঁচের ভাষার সমালোচনা করলেন?

Backus-এর দল ১৯৫৭ সালে প্রথম FORTRAN compiler প্রকাশ করে, আর FORTRAN-এর সাফল্যই প্রমাণ করে যে উচ্চ-স্তরের imperative ভাষা থেকে দক্ষ machine code বানানো যায়। তাই ১৯৭৭ সালে Turing Award পেয়ে যখন তিনি “Can Programming Be Liberated from the von Neumann Style?” শিরোনামে বক্তৃতা দেন (প্রকাশ ১৯৭৮), অনেকে অবাক হয়েছিলেন।

তাঁর যুক্তির কেন্দ্রে ছবি ৭.১-এর সেই bus. CPU আর মেমরির মাঝে একবারে একটি word যায়; Backus একে “von Neumann bottleneck” বলেন। তাঁর মতে সমস্যা শুধু হার্ডওয়্যারের নয়: প্রচলিত ভাষাগুলোও প্রোগ্রামারকে একই সরু পথে চিন্তা করায়। একটি assignment একবারে একটি ঘর বদলায়, তাই বড় কাজ লিখতে হয় অসংখ্য ছোট assignment আর loop দিয়ে, যেখানে পুরো কাজের গাণিতিক কাঠামো হারিয়ে যায়। দুটি ভেক্টরের inner product-এর মতো সরল জিনিসও loop, সূচক আর জমার variable দিয়ে লিখতে হয়, আর সেই কোড সম্পর্কে বীজগাণিতিক যুক্তি (যেমন দুটি অংশ জোড়া লাগানো) প্রায় অসম্ভব।

বিকল্প হিসেবে তিনি FP নামের একটি ভাষার প্রস্তাব দেন, যেখানে variable নেই, assignment নেই; আছে কয়েকটি function আর সেগুলো জোড়া লাগানোর নিয়ম (composition, map-এর মতো গঠন), আর program-এর ওপর সমীকরণ দিয়ে যুক্তি চালানো যায়। FP নিজে খুব বেশি ব্যবহৃত হয়নি, কিন্তু বক্তৃতাটি functional programming-এর গবেষণাকে বড় ধাক্কা দেয়। আজকের map, filter, reduce আর NumPy-র মতো “পুরো array একসঙ্গে” ধাঁচে সেই চিন্তার প্রভাব স্পষ্ট।

আরেকটি দিক: হার্ডওয়্যারও bottleneck-এর সঙ্গে লড়েছে cache, pipeline, SIMD আর বহু core দিয়ে। কিন্তু এগুলো ভালোভাবে ব্যবহার করতে compiler-কে জানতে হয় কোন হিসাব একে অপরের ওপর নির্ভর করে না, আর imperative কোডের side effect আর aliasing ঠিক সেটিই লুকিয়ে রাখে।

মূল উপলব্ধি: একটি ভাষা যে যন্ত্রের অনুকরণে তৈরি, তার সীমাও উত্তরাধিকারে পায়। Backus-এর প্রশ্ন ছিল, প্রোগ্রামিং-এর চিন্তা কি যন্ত্রের একটি-একটি-word কাঠামোর বাইরে যেতে পারে; পর্ব ০৯-এ সেই উত্তরের দিকে যাবেন।

প্র ০৩Böhm–Jacopini theorem যদি বলে goto কখনো লাগে না, তাহলে break, return আর exception-এর মতো জিনিস ভাষায় রাখা হয় কেন?

১৯৬৬ সালের ফলটি একটি অস্তিত্বের প্রমাণ: যেকোনো flowchart-কে ক্রম, নির্বাচন আর পুনরাবৃত্তি দিয়ে সমান অর্থের program-এ বদলানো যায়. কিন্তু প্রমাণের কৌশলটি দেখলে বোঝা যায় দামটা কোথায়। সাধারণ রূপান্তরে পুরো program একটি বড় while loop হয়ে যায়, যার ভেতরে একটি বাড়তি variable (ধরুন pc) মনে রাখে “এখন কোন অংশ চলবে”, আর একটি লম্বা if-else শৃঙ্খল সেই অনুযায়ী অংশ বাছে। অর্থাৎ goto সরে গেল, কিন্তু তার জায়গায় এল একটি নিজের বানানো program counter. লেখাটি “structured”, অথচ বোঝা আগের মতোই কঠিন।

বাস্তব উদাহরণ: একটি তালিকায় প্রথম Rajshahi-র অর্ডার খুঁজে পেলেই থামতে চান। শুধু while দিয়ে লিখলে একটি found flag লাগে, loop-এর শর্তে !found যোগ করতে হয়, আর শরীরের বাকি অংশ একটি if-এর ভেতরে ঢোকাতে হয়। break বা আগেভাগে return থাকলে এক লাইনেই কাজ হয়। পরে S. Rao Kosaraju (১৯৭০-এর দশকে) দেখান, বাড়তি variable ছাড়া goto সরাতে চাইলে বহু-স্তরের break-এর মতো গঠন লাগে; অর্থাৎ শুধু তিন গঠন আর flag-ছাড়া লেখা সব সময় সম্ভব নয়।

Exception আরেক ধাপ এগিয়ে: error হলে অনেকগুলো procedure call পেরিয়ে একটি নির্দিষ্ট handler-এ লাফ দেয়। এটি সবচেয়ে “দূরের” goto, কিন্তু নিয়ন্ত্রিত: লক্ষ্য শুধু call stack-এর ওপরের কোনো handler, আর পথে প্রতিটি frame নিয়ম মেনে সরানো হয় (পর্ব ২৮)।

ভাষা-নকশার দিক থেকে প্রশ্নটি তাই প্রকাশক্ষমতার নয়, পাঠযোগ্যতা আর নিরাপত্তার। পর্ব ০৬-এর (ভাষা নকশার লক্ষ্য আর আপস) ভাষায়, এখানে writability আর readability-র আপস: কয়েকটি নিয়ন্ত্রিত লাফ কোডকে ছোট ও পরিষ্কার করে, আবার প্রতিটি নতুন লাফ “এখানে কোন পথে আসা যায়” প্রশ্নটি একটু কঠিন করে। Haat v1 সবচেয়ে সরল বিকল্প বেছেছে: শুধু while আর return.

মূল উপলব্ধি: একটি theorem বলে কী সম্ভব; ভাষার নকশা ঠিক করে কী আরামদায়ক। তিন গঠন যথেষ্ট, কিন্তু কয়েকটি নিয়ন্ত্রিত বেরোনোর পথ ছাড়া বাস্তব কোড অপ্রয়োজনীয়ভাবে জটিল হয়।

প্র ০৪এত সমালোচনার পরও imperative ধাঁচ কেন এখনো সবচেয়ে প্রচলিত, আর এটি কি সবসময় দ্রুততর?

প্রথম কারণ যন্ত্রের সঙ্গে মিল। CPU নিজে একটি imperative যন্ত্র: register আর মেমরিতে লেখে, পরের নির্দেশে যায়, লাফ দেয়। তাই C-র মতো ভাষার প্রতিটি গঠনের একটি সরাসরি যান্ত্রিক রূপ আছে, আর প্রোগ্রামার মোটামুটি অনুমান করতে পারেন কোড কত মেমরি নেবে আর কত কাজ করবে। Operating system, database engine, game engine বা embedded কোডে এই পূর্বানুমান খুব দামি।

দ্বিতীয় কারণ মানুষের অভ্যাস আর শেখানো। রেসিপি, অফিসের কাজের তালিকা, বাজারের ফর্দ, আমাদের দৈনন্দিন নির্দেশ সবই ধাপে ধাপে লেখা। প্রথম ভাষা হিসেবে বেশিরভাগ মানুষ imperative কিছু শেখেন, আর সেই মানসিক মডেল নিয়েই অন্য ধাঁচে যান। তৃতীয় কারণ ইতিহাস আর ecosystem: FORTRAN, C আর তাদের উত্তরসূরিদের বিশাল লাইব্রেরি, tool আর অভিজ্ঞ মানুষের ভান্ডার; নতুন ভাষাও তাই imperative ভিত্তির ওপর অন্য ধাঁচ যোগ করে (পর্ব ১৩)।

কিন্তু “imperative মানেই দ্রুত” কথাটি ভুল সরলীকরণ। গতি আসে বাস্তবায়ন থেকে: CPython imperative ভাষা চালায় bytecode interpreter দিয়ে, আর OCaml বা Haskell-এর native compiler functional কোড থেকে প্রায়ই খুব দক্ষ machine code বানায়। আবার imperative কোডের side effect আর aliasing optimizer-এর হাত বেঁধে দেয়: অংশ ৭-এর *a = 1; *b = 2; return *a; উদাহরণে compiler সরল উত্তরটি নিতে পারে না। অন্যদিকে immutable ডেটা বহু thread-এ ভাগ করা নিরাপদ, তাই সমান্তরাল কাজে functional ধাঁচ কখনো সহজ পথ দেয়।

আধুনিক উত্তর তাই মিশ্রণ: Rust imperative কোড লিখতে দেয়, কিন্তু ownership আর borrowing নিয়মে aliasing আর mutation একসঙ্গে হতে দেয় না (পর্ব ৭৬); Java আর Python-এ stream বা comprehension-এর মতো declarative অংশ যোগ হয়েছে। কোন গতি দাবি সত্য, তা জানার একমাত্র উপায় নিজের যন্ত্রে নিজের কাজ মাপা।

মূল উপলব্ধি: imperative ধাঁচ টিকে আছে কারণ এটি যন্ত্র আর মানুষের অভ্যাস দুটোর সঙ্গেই মেলে; কিন্তু গতি paradigm-এর ধর্ম নয়, বাস্তবায়ন আর কাজের ধরনের ফল।

প্র ০৫Procedural decomposition কি বড় software-এর জন্য যথেষ্ট? Parnas-এর information hiding কী নতুন কথা বলেছিল?

Stepwise refinement (Wirth, ১৯৭১) কাজকে “কী করতে হবে” ধরে ভাঙে: প্রথমে বড় ধাপ, তারপর প্রতিটি ধাপের ছোট ধাপ। ছোট program-এ এটি চমৎকার কাজ করে, যেমন বাজারঘরের তিন স্তরের ভাগ। কিন্তু বড় software-এ একটি সমস্যা দেখা দেয়: অনেক procedure একই ডেটার কাঠামো (ধরুন অর্ডারের record) সরাসরি ব্যবহার করে। কাঠামোটি বদলালে, যেমন lines[2]-এর জায়গায় একটি linked list, সেই সব procedure একসঙ্গে বদলাতে হয়।

David Parnas ১৯৭২ সালে Communications of the ACM-এ “On the Criteria To Be Used in Decomposing Systems into Modules” প্রবন্ধে এই প্রশ্নটি তোলেন। তিনি একটি ছোট সিস্টেম দুইভাবে ভাগ করে দেখান: একবার কাজের ধাপ ধরে (flowchart-ধাঁচে), আরেকবার “কোন সিদ্ধান্ত পরে বদলাতে পারে” ধরে। দ্বিতীয় ভাগে প্রতিটি module একটি সম্ভাব্য পরিবর্তনশীল সিদ্ধান্ত (ডেটা কীভাবে রাখা হয়, কোন ক্রমে সাজানো হয়) লুকিয়ে রাখে, আর বাইরে শুধু কয়েকটি procedure দেখায়। এর নাম information hiding. তাঁর যুক্তি: পরিবর্তন এলে দ্বিতীয় ভাগে অনেক কম module বদলাতে হয়।

এই ভাবনা থেকেই এসেছে abstract data type, module সিস্টেম (পর্ব ১৮) আর object-oriented programming-এর encapsulation (পর্ব ০৮)। C-তে এর একটি সাধারণ রূপ: header ফাইলে শুধু function-এর ঘোষণা আর একটি অসম্পূর্ণ struct, আর বাস্তবায়ন আলাদা .c ফাইলে (C কোর্সের পর্ব ২৯)। Procedural ভাষাতেও তাই information hiding করা যায়; ভাষা শুধু ঠিক করে সেটি কতটা সহজ আর কতটা বাধ্যতামূলক।

বাজারঘরের উদাহরণে দেখুন: district_sum জানে না একটি অর্ডারের মোট কীভাবে হিসাব হয়; সে শুধু order_total ডাকে। এটি এক ধরনের লুকানো। কিন্তু সে জানে অর্ডারের district নামের একটি ক্ষেত্র আছে; ক্ষেত্রের নাম বদলালে তাকেও বদলাতে হবে। কতটা লুকাবেন, তা একটি নকশার সিদ্ধান্ত।

মূল উপলব্ধি: procedure দিয়ে কাজ ভাগ করা প্রথম ধাপ; বড় সিস্টেমে আসল প্রশ্ন “কোন সিদ্ধান্ত কোথায় লুকানো থাকবে”. Procedural, modular আর object-oriented ধাঁচ এই প্রশ্নেরই ক্রমবর্ধমান উত্তর।

অনুশীলন

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

  1. বাস্তবায়ন — while যোগ করুন: অংশ ৩-এর state interpreter-এ (ev, ex) একটি While(cond, body) node যোগ করুন, সংজ্ঞা ৭.১-এর loop নিয়ম মেনে। তারপর var total = 0; var rounds = 0; while total < 5000 { total = total + 1250; rounds = rounds + 1; } চালিয়ে শেষ state লিখুন।

    নতুন node আর < operator যোগ করে ex-এর শুরুতে একটি শাখা:

    While = node("While", "cond body")
    OPS["<"] = lambda a, b: a < b
    
    def ex(st, s):
        if isinstance(st, While):
            while ev(st.cond, s):            # check, run body, check again
                for inner in st.body:
                    s = ex(inner, s)
            return s
        if isinstance(st, If):
            for inner in (st.then if ev(st.cond, s) else []):
                s = ex(inner, s)
            return s
        e = st.init if isinstance(st, Let) else st.value
        return {**s, st.name: ev(e, s)}
    
    T, R = Var("total"), Var("rounds")
    prog = [Let("total", Num(0)), Let("rounds", Num(0)),
            While(Binary("<", T, Num(5000)),
                  [Assign("total", Binary("+", T, Num(1250))),
                   Assign("rounds", Binary("+", R, Num(1)))])]
    s = {}
    for st in prog:
        s = ex(st, s)
    print(s)

    Python 3.14-এ চালানো ফল: {'total': 5000, 'rounds': 4}. লক্ষ করুন, বাস্তবায়নে আমরা Python-এর নিজের while ব্যবহার করেছি: interpreter-এর ভাষার loop দিয়ে চালানো ভাষার loop-এর অর্থ দেওয়া। সংজ্ঞা ৭.১-এর recursive সমীকরণ সরাসরি লিখলেও চলত (শরীর একবার চালিয়ে ফল-state-এর ওপর একই While node দিয়ে আবার ex ডাকা), কিন্তু হাজার ঘোরার loop-এ Python-এর recursion সীমায় পৌঁছানোর ঝুঁকি থাকত। bazar.haat-এর loop অংশও একই ফল দেয়: reference বাস্তবায়ন 5000 আর rounds - 1 = 3 ছাপে।

  2. ভুল খুঁজুন: একজন compiler-লেখক Haat-এর while c { B }-কে এভাবে লাফে নামালেন: top: B; if c goto top;. তাঁর যুক্তি: “এতে প্রতি ঘোরায় একটি লাফ কম।” সীমা ৫০০০ দিয়ে stepper-এর loop চালালে উত্তর ঠিক আসে। অনুবাদটি কি সঠিক? না হলে একটি পাল্টা উদাহরণ দিন আর ঠিক করুন।

    সঠিক নয়। এই রূপ হলো do-while: শরীর অন্তত একবার চলে, শর্ত পরে দেখা হয়। শুরুতেই শর্ত মিথ্যা হলে while-এর শরীর একবারও চলার কথা নয়। Python 3.14-এ দুটি রূপ পাশাপাশি চালানো ফল (সীমা, while-এর (total, rounds), ভুল অনুবাদের (total, rounds)):

    0 (0, 0) (1250, 1)
    1 (1250, 1) (1250, 1)
    2500 (2500, 2) (2500, 2)
    5000 (5000, 4) (5000, 4)

    সীমা 0 হলে while কিছুই করে না (0, 0), কিন্তু ভুল অনুবাদ একবার ঘুরে (1250, 1) দেয়। সমাধান দুই রকম: সরল রূপ top: if !c goto done; B; goto top; done: (Haat reference ঠিক এটিই বানায়: JUMP_IF_FALSE আর JUMP), অথবা প্রতি ঘোরায় একটি লাফ বাঁচাতে চাইলে শুরুতে একবার পরীক্ষা যোগ করা: if !c goto done; top: B; if c goto top; done:. দ্বিতীয় কৌশলটি বাস্তব compiler-এ “loop rotation” নামে পরিচিত। শিক্ষা: অনুবাদ পরীক্ষা করুন সীমার মান দিয়ে, বিশেষ করে “শূন্যবার” ঘোরার ক্ষেত্রে।

  3. আউটপুট অনুমান করুন: নিচের Haat program কী ছাপবে? প্রতিটি ঘোরার পরে n-এর মানগুলোও লিখুন।
    var n = 6;
    var steps = 0;
    while n != 1 {
        if n % 2 == 0 { n = n / 2; } else { n = 3 * n + 1; }
        steps = steps + 1;
    }
    print(steps);

    প্রতিটি ঘোরার পরে n: 3, 10, 5, 16, 8, 4, 2, 1. মোট ৮টি ঘোরা, তাই ছাপা হবে 8. Haat reference বাস্তবায়নে চালানো ফলও 8. এটি বিখ্যাত Collatz ক্রম; প্রতিটি ধনাত্মক পূর্ণসংখ্যা থেকে শুরু করলে কি সবসময় 1-এ পৌঁছায়, তা আজও প্রমাণিত হয়নি। তাই এই সাধারণ চেহারার loop সব শুরুর মানে থামে কি না, কেউ জানে না: loop-এর থামা প্রমাণ করা কতটা কঠিন হতে পারে, এটি তার একটি ভালো উদাহরণ।

  4. প্রমাণ — loop invariant: Haat-এ var total = 0; var rounds = 0; while total < L { total = total + 1250; rounds = rounds + 1; }, যেখানে L ≥ 0 আর এত ছোট যে overflow হয় না। প্রমাণ করুন: loop শেষ হয়, আর শেষে total = 1250 × rounds এবং rounds = ⌈L / 1250⌉.

    Invariant (প্রতি ঘোরার শুরুতে সত্য থাকা কথা, loop invariant) নিন I: total = 1250 × rounds এবং total ≤ L + 1249 এবং (rounds = 0 অথবা total − 1250 < L).

    1. শুরু: total = 0, rounds = 0. 0 = 1250 × 0, আর 0 ≤ L + 1249 (কারণ L ≥ 0), আর rounds = 0. তাই I সত্য।
    2. রক্ষা: ধরুন I সত্য আর শর্ত total < L সত্য। নতুন মান total′ = total + 1250, rounds′ = rounds + 1. তাহলে total′ = 1250 × rounds + 1250 = 1250 × rounds′. আর total < L থেকে total′ − 1250 < L, তাই total′ < L + 1250, অর্থাৎ total′ ≤ L + 1249. তিনটি অংশই আবার সত্য।
    3. থামা: প্রতি ঘোরায় L − total ঠিক 1250 কমে, আর শর্ত সত্য থাকতে হলে L − total > 0. তাই সর্বোচ্চ ⌈L / 1250⌉ ঘোরার পর শর্ত মিথ্যা হয়।
    4. শেষে: শর্ত মিথ্যা, অর্থাৎ total ≥ L; আর I থেকে total = 1250 × rounds. rounds = 0 হলে total = 0 ≥ L, তাই L = 0 = ⌈0 / 1250⌉. নইলে 1250 × (rounds − 1) < L ≤ 1250 × rounds, যা ঠিক rounds = ⌈L / 1250⌉-এর সংজ্ঞা। ∎

    যাচাই: L = 0 থেকে 19999 পর্যন্ত ৭ ধাপ করে সব মানে Python 3.14-এ loop চালিয়ে দুটি সমতাই মিলেছে; L = 5000-এ rounds = 4, যা bazar.haat-এর rounds - 1 = 3-এর উৎস। এই ধরনের যুক্তির পূর্ণ গণিত, Hoare logic, আসবে পর্ব ৪২-এ।

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

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

ক্রমHaat-এ expression বাঁ থেকে ডানে হিসাব হয়, আর function ডাকার আগে তার সব argument হিসাব হয়। var sum = 0;-এর পরে sum = sum + keep("Dhaka", "Dhaka", discounted(line(2, 520))); চলার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. বাঁ operand sum-এর মান 0 পড়া
  2. line(2, 520) ডাকা, ফেরত 1040
  3. discounted(1040) ডাকা, ফেরত 936
  4. keep(“Dhaka”, “Dhaka”, 936) ডাকা, ফেরত 936
  5. 0 + 936 যোগ করে ফল sum-এর ঘরে লেখা

Imperative programming paradigm-এর মূল বৈশিষ্ট্য কোনটি?

  • শুধু কী ফল চাই তা বলা, কীভাবে হবে তা ভাষা ঠিক করে
  • কোনো variable কখনো বদলানো যায় না
  • Program আদেশের একটি ক্রম, যা ধাপে ধাপে state বদলায়
  • সব কোড class আর object-এর ভেতরে থাকতে হয়

von Neumann যন্ত্রে imperative ভাষার “পরের statement-এ যাওয়া” (sequencing) কোন যান্ত্রিক কাজের সঙ্গে মেলে?

  • Program counter পরের নির্দেশের ঠিকানায় এগোনো
  • মেমরির একটি ঘরে নতুন মান লেখা
  • ALU-তে দুটি সংখ্যা যোগ করা
  • Call stack-এ একটি নতুন frame তোলা

Böhm–Jacopini theorem (১৯৬৬) অনুযায়ী, প্রয়োজনে কয়েকটি বাড়তি Boolean variable নিলে যেকোনো flowchart program কোন তিনটি গঠন দিয়ে লেখা যায়?

  • goto, label আর procedure call
  • ক্রম, নির্বাচন আর পুনরাবৃত্তি
  • Recursion, exception আর assignment
  • break, continue আর return

Haat program: var a = 3; var b = 5; a = a + b; b = a - b; a = a - b; print(a); print(b); কী ছাপবে?

  • 3 আর 5
  • 8 আর 5
  • 8 আর 3
  • 5 আর 3

Python 3-এ x = [1]; y = x; y.append(2); print(len(x)) কী ছাপবে, আর কেন?

  • 1, কারণ শুধু y বদলেছে
  • Error, কারণ x-এ append করা হয়নি
  • 2, কারণ x আর y একই list-কে নির্দেশ করে
  • 3

একটি সাধারণ bytecode compiler while c { B }-কে সাধারণত কোন আকারে নামায়?

  • শর্ত পরীক্ষা, মিথ্যা হলে সামনে লাফ; শরীর; তারপর শর্তে পেছনে লাফ
  • শরীর, তারপর শর্ত সত্য হলে শরীরের শুরুতে লাফ, শুরুতে কোনো পরীক্ষা নেই
  • শরীরকে যতবার ঘুরবে ততবার কপি করে, কোনো লাফ ছাড়া
  • প্রতিটি ঘোরার জন্য একটি নতুন procedure call

শব্দকোষ

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

মনে রাখুন

  1. Imperative program আদেশের ক্রম; প্রতিটি আদেশ state বদলায়। Assignment: ⟦x = e⟧(σ) = σ[x ↦ ⟦e⟧σ]; sequencing মানে আগের ফল-state পরের ইনপুট।
  2. এর পেছনে von Neumann যন্ত্র: variable = মেমরির ঘর, assignment = store, sequencing = PC এগোনো, শর্ত আর loop = লাফ। Backus এর সীমাকে বলেছিলেন von Neumann bottleneck.
  3. Structured programming: ক্রম, নির্বাচন, পুনরাবৃত্তি যথেষ্ট (Böhm–Jacopini ১৯৬৬); Dijkstra ১৯৬৮; কিন্তু compiler আবার সব কিছু JUMP_IF_FALSE আর JUMP-এর মতো লাফে নামায়।
  4. Procedural decomposition: বড় কাজকে নাম দেওয়া ছোট procedure-এ ভাঙা (stepwise refinement); প্রতিটি call একটি stack frame. বাজারঘরের কাজ C, Python আর Haat-এ একই উত্তর: 2126.
  5. Side effect আর aliasing imperative কোডের দাম: একই call ভিন্ন উত্তর দিতে পারে, এক নামের বদল আরেক নামে দেখা যায়, আর optimizer-এর হাত বাঁধা পড়ে।

পরের পর্বে: state আর procedure একসঙ্গে বেঁধে ফেললে কী হয়? পর্ব ০৮-এ object, class, inheritance আর dynamic dispatch: একই বাজারঘরের কাজ object-oriented ধাঁচে, আর C++-এর vtable ও Python-এর method খোঁজার নিয়ম সত্যিকারের run-এ।

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

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