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

Static testing — review, walkthrough, inspection আর static analysis

Static Testing: Reviews, Walkthroughs, Inspections and Static Analysis

Taught in Bangla, this lesson contrasts static and dynamic testing and covers informal reviews, walkthroughs, technical reviews and inspections with their roles and steps. It reviews an ambiguous coupon requirement into a testable form. A real run of Ruff 0.17.5 and mypy 2.4.1 on a seeded checkout.py catches seven of eight planted defects, and in-page Python runs unit tests on the same module to show that only tests and human review catch a >= versus > mismatch with the spec.

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

  • Static আর dynamic testing-এর পার্থক্য, আর কোনটি কোন ধরনের ভুল সহজে ধরে
  • চার ধরনের review চেনা, আর review-এর role ও ধাপ ধরে একটি inspection চালানো
  • একটি requirement-এ অস্পষ্টতা খুঁজে সেটিকে test করা যায় এমন রূপে লেখা
  • Ruff আর mypy-র রিপোর্ট লাইন ধরে পড়া, আর কোন ভুল কোন tool ধরে তা বোঝা
  • একই module-এ static analysis আর unit test পাশাপাশি চালিয়ে দুটির সীমা তুলনা করা

১ · Static বনাম dynamic — না চালিয়ে ভুল খোঁজা

এ পর্যন্ত মডিউলের প্রায় সব উদাহরণে কোড চালানো হয়েছে: একটি ফাংশনকে input দিয়ে ফল দেখা, তারপর প্রত্যাশার সাথে মেলানো। পর্ব ০২-এ এর নাম দেখেছেন dynamic testing. কিন্তু testing-এর বড় একটি অংশে কিছুই চালানো হয় না। শুধু পড়া হয়, প্রশ্ন করা হয়, আর নিয়মের সাথে মেলানো হয়।

রান্নার আগে মা রেসিপির খাতা পড়ে বললেন, “এখানে দুই চামচ লবণ লেখা, এক কেজি মাংসে এটা বেশি হয়ে যাবে।” কিছুই রান্না হয়নি, তবু ভুলটি ধরা পড়ল। এটি static testing. রান্নার পরে চেখে দেখে “লবণ বেশি” বলা হলো dynamic testing. প্রথমটি ভুলের কারণ সরাসরি দেখায় (খাতার লেখা), দ্বিতীয়টি দেখায় ফল (মুখে লবণ বেশি লাগা), তারপর কারণ খুঁজতে হয়।

এই পার্থক্যটি গুরুত্বপূর্ণ। পর্ব ০২-এর ভাষায়: dynamic testing একটি failure দেখায়, তারপর debugging করে তার পেছনের defect খুঁজতে হয়। Static testing defect-টিকেই সরাসরি দেখে, কারণ সে কোড বা দলিলের ভেতরে তাকায়। আরেকটি সুবিধা: এমন কাজের ফলও যাচাই করা যায়, যা চালানোই যায় না, যেমন একটি requirement-এর বাক্য বা একটি test plan.

কী দিয়ে কী যাচাই হয়

ওপরে না চালিয়ে যাচাই, নিচে চালিয়ে যাচাই

Static testing versus dynamic testing Static · না চালিয়ে Dynamic · চালিয়ে Requirement, story → review নকশা (design) → review কোড → review, ruff, mypy Test case, plan → review Software + test input → ফল ফল ≠ প্রত্যাশা → failure ধরে: defect সরাসরি ধরে: failure, পরে defect
ছবি ৬.১ — Static testing চালানো যায় না এমন দলিলও যাচাই করে আর defect সরাসরি দেখায়; dynamic testing আচরণ দেখে, কারণ খুঁজতে পরে debugging লাগে।

কোন ধরনের ভুল static testing-এ সহজে ধরা পড়ে? ISTQB-এর syllabus-এ যে তালিকা আছে, তার সারকথা আমাদের ভাষায়:

কোথায়কী ধরনের ভুলবাজারঘরে উদাহরণ
Requirementঅস্পষ্টতা, অসংগতি, বাদ পড়া কথা“১০০০ টাকার বেশি”-তে delivery charge ধরা হবে কি?
নকশাঅদক্ষ গঠন, দুই অংশের মধ্যে ভুল যোগাযোগCoupon আর delivery দুই জায়গায় আলাদা করে মোট টাকা হিসাব করে
কোডভুল নাম, ব্যবহার না হওয়া variable, ভুল type, পৌঁছানো যায় না এমন কোডtotl লেখা, অথচ variable-এর নাম total
মানদণ্ডকোডিং নিয়ম না মানা== None, যেখানে Python-এর রীতি is None
Test-এর দলিলভুল প্রত্যাশিত ফল, বাদ পড়া সীমাঠিক ১০০০ টাকার কোনো test case নেই
নিরাপত্তাযাচাইহীন input, কোডে বসানো passwordPhone number সরাসরি database query-তে জোড়া

তবে static testing সব পারে না। কোড আসলে কত দ্রুত চলে, অন্য service-এর সাথে মিলে কাজ করে কি না, ব্যবহারকারীর ফোনে বোতামটি দেখা যায় কি না, এগুলো চালিয়েই দেখতে হয়। তাই দুটি প্রতিদ্বন্দ্বী নয়, পরিপূরক। সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৫-এ এই ভাগটি এক অনুচ্ছেদে আছে; এখানে আমরা review-এর ধরন, role আর ধাপ, আর আসল tool চালিয়ে দেখব।

২ · Review-এর চার ধরন — আড্ডা থেকে আনুষ্ঠানিক সভা

Review মানে এক বা একাধিক মানুষ একটি কাজের ফল (work product) পড়ে ভুল, প্রশ্ন আর উন্নতির জায়গা খোঁজেন। পরীক্ষার খাতা দেখার কথা ভাবুন। পাশের বন্ধুকে “একটু দেখে দে তো” বলা এক রকম; বোর্ডের পরীক্ষক নম্বর দেওয়ার নির্দিষ্ট নির্দেশনা মেনে প্রতিটি খাতা দেখেন, আর প্রধান পরীক্ষক আবার কিছু খাতা মিলিয়ে দেখেন, এটি আরেক রকম। দুটোই review, পার্থক্য আনুষ্ঠানিকতায়।

ISTQB-এর syllabus চারটি প্রচলিত ধরনের নাম দেয়। ওপর থেকে নিচে আনুষ্ঠানিকতা বাড়ে:

ধরনকে চালানমূল উদ্দেশ্যলিখিত রেকর্ড
Informal reviewকোনো নির্দিষ্ট নিয়ম নেইদ্রুত কিছু ভুল ধরাসাধারণত নেই
Walkthroughসাধারণত লেখক নিজেবোঝানো, জ্ঞান ভাগ, মত নেওয়া, ভুল ধরাঐচ্ছিক
Technical reviewপ্রশিক্ষিত moderator; reviewer-রা বিষয়ের দক্ষ মানুষপ্রযুক্তিগত সিদ্ধান্তে মতৈক্য, বিকল্প বিবেচনা, ভুল ধরাহ্যাঁ
Inspectionপ্রশিক্ষিত moderator, লেখক ননযত বেশি সম্ভব defect খোঁজা, আর প্রক্রিয়ার মাপ রাখাহ্যাঁ, মাপসহ

Informal review সবচেয়ে সাধারণ। একজন developer পাশের সহকর্মীকে স্ক্রিনে কোড দেখালেন, বা একজন tester আরেকজনকে নিজের test case-এর তালিকা পাঠালেন। কোনো সভা বা ফর্ম নেই। দ্রুত আর সস্তা, তাই প্রতিদিন হয়। দুর্বলতা: কতটা দেখা হলো, কী পাওয়া গেল, কিছুই মাপা হয় না।

Walkthrough-এ লেখক নিজে সবাইকে দলিল বা কোড ধাপে ধাপে দেখান, সাধারণত একটি উদাহরণ ধরে। যেমন বাজারঘরের developer একটি ১২০০ টাকার অর্ডার নিয়ে দেখালেন coupon আর delivery-র হিসাব কোন ফাংশন থেকে কোন ফাংশনে যায়। নতুন সদস্যকে শেখানো বা নকশা নিয়ে মত নেওয়ার জন্য এটি খুব কাজের। ঝুঁকি: লেখক যেহেতু পথ দেখান, তাঁর নিজের অন্ধ জায়গাগুলোও পথের বাইরে থেকে যায় (পর্ব ০৩-এর confirmation bias).

Technical review-এ বিষয়ের দক্ষ সহকর্মীরা একটি প্রযুক্তিগত প্রশ্নে বসেন: “payment-এর নকশায় retry কোথায় হবে?” এখানে লক্ষ্য শুধু ভুল ধরা নয়, বিকল্প তুলনা করে সিদ্ধান্তে পৌঁছানোও।

Inspection সবচেয়ে আনুষ্ঠানিক। নির্দিষ্ট role, আগাম প্রস্তুতি, checklist, প্রবেশ ও প্রস্থানের শর্ত, আর লিখিত defect তালিকা থাকে। কত পাতা বা কত লাইন কত সময়ে দেখা হলো, কতটি defect পাওয়া গেল, এমন মাপ রাখা হয়, যাতে পরের বার প্রক্রিয়াটি উন্নত করা যায়।

Inspection-এর আনুষ্ঠানিক রূপটি Michael Fagan-এর নামে পরিচিত। তিনি IBM-এ কাজ করার সময় ১৯৭৬ সালে IBM Systems Journal-এ “Design and code inspections to reduce errors in program development” প্রবন্ধে পদ্ধতিটি বর্ণনা করেন। তাই একে প্রায়ই “Fagan inspection” বলা হয়। পরে IEEE 1028 (software review আর audit-এর মানদণ্ড) আর ISO/IEC 20246 (work product review-এর মানদণ্ড, ২০১৭) review-এর ধরন আর ধাপের সাধারণ ভাষা দেয়। নাম আর ধাপের সংখ্যা উৎসভেদে একটু আলাদা; ধারণা একই।

কোনটি কখন

ধরনটি বাছুন ঝুঁকি দেখে, অভ্যাস দেখে নয় (পর্ব ০৩-এর প্রসঙ্গ-নির্ভরতার নীতি)। বাজারঘরের product page-এর লেখা বদলাতে informal review যথেষ্ট। টাকার হিসাবের নিয়ম, যেমন coupon আর payment-এর requirement, inspection-এর যোগ্য। একই প্রতিষ্ঠানে একাধিক ধরন পাশাপাশি চলে।

৩ · Review-এর role আর ধাপ — একটি inspection সভা

আনুষ্ঠানিক review-এ প্রত্যেকের কাজ আলাদা। ISTQB-এর syllabus (v4.0) যে role-গুলোর কথা বলে, বাজারঘরের coupon module-এর inspection-এ সেগুলো দেখতে এমন:

Roleকাজবাজারঘরে কে
Managerকী review হবে ঠিক করেন, সময় আর লোক দেনদলের প্রধান
Author (লেখক)যাচাই হওয়া কাজটি লিখেছেন, পরে ভুল ঠিক করেনCoupon কোডের developer
Moderator (facilitator)সভা চালান, সময় রাখেন, সবাইকে বলার সুযোগ দেন, তর্ক থামানঅন্য দলের একজন অভিজ্ঞ সদস্য
Scribe (recorder)পাওয়া সব বিষয় আর সিদ্ধান্ত লিখে রাখেনএকজন junior tester
Reviewerকাজটি পড়ে ভুল আর প্রশ্ন খোঁজেন; একেকজন একেক দৃষ্টিকোণ থেকেTester, আরেক developer, হিসাব বিভাগের একজন
Review leaderপুরো review-এর দায়িত্ব নেন: কে আসবেন, কোথায়, কবেQA lead

ছোট দলে একজন একাধিক role নিতে পারেন, তবে একটি নিয়ম প্রায় সব জায়গায় মানা হয়: inspection-এ লেখক moderator হন না। কারণটি পর্ব ০৩-এর independence: যিনি লিখেছেন, তিনি সভার দিক ঠিক করলে নিজের অন্ধ জায়গার দিকে আলো পড়ে কম।

ধাপের দিক থেকে ISTQB-এর syllabus (v4.0) review-কে পাঁচটি কাজে ভাগ করে: planning (পরিকল্পনা: কী, কতটুকু, কোন checklist, কবে শেষ), review initiation (শুরু: সবার হাতে দলিল আর নির্দেশনা পৌঁছানো), individual review (প্রত্যেকে আলাদা করে পড়া), communication and analysis (সভায় বা লিখিতভাবে পাওয়া বিষয়গুলো আলোচনা ও শ্রেণিবিভাগ), আর fixing and reporting (ঠিক করা আর ফলাফলের রিপোর্ট)। Fagan-এর মূল পদ্ধতিতে প্রস্তুতি, সভা, পুনরায় কাজ (rework) আর পরে যাচাই (follow-up) আলাদা ধাপ হিসেবে আছে। নিচের stepper-এ একটি inspection শুরু থেকে শেষ পর্যন্ত দেখুন। বিষয়: বাজারঘরের checkout.py, যেখানে coupon, delivery charge আর payment-এর ফাংশন আছে।

  1. Planningপরিকল্পনা
  2. Initiationশুরু
  3. Individualএকা পড়া
  4. Meetingআলোচনা
  5. Fix, reportঠিক করা
Planningreview leader
বিষয়: checkout.py + coupon spec
Reviewer: A tester, B dev,
          C হিসাব বিভাগ
Checklist: সীমা, None, error
প্রবেশ শর্ত: ruff, mypy পরিষ্কার?
সময়: সভা 60 মিনিট
Initiationmoderator
সবাই পেলেন: কোড, spec,
checklist, প্রত্যেকের দৃষ্টিকোণ
A: requirement মেলানো
B: error handling
C: টাকার হিসাব
Individual review৮টি নোট
A: >= at 1000, unknown coupon,
   None district
B: >= at 1000, pay() hides
   errors, no test for 1000
C: rounding?, unknown coupon
Meeting৬টি আলাদা বিষয়
একই বিষয় একবার: 8 নোট → 6
1 >= at 1000        defect
2 unknown coupon    defect
3 pay() hides errors defect
4 no test for 1000  test-এ ফাঁক
5 None district     spec প্রশ্ন
6 rounding          বন্ধ: spec-এ আছে
Meeting-এর নিয়মmoderator
✓ সমস্যা লেখা হয়, সমাধান নয়
✓ কোড নিয়ে কথা, মানুষ নয়
✓ scribe সব লেখেন
✗ “কে লিখেছে?” প্রশ্ন নেই
ফল: 5টি খোলা বিষয়
Fix, follow-upauthor + moderator
3 defect → author ঠিক করলেন
1 test-এর ফাঁক → tester লিখলেন
1 spec প্রশ্ন → product owner
moderator মিলিয়ে দেখলেন
রিপোর্ট: 60 মিনিট, 5টি বিষয়
  1. Planning. Review leader ঠিক করলেন কী দেখা হবে (কোড আর coupon-এর spec), কারা দেখবেন, কোন checklist, আর একটি প্রবেশ শর্ত: আগে ruff আর mypy চালিয়ে যন্ত্রে ধরা যায় এমন ভুল সরানো, যাতে মানুষের সময় যুক্তির ভুলে যায়।
  2. Initiation. Moderator সবাইকে উপকরণ পাঠালেন, আর প্রত্যেককে আলাদা দৃষ্টিকোণ দিলেন। একই জিনিস তিনজনে একভাবে পড়লে একই ভুল তিনবার পাওয়া যায়, নতুন ভুল কম।
  3. Individual review. প্রত্যেকে সভার আগে একা পড়ে নোট লিখলেন: A তিনটি, B তিনটি, C দুটি, মোট ৮টি। “>= at 1000” দুজনেই পেয়েছেন। বেশিরভাগ defect এই একা পড়ার ধাপেই পাওয়া যায়; সভা সেগুলো মেলায়।
  4. Meeting: মেলানো আর শ্রেণিবিভাগ। একই বিষয় একবার গোনা হলো, তাই ৮টি নোট থেকে ৬টি আলাদা বিষয়। কোডের defect ৩টি, test-এর একটি ফাঁক, spec-এর একটি প্রশ্ন। Rounding-এর প্রশ্নটি বন্ধ: spec-এ আগেই লেখা আছে ছাড় নিচের দিকে পূর্ণ টাকায়।
  5. সভার নিয়ম। Moderator সভা পরিষ্কার রাখেন: সমস্যা লেখা হয়, সমাধানের নকশা সভার বাইরে; কথা কোড নিয়ে, মানুষ নিয়ে নয় (পর্ব ০৩-এর দোষারোপ ছাড়া ভাষা)। Scribe সব লেখেন। শেষে খোলা বিষয় ৫টি।
  6. Fixing, follow-up আর রিপোর্ট। লেখক ৩টি defect ঠিক করলেন, tester ১০০০ টাকার test যোগ করলেন, spec-এর প্রশ্নটি গেল product owner-এর কাছে। Moderator মিলিয়ে দেখে review বন্ধ করলেন। রিপোর্টে সময় আর বিষয়ের সংখ্যা থাকে, যাতে পরের inspection-এর পরিকল্পনা ভালো হয়।

সাফল্যের শর্ত: review কাজে লাগে যখন লক্ষ্য স্পষ্ট, সময় যথেষ্ট, এক বসায় খুব বেশি জিনিস দেওয়া হয় না, আর পাওয়া বিষয়কে লেখকের মূল্যায়নে ব্যবহার করা হয় না। শেষের শর্তটি ভাঙলে মানুষ ভুল লুকাতে শেখে, আর review একটি আনুষ্ঠানিক অভিনয়ে পরিণত হয়।

৪ · Requirement-এর review — অস্পষ্টতা আর testability

একটি requirement ভুল হলে নকশা, কোড আর test case, সবই সেই ভুল বহন করে (পর্ব ০৩-এর early testing). আর requirement চালানো যায় না, তাই একে যাচাই করার একমাত্র পথ static testing. Tester এখানে একটি বিশেষ প্রশ্ন নিয়ে বসেন: “এই বাক্য থেকে কি আমি প্রত্যাশিত ফল লিখতে পারব?” না পারলে requirement-টির testability কম, অর্থাৎ এটি test করা যায় না।

Requirement review-এর জন্য একটি সাধারণ checklist:

প্রশ্নসতর্ক সংকেত
প্রতিটি সীমা কি স্পষ্ট?“বেশি”, “পর্যন্ত”, “মধ্যে”: সীমার মানটি ভেতরে না বাইরে?
প্রতিটি শব্দের অর্থ কি একটাই?“অর্ডার”, “ঢাকা”, “দিন”: কোন অর্থে?
মাপা যায় কি?“দ্রুত”, “সহজ”, “বেশিরভাগ সময়”: কত সেকেন্ড, কোন মাপে?
ভুল input-এ কী হবে?ফাঁকা ঘর, অজানা coupon, বাতিল অর্ডার: লেখাই নেই
অন্য নিয়মের সাথে মেলে কি?দুটি coupon একসাথে, ছাড়ের পরে delivery-র নিয়ম
উদাহরণ আছে কি?সংখ্যা দিয়ে ২–৩টি উদাহরণ থাকলে ভুল বোঝা কমে

এবার বাজারঘরের coupon নিয়মটি এই checklist দিয়ে পড়ুন। নিয়মটি এক লাইনের, তবু তিনটি প্রশ্ন বেরোয়। উত্তরগুলো এই কোর্সের সব পর্বে একই থাকবে।

মূল requirementএক লাইন
“১০০০ টাকার বেশি অর্ডারে
১০% ছাড়, সর্বোচ্চ ৩০০ টাকা।”
প্রশ্ন ১সীমা
ঠিক 1000 টাকায় ছাড় আছে?
উত্তর: না। “বেশি” মানে 1000 বাদ
1000 → 0
1001 → 100
প্রশ্ন ২শব্দের অর্থ
“অর্ডার” = delivery charge সহ?
পণ্য 950 + delivery 120 = 1070
উত্তর: শুধু পণ্যের দাম
950 → ছাড় 0
প্রশ্ন ৩ভগ্নাংশ
1005-এর 10% = 100.5 টাকা?
উত্তর: নিচের দিকে পূর্ণ টাকা
1005 → 100
নতুন requirementউদাহরণসহ
পণ্যের দাম (delivery ছাড়া)
1000-এর বেশি হলে 10% ছাড়,
নিচের দিকে পূর্ণ টাকা, max 300
1000 → 0    1001 → 100
1005 → 100  3000 → 300
5000 → 300
  1. মূল বাক্য। তিনটি শব্দে দাগ: “বেশি”, “অর্ডারে” আর “১০% ছাড়”। “সর্বোচ্চ ৩০০ টাকা” অংশটি স্পষ্ট, তাই দাগ নেই। প্রতিটি দাগের জন্য tester একটি প্রশ্ন লেখেন, অনুমান নয়।
  2. সীমা। “বেশি” আক্ষরিকভাবে ১০০০ বাদ দেয়, কিন্তু কথ্য ভাষায় অনেকে “১০০০ বা বেশি” বোঝেন। Product owner নিশ্চিত করলেন: ঠিক ১০০০-এ ছাড় ০, ১০০১-এ ১০০. এই একটি প্রশ্ন কোডের >= বনাম > ভুল আগেই থামায়।
  3. “অর্ডার” কী? পণ্যের দাম ৯৫০, ঢাকার বাইরের delivery ১২০, মোট ১০৭০. মোট ধরলে ছাড় পাবে, পণ্যের দাম ধরলে পাবে না। উত্তর: শুধু পণ্যের দাম; তাই এখানে ছাড় ০.
  4. ভগ্নাংশ। ১০০৫-এর ১০% হয় ১০০.৫. পয়সা দেখানো হবে, ওপরে গোল হবে, না নিচে? উত্তর: নিচের দিকে পূর্ণ টাকা, তাই ১০০.
  5. Test করা যায় এমন রূপ। নতুন লেখায় তিনটি উত্তর ঢুকেছে, সাথে সংখ্যার উদাহরণ। প্রতিটি উদাহরণ সরাসরি একটি test case-এর প্রত্যাশিত ফল। ৩০০০-এ ঠিক ৩০০, তাই সর্বোচ্চ সীমাও বোঝা যায়।

লক্ষ করুন, tester নিজে উত্তর ঠিক করেননি; প্রশ্ন তুলেছেন, উত্তর দিয়েছেন requirement-এর মালিক। আর প্রশ্নগুলো এসেছে একটি সরল কৌশল থেকে: প্রতিটি সীমার মান আর প্রতিটি নামবাচক শব্দে থামা। Requirement থেকে acceptance criteria আর testability নিয়ে পূর্ণ আলোচনা পর্ব ১৫-এ (Requirement থেকে test — acceptance criteria আর testability), আর সীমার মান বাছাইয়ের নিয়মমাফিক কৌশল পর্ব ৮-এ (Boundary value analysis). Requirement যাচাইয়ের প্রক্রিয়ার দিকটি সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ২৪-এ আছে।

৫ · কোডের review — মানুষ কী দেখেন, যন্ত্র কী দেখে

আজকের বেশিরভাগ দলে code review হয় pull request-এ: একজন কোড বদলান, অন্যরা পরিবর্তনটুকু পড়ে মন্তব্য করেন, তারপর কোড মূল শাখায় যোগ হয়। এটি আসলে informal review আর technical review-এর মাঝামাঝি একটি রূপ। মন্তব্য কীভাবে লিখবেন আর review-এর পুরো কর্মপ্রবাহ সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৪৪-এর বিষয়। এখানে tester-এর দৃষ্টিকোণটুকু দেখি।

একজন tester code review-এ সাধারণত চারটি প্রশ্ন নিয়ে বসেন:

  • Requirement-এর সাথে মেলে? Spec বলে “১০০০-এর বেশি”, কোডে >=. কোনো tool এটি জানে না, কারণ tool spec পড়ে না।
  • ভুল পথে কী হয়? অজানা coupon, ফাঁকা জেলা, payment ব্যর্থ। Developer প্রায়ই স্বাভাবিক পথ (happy path) ভালো করে লেখেন, ভুল পথ কম।
  • Error কি চাপা পড়ছে? সব ধরনের error ধরে চুপ করে থাকা কোড test-কেও অন্ধ করে দেয়। এই পর্বেই একটি উদাহরণ দেখবেন।
  • Test কোথায়? নতুন আচরণের জন্য test আছে কি, আর সেই test কি সত্যিই কিছু যাচাই করে? Test-এর কোডও review-এর বিষয়।

এর বাইরে বহু ভুল আছে যা একটি নির্দিষ্ট ধাঁচ মেনে চলে: ভুল বানানের variable, ব্যবহার না হওয়া import, ভুল type. এগুলো মানুষের চোখে এড়িয়ে যায়, কিন্তু যন্ত্র কখনো ক্লান্ত হয় না। তাই ভালো দলে কাজ ভাগ করা থাকে: ধাঁচের ভুল যন্ত্রের, অর্থের ভুল মানুষের। Inspection-এর প্রবেশ শর্তে “আগে tool চালান” রাখার কারণ এটাই।

৬ · Static analysis-এর tool — linter, type checker আর SAST

Static analysis মানে tool দিয়ে কোড না চালিয়ে বিশ্লেষণ। প্রধান তিনটি ধরন:

Linter

নিয়মের তালিকা ধরে সন্দেহজনক ধাঁচ খোঁজে: অজানা নাম, অব্যবহৃত import, bare except. Python-এ Ruff, flake8, pylint; JavaScript-এ ESLint.

Type checker

Type hint পড়ে অসংগতি খোঁজে: সংখ্যার জায়গায় লেখা, None হতে পারে এমন মানে সরাসরি হিসাব। Python-এ mypy, pyright; JavaScript-এর জগতে TypeScript.

SAST

নিরাপত্তার দিকে মনোযোগী static analysis: যাচাইহীন input কোথায় পৌঁছায়। বিস্তারিত সাইবার সিকিউরিটি কোর্সের পর্ব ৪৯-এ, tester-এর প্রক্রিয়া পর্ব ৫২-তে।

Linter ভেতরে কীভাবে কাজ করে? সে কোডকে লেখার সারি হিসেবে পড়ে না, পড়ে একটি গাছ হিসেবে: abstract syntax tree (AST). Python-এর নিজের ast module এই গাছ বানিয়ে দেয়। নিচের খুদে checker-টি একটি test ফাইল পরীক্ষা করে, কারণ test-এর কোডও ভুল হতে পারে। তিনটি নিয়ম: N1 None-এর সাথে == বা != দিয়ে তুলনা, N2 bare except, আর N3 বন্ধনীর ভেতরে লেখা assert, যা সবসময় সত্য। “চালান” চাপুন; প্রথমবার ব্রাউজারে Python (Pyodide) নামতে কয়েক সেকেন্ড লাগে।

import ast

SOURCE = '''
def test_discount():
    result = discount(1500, "EID10")
    assert (result == 150, "wrong discount")
    if result != None:
        print("checked")

def test_pay():
    try:
        pay(0)
    except:
        pass
'''

def check(src):
    found = []
    for node in ast.walk(ast.parse(src)):
        if isinstance(node, ast.Compare):          # rule N1
            for op, right in zip(node.ops, node.comparators):
                if (isinstance(op, (ast.Eq, ast.NotEq))
                        and isinstance(right, ast.Constant)
                        and right.value is None):
                    found.append((node.lineno, "N1 compare with None"))
        elif isinstance(node, ast.ExceptHandler) and not node.type:
            found.append((node.lineno, "N2 bare except"))
        elif isinstance(node, ast.Assert):
            if isinstance(node.test, ast.Tuple):
                found.append((node.lineno, "N3 assert is always true"))
    return sorted(found)

for line, message in check(SOURCE):
    print(f"line {line}: {message}")

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

line 4: N3 assert is always true
line 5: N1 compare with None
line 11: N2 bare except

ast.parse লেখাটিকে গাছ বানায়, কিন্তু চালায় না; তাই discount বা pay কোথাও না থাকলেও সমস্যা হয়নি। ast.walk গাছের প্রতিটি node একে একে দেয়। তুলনা (ast.Compare) পেলে N1 দেখে ডান দিকের মান None আর চিহ্ন == বা != কি না। except-এর পরে কোনো ধরনের নাম না থাকলে (node.type ফাঁকা) N2. আর assert-এর পরের অংশটি যদি একটি tuple হয়, N3. লাইন নম্বর গোনা শুরু SOURCE-এর প্রথম ফাঁকা লাইন থেকে, তাই assert-এর লাইন ৪.

সবচেয়ে বিপজ্জনক N3. assert (result == 150, "wrong discount") লিখলে Python দুই উপাদানের একটি tuple দেখে, আর ফাঁকা নয় এমন tuple সবসময় সত্য। ফলে ছাড় ভুল হলেও test পাস করে। এমন test আছে বলে দল নিশ্চিন্ত থাকে, অথচ সেটি কিছুই যাচাই করে না। সঠিক রূপ: assert result == 150, "wrong discount", বন্ধনী ছাড়া। আসল linter-এ এমন শত শত নিয়ম আছে, প্রতিটি এভাবেই গাছের কোনো একটি ধাঁচ খোঁজে।

৭ · সত্যিকারের run — বাজারঘরের module-এ Ruff আর mypy

এবার আসল tool. নিচের checkout.py ফাইলটি ইচ্ছা করে ভুলে ভরা, যাতে কোন tool কী ধরে তা দেখা যায়। ফাইলে আটটি ভুল আছে; পড়ে দেখুন কয়টি নিজে খুঁজে পান। Wallet-এর ফাংশনটি একটি MOCK, আসল টাকা লেনদেন হয় না।

import json

COUPONS = {"EID10": 10}


def find_coupon(code: str) -> int | None:
    return COUPONS.get(code)


def discount(total: int, code: str) -> int:
    percent = find_coupon(code)
    if total >= 1000:
        return min(total * percent // 100, 300)
    return 0


def delivery_charge(district: str | None) -> int:
    if district == None:
        return "60"
    return 60 if district == "Dhaka" else 120


def add_item(item: str, cart: list[str] = []) -> list[str]:
    cart.append(item)
    return cart


def charge_wallet(amount: int) -> bool:  # MOCK wallet
    return amount > 0


def pay(total: int) -> bool:
    try:
        return charge_wallet(totl)
    except:
        return False

Tool দুটি একটি আলাদা Python project-এ বসানো হয়েছে, project-এর ব্যবস্থাপক uv দিয়ে। Ruff-এর কোন নিয়মগুলো চালু থাকবে তা pyproject.toml-এ স্পষ্ট করে লেখা, কারণ Ruff-এর নিজে থেকে চালু নিয়মের তালিকা সংস্করণভেদে বদলায়:

[tool.ruff.lint]
select = ["E4", "E7", "E9", "F", "B"]

এখানে E আর F হলো pycodestyle আর Pyflakes থেকে আসা মৌলিক নিয়ম, B হলো flake8-bugbear থেকে আসা “সম্ভাব্য bug”-এর নিয়ম। এবার কমান্ড:

cd ~/bazarghar-qa
uv add ruff mypy
uv run ruff check checkout.py --output-format concise
uv run mypy checkout.py

সত্যিকারের run (Ruff 0.17.5 আর mypy 2.4.1, দুটিই MIT licence-এর; Python 3.12):

$ uv run ruff check checkout.py --output-format concise
checkout.py:1:8: F401 [*] `json` imported but unused
checkout.py:18:20: E711 Comparison to `None` should be `cond is None`
checkout.py:23:43: B006 Do not use mutable data structures for argument defaults
checkout.py:34:30: F821 Undefined name `totl`
checkout.py:35:5: E722 Do not use bare `except`
Found 5 errors.
[*] 1 fixable with `--fix` (2 unsafe fixes available with `--fix --unsafe-fixes`).

$ uv run mypy checkout.py
checkout.py:13: error: Unsupported operand types for * ("int" and "None")  [operator]
checkout.py:13: note: Right operand is of type "int | None"
checkout.py:19: error: Incompatible return value type (got "str", expected "int")  [return-value]
checkout.py:34: error: Name "totl" is not defined; did you mean "total"?  [name-defined]
Found 3 errors in 1 file (checked 1 source file)

প্রতিটি লাইনের গঠন একই: ফাইল, লাইন, কলাম, নিয়মের code, বার্তা। দুটি tool দুই ধরনের প্রশ্ন করে। Ruff জিজ্ঞেস করে “এই ধাঁচটি কি সন্দেহজনক?” mypy জিজ্ঞেস করে “এই মানের type কি এখানে চলে?” তাই mypy ধরেছে এমন দুটি ভুল যা Ruff দেখেনি: percent None হতে পারে অথচ তা দিয়ে গুণ করা হচ্ছে (অজানা coupon code দিলে), আর int ফেরত দেওয়ার কথা বলা ফাংশন "60" লেখা ফেরত দিচ্ছে। totl-এর ভুল দুটি tool-ই ধরেছে।

Concise রূপ সংক্ষিপ্ত। কোনো একটি বিষয় বিস্তারিত বুঝতে --output-format concise বাদ দিলে Ruff আশপাশের কোড আর সমাধানের প্রস্তাবসহ পূর্ণ রিপোর্ট দেয়। নিচের stepper-এ E711-এর পূর্ণ রিপোর্ট (একই run থেকে, হুবহু) লাইন ধরে পড়ুন:

1E711 Comparison to `None` should be `cond is None`2  --> checkout.py:18:203   |417 | def delivery_charge(district: str | None) -> int:518 |     if district == None:6   |                    ^^^^719 |         return "60"8help: Replace with `cond is None`9   -     if district == None:1018 +     if district is None:11note: This is an unsafe fix and may change runtime behavior
কী পড়ছি
অংশ
মান
  1. Code আর বার্তা। E711 নিয়মের পরিচয়; E বলে এটি pycodestyle পরিবারের, মানে কোডিং রীতির নিয়ম। বার্তা বলে None-এর সাথে তুলনায় is ব্যবহার করুন। PEP 8-এর পরামর্শও তাই।
  2. ঠিকানা। checkout.py:18:20 মানে ফাইল checkout.py, লাইন ১৮, কলাম ২০. Editor-এ সরাসরি এই জায়গায় যাওয়া যায়, আর CI-এর রিপোর্টেও একই ঠিকানা থাকে।
  3. প্রসঙ্গ। আগের আর পরের লাইনসহ কোড, আর ^^^^ চিহ্ন ঠিক None-এর নিচে। প্রসঙ্গের শেষ লাইনে return "60" দেখা যাচ্ছে; Ruff এটিকে ভুল বলেনি, কারণ type-এর প্রশ্ন তার কাজ নয়।
  4. প্রস্তাব। help লাইন সমাধান বলে, আর diff দেখায়: - চিহ্নের লাইন সরবে, + চিহ্নের লাইন বসবে। Tool শুধু ভুল বলে না, ঠিক রূপটিও দেখায়।
  5. Unsafe fix কেন? == একটি object-এর নিজের তুলনার নিয়ম ডাকে, যা কোনো class বদলে রাখতে পারে; is শুধু দেখে দুটি একই object কি না। তাই বদলে আচরণ পাল্টানোর সামান্য সম্ভাবনা থাকে, আর Ruff এমন বদল নিজে থেকে করে না, --unsafe-fixes চাইলে তবেই।
  6. সিদ্ধান্ত। এখানে district একটি সাধারণ লেখা বা None, তাই বদলটি নিরাপদ; ঠিক করুন। কিন্তু রিপোর্টের প্রসঙ্গে ধরা পড়া আসল সমস্যা লাইন ১৯: জেলা না থাকলে charge কত হবে, সেটি spec-এর প্রশ্ন, আর লেখা "60" ফেরত দেওয়া type-এর ভুল (mypy). একটি সতর্কবার্তা পড়তে গিয়ে পাশের ভুলও চোখে পড়ে।

আটটি ভুলের তালিকা আর কে কোনটি ধরল, এক টেবিলে:

#ভুলRuffmypy
1অব্যবহৃত import jsonF401—
2অজানা coupon-এ None দিয়ে গুণ—operator
3ঠিক ১০০০-এ ছাড় (>=)——
4== NoneE711—
5int-এর জায়গায় "60"—return-value
6সব ডাকে একই cart listB006—
7totl বানান ভুলF821name-defined
8Bare except সব error চাপা দেয়E722—

দুটি tool মিলে আটটির সাতটি ধরেছে, কোড একবারও না চালিয়ে, এক সেকেন্ডেরও কম সময়ে। যেটি ধরেনি, সেটি ৩ নম্বর: requirement-এর সাথে অমিল। কোডের দিক থেকে total >= 1000 একদম বৈধ Python; ভুলটি আছে শুধু কোড আর spec-এর সম্পর্কে। এর প্রমাণ: সব ভুল ঠিক করা checkout_fixed.py-তে আমরা >= ইচ্ছা করে রেখে দিলাম, আর দুটি tool-ই সন্তুষ্ট:

$ uv run ruff check checkout_fixed.py
All checks passed!
$ uv run mypy checkout_fixed.py
Success: no issues found in 1 source file

“All checks passed” মানে “আমার জানা নিয়মগুলো ভাঙেনি”, “কোড ঠিক আছে” নয়। পর্ব ০৩-এর প্রথম নীতি static analysis-এর বেলাতেও খাটে: tool ভুলের উপস্থিতি দেখায়, অনুপস্থিতি প্রমাণ করে না। উল্টো দিকে tool কখনো নিরীহ কোডকেও সমস্যা বলে, একে বলে false positive; বেশি হলে মানুষ সতর্কবার্তা পড়াই ছেড়ে দেন।

৮ · একই module-এ test চালালে — কে কী ধরে

এবার উল্টো দিক। একই ভুলে ভরা কোডে পাঁচটি সাধারণ unittest চালাই, যেমন একজন developer লিখতে পারেন। কোন ভুল test-এ ধরা পড়ে, কোনটি পড়ে না?

import sys, unittest
COUPONS = {"EID10": 10}       # same buggy code as checkout.py
def discount(total, code):
    percent = COUPONS.get(code)
    if total >= 1000:
        return min(total * percent // 100, 300)
    return 0
def delivery_charge(district):
    if district == None:
        return "60"
    return 60 if district == "Dhaka" else 120
def add_item(item, cart=[]):
    cart.append(item)
    return cart
charge_wallet = lambda amount: amount > 0   # MOCK wallet
def pay(total):
    try:
        return charge_wallet(totl)
    except:
        return False
class DynamicTests(unittest.TestCase):
    def test_1500_gets_150(self):
        self.assertEqual(discount(1500, "EID10"), 150)
    def test_exactly_1000_gets_0(self):
        self.assertEqual(discount(1000, "EID10"), 0)
    def test_unknown_code_gets_0(self):
        self.assertEqual(discount(1500, "XYZ"), 0)
    def test_two_new_carts(self):
        add_item("rice")
        self.assertEqual(add_item("dal"), ["dal"])
    def test_pay_zero_refused(self):
        self.assertFalse(pay(0))
suite = unittest.TestLoader().loadTestsFromTestCase(DynamicTests)
runner = unittest.TextTestRunner(stream=sys.stdout, verbosity=2)
runner.run(suite)

আসল আউটপুট (ব্রাউজারের Python, traceback আর মাঝের দাগ-রেখা ছাঁটা):

test_1500_gets_150 (__main__.DynamicTests.test_1500_gets_150) ... ok
test_exactly_1000_gets_0 (__main__.DynamicTests.test_exactly_1000_gets_0) ... FAIL
test_pay_zero_refused (__main__.DynamicTests.test_pay_zero_refused) ... ok
test_two_new_carts (__main__.DynamicTests.test_two_new_carts) ... FAIL
test_unknown_code_gets_0 (__main__.DynamicTests.test_unknown_code_gets_0) ... ERROR
…
TypeError: unsupported operand type(s) for *: 'int' and 'NoneType'
…
AssertionError: 100 != 0
…
AssertionError: Lists differ: ['rice', 'dal'] != ['dal']
…
Ran 5 tests in 0.002s

FAILED (failures=2, errors=1)

প্রথমে মনে রাখুন, unittest.main() সরাসরি ডাকা হয়নি, কারণ সেটি শেষে sys.exit ডেকে পাতার block থামিয়ে দেয়; তাই suite বানিয়ে TextTestRunner দিয়ে চালানো। এবার ফল পড়ুন। পাঁচটি test তিনটি ভুল ধরেছে। FAIL মানে assertion মেলেনি: ঠিক ১০০০-এ কোড দিল ১০০, চাই ০, এটিই সেই ভুল যা কোনো tool ধরেনি। দ্বিতীয় cart-এ আগের ডাকের 'rice' রয়ে গেছে, কারণ default list একবারই তৈরি হয় (B006-এর ভুল)। ERROR মানে test চলার সময় অপ্রত্যাশিত exception: অজানা coupon-এ None দিয়ে গুণ (mypy-র ধরা ভুল)।

আর লক্ষ করুন test_pay_zero_refused: পাস! pay(0)-এর ভেতরে totl অজানা, তাই NameError হয়, কিন্তু bare except সেটি গিলে False ফেরত দেয়, আর test ঠিক সেটিই আশা করছিল। কোড ভাঙা, test সবুজ। Ruff আর mypy দুজনেই এক সেকেন্ডে এই লাইন দেখিয়েছিল। এ ছাড়া অব্যবহৃত import আর == None কোনো আচরণ বদলায় না, তাই কোনো test কখনো এগুলো ধরবে না; আর "60"-এর ভুল ধরা পড়েনি কারণ কেউ জেলা ছাড়া test লেখেননি।

ভুলRuff + mypyএই ৫টি testমন্তব্য
1 অব্যবহৃত importধরেছেনাTest কখনো ধরবে না
2 None দিয়ে গুণধরেছেধরেছে (ERROR)দুটোই, যদি অজানা code-এর test থাকে
3 >= বনাম >নাধরেছে (FAIL)শুধু test আর মানুষের review
4 == Noneধরেছেনারীতির ভুল; test কখনো ধরবে না
5 "60"ধরেছেনাTest লেখা হয়নি বলে
6 একই cart listধরেছেধরেছে (FAIL)Test-এ দুবার ডাকতে হয়
7 totlধরেছেনাBare except test-কে অন্ধ করেছে
8 Bare exceptধরেছেনানিজে failure দেখায় না, অন্য ভুল লুকায়

হিসাব: static analysis ৮টির ৭টি, এই test-গুলো ৮টির ৩টি, আর দুটি মিলে ৮টিই। তবে সংখ্যাটি দেখে ভুল উপসংহার টানবেন না। এখানে ভুলগুলো ইচ্ছা করে এমন বাছা হয়েছে যাতে tool-এর শক্তি দেখা যায়; আসল প্রকল্পে সবচেয়ে দামি ভুলগুলো প্রায়ই ৩ নম্বরের মতো: কোড নিখুঁত Python, কিন্তু ব্যবসার নিয়ম ভুল বোঝা। সেগুলো ধরে requirement review, মানুষের code review আর requirement থেকে লেখা test. শিক্ষাটি হলো স্তর সাজানো: commit-এর আগে tool, তারপর মানুষের review, তারপর test, যার প্রতিটি আলাদা ধরনের ভুল ধরে।

আরও গভীরে: কোনো static analysis tool সব ভুল নির্ভুলভাবে ধরতে পারে না, এবং এটি প্রকৌশলের দুর্বলতা নয়, গণিতের সীমা। Henry Rice ১৯৫৩ সালে প্রমাণ করেন, প্রোগ্রামের আচরণ নিয়ে যেকোনো অতুচ্ছ প্রশ্নের (যেমন “এই ফাংশন কখনো None ফেরত দেয় কি?”) সব প্রোগ্রামের জন্য নির্ভুল উত্তর দেয় এমন সাধারণ পদ্ধতি থাকতে পারে না। তাই প্রতিটি tool একটি দিক বেছে নেয়: হয় কোনো আসল ভুল বাদ না দেওয়ার চেষ্টা (sound), যার দাম বেশি false positive; নয়তো শুধু নিশ্চিত ভুল বলা, যার দাম কিছু ভুল বাদ পড়া (false negative). Ruff-এর মতো linter আর mypy-র মতো type checker সাধারণত দ্বিতীয় দিকে ঝোঁকে, যাতে developer সতর্কবার্তায় আস্থা রাখেন।

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

  • Static আর dynamic testing-এর পার্থক্য? — Static চালায় না, defect সরাসরি দেখে, দলিলও যাচাই করে; dynamic চালিয়ে failure দেখে।
  • চার ধরনের review বলুন। — Informal review, walkthrough, technical review, inspection; শেষেরটি সবচেয়ে আনুষ্ঠানিক।
  • Walkthrough আর inspection-এর মূল পার্থক্য? — Walkthrough লেখক চালান, লক্ষ্য বোঝানো ও শেখা; inspection প্রশিক্ষিত moderator চালান, role, checklist আর মাপসহ, লক্ষ্য সর্বোচ্চ defect.
  • Review-এ moderator আর scribe-এর কাজ? — Moderator সভা চালান ও নিরপেক্ষ রাখেন; scribe পাওয়া বিষয় আর সিদ্ধান্ত লেখেন।
  • Static analysis থাকলে test কেন লাগে? — Tool spec জানে না; requirement-এর সাথে অমিল, সময়, integration শুধু চালিয়ে বা মানুষের বিচারে ধরা পড়ে।

৯ · AI-এর যুগে review আর static analysis

AI assistant এখন pull request-এ মন্তব্য লেখে, requirement পড়ে প্রশ্ন তোলে, আর linter-এর সতর্কবার্তার সমাধান প্রস্তাব করে। এগুলো কাজের, তবে এই পর্বের শিক্ষাগুলো AI-এর বেলায় আরও জোরালো। AI প্রায়ই কোড যা করে সেটিকেই ঠিক ধরে নেয়: >= দেখে সে লিখবে “১০০০ বা বেশিতে ছাড়, ঠিক আছে”, কারণ spec তার সামনে নেই। Test লিখতে বললে প্রায়ই শুধু happy path লেখে, আর কোডের বর্তমান আচরণকেই প্রত্যাশিত ফল বানায়, ফলে ভুল কোডেও test পাস করে। Linter-এর সতর্কবার্তা চুপ করাতে সে # noqa বা # type: ignore বসিয়ে দিতে পারে, যা সমস্যা লুকায়, ঠিক করে না। নেই এমন Ruff নিয়মের code বা mypy-র option বানিয়েও বলতে পারে, অপেক্ষার জন্য sleep বসাতে পারে, এত mock করতে পারে যে আসল কিছুই যাচাই হয় না, আর না চালিয়েই “সব test পাস” দাবি করতে পারে।

AI-কে reviewer হিসেবে ব্যবহার করলে spec সাথে দিন, আর ঠিক কী খুঁজতে হবে বলে দিন:

তুমি একজন tester হিসেবে নিচের Python কোড review করো। সাথে requirement দিলাম। Requirement: পণ্যের দাম (delivery ছাড়া) ১০০০ টাকার বেশি হলে ১০% ছাড়, নিচের দিকে পূর্ণ টাকা, সর্বোচ্চ ৩০০ টাকা। ১. প্রতিটি সীমার মান (999, 1000, 1001, 3000, 3010) কোডে কী ফল দেবে, আর requirement কী বলে, পাশাপাশি টেবিল দাও। ২. অজানা coupon, ফাঁকা input আর error চাপা পড়ার জায়গা আলাদা করে দেখাও। ৩. কোনো linter নিয়মের code বা tool option উল্লেখ করলে বলো কোন সংস্করণের docs-এ আছে; নিশ্চিত না হলে লেখো “নিশ্চিত নই”। ৪. # noqa বা # type: ignore দিয়ে কোনো সতর্কবার্তা চাপা দেওয়ার প্রস্তাব দিও না। ৫. কোড বা test চালিয়েছ বলে দাবি করো না।

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

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

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

প্র ০১Fagan-এর আনুষ্ঠানিক inspection এত কার্যকর বলে পরিচিত হলেও আজকের বেশিরভাগ দল কেন হালকা pull request review বেছে নিয়েছে? কী হারিয়েছে, কী পেয়েছে?

Michael Fagan ১৯৭৬ সালে IBM-এ নকশা আর কোডের inspection-এর যে পদ্ধতি বর্ণনা করেন, তাতে ছিল প্রশিক্ষিত moderator, নির্দিষ্ট role, আগাম প্রস্তুতি, checklist, আর প্রতিটি ধাপের মাপ। সেই সময়ের প্রেক্ষাপট মনে রাখুন: কোড কাগজে ছাপা হতো, compile আর test চালানো ছিল ধীর আর দামি, release হতো বছরে একবার বা দুবার। এমন পরিবেশে একটি ভুল ধরতে কয়েকজন মানুষের এক ঘণ্টার সভা সস্তাই ছিল। Fagan আর পরের অনেক প্রতিবেদন inspection-এর বড় লাভের কথা বলেছে, যদিও নির্দিষ্ট সংখ্যাগুলো প্রসঙ্গভেদে অনেক আলাদা।

আজ পরিস্থিতি বদলেছে। কোড দিনে কয়েকবার merge হয়, CI কয়েক মিনিটে হাজারো test চালায়, আর দল ছড়িয়ে আছে নানা শহরে বা দেশে। প্রতিটি ছোট বদলের জন্য সবাইকে এক সভায় আনা অবাস্তব। তাই এসেছে tool-ভিত্তিক, অসমকালীন (asynchronous) review: pull request-এ মন্তব্য, যখন যার সময় হয়।

কী পাওয়া গেল? গতি, আর বহু চোখে নিয়মিত দেখা। Alberto Bacchelli আর Christian Bird ২০১৩ সালে (ICSE সম্মেলনে) Microsoft-এর developer-দের নিয়ে একটি গবেষণায় দেখান, মানুষ code review থেকে প্রধানত defect খোঁজা আশা করেন, কিন্তু বাস্তবে review-এর বড় ফল আসে অন্য জায়গায়: কোডের মান উন্নত হওয়া, জ্ঞান ভাগাভাগি, দলের সবার কোড চেনা, আর বিকল্প সমাধান নিয়ে আলোচনা।

কী হারাল? প্রস্তুতির শৃঙ্খলা আর মাপ। হালকা review-এ কেউ পুরো বদল মন দিয়ে পড়লেন কি না, কোন checklist মানা হলো, তা প্রায়ই অজানা। বড় pull request-এ মন্তব্য কমে যায়; মানুষ “দেখতে ভালো” লিখে দেন। তাই অনেক দল মাঝামাঝি পথ নেয়: সাধারণ বদলে pull request review, আর টাকার হিসাব, নিরাপত্তা বা safety-র মতো ঝুঁকিপূর্ণ জায়গায় আনুষ্ঠানিক inspection-এর উপাদান (checklist, নির্দিষ্ট reviewer, লিখিত সিদ্ধান্ত)।

মূল উপলব্ধি: review-এর আনুষ্ঠানিকতা একটি সুইচ নয়, একটি নিয়ন্ত্রক; ঝুঁকি যত বেশি, নিয়ন্ত্রকটি তত আনুষ্ঠানিকতার দিকে ঘোরান।

প্র ০২একটি static analysis tool যদি অনেক বেশি সতর্কবার্তা দেয়, তবে সেটি ভালো না খারাপ? বড় প্রতিষ্ঠানগুলোর অভিজ্ঞতা কী বলে?

প্রথমে একটি তাত্ত্বিক সত্য: Henry Rice ১৯৫৩ সালে প্রমাণ করেন, প্রোগ্রামের আচরণ নিয়ে অতুচ্ছ প্রশ্নের সাধারণ, সর্বদা নির্ভুল উত্তর দেওয়া অসম্ভব। তাই প্রতিটি tool কোথাও আপস করে: হয় কিছু আসল ভুল বাদ দেয়, নয়তো কিছু নিরীহ কোডকে ভুল বলে। “সব ধরি” ধাঁচের tool বেশি false positive দেয়।

বাস্তবের অভিজ্ঞতা একই দিকে। বাণিজ্যিক static analysis tool Coverity-র নির্মাতাদের লেখা একটি প্রবন্ধ, “A Few Billion Lines of Code Later” (Al Bessey ও সহকর্মীরা, Communications of the ACM, ২০১০), বর্ণনা করে কীভাবে ক্রেতারা অনেক ভুল সতর্কবার্তা দেখলে পুরো tool-এর ওপরই আস্থা হারান; তাই নির্মাতারা ইচ্ছা করে কিছু বিশ্লেষণ বাদ দিয়েছিলেন। Google-এর Tricorder platform নিয়ে Caitlin Sadowski ও সহকর্মীদের ২০১৫ সালের (ICSE) প্রবন্ধে একটি গুরুত্বপূর্ণ ধারণা আছে: “effective false positive”, মানে developer যে সতর্কবার্তা দেখে কিছু করেন না, সেটি আসলে সঠিক হলেও কার্যত ভুল সতর্কবার্তা। তাঁদের নীতি ছিল এমন হার কম রাখা, developer-এর মতামত নেওয়া, আর যে নিয়ম বেশি উপেক্ষিত হয় তা বাদ দেওয়া।

অর্থাৎ ভালো tool সবচেয়ে বেশি সতর্কবার্তা দেয় না; দেয় এমন সতর্কবার্তা যার ওপর মানুষ কাজ করেন। এই পর্বের run-এ Ruff-এর নিয়ম select দিয়ে ছোট রাখার কারণও এটাই। পুরোনো বড় কোডে নতুন tool চালালে হাজারো সতর্কবার্তা আসে; অভিজ্ঞ দল তখন সব একসাথে না মিটিয়ে শুধু নতুন বা বদলানো কোডে নিয়ম বাধ্যতামূলক করে, আর কোনো নিয়ম চুপ করালে কারণ লিখে রাখে।

Tester-এর দিক থেকে একটি সতর্কতা: সতর্কবার্তা কম মানে কোড ভালো, এমন নয়। হয়তো নিয়মই কম চালু। তাই রিপোর্টে “কোন নিয়মগুলো চালু ছিল” লেখা থাকা দরকার, ঠিক যেমন test রিপোর্টে লেখা থাকে কী test হয়েছে।

মূল উপলব্ধি: static analysis-এর মান মাপা হয় ধরা ভুলের সংখ্যায় নয়, মানুষ যে সতর্কবার্তায় সত্যিই কাজ করেন তার অনুপাতে।

প্র ০৩Python-এ type hint ঐচ্ছিক, চলার সময় যাচাইও হয় না। তবু একটি বড় দল কেন লাখো লাইনের পুরোনো কোডে mypy চালাতে চাইবে, আর কীভাবে ধাপে ধাপে করবে?

mypy-র শুরু Jukka Lehtosalo-র গবেষণা থেকে, ২০১০-এর দশকের শুরুতে। পরে Guido van Rossum আর অন্যদের সাথে মিলে PEP 484 (২০১৪ সালে প্রস্তাবিত) Python-এ type hint-এর মানসম্মত রূপ দেয়, যা Python 3.5 (২০১৫)-এ যুক্ত হয়। মূল ধারণা “gradual typing”: যেখানে hint আছে সেখানে যাচাই, যেখানে নেই সেখানে চুপ। এই পর্বের অনুশীলনে দেখবেন, hint ছাড়া একটি ফাংশনে mypy কিছুই বলে না, কারণ ডিফল্টে hint ছাড়া ফাংশনের ভেতরটা সে যাচাই করে না।

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

Dropbox ২০১৯ সালে তাদের engineering blog-এ লেখে, কয়েক বছরে তারা প্রায় ৪০ লাখ লাইনের Python কোডে type check চালু করেছে। তাদের বর্ণনায় ধাপগুলো শিক্ষণীয়: প্রথমে নতুন কোডে hint বাধ্যতামূলক, তারপর সবচেয়ে বেশি ব্যবহৃত module থেকে শুরু, CI-তে mypy যোগ যাতে আর পিছিয়ে না যায়, আর বড় কোডে mypy ধীর হয়ে পড়ায় তার গতি বাড়ানোর কাজ। পরে mypy-কে দ্রুত করতে তার কোড compile করার একটি পদ্ধতিও (mypyc) এসেছে।

Tester-এর জন্য শিক্ষা: type checker একটি সস্তা, দ্রুত, ক্লান্তিহীন reviewer, কিন্তু সে শুধু ততটুকু দেখে যতটুকু hint লেখা আছে। Hint ভুল হলে (যেমন int লেখা, অথচ আসলে None-ও আসে) mypy আত্মবিশ্বাসের সাথে ভুল নিশ্চয়তা দেয়। তাই hint-ও review-এর বিষয়।

মূল উপলব্ধি: gradual typing একটি বড় কোডে ধাপে ধাপে নিরাপত্তার জাল বিছানোর উপায়; জালের ফাঁক কোথায়, তা জানতে হয় hint কোথায় নেই দেখে।

প্র ০৪Ariane 5-এর ১৯৯৬ সালের দুর্ঘটনার তদন্ত testing নিয়ে যেমন কথা বলেছে, review নিয়েও বলেছে। এখান থেকে requirement আর নকশার review সম্পর্কে কী শেখার আছে?

১৯৯৬ সালের ৪ জুন Ariane 5 রকেট প্রথম উড্ডয়নের প্রায় ৪০ সেকেন্ড পরে পথ হারিয়ে ধ্বংস হয়। Jacques-Louis Lions-এর নেতৃত্বে তদন্ত বোর্ডের প্রতিবেদনের সারকথা: inertial reference system-এর software Ariane 4 থেকে নেওয়া হয়েছিল। সেখানে একটি ৬৪-বিটের দশমিক সংখ্যাকে ১৬-বিটের পূর্ণসংখ্যায় রূপান্তরের সময় মান সীমা ছাড়িয়ে যায়, কারণ Ariane 5-এর গতিপথে আনুভূমিক বেগ Ariane 4-এর চেয়ে অনেক বেশি। Exception হয়, আর মূল ও backup দুটি system-ই একই কারণে বন্ধ হয়, আর রকেট ভুল তথ্য পায়। আরও বিস্ময়কর, যে হিসাবটি ব্যর্থ হয় সেটি উড্ডয়নের পরে আর দরকারই ছিল না।

এটি কি testing-এর ব্যর্থতা? আংশিক। প্রতিবেদন বলে, Ariane 5-এর আসল গতিপথের data দিয়ে system-টি পুরোপুরি পরীক্ষা করা হয়নি। কিন্তু মূল ব্যর্থতা ছিল আরও আগে: একটি অনুমান (“এই মান কখনো এত বড় হবে না”) Ariane 4-এর জন্য যুক্তিসংগত ছিল, আর নতুন রকেটের requirement-এর সাথে সেটি কেউ আবার মিলিয়ে দেখেননি। কিছু রূপান্তরে সুরক্ষা রাখা হয়নি সেই অনুমানের ভিত্তিতে, আর সিদ্ধান্তটি নতুন প্রেক্ষাপটে যাচাই হয়নি। প্রতিবেদনের সুপারিশে তাই শুধু বেশি test নয়, requirement, justification আর পুরো flight software-এর review-এর কথাও আছে।

Static testing-এর ভাষায় শিক্ষা তিনটি। এক, পুনর্ব্যবহৃত কোডের অনুমান একটি দলিল, আর সেটিও review-এর বিষয়; “আগে কাজ করেছে” কোনো প্রমাণ নয় (পর্ব ০৩-এর প্রসঙ্গ-নির্ভরতা)। দুই, requirement review-এ সীমার প্রশ্ন (“সর্বোচ্চ মান কত হতে পারে?”) এই পর্বের coupon নিয়মের “ঠিক ১০০০” প্রশ্নের বড় রূপ। তিন, পরে বিমান ও মহাকাশ খাতে abstract interpretation-ভিত্তিক static analysis-এর ব্যবহার বাড়ে, যা সব সম্ভাব্য মানের পরিসর হিসাব করে overflow-এর সম্ভাবনা দেখাতে পারে; Ariane 5-এর কোড এমন একটি tool দিয়ে পরে বিশ্লেষণ করা হয়েছিল বলে প্রায়ই উল্লেখ করা হয়।

মূল উপলব্ধি: সবচেয়ে দামি ভুলগুলো প্রায়ই কোডে নয়, কোডের পেছনের অনুমানে; সেগুলো খুঁজে পাওয়ার জায়গা review-এর টেবিল।

প্র ০৫একজন reviewer এক বসায় কতটা কোড ভালোভাবে দেখতে পারেন? বড় pull request কেন review-এর শত্রু, আর tester এ নিয়ে কী করতে পারেন?

Inspection-এর শুরু থেকেই প্রস্তুতির গতি একটি মাপ ছিল: ঘণ্টায় কত লাইন বা কত পাতা দেখা হলো। ধারণাটি সরল। খুব দ্রুত পড়লে চোখ লাইনের ওপর দিয়ে যায়, মন বিষয়ে ঢোকে না। Fagan-ধাঁচের inspection-এর নির্দেশনায় তাই প্রতি বসায় কতটা দেখা হবে আর সভা কত দীর্ঘ হবে, তার সীমা রাখা হতো।

পরে হালকা code review-এর যুগেও একই পর্যবেক্ষণ এসেছে। SmartBear নামের একটি tool নির্মাতা প্রতিষ্ঠান Cisco-র একটি দলের review data বিশ্লেষণ করে ২০০৬ সালের দিকে একটি বই প্রকাশ করে (Best Kept Secrets of Peer Code Review, Jason Cohen); সেখানে বলা হয়, একবারে কয়েকশো লাইনের বেশি দেখলে আর এক ঘণ্টার মতো সময় পেরোলে প্রতি লাইনে পাওয়া defect কমে যায়। এই গবেষণাটি একটি প্রতিষ্ঠানের data আর tool নির্মাতার নিজের প্রকাশনা, তাই নির্দিষ্ট সংখ্যাগুলো সাবধানে নিন; তবে প্রবণতাটি অনেক দলের অভিজ্ঞতার সাথে মেলে। এর একটি কৌতুকপূর্ণ সংস্করণ developer-দের মধ্যে প্রচলিত: দশ লাইনের বদলে দশটি মন্তব্য, হাজার লাইনের বদলে “দেখতে ভালো”।

বড় বদল কেন খারাপ? মনোযোগ ফুরিয়ে যায়; বদলের উদ্দেশ্য বোঝা কঠিন হয়; একটি ঝুঁকিপূর্ণ লাইন শত সাধারণ লাইনের ভিড়ে হারায়; আর লেখকও বড় বদলে অনেক মন্তব্য পেলে আত্মরক্ষায় যান।

Tester কী করতে পারেন? এক, দলের নিয়মে ছোট pull request-এর পক্ষে কথা বলা, এক বদলে এক উদ্দেশ্য। দুই, review-এর আগে যন্ত্রের কাজ যন্ত্রকে দেওয়া (Ruff, mypy, CI), যাতে মানুষের সীমিত মনোযোগ ব্যবসার নিয়মে যায়। তিন, ঝুঁকিপূর্ণ ফাইলের (টাকার হিসাব, payment) জন্য আলাদা checklist আর নির্দিষ্ট reviewer. চার, নিজের review-এ সময় নেওয়া: দ্রুত “অনুমোদন” দেওয়া reviewer আসলে কিছুই যাচাই করেননি।

মূল উপলব্ধি: review-এর মান নির্ভর করে মানুষের মনোযোগের ওপর, আর মনোযোগ সীমিত সম্পদ; ছোট বদল আর যন্ত্রের আগাম ছাঁকনি সেই সম্পদ বাঁচায়।

অনুশীলন

খাতা-কলমে করুন; উত্তর খোলার আগে নিজের উত্তর লিখে রাখুন।

  1. Requirement review থেকে test case: বাজারঘরের delivery নিয়ম: “ঢাকার ভেতরে ৬০ টাকা, বাইরে ১২০ টাকা।” (ক) §৪-এর checklist ধরে অন্তত চারটি অস্পষ্টতা খুঁজুন। (খ) প্রতিটি প্রশ্নের জন্য একটি করে test case লিখুন, যেখানে প্রত্যাশিত ফলের ঘরে “product owner-এর উত্তর অনুযায়ী” লেখা থাকবে।

    (ক) একটি সম্ভাব্য তালিকা:

    • “ঢাকা” মানে কী? ঢাকা শহর (সিটি কর্পোরেশন), না ঢাকা জেলা? সাভার বা কেরানীগঞ্জ ঢাকা জেলায়, কিন্তু অনেকে শহরের বাইরে ধরেন।
    • নাম কীভাবে লেখা? “Dhaka”, “dhaka”, “ঢাকা”, শেষে ফাঁকা স্থান: সবই কি ঢাকা? (পর্ব ০৩-এ ঠিক এমন একটি bug দেখেছেন।)
    • জেলা না দিলে? Charge কত, নাকি অর্ডারই নেওয়া হবে না?
    • কোন ঠিকানা? ক্রেতার প্রোফাইলের ঠিকানা, না এই অর্ডারের delivery ঠিকানা?
    • কোনো ছাড় বা ব্যতিক্রম? Coupon-এ কি delivery charge-ও কমে? (এই কোর্সে উত্তর: না, ছাড় শুধু পণ্যের দামে।) বড় অর্ডারে কি delivery ফ্রি? (এই কোর্সে উত্তর: ঢাকার ভেতরে অর্ডার ২০০০ টাকা বা বেশি হলে ফ্রি, আর সীমাটি ছাড়ের আগের দামে; পর্ব ০৯।)

    (খ) উদাহরণ test case: TC1 জেলা “Dhaka”, প্রত্যাশিত ৬০. TC2 জেলা “ঢাকা” (বাংলায়), প্রত্যাশিত: উত্তর অনুযায়ী। TC3 ঠিকানা সাভার, প্রত্যাশিত: উত্তর অনুযায়ী। TC4 জেলার ঘর ফাঁকা, প্রত্যাশিত: উত্তর অনুযায়ী (charge, না error বার্তা)। TC5 প্রোফাইলে Rajshahi, অর্ডারের ঠিকানা Dhaka, প্রত্যাশিত: উত্তর অনুযায়ী। লক্ষ করুন, প্রত্যাশিত ফল নিজে বানাননি; প্রশ্ন খোলা রেখেছেন। এটিই requirement review-এর সততা।

  2. আউটপুট অনুমান করুন: নিচের ফাইলে uv run ruff check free_delivery.py --output-format concise (নিয়ম §৭-এর মতো) আর uv run mypy free_delivery.py চালালে কী আসবে? কোন ভুলটি দুটি tool-ই বাদ দেবে?
    import os
    
    
    def is_free(order):
        if order.total != None and order.total > 1000:
            return True

    সত্যিকারের run (Ruff 0.17.5, mypy 2.4.1):

    free_delivery.py:1:8: F401 [*] `os` imported but unused
    free_delivery.py:5:23: E711 Comparison to `None` should be `cond is not None`
    Found 2 errors.
    
    $ uv run mypy free_delivery.py
    Success: no issues found in 1 source file

    Ruff দুটি ধাঁচ ধরল: অব্যবহৃত os আর != None. mypy কিছুই বলল না, কারণ is_free-এ কোনো type hint নেই, আর ডিফল্টে mypy hint ছাড়া ফাংশনের ভেতরটা যাচাই করে না। “Success” মানে এখানে “যাচাই করার মতো কিছু পাইনি”। দুটি tool-ই বাদ দিল আসল যুক্তির ভুল: শর্ত না মিললে ফাংশন কিছু ফেরত দেয় না, অর্থাৎ None, False নয়। আর নাম “free delivery” হলেও requirement-এ এমন নিয়মের কথা আছে কি না, সেটি review-এর প্রশ্ন।

  3. Test-এর bug খুঁজুন: একজন developer coupon-এর জন্য নিচের test লিখলেন। discount-এ ভুল আছে (ঠিক ১০০০-এ ১০০ টাকা ছাড় দেয়), তবু test পাস করে। কেন? কোন tool এটি আগে থেকে ধরত?
    def discount(total: int) -> int:
        return min(total // 10, 300) if total >= 1000 else 0
    
    
    def test_exactly_1000() -> None:
        assert (discount(1000) == 0, "no discount at 1000")

    বন্ধনীর কারণে assert একটি দুই উপাদানের tuple পায়: (False, "no discount at 1000"). ফাঁকা নয় এমন tuple সবসময় সত্য, তাই assert কখনো ব্যর্থ হয় না। সত্যিকারের run (path ছোট করা):

    $ uv run ruff check test_coupon.py --output-format concise
    test_coupon.py:6:5: F631 Assert test is a non-empty tuple, which is always `True`
    
    $ uv run mypy test_coupon.py
    test_coupon.py:6: error: Assertion is always true, perhaps remove parentheses?  [misc]
    
    $ uv run python -c "import test_coupon as t; t.test_exactly_1000(); print('test passed')"
    test_coupon.py:6: SyntaxWarning: assertion is always true, perhaps remove parentheses?
      assert (discount(1000) == 0, "no discount at 1000")
    test passed

    Ruff (F631), mypy আর Python নিজেও (SyntaxWarning) সতর্ক করেছে, তবু test “passed”. সতর্কবার্তা উপেক্ষা করলে ভাঙা test বছরের পর বছর সবুজ থাকতে পারে। ঠিক রূপ: assert discount(1000) == 0, "no discount at 1000"; তখন test সত্যিই fail করবে আর কোডের ভুল ধরা পড়বে। শিক্ষা: test-এর কোডেও static analysis চালান, আর প্রতিটি নতুন test একবার ইচ্ছা করে ভাঙা কোডে চালিয়ে দেখুন লাল হয় কি না।

  4. Review-এর ধরন আর role চিনুন: তিনটি ঘটনা: (ক) নতুন payment নকশা বোঝাতে লেখক দলকে একটি অর্ডারের উদাহরণ ধরে ধাপে ধাপে দেখালেন; কোনো লিখিত রেকর্ড রাখা হয়নি। (খ) Coupon requirement-এর জন্য তিনজন reviewer আগে থেকে checklist নিয়ে পড়লেন, অন্য দলের একজন প্রশিক্ষিত ব্যক্তি সভা চালালেন, একজন সব লিখলেন, আর সময় ও defect-এর সংখ্যা রিপোর্টে গেল। (গ) একজন developer চা খেতে খেতে সহকর্মীকে ফোনে পাঁচ লাইনের বদল দেখালেন। প্রতিটি কোন ধরনের review, আর (খ)-তে কোন কোন role আছে?
    • (ক) Walkthrough: লেখক নিজে চালাচ্ছেন, উদাহরণ ধরে বোঝানো আর মত নেওয়া মূল উদ্দেশ্য, রেকর্ড ঐচ্ছিক।
    • (খ) Inspection: আগাম প্রস্তুতি, checklist, লেখক নন এমন প্রশিক্ষিত moderator, scribe, আর মাপসহ রিপোর্ট। Role: moderator (সভা চালানো ব্যক্তি), scribe (যিনি লিখলেন), reviewer (তিনজন), আর লেখক (requirement যিনি লিখেছেন, পরে সংশোধন করবেন)। পরিকল্পনা যিনি করেছেন, তিনি review leader.
    • (গ) Informal review: কোনো নিয়ম, প্রস্তুতি বা রেকর্ড নেই। ছোট বদলের জন্য এটি যথেষ্ট হতে পারে; তবে বদলটি যদি টাকার হিসাবে হয়, প্রসঙ্গ অনুযায়ী আরও আনুষ্ঠানিক review দরকার।

    একটি সাধারণ ভুল: (ক)-কে technical review বলা। Technical review-এ বিষয়ের দক্ষ সহকর্মীরা একটি প্রযুক্তিগত সিদ্ধান্তে পৌঁছাতে বসেন, আর সাধারণত লিখিত ফল থাকে; এখানে লেখক শুধু বোঝাচ্ছেন।

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

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

ক্রমISTQB-এর syllabus অনুযায়ী একটি review-এর কাজগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Planning — কী, কতটুকু, কোন checklist, কবে শেষ
  2. Review initiation — সবার হাতে উপকরণ আর নির্দেশনা পৌঁছানো
  3. Individual review — প্রত্যেকে আলাদা করে পড়ে নোট লেখা
  4. Communication and analysis — পাওয়া বিষয় আলোচনা ও শ্রেণিবিভাগ
  5. Fixing and reporting — ঠিক করা, যাচাই আর রিপোর্ট

কোন ধরনের review-এ প্রশিক্ষিত moderator, নির্দিষ্ট role, checklist, আগাম প্রস্তুতি আর defect-এর মাপসহ লিখিত রিপোর্ট থাকে, আর লক্ষ্য যত বেশি সম্ভব defect খোঁজা?

  • Informal review
  • Walkthrough
  • Technical review
  • Inspection

একটি আনুষ্ঠানিক review সভায় কে আলোচনা চালান, সময় রাখেন আর নিশ্চিত করেন যে সবাই বলার সুযোগ পান?

  • Scribe
  • Moderator
  • Author
  • Manager

Requirement: “১০০০ টাকার বেশি অর্ডারে ১০% ছাড়”। কোডে লেখা if total >= 1000:, আর কোডে কোনো type বা বানানের ভুল নেই। এই ভুলটি সবচেয়ে নির্ভরযোগ্যভাবে কোনটি ধরবে?

  • Ruff-এর মতো linter
  • mypy-র মতো type checker
  • ঠিক ১০০০ টাকার test case, বা requirement সাথে নিয়ে code review
  • কোড formatter

Python-এর একটি test-এ লেখা: assert (discount(1000) == 0, "no discount"). discount(1000) ভুল করে 100 ফেরত দিলে কী হবে?

  • Test পাস করবে, কারণ assert-এর ভেতরে একটি tuple, যা সবসময় সত্য
  • Test fail করবে, বার্তা “no discount”
  • TypeError হবে
  • Python ফাইলটি চালাতেই অস্বীকার করবে

নিচের কোনটি dynamic testing-এর উদাহরণ?

  • Coupon requirement পড়ে “ঠিক ১০০০-এ কী হবে?” প্রশ্ন তোলা
  • Checkout ফাংশনে 1001 টাকা দিয়ে চালিয়ে ছাড় 100 আসে কি না দেখা
  • mypy দিয়ে type-এর ভুল খোঁজা
  • কোডের inspection সভা

Type hint নেই এমন একটি Python ফাংশনে স্পষ্ট type-এর ভুল আছে, তবু mypy বলল “Success: no issues found”. সবচেয়ে সম্ভাব্য কারণ কী?

  • mypy type-এর ভুল ধরতে পারে না
  • ফাংশনে আসলে কোনো ভুল নেই
  • ডিফল্টে mypy type hint ছাড়া ফাংশনের ভেতরটা যাচাই করে না
  • mypy কোড চালিয়ে দেখেছে যে কোনো exception হয়নি

শব্দকোষ

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

মনে রাখুন

  1. Static testing না চালিয়ে requirement, নকশা, কোড আর test পড়ে defect সরাসরি খোঁজে; dynamic testing চালিয়ে failure দেখে।
  2. চার ধরনের review: informal, walkthrough, technical review, inspection; ঝুঁকি দেখে আনুষ্ঠানিকতা বাছুন।
  3. Inspection-এর role: author, moderator, scribe, reviewer (সাথে manager আর review leader); ধাপ: planning থেকে fixing and reporting.
  4. Requirement review-এ প্রতিটি সীমা আর নামবাচক শব্দে থামুন; উত্তর সংখ্যার উদাহরণসহ লিখিয়ে নিন।
  5. Ruff আর mypy ধাঁচ আর type-এর ভুল সেকেন্ডে ধরে, কিন্তু spec-এর সাথে অমিল ধরে না; tool, মানুষের review আর test, তিনটিই লাগে।

পরের পর্বে: মডিউল ২ শুরু। Coupon নিয়মের অসংখ্য সম্ভাব্য অর্ডার-মূল্য থেকে অল্প কয়েকটি test কীভাবে বাছবেন, যাতে প্রতিটি দলের একটি প্রতিনিধি থাকে: equivalence partitioning.

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

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