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

Test management আর estimation — tool, পরিকল্পনা আর অগ্রগতি

Test Management and Estimation — Tools, Planning and Progress

Taught in Bangla, this lesson treats test management as a cycle of planning, monitoring, control and completion, with tools as its ledger. Three-point estimates and PERT give about 46 hours for two features, while a seeded Monte Carlo puts the 85% figure near 54.6 hours because fix-retest cycles are uncertain. Three real test cycles in a small SQLite tracker are compared with the estimate, and burn-up versus burndown charts show scope change clearly. It ends with decisions when testing falls behind.

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

  • Test planning, monitoring, control আর completion: কে কী করেন, কোন নথি তৈরি হয়
  • Test management tool কী রাখে, কয়েকটি পরিচিত tool আর তাদের লাইসেন্স, আর SQLite-এ নিজের ছোট tracker
  • Ratio, metrics, Wideband Delphi, planning poker, test point আর তিন-বিন্দু অনুমান: কখন কোনটি
  • PERT-এর গড় আর বিচ্যুতি, variance যোগ করা, Monte Carlo দিয়ে P85, আর cone of uncertainty
  • Burn-up আর burndown পড়া, পিছিয়ে পড়লে বিকল্প মেপে সিদ্ধান্ত, আর test completion report-এ অনুমানের শিক্ষা লেখা

১ · Test management — লঞ্চের যাত্রার চারটি কাজ

সদরঘাট থেকে বরিশালগামী একটি লঞ্চের কথা ভাবুন। ছাড়ার আগে সারেং পথ, জ্বালানি আর কোন ঘাটে কখন থামবেন তার হিসাব করেন। পথে বারবার ঘড়ি আর তীরের চিহ্ন মিলিয়ে দেখেন, সময়ের আগে না পিছে। কুয়াশায় দেরি হলে সিদ্ধান্ত নেন: গতি বাড়াবেন, ছোট একটি ঘাট বাদ দেবেন, নাকি যাত্রীদের জানাবেন যে পৌঁছাতে এক ঘণ্টা দেরি হবে। আর ঘাটে পৌঁছে লগবুকে লেখেন কোথায় কত সময় গেল, যাতে পরের যাত্রার হিসাব ভালো হয়। কাজ চারটি: পরিকল্পনা, পথে মাপা, দিক বদলানো, আর শেষে হিসাব।

Test-এর কাজেও ঠিক এই চারটি ধাপ, আর এদের একসাথে বলে test management. ISO/IEC/IEEE 29119-2 মান test management-এর তিনটি process-এর নাম দেয়: test planning, test monitoring and control, আর test completion. ISTQB-এর Foundation syllabus-ও (v4.0, ২০২৩) test process-এর ভেতরে একই কাজগুলো রাখে। নাম যাই হোক, প্রতিটি ধাপের একটি প্রশ্ন আছে:

Test management-এর চক্র

planning → monitoring ⇄ control → completion → next estimate

  1. Planningtest planকী, কতটা, কতক্ষণ?
  2. Monitoringprogress reportআমরা কোথায়?
  3. Controldecision logপিছিয়ে থাকলে কী করব?
  4. Completioncompletion reportকী শিখলাম?
ছবি ৭৪.১ — Monitoring আর control চলে পাশাপাশি, যতদিন test চলে। Completion-এর শিক্ষা (আসলে কত সময় লাগল) পরের release-এর অনুমানের কাঁচামাল।
কাজমূল প্রশ্নযা তৈরি হয়এই কোর্সে কোথায়
Planningকী test হবে, কীভাবে, কতক্ষণে, কে করবেনTest plan, অনুমান, schedule, entry আর exit criteriaপর্ব ১৭ (গঠন), এই পর্ব (অনুমান)
Monitoringপরিকল্পনার তুলনায় আমরা কোথায়Test progress report, burn-up, defect-এর প্রবণতাপর্ব ১৯ (মৌলিক মাপ), এই পর্ব
Controlবিচ্যুতি হলে কী বদলাবসিদ্ধান্তের লিখিত রেকর্ড, নতুন অগ্রাধিকারএই পর্ব
Completionকী হলো, কী রয়ে গেল, কী শিখলামTest completion report, সংরক্ষিত testwareপর্ব ১৯ (রিপোর্টের গঠন), এই পর্ব

পর্ব ১৭ (Test plan আর strategy)-এ আপনি বাজারঘরের রিভিউ feature-এর (US-12) এক পাতার plan লিখেছেন, entry-exit criteria বসিয়েছেন, আর একটি সরল তিন-বিন্দু calculator চালিয়েছেন। পর্ব ১৯ (Test execution আর reporting)-এ planned, executed, passed গুনেছেন আর summary report লিখেছেন। এই পর্ব মাঝের ফাঁক ভরায়: অনুমান কতটা বিশ্বাসযোগ্য, পিছিয়ে পড়লে কী সিদ্ধান্ত, আর শেষে অনুমান বনাম বাস্তব থেকে শেখা।

মূল ধারণা

Test manager বা QA lead-এর আসল কাজ test চালানো নয়, সিদ্ধান্তের তথ্য সময়মতো আর সৎভাবে দেওয়া: কতটা হয়েছে, কতটা বাকি, কোন ঝুঁকি এখনো যাচাই হয়নি, আর তারিখ ধরতে হলে কী ছাড়তে হবে।

২ · Test management tool — খাতা কী রাখে

পাঁচজনের দলে ২০টি test case একটি spreadsheet-এ ভালোই চলে। কিন্তু ৮০০টি case, তিনটি release একসাথে, আর দশজন মানুষ হলে প্রশ্ন জটিল হয়: এই build-এ কোন case শেষবার কবে চলেছে? কোন requirement-এর কোনো পাস করা test নেই? কোন defect কোন case থেকে এসেছে? Test management tool এই প্রশ্নগুলোর জন্য একটি সাধারণ ভান্ডার। প্রায় সব tool-এর ভেতরে একই কয়েকটি জিনিস:

  • Test case আর suite: ধাপ, প্রত্যাশিত ফল, priority, কোন requirement-এর সাথে যুক্ত (traceability).
  • Test run বা test cycle: একটি নির্দিষ্ট build-এ কোন case-গুলো চালানো হবে, কে চালাবেন। একই case বহু run-এ থাকে।
  • Execution: প্রতিবার চালানোর ফল (pass, fail, blocked), সময়, প্রমাণ। পুরোনো ফল মোছে না, নতুন সারি যোগ হয়।
  • Defect-এর link: ব্যর্থ execution থেকে bug tracker-এর defect-এ যাওয়ার পথ (পর্ব ১৮)।
  • রিপোর্ট: অগ্রগতি, requirement coverage, defect-এর প্রবণতা। Automation-এর ফল সাধারণত JUnit XML আকারে ঢোকানো যায় (পর্ব ৬৭)।

কয়েকটি পরিচিত tool, শুধু চেনার জন্য (দাম বা তুলনামূলক রায় নয়; প্রতিটির বৈশিষ্ট্য নিজের প্রয়োজনে তাদের docs-এ মিলিয়ে নিন):

Toolধরনলাইসেন্স
TestRailআলাদা web tool, cloud বা নিজের serverবাণিজ্যিক, proprietary
Zephyr (SmartBear-এর)মূলত Jira-র ভেতরের appবাণিজ্যিক, proprietary
XrayJira-র ভেতরের app; test-কে Jira issue হিসেবে রাখেবাণিজ্যিক, proprietary
qTest (Tricentis-এর)আলাদা web tool, বড় প্রতিষ্ঠানের জন্যবাণিজ্যিক, proprietary
Kiwi TCMSনিজের server-এ চালানো যায় এমন web toolopen source, GPL-2.0
Spreadsheet + bug trackerছোট দলের সবচেয়ে প্রচলিত শুরুযে tool ব্যবহার করেন তার লাইসেন্স

এই পর্বের জন্য Kiwi TCMS নিজের কম্পিউটারে চালানোর কথা ভাবা হয়েছিল, কারণ এটি open source. কিন্তু এর docs স্পষ্ট বলে, production-এ চালাতে container পরিবেশ লাগে, আর উদাহরণগুলো Docker দিয়ে; সাথে আলাদা database server. এই কোর্সের lab-এ Docker নেই, আর একটি ভারী service শুধু চার টেবিলের ধারণা দেখাতে চালানো অপচয়। তাই নিচে একটি ছোট SQLite tracker বানানো হয়েছে, যা প্রতিটি tool-এর মূল কাঠামো খোলাখুলি দেখায়।

Tool বাছার প্রশ্ন, দামের আগে: দল কি আগে থেকেই Jira ব্যবহার করে? Automation-এর ফল কি স্বয়ংক্রিয়ভাবে ঢোকে? Data export করা যায় তো, যাতে tool বদলালে ইতিহাস না হারায়? আর ডেটা কোথায় থাকে (পর্ব ৬৫)? Tool বদলে প্রক্রিয়া ঠিক হয় না; খারাপ প্রক্রিয়া দামি tool-এ শুধু বেশি সুন্দর দেখায়।

নিজের ছোট tracker — চারটি টেবিল

নিচের tracker.py শুধু Python-এর standard library দিয়ে লেখা। চারটি টেবিল: test_case, test_run, execution (প্রতিবার চালানো একটি নতুন সারি), আর defect. অগ্রগতির হিসাব একটি function-এ: scope কত, কয়টি case অন্তত একবার চলেছে, কয়টির সর্বশেষ ফল pass, আর কয়টি defect খোলা। পর্ব ১৯-এর একটি শিক্ষা এখানে নিয়ম হয়ে বসেছে: পুরোনো pass পরের fail-কে ঢাকতে পারে না। (Blocked-এর নিয়মে এই ছোট কোডের একটি ফাঁক আছে; অনুশীলন ১-এ নিজেই খুঁজে পাবেন।)

SCHEMA = """
CREATE TABLE IF NOT EXISTS test_case(id TEXT PRIMARY KEY, area TEXT, title TEXT, added_at REAL);
CREATE TABLE IF NOT EXISTS test_run(id INTEGER PRIMARY KEY, name TEXT, build TEXT, bugs TEXT);
CREATE TABLE IF NOT EXISTS execution(id INTEGER PRIMARY KEY, run_id INT, tc_id TEXT,
    status TEXT CHECK(status IN ('pass','fail','blocked')), secs REAL, at REAL);
CREATE TABLE IF NOT EXISTS defect(id TEXT PRIMARY KEY, tc_id TEXT, severity TEXT,
    title TEXT, status TEXT DEFAULT 'open', run_id INT);
"""

def record_run(con, run_id, xml_path):
    """One execution row per testcase, in file order, stamped as it is read."""
    for tc in ET.parse(xml_path).getroot().iter("testcase"):
        bad = tc.find("failure") is not None or tc.find("error") is not None
        con.execute("INSERT INTO execution(run_id,tc_id,status,secs,at) VALUES(?,?,?,?,?)",
                    (run_id, tc_id(tc.get("name")), "fail" if bad else "pass",
                     float(tc.get("time")), time.time()))

def progress(con):
    """Burn-up point: scope, executed at least once, passing on latest execution, open defects."""
    scope = con.execute("SELECT COUNT(*) FROM test_case").fetchone()[0]
    done = con.execute("SELECT COUNT(DISTINCT tc_id) FROM execution").fetchone()[0]
    passing = con.execute("""SELECT COUNT(*) FROM execution e WHERE status='pass' AND id =
        (SELECT MAX(id) FROM execution WHERE tc_id = e.tc_id)""").fetchone()[0]
    opened = con.execute("SELECT COUNT(*) FROM defect WHERE status='open'").fetchone()[0]
    return scope, done, passing, opened

এই tracker automation-এর JUnit XML পড়ে execution লেখে; হাতে চালানো test হলে tester নিজে সারি যোগ করতেন। অংশ ৬-এ এটি দিয়ে সত্যিকারের তিনটি test cycle চলবে।

৩ · Estimation-এর কৌশল — test-এর চোখে

সাধারণ software estimation (story point, function point, COCOMO, planning poker-এর পূর্ণ রাউন্ড) সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৬০-এ, আর WBS, Gantt আর CPM-PERT পর্ব ৬১-এ। এখানে প্রশ্ন সরু: test estimation-এ কোন কৌশল কী ধরে নেয়, আর test-এর কাজে কোথায় ফাঁদ। ISTQB-এর Foundation syllabus চারটির নাম দেয়: ratio, extrapolation, Wideband Delphi আর three-point; বাস্তবে আরও কয়েকটি চলে।

➗ Ratio-ভিত্তিক

Ratio-based estimation: আগের release-এ development-এর তুলনায় test-এ কত সময় গেছে, সেই অনুপাত নতুন কাজে বসানো। দ্রুত, কিন্তু দুই release-এর ঝুঁকি আলাদা হলে ভুল।

ধরে নেয়: কাজের ধরন একই

📏 Metrics-ভিত্তিক

Metrics-based estimation: test case-এর সংখ্যা × আগের মাপা মিনিট, আর retest-এর অনুপাত। Extrapolation-ও এই পরিবারের: চলমান কাজের প্রথম কয়েক দিনের হার থেকে বাকিটা।

ধরে নেয়: ইতিহাস সব কাজ ধরেছে

🗳️ বিশেষজ্ঞ-ভিত্তিক

Wideband Delphi: কয়েকজন গোপনে অনুমান, পরিসর দেখানো, আলোচনা, আবার গোপনে। Planning poker এর agile রূপ, story point-এ।

ধরে নেয়: বিশেষজ্ঞরা কাজটি চেনেন

🧩 ভাগ করে অনুমান

WBS-এ কাজ ভেঙে প্রতিটিতে three-point estimation. পুরোনো আরেকটি পদ্ধতি test point analysis, যা function point-এর ধাঁচে আকার মাপে।

ধরে নেয়: কোনো কাজ বাদ পড়েনি

Test point analysis সাধারণভাবে ১৯৯০-এর দশকে ডাচ প্রতিষ্ঠান Sogeti-র TMap পদ্ধতির অংশ হিসেবে পরিচিত বলে বলা হয়: function point থেকে শুরু করে প্রতিটি function-এর গুরুত্ব, ব্যবহার আর জটিলতা দিয়ে ওজন দেওয়া। আজ এটি কম দেখা যায়, কিন্তু মূল কথাটি কাজের: সব function-এর test সমান ভারী নয়, যা পর্ব ৭৩ (Risk-based testing)-এর মূল ভাবনা।

একই feature, চারটি পদ্ধতি

বাজারঘরের checkout-এর test-এর অনুমান চার পথে; সংখ্যা কাল্পনিক, হিসাব সত্যি। Metrics-এর মিনিটগুলো পর্ব ১৭-এর calculator-এর একই অনুমান (প্রতি case লেখা ১৫, চালানো ৬, প্রথমবার ২০% ফেল, ৫০% regression):

import math, statistics
# One feature (checkout tests), four estimation methods. All numbers invented.
# 1) ratio-based: test effort as a share of development effort, from past releases
DEV_HOURS = 120
PAST = [(100, 31), (80, 30), (150, 48)]       # (dev h, test h) of earlier releases
ratio = sum(t for _, t in PAST) / sum(d for d, _ in PAST)
print(f"ratio  : {ratio:.3f} x {DEV_HOURS} h = {ratio * DEV_HOURS:.1f} h")
# 2) metrics-based: test case count x measured minutes per activity
CASES, DESIGN, RUN, FAIL, REG = 40, 15, 6, 0.20, 0.50
mins = CASES * DESIGN + CASES * RUN + math.ceil(CASES * FAIL) * RUN \
       + math.ceil(CASES * REG) * RUN + 8 * 20 + 120       # 8 bug reports, setup
print(f"metrics: {mins} min = {mins / 60:.1f} h")
# 3) Wideband Delphi: anonymous rounds, coordinator shows the spread
rounds = [[30, 45, 38, 70], [40, 46, 42, 52]]
for i, r in enumerate(rounds, 1):
    lo, hi, med = min(r), max(r), statistics.median(r)
    print(f"delphi round {i}: {sorted(r)} median={med} spread={hi / lo:.2f}x")
# 4) three-point on the work breakdown (O, M, P hours)
WBS = [(6, 8, 14), (2, 3, 6), (5, 7, 10), (6, 9, 16), (3, 4, 7)]
e = sum((o + 4 * m + p) / 6 for o, m, p in WBS)
sd = math.sqrt(sum(((p - o) / 6) ** 2 for o, _, p in WBS))
print(f"3-point: E={e:.1f} h sd={sd:.1f} h -> about {e - sd:.0f}..{e + sd:.0f} h (one sd)")
est = [ratio * DEV_HOURS, mins / 60, statistics.median(rounds[-1]), e]
print(f"methods span {min(est):.1f}..{max(est):.1f} h, median {statistics.median(est):.1f} h")

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

ratio  : 0.330 x 120 h = 39.6 h
metrics: 1288 min = 21.5 h
delphi round 1: [30, 38, 45, 70] median=41.5 spread=2.33x
delphi round 2: [40, 42, 46, 52] median=44.0 spread=1.30x
3-point: E=33.2 h sd=2.5 h -> about 31..36 h (one sd)
methods span 21.5..44.0 h, median 36.4 h

সবচেয়ে কম অনুমানটিই সবচেয়ে সন্দেহজনক। Metrics-ভিত্তিক ২১.৫ ঘণ্টা বাকি তিনটির প্রায় অর্ধেক। এর ইতিহাসে test analysis, exploratory session, আলোচনা আর পরিবেশের সমস্যা নেই। পদ্ধতিটি ভুল নয়, তার কাঁচামাল অসম্পূর্ণ। Metrics-এর মান নির্ভর করে কোন কাজ মাপা হয়েছিল তার ওপর।

Delphi-র দুই রাউন্ড। প্রথম রাউন্ডে ৩০ থেকে ৭০, সর্বোচ্চ সর্বনিম্নের ২.৩৩ গুণ। দ্বিতীয় রাউন্ডে ৪০ থেকে ৫২, পরিসর ১.৩০ গুণে নেমেছে। পরিসর সরু হওয়া মানে আলোচনায় নতুন তথ্য ভাগ হয়েছে; শুধু গড় করলে সেই তথ্যটি হারিয়ে যেত।

চারটি পদ্ধতি একসাথে। পরিসর ২১.৫ থেকে ৪৪.০ ঘণ্টা। পেশাদার অভ্যাস হলো অন্তত দুটি স্বাধীন পদ্ধতি চালানো, আর বড় পার্থক্য পেলে গড় না করে কারণ খোঁজা।

৪ · তিন-বিন্দু অনুমান গভীরে — গড়, বিচ্যুতি আর retest-এর চক্র

পর্ব ১৭-এ সূত্রটি দেখেছেন: PERT-এর গড় E = (O + 4M + P) / 6. এর সঙ্গী একটি বিচ্যুতির মাপ, standard deviation σ = (P − O) / 6. কয়েকটি স্বাধীন কাজ যোগ করলে গড় যোগ হয়, কিন্তু σ সরাসরি যোগ হয় না: যোগ হয় variance (σ²), তারপর বর্গমূল। কারণ সব কাজ একসাথে সবচেয়ে খারাপ হওয়ার সম্ভাবনা কম।

Test-এর অনুমানে একটি অংশ বাকিগুলোর মতো নয়: fix আর retest-এর চক্র কতবার লাগবে। প্রথম চক্রে কয়টি defect পাওয়া যাবে, developer কত দ্রুত ঠিক করবেন, ঠিক করার পরে নতুন কিছু ভাঙবে কি না, এর কোনোটিই tester-এর হাতে নেই। নিচের ধাপগুলোতে review আর checkout-এর test-এর একটি পূর্ণ অনুমান দেখুন (ঘণ্টা মানে person-hour, একজন মানুষের এক ঘণ্টার কাজ; সংখ্যা কাল্পনিক, হিসাব script দিয়ে মেলানো)।

অনুমানের খাতা (person-hour)
কাজ
O · M · P
E
σ
  1. কাজ ভাঙা। চারটি কাজ: test analysis আর design, পরিবেশ আর test data, প্রথমবার চালানো, regression আর রিপোর্ট। পঞ্চম অংশ আলাদা: fix-retest চক্র, যার সংখ্যাই অনিশ্চিত। শুরুতেই প্রশ্ন করুন, কোনো কাজ বাদ পড়েনি তো? আগের অংশে metrics-ভিত্তিক অনুমান ঠিক এখানেই হোঁচট খেয়েছে।
  2. প্রথম কাজ। Analysis আর design: O = ১০, M = ১৪, P = ২৪ ঘণ্টা। E = (১০ + ৪ × ১৪ + ২৪) ÷ ৬ = ৯০ ÷ ৬ = ১৫.০০; σ = (২৪ − ১০) ÷ ৬ = ২.৩৩. খেয়াল করুন, E সবচেয়ে সম্ভাব্য মান ১৪-এর চেয়ে বেশি, কারণ P অনেক দূরে।
  3. বাকি তিনটি। পরিবেশ ২·৪·১০ থেকে E ৪.৬৭, σ ১.৩৩; প্রথম run ৮·১০·১৪ থেকে E ১০.৩৩, σ ১.০০; regression আর রিপোর্ট ৪·৬·১০ থেকে E ৬.৩৩, σ ১.০০. পরিবেশের কাজ ছোট, কিন্তু অনুপাতে সবচেয়ে অনিশ্চিত: P হলো M-এর আড়াই গুণ।
  4. যোগ। গড়ের যোগ ১৫.০০ + ৪.৬৭ + ১০.৩৩ + ৬.৩৩ = ৩৬.৩৩ ঘণ্টা। σ-এর যোগ ২.৩৩ + ১.৩৩ + ১ + ১ = ৫.৬৭ নয়; variance-এর যোগ ৫.৪৪ + ১.৭৮ + ১ + ১ = ৯.২২, বর্গমূল ৩.০৪. একাধিক কাজ যোগ করলে আপেক্ষিক অনিশ্চয়তা কমে, যদি কাজগুলো সত্যিই স্বাধীন হয়।
  5. Retest-এর চক্র। এক চক্রে ৩·৪·৬ ঘণ্টা, E ৪.১৭. চক্রের সংখ্যা অতীত থেকে: ১টি ২০%, ২টি ৪০%, ৩টি ৩০%, ৪টি ১০% সম্ভাবনা, প্রত্যাশিত ২.৩টি। প্রত্যাশিত সময় ২.৩ × ৪.১৭ = ৯.৫৮. মোট PERT গড় ৩৬.৩৩ + ৯.৫৮ ≈ ৪৫.৯ ঘণ্টা। কিন্তু চক্রের সংখ্যা একটি লাফানো সংখ্যা; তার ছড়ানো ছবি সূত্রে আসে না।
  6. যা জানানো হবে। নিচের Monte Carlo একই অনুমান ২০,০০০ বার চালিয়ে বলছে: ৮৫% সম্ভাবনায় ৫৪.৬ ঘণ্টার মধ্যে শেষ। দিনে ৬ ঘণ্টা মনোযোগের কাজে একজনের ৯.১ দিন, plan-এ ১০ দিন। জানানোর বাক্য: “গড়ে ৪৬–৪৯ ঘণ্টা; ৮৫% নিশ্চয়তায় ৫৫ ঘণ্টা; retest চক্র তিনটির বেশি লাগলে বাড়বে।”

Monte Carlo simulation-এর ধারণা সরল: প্রতিটি কাজের সময় তার O-M-P পরিসর থেকে এলোমেলোভাবে একটি মান নিয়ে মোট যোগ করুন; চক্রের সংখ্যাও সম্ভাবনা অনুযায়ী এলোমেলোভাবে নিন। হাজারবার করলে মোট সময়ের একটি বণ্টন পাওয়া যায়, যেখান থেকে “৮৫% সম্ভাবনায় কত”, অর্থাৎ percentile, সরাসরি পড়া যায়। নিচের কোড এলোমেলো সংখ্যার জন্য triangular distribution ব্যবহার করে, আর seed ৭৪ দেওয়া, তাই প্রতিবার একই ফল:

import math, random, statistics
# Test effort for review + checkout, person-hours (invented O, M, P)
TASKS = {"analysis + design": (10, 14, 24),
         "environment + data": (2, 4, 10),
         "first execution":    (8, 10, 14),
         "regression + report": (4, 6, 10)}
CYCLE = (3, 4, 6)                    # one fix -> retest cycle, hours
CYCLES, WEIGHTS = [1, 2, 3, 4], [0.2, 0.4, 0.3, 0.1]
e_sum = var = 0.0
for name, (o, m, p) in TASKS.items():
    e, s = (o + 4 * m + p) / 6, (p - o) / 6
    e_sum += e; var += s * s
    print(f"{name:20} E={e:5.2f} h  sd={s:4.2f}")
ec = sum(c * w for c, w in zip(CYCLES, WEIGHTS))       # expected cycles
e_cyc = (CYCLE[0] + 4 * CYCLE[1] + CYCLE[2]) / 6
print(f"{'retest cycles':20} E={ec * e_cyc:5.2f} h  ({ec:.1f} cycles x {e_cyc:.2f} h)")
e_all = e_sum + ec * e_cyc
print(f"PERT total {e_all:.1f} h; tasks-only sd {math.sqrt(var):.2f} h")
rng = random.Random(74)
runs = []
for _ in range(20000):
    t = sum(rng.triangular(o, p, m) for o, m, p in TASKS.values())
    n = rng.choices(CYCLES, WEIGHTS)[0]
    t += sum(rng.triangular(CYCLE[0], CYCLE[2], CYCLE[1]) for _ in range(n))
    runs.append(t)
q = statistics.quantiles(runs, n=100)
print(f"Monte Carlo 20000 runs: P50={q[49]:.1f} P85={q[84]:.1f} P95={q[94]:.1f} h")
print(f"chance to finish within {e_all:.0f} h: {sum(r <= round(e_all) for r in runs) / len(runs):.0%}")
print(f"P85 for 1 tester at 6 focused h/day: {q[84] / 6:.1f} days -> plan {math.ceil(q[84] / 6)}")

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

analysis + design    E=15.00 h  sd=2.33
environment + data   E= 4.67 h  sd=1.33
first execution      E=10.33 h  sd=1.00
regression + report  E= 6.33 h  sd=1.00
retest cycles        E= 9.58 h  (2.3 cycles x 4.17 h)
PERT total 45.9 h; tasks-only sd 3.04 h
Monte Carlo 20000 runs: P50=48.5 P85=54.6 P95=58.2 h
chance to finish within 46 h: 33%
P85 for 1 tester at 6 focused h/day: 9.1 days -> plan 10

PERT-এর গড়ে শেষ হওয়ার সম্ভাবনা মাত্র ৩৩%. “৪৬ ঘণ্টা” বললে তিনবারে দুবার কথা রাখা যাবে না। এর দুটি কারণ। প্রথমত, P50 (৪৮.৫) PERT-এর ৪৫.৯-এর চেয়ে বেশি: triangular বণ্টনের গড় (O + M + P) ÷ ৩, যা ডানে লম্বা লেজের কাজে PERT-এর (O + 4M + P) ÷ ৬-এর চেয়ে বড়। যেমন analysis-এ (১০ + ১৪ + ২৪) ÷ ৩ = ১৬, PERT-এ ১৫. কোন বণ্টন বাস্তবের কাছাকাছি, তা জানা যায় শুধু নিজের ইতিহাস মেপে। দ্বিতীয়ত, retest চক্রের সংখ্যা ১ থেকে ৪ লাফায়; চার চক্রের দুর্ভাগ্য P95-কে ৫৮.২-এ ঠেলে দেয়।

কোন সংখ্যা plan-এ যাবে, তা ব্যবসার সিদ্ধান্ত। P50 মানে আধাআধি ঝুঁকি; P85 সাধারণ সতর্ক পছন্দ; চুক্তির তারিখে কেউ P95 চান। কোন percentile-এ commit হবে, তা ঠিক করেন যিনি ঝুঁকির দায় নেন। নিজে করে দেখুন: WEIGHTS-কে [0.5, 0.3, 0.15, 0.05] করলে, অর্থাৎ developer-রা প্রথমবারেই বেশি ঠিক করলে, P85 কতটা নামে?

স্বাধীনতার অনুমান প্রায়ই মিথ্যা। Variance যোগ করার নিয়ম ধরে নেয় কাজগুলো একে অপরের ওপর নির্ভর করে না। বাস্তবে একই কারণ (যেমন অস্থির test environment) একসাথে অনেক কাজকে ধীর করে। এজন্যই একক σ-এর চেয়ে নিজের অতীতের আসল-বনাম-অনুমান তালিকা বেশি নির্ভরযোগ্য।

Cone of uncertainty — কখন অনুমান বিশ্বাস করবেন

Barry Boehm-এর ১৯৮১ সালের বই থেকে Steve McConnell-এর জনপ্রিয় করা cone of uncertainty-র ছবি বলে: শুরুর ধারণার পর্যায়ে অনুমান আসল মানের এক-চতুর্থাংশ থেকে চার গুণ পর্যন্ত ভুল হতে পারে, আর requirement ও নকশা স্থির হওয়ার সাথে পরিসর সরু হয়। ছবিটি সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৬০-এ আছে। এর সংখ্যাগুলোর তথ্যভিত্তি নিয়ে কিছু লেখক, যেমন Laurent Bossavit, প্রশ্ন তুলেছেন; তাই সংখ্যাগুলো আইন হিসেবে নয়, একটি ধারণা হিসেবে নিন। Test-এর জন্য এর তিনটি ব্যবহারিক শিক্ষা:

  1. Test-এর অনুমান দেরিতে স্থির হয়: case-এর সংখ্যা জানা যায় test analysis-এর পরে, retest-এর সংখ্যা প্রথম run-এর পরে। শুরুতে চওড়া পরিসর দিন।
  2. নির্দিষ্ট মুহূর্তে আবার অনুমান করুন: requirement review শেষে, test design শেষে, প্রথম cycle শেষে। প্রতিবার পরিসর সরু হওয়া উচিত; না হলে কিছু একটা স্থির হচ্ছে না।

৫ · Delphi আর planning poker — মানুষের অনুমান একসাথে

Wideband Delphi (Barry Boehm-এর ১৯৮১ সালের বইয়ে বর্ণিত, RAND-এর Delphi পদ্ধতির একটি রূপ) আর planning poker (James Grenning ২০০২, পরে Mike Cohn-এর বইয়ে জনপ্রিয়)-এর ইতিহাস আর পূর্ণ রাউন্ড সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ৬০-এ। দুটির মূল নিয়ম এক: প্রথম অনুমান গোপনে আর একসাথে, যাতে প্রথম শোনা সংখ্যা বাকিদের টেনে না নেয়; এই টানের নাম anchoring, আর গোপনে দিলেই তা এড়ানো যায়।

Test-এর অনুমানে এই আলোচনা বিশেষ কাজের, কারণ test-এর অজানা ঝুঁকি প্রায়ই একজন মানুষই জানেন। একটি sprint planning-এ ভাবুন, তিনজন developer আর একজন tester একটি story-তে “৩, ৩, ৫, ১৩” দেখালেন। ১৩ দিয়েছেন tester: “Mobile-wallet-এর timeout হলে দুবার টাকা কাটার পুরোনো সমস্যা (পর্ব ৩৭) আবার যাচাই করতে হবে, আর তার জন্য fake gateway-কে timeout-এ রাখার পরিবেশ লাগবে।” Developer-রা শুধু কোড লেখার কাজ গুনেছিলেন। আলোচনার পরে দ্বিতীয় রাউন্ডে “৮, ৮, ৮, ১৩”। এই তথ্য না এলে story-টি sprint-এ ঢুকত ছোট আকারে, আর শেষ দিনে test-এর সময় চেপে যেত।

Story point বনাম ঘণ্টা: agile দলে test আলাদা অনুমান হয় না; story-র point-এর মধ্যে test-ও থাকে, আর “Done” মানে test হয়েছে (পর্ব ৪৪-এর definition of done). আলাদা test পর্যায় (যেমন UAT) থাকলে তা সাধারণত ঘণ্টায় অনুমান হয়। দুটি একক মেশাবেন না: “১৩ point = ২৬ ঘণ্টা” ধরনের স্থির রূপান্তর story point-এর উদ্দেশ্যই নষ্ট করে।

৬ · সত্যিকারের run — অনুমান আগে, তারপর তিনটি test cycle

এবার অনুমান আর বাস্তবের সত্যিকারের তুলনা। মানুষের সময় (test লেখা, ভাবা, bug report) এখানে মাপা সম্ভব নয়; যা মাপা যায় তা হলো যন্ত্রের সময়: test cycle চালাতে কম্পিউটারের কত সেকেন্ড লাগে। পদ্ধতি একই: আগের মাপা ইতিহাস থেকে O-M-P, অনুমান লিখে রাখা, তারপর চালানো আর মেলানো।

সবকিছু এই কোর্সের লেখার সময় একটি সাধারণ Windows ডেস্কটপে চালানো, বাজারঘর app-এর একটি কপির বিরুদ্ধে, শুধু 127.0.0.1:8892-এ, নিজের SQLite database নিয়ে। Python 3.12.13, pytest 9.2.0 (MIT), httpx 0.28.1 (BSD-3-Clause), Uvicorn 0.54.0 (BSD-3-Clause), uv 0.11.28 (MIT অথবা Apache-2.0), আর Python-এর নিজের sqlite3 (SQLite 3.53.1). এই tool-গুলোর কোনোটি usage-তথ্য পাঠায় না; app নিজেও বাইরে কোনো যোগাযোগ করে না। Path নিরপেক্ষ করা।

কী test হবে — ২৪টি case, তিনটি cycle

  • Review (TC-R01–R12): AC1–AC6-এর মূল সীমা: অধিকার (403, 409), তারা 0, 6 আর "5", লেখা ৯/১০ আর ৫০০/৫০১ অক্ষর, ৫টি emoji, গড় “4.3”.
  • Checkout (TC-C01–C12): coupon আর delivery-র সীমা, phone-এর দুটি নিয়ম, 1001 টাকার order-এ মোট 961, timeout-এর পরে একই Idempotency-Key-তে একটিই charge, shipped order cancel করলে 409.
  • Cycle 1 (build 1.4.0): app-এ দুটি বসানো (seeded) bug চালু, coupon_ge আর review_utf16_length. এগুলো course-এর app-এর ইচ্ছাকৃত switch, আসল খুঁজে পাওয়া defect নয়। Cycle 2 (build 1.4.1, bug বন্ধ): ব্যর্থ case-এর retest, আর scope-এ যোগ হওয়া দুটি নতুন regression test. Cycle 3: পুরো ২৬টির regression.

প্রথমে অনুমান, চালানোর আগে লেখা

আগের পর্বগুলোর সত্যিকারের মাপ থেকে দুটি তিন-বিন্দু: প্রতিবার pytest চালানোর বাড়তি খরচ (server চালু আর pytest শুরু), পর্ব ৬৪-এ app চালু হতে প্রায় ০.৬ সেকেন্ড আর পর্ব ৬৭-এর পাঁচটি run-এ wall সময় থেকে pytest-এর সময় বাদ দিয়ে ০.৬৭ থেকে ১.৩২ সেকেন্ড, তাই O ০.৬০, M ০.৭৫, P ১.৩২; আর প্রতিটি live API test, পর্ব ৬৭-এ ০.০৮৫ থেকে ০.১১০ আর পর্ব ৬৪-এর api stage-এ ০.১১৭ সেকেন্ড, তাই O ০.০৮৫, M ০.১০০, P ০.১১৭. Cycle 2-এ দুটি retest ধরা হয়েছে, কারণ দুটি bug আমরা নিজেরাই বসিয়েছি; সেটি একটি সুবিধা, যা আসল project-এ থাকে না। estimate.py-এর সত্যিকারের আউটপুট:

$ python estimate.py
cycle 1: review          E= 2.02 s  sd=0.14
cycle 1: checkout        E= 2.02 s  sd=0.14
cycle 2: retest + 2 new  E= 1.22 s  sd=0.12
cycle 3: regression      E= 3.43 s  sd=0.18
total E=8.70 s  sd=0.29  ~95% range 8.11..9.28 s
assumed fail rate (lesson 17 plan): 20% of 24 = 5

তারপর চালানো

run_cycles.py প্রতিটি cycle-এ নিজের server চালু করে, pytest চালিয়ে JUnit XML লেখে, tracker-এ execution লেখে, ব্যর্থ case থেকে defect খোলে, আর শেষে নিজের চালু করা server-টিকেই তার process দিয়ে বন্ধ করে। Retest-এ case পাস করলে তার defect বন্ধ হয়। চতুর্থ run-এর পুরো আউটপুট:

cd ~/bazarghar-qa
uv sync                                  # app + pytest + httpx from uv.lock
uv run python run_cycles.py              # port 8892, own lab.db, own tracker.db
  checkpoint plan registered        scope=24 executed= 0 passing= 0 open_defects=0
== cycle 1 build=1.4.0 bugs=coupon_ge,review_utf16_length  server ready in 0.70 s
  review      1.43 s  1 failed, 11 passed in 1.10s
  checkpoint after review           scope=24 executed=12 passing=11 open_defects=1
  checkout    1.51 s  1 failed, 11 passed in 1.16s
  checkpoint after checkout         scope=24 executed=24 passing=22 open_defects=2
  cycle wall (server + pytest) 3.64 s
  checkpoint scope +2 (regression)  scope=26 executed=24 passing=22 open_defects=2
== cycle 2 build=1.4.1 bugs=-  server ready in 0.67 s
  retest      0.84 s  4 passed in 0.45s
  checkpoint after retest           scope=26 executed=26 passing=26 open_defects=0
  cycle wall (server + pytest) 1.50 s
== cycle 3 build=1.4.1 bugs=-  server ready in 0.66 s
  regression  2.87 s  26 passed in 2.52s
  checkpoint after regression       scope=26 executed=26 passing=26 open_defects=0
  cycle wall (server + pytest) 3.52 s
all three cycles: 9.37 s wall
executions: 54 | per status: [('fail', 2), ('pass', 52)]
defects: [('BG-201', 'TC-R10', 'closed'), ('BG-202', 'TC-C01', 'closed')]

দুটি ব্যর্থতা ঠিক যেখানে প্রত্যাশিত: TC-R10 (৫টি emoji UTF-16 হিসাবে ১০ একক, তাই ভুল build সেটি গ্রহণ করেছে) থেকে BG-201, আর TC-C01 (১০০০ টাকায় ছাড় পেয়ে গেছে) থেকে BG-202. নতুন দুটি regression test সত্যিই কিছু ধরে কি না, তা আলাদা যাচাই করা হলো: bug দুটি আবার চালু করে শুধু test_regression.py চালালে দুটিই ফেল করে, assert 960 == 1060 আর assert 422 == 201. যে regression test bug চালু থাকলেও পাস করে, সেটি scope বাড়ায়, সুরক্ষা নয়।

Script-টি মোট চারবার চালানো হয়েছে (প্রথম তিনবার tracker-এ পরিকল্পনা আগে না বসিয়ে; cycle-এর কাজ হুবহু একই)। শেষ লাইনের ৯.৩৭ সেকেন্ডে tracker-এ পরিকল্পনা বসানোর সময়ও আছে, তাই তুলনা শুধু তিনটি cycle-এর wall সময়ের যোগফলে:

Cycleঅনুমান E (σ)run ১run ২run ৩run ৪
1: review + checkout4.04 s (0.20)4.473.633.703.64
2: retest + ২টি নতুন1.22 s (0.12)1.411.491.421.50
3: regression ২৬3.43 s (0.18)3.323.633.243.52
মোট8.70 s (8.11–9.28)9.208.758.368.66

মোট চমৎকার মিলেছে, কিন্তু আংশিক ভাগ্যে। চারটি মোটই ৯৫%-এর পরিসরের ভেতরে। কিন্তু ভেতরে দেখুন:

  • Cycle 2 প্রতিবার বেশি: ১.৪১ থেকে ১.৫০, অনুমানের চেয়ে ১৬–২৩%. ছোট cycle-এ নির্দিষ্ট খরচই প্রধান: wall ১.৫০ থেকে pytest-এর নিজের ০.৪৫ বাদ দিলে ১.০৫ সেকেন্ড শুধু server আর pytest চালু হওয়া, অথচ অনুমানে M ছিল ০.৭৫. আর এই চারটি test অন্যদের চেয়ে ভারী (order বানানো, ৫০০ emoji).
  • Cycle 1 প্রায়ই কম: অনুমান দুটি batch-এর জন্য দুবার “server + pytest” খরচ ধরেছিল, কিন্তু server চালু হয়েছে একবারই। একটি ভুল আরেকটিকে কাটাকাটি করেছে। মোট মিলে যাওয়া মানেই প্রতিটি অংশ ঠিক নয়।
  • প্রথম run ধীর: run ১-এ server চালু হতে ১.৪২ সেকেন্ড (নতুন database তৈরি, ঠান্ডা disk cache), পরের তিনবার ০.৬৬–০.৭০. পর্ব ৬৭-এও প্রথম run ধীর ছিল।
  • সবচেয়ে বড় অনিশ্চয়তা অনুমানেই ছিল না: retest-এর সংখ্যা। বসানো bug দুটি জানা ছিল বলে retest ২টি ধরা গেছে। পর্ব ১৭-এর plan-এর মতো ২০% ধরলে ৫টি ব্যর্থতা, আর cycle 2-এর অনুমান ১.২২ থেকে বেড়ে প্রায় ১.৫২ সেকেন্ড।

যন্ত্রে ২৬টি case-এর পুরো regression ৩.৫ সেকেন্ডের কম; পর্ব ১৭-এর অনুমানে একজন মানুষের হাতে প্রতিটি case চালাতে ৬ মিনিট। তবু automation-এর effort শূন্য নয়: ২৬টি test লেখা, বসানো bug দিয়ে যাচাই আর tracker বানানো মানুষের কাজ, যা এই টেবিলে নেই। অনুমানে তিনটি ঘর রাখুন: লেখা, চালানো, রক্ষণাবেক্ষণ (পর্ব ৬৮)।

Tracker-এর একটি দিন — ধাপে ধাপে

tracker.db · progress()
মুহূর্ত
scope
executed
passing
খোলা defect
  1. পরিকল্পনা বসানো। চালানোর আগেই ২৪টি case tracker-এ। এটি জরুরি: scope আগে না বসালে প্রথম batch-এর পরে tracker ভাববে মোট case ১২টি, আর “১২-এর ১২ চলেছে” দেখাবে ১০০%. এই পর্বের প্রথম তিনটি run-এ ঠিক এই ভুলটিই ছিল।
  2. Review batch. ১২টি চলল, ১১টি পাস। TC-R10 ফেল: ৫টি emoji-র রিভিউ গ্রহণ করা হয়েছে, যা AC3 অনুযায়ী ১০ code point-এর কম। Defect BG-201 খোলা হলো, case-এর সাথে যুক্ত। Executed ১২, passing ১১।
  3. Checkout batch. আরও ১২টি, একটি ফেল: TC-C01, ১০০০ টাকায় ছাড় ০ হওয়ার কথা। BG-202. এখন ২৪-এর ২৪ চলেছে, ২২টি পাস, দুটি defect খোলা। “Executed ১০০%” কিন্তু “passing ৯১.৭%”: দুটি রেখা আলাদা থাকার এটাই কারণ।
  4. Scope বাড়ল। প্রতিটি defect-এর জন্য একটি regression test (TC-C13: oil আর atta-র ১০০০ টাকার আসল cart; TC-R13: ৫০০টি emoji গ্রহণ)। Scope ২৪ থেকে ২৬. কোনো test চলেনি, তবু executed ২৪-এর ২৪ থেকে ২৬-এর ২৪ হলো। এটি অগ্রগতির পতন নয়, scope-এর বৃদ্ধি; burn-up এই দুটি আলাদা দেখায়।
  5. Retest, build 1.4.1. ব্যর্থ দুটি আর নতুন দুটি, চারটিই পাস। দুটি defect বন্ধ। Passing ২৬. পুরোনো fail সারি মোছা হয়নি; ইতিহাস থাকে।
  6. পুরো regression. ২৬-এর ২৬ পাস। নতুন কিছু না বাড়লেও এই cycle জরুরি: fix অন্য কোথাও কিছু ভাঙেনি, তার প্রমাণ। মোট ৫৪টি execution: ২টি fail, ৫২টি pass.

৭ · Monitoring — burn-up, burndown আর SQL দিয়ে অবস্থা

উপরের log-কে ছবিতে আনলে পাওয়া যায় একটি burnup chart: একটি রেখায় মোট scope, আরেকটিতে সম্পন্ন কাজ। Burndown chart শুধু বাকি কাজ দেখায়, যা scope বাড়লে বিভ্রান্ত করে: চতুর্থ মুহূর্তে বাকি কাজ ০ থেকে ২ হয়ে যেত, আর মনে হতো দল পিছিয়েছে।

সত্যিকারের lab log-এর burn-up

scope, executed, passing at six checkpoints (tracker.db)

বাজারঘর lab-এর burn-up: scope, executed আর passing 0 10 20 30 ১ ২ ৩ ৪ ৫ ৬ scope 26 scope 24 ফাঁক = বাকি scope executed passing ১ পরিকল্পনা · ৩ cycle 1 শেষ · ৪ scope +২ · ৬ regression
ছবি ৭৪.২ — মুহূর্ত ৪-এ কোনো test চলেনি, তবু scope-এর রেখা উঠে executed-এর সাথে ফাঁক তৈরি করেছে। Executed আর passing-এর মাঝের ফাঁক মানে চলেছে কিন্তু এখনো পাস নয়: খোলা defect-এর কাজ।

পর্ব ১৯-এ দেখেছেন, executed রেখা সাধারণত S-আকৃতির হয়: শুরুতে ধীর (পরিবেশ, প্রথম bug), মাঝে দ্রুত, শেষে ধীর (কঠিন case, retest). তাই শুরুর দুই দিনের ধীর হার দেখে সোজা রেখা টেনে শেষের তারিখ বলা বিপজ্জনক। সংকেতগুলো একসাথে দেখুন:

সংকেতযা বোঝায়প্রথম প্রশ্ন
Executed, planned-এর অনেক নিচেহার কম, বা blocked বেশিবাধা কি পরিবেশ, data, নাকি build?
Executed আর passing-এর ফাঁক বাড়ছেDefect আসছে, ঠিক হচ্ছে নাFix-এর হার কত? Triage হচ্ছে তো?
Scope রেখা বারবার উঠছেনতুন requirement বা defect-এর regressionকে scope বাড়াচ্ছেন, কোন তারিখের বিনিময়ে?
খোলা critical defect শেষ দিকে নামছে নাExit criteria-র ঝুঁকিRelease-এর আলোচনা এখনই, শেষ দিনে নয়

পর্ব ১৯-এ SQL দিয়ে প্রতিটি case-এর সর্বশেষ ফল খুঁজেছেন। এবার একধাপ এগিয়ে, দিনে দিনে burn-up: প্রতিটি দিনের শেষে সেদিন পর্যন্ত চলা case আর তখনকার সর্বশেষ ফল। নিচের কাল্পনিক ভান্ডারে তিন দিনের হাতে চালানো ২৪টি case (R মানে review, C মানে checkout), plan-এর দৈনিক লক্ষ্য, আর defect. এটি পাতার ভেতরের SQLite; query বদলে চালিয়ে দেখুন:

-- 1) burn-up per day: planned vs executed vs passing (latest result so far)
SELECT p.day, p.planned_cum AS planned,
  (SELECT COUNT(DISTINCT tc) FROM execution
    WHERE day <= p.day AND status != 'blocked') AS executed,
  (SELECT COUNT(*) FROM execution e
    WHERE e.day <= p.day AND e.status = 'pass' AND e.id =
      (SELECT MAX(id) FROM execution WHERE tc = e.tc AND day <= p.day)) AS passing,
  (SELECT COUNT(*) FROM execution WHERE day = p.day AND status = 'blocked') AS blocked
FROM plan p ORDER BY p.day;

-- 2) open defects at the end of each day, by severity
SELECT p.day, d.severity, COUNT(*) AS open_defects
FROM plan p JOIN defect d
  ON d.opened <= p.day AND (d.closed IS NULL OR d.closed > p.day)
GROUP BY p.day, d.severity ORDER BY p.day, d.severity;

-- 3) not yet passing at the end, with the reason
SELECT tc, status AS latest, day FROM execution e
WHERE e.id = (SELECT MAX(id) FROM execution WHERE tc = e.tc) AND status != 'pass';

প্রথম query-র তিনটি সারি: দিন ১-এ planned ১০, executed ১০, passing ৯, blocked ০; দিন ২-এ planned ২০, executed ২১, passing ১৯, blocked ২; দিন ৩-এ planned ২৪, executed ২৪, passing ২৩, blocked ০. দ্বিতীয় query: দিন ১ শেষে একটি major খোলা; দিন ২ শেষে একটি critical আর একটি major; দিন ৩ শেষে একটি critical. তৃতীয়টি একটিমাত্র সারি দেয়: C11 fail 3.

দিন ২-এর ফাঁদ। Executed ২১, planned ২০: সংখ্যায় দল এগিয়ে। অথচ C10 আর C11, অর্থাৎ wallet-এর দুটি case, blocked; ঝুঁকির দিক থেকে সবচেয়ে গুরুত্বপূর্ণ দুটিই চলেনি। সহজ case আগে চালিয়ে planned-এর সংখ্যা ছোঁয়া যায়, তাই শুধু গুনতি দিয়ে monitoring সহজেই Goodhart's law-এর শিকার হয়। দিন ৩-এ C10 পাস, কিন্তু C11 ফেল করল একটি critical defect নিয়ে, যা release-এর আগের দিন খোলা। Blocked case-কে ঝুঁকি অনুযায়ী আলাদা করে দেখালে দ্বিতীয় দিনেই আলোচনা শুরু হতো।

৮ · Control — অগ্রগতি পিছিয়ে পড়লে কী করবেন

Monitoring বলে “আমরা পিছিয়ে”; control জিজ্ঞেস করে “তাহলে কী বদলাব?” হাতে সাধারণত চার রকম বিকল্প থাকে: তারিখ সরানো, scope ছোট করা (ঝুঁকি অনুযায়ী ক্রম বদলে), বাধা দূর করে হার বাড়ানো, আর মানুষ যোগ করা। টাকার প্রশ্ন এখানে নেই; আছে সময়, scope আর ঝুঁকির বিনিময়। নিচে একটি কাল্পনিক release window: ১২০টি case, ৬ দিন, দিনে ২০টির plan. তৃতীয় দিনের শেষে হিসাব:

import math
# Release test window: 120 test cases, 6 days, plan 20 per day. Invented numbers.
PLAN_TOTAL, DAYS, DONE_DAY = 120, 6, 3
executed = [12, 14, 16]                       # actual per day so far
blocked_now = 9                               # waiting for a test environment fix
done = sum(executed); rate = done / DONE_DAY
left, days_left = PLAN_TOTAL - done, DAYS - DONE_DAY
print(f"day {DONE_DAY}: executed {done}/{DONE_DAY * 20} planned, rate {rate:.1f}/day")
print(f"forecast at this rate: {left} left -> {left / rate:.1f} more days "
      f"-> finish day {DONE_DAY + math.ceil(left / rate)} (plan: day {DAYS})")
REMAINING = {"high": 30, "medium": 28, "low": 20}   # remaining cases by risk
def run(capacity):                            # spend capacity on highest risk first
    out = {}
    for level, n in REMAINING.items():
        out[level] = min(n, capacity); capacity -= out[level]
    return out
options = {
    "A keep scope, extend":     (left, DONE_DAY + math.ceil(left / rate)),
    "B risk order, no extend":  (rate * days_left, DAYS),
    "C fix blocker (18/day)":   (18 * days_left, DAYS),
    # D: new tester at 50%, 75%, 100% speed; coaching costs the first 2 cases/day
    "D add tester from day 4":  (sum(rate - c + rate * f for c, f in
                                     [(2, 0.5), (2, 0.75), (0, 1.0)]), DAYS),
}
for name, (cap, finish) in options.items():
    got = run(int(cap))
    print(f"{name:25} capacity {int(cap):3}  high {got['high']}/30  "
          f"medium {got['medium']}/28  low {got['low']}/20  finish day {finish}")
print(f"blocked now: {blocked_now} of {left} remaining = {blocked_now / left:.0%}")

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

day 3: executed 42/60 planned, rate 14.0/day
forecast at this rate: 78 left -> 5.6 more days -> finish day 9 (plan: day 6)
A keep scope, extend      capacity  78  high 30/30  medium 28/28  low 20/20  finish day 9
B risk order, no extend   capacity  42  high 30/30  medium 12/28  low 0/20  finish day 6
C fix blocker (18/day)    capacity  54  high 30/30  medium 24/28  low 0/20  finish day 6
D add tester from day 4   capacity  69  high 30/30  medium 28/28  low 11/20  finish day 6
blocked now: 9 of 78 remaining = 12%

প্রতিটি বিকল্পের ফল একই ভাষায় লেখা: কোন ঝুঁকির কতগুলো case চলবে, আর কবে শেষ। এভাবে লিখলে আলোচনা “আরও জোরে কাজ করুন” থেকে “কোন ঝুঁকি মেনে নেব” প্রশ্নে চলে আসে। নিচের ধাপগুলোতে সিদ্ধান্তটি দেখুন।

দিন ৩ শেষে · ১২০টি case, ৬ দিন
বিকল্প
সামর্থ্য
high · med · low
শেষ
  1. অবস্থা। তিন দিনে ৪২টি case চলেছে, plan ছিল ৬০; হার দিনে ১৪. দুর্বল হার দেখে প্রথম প্রশ্ন “কে ধীর?” নয়, “কী বাধা?” এখানে ৯টি case একটি test environment-এর সমস্যায় আটকে।
  2. পূর্বাভাস। বাকি ৭৮টি, এই হারে আরও ৫.৬ দিন, অর্থাৎ শেষ দিন ৯-এ; plan ছিল দিন ৬. Blocked ৯/৭৮ = ১২%, পর্ব ১৭-এর ২৫%-এর suspension সীমার নিচে, তাই test থামানোর দরকার নেই। পূর্বাভাসটি একটি সোজা রেখা; S-curve-এর শেষ দিকের ধীরতা ধরলে আরও খারাপ হতে পারে।
  3. A — সময় বাড়ানো। সব ৭৮টি চলবে, শেষ দিন ৯. তারিখ বদলানো product owner-এর সিদ্ধান্ত; test দলের কাজ দেরি আর বিকল্পগুলো আজই জানানো।
  4. B — ঝুঁকি অনুযায়ী ক্রম। তারিখ একই, এই হারে ৪২টি: high-এর ৩০টি সব, medium-এর ১২টি, low একটিও না। মোট ৪৮টি case বাদ। কোন case high, তা আসে risk analysis থেকে (পর্ব ৭৩, Risk-based testing).
  5. C — বাধা দূর। পরিবেশের সমস্যা মিটলে, ধরা যাক হার দিনে ১৮. তিন দিনে ৫৪টি: high ৩০, medium ২৪, low ০. মানুষ যোগ করার আগে জিজ্ঞেস করুন, যাঁরা আছেন তাঁরা কোথায় আটকে আছেন।
  6. D — নতুন tester. ৬৯টি পর্যন্ত, যদি নতুন মানুষটি প্রথম দিন অর্ধেক আর দ্বিতীয় দিন তিন-চতুর্থাংশ গতিতে কাজ করেন, আর তাঁকে শেখাতে প্রথম tester দিনে ২টি case-এর সময় হারান। বাজারঘর না চেনা কেউ এলে লাভ আরও কম। দেরিতে মানুষ যোগ করলে যোগাযোগ আর শেখার খরচ বাড়ে: Brooks’s law.
  7. সিদ্ধান্ত। আজই C (পরিবেশ ঠিক করা, ঝুঁকির ক্রমে চালানো), দিন ৫-এ আবার মাপা। Product owner-কে লিখিত বিকল্প: দিন ৬-এ কমপক্ষে high ৩০, medium ২৪; বাকি ৪টি medium আর ২০টি low চলবে না, যা residual risk হিসেবে রিপোর্টে যাবে; সব চাইলে দিন ৯। সিদ্ধান্ত আর কারণ tracker-এর decision log-এ।

যা control নয়: চুপচাপ exit criteria নামিয়ে দেওয়া, blocked case-কে “not applicable” লেখা, সহজ case আগে চালিয়ে সংখ্যা দেখানো, বা দিনে ১২ ঘণ্টা কাজ করিয়ে plan রক্ষা। প্রথম তিনটি তথ্যকে মিথ্যা বানায়; শেষটি ক্লান্ত মানুষের ভুল বাড়ায়, আর test-এর ভুল মানে গ্রাহকের কাছে bug.

৯ · Completion — রিপোর্ট, সংরক্ষণ আর অনুমানের শিক্ষা

Test completion report-এর গঠন পর্ব ১৯-এ দেখেছেন: কী test হলো, কী হলো না, ফল, defect, exit criteria, residual risk, বিচ্যুতি আর সুপারিশ। Test management-এর চোখে completion-এর আরও তিনটি কাজ, যেগুলো প্রায়ই বাদ পড়ে:

  1. Testware সংরক্ষণ: test case, script, test data তৈরির script, পরিবেশের বিবরণ আর tracker-এর export এমন জায়গায় রাখা, যাতে পরের release-এ খুঁজে পাওয়া যায়। এই lab-এ সেটি tests_rc/, tracker.py আর run_cycles.py; database আর venv মুছে ফেলা হয়েছে, কারণ সেগুলো আবার বানানো যায়।
  2. Defect-এর হিসাব মেলানো: প্রতিটি খোলা defect-এর একটি সিদ্ধান্ত থাকা চাই: পরের release, known issue, বা বাতিল। “খোলা, কেউ জানে না কেন” থাকলে পরের দল সেটি নতুন করে খুঁজবে।
  3. অনুমান বনাম বাস্তব লেখা: এটিই পরের অনুমানের কাঁচামাল। অংশ ৬-এর টেবিলটি এর একটি ছোট রূপ: কোন অংশ বেশি নিল (ছোট cycle-এর নির্দিষ্ট খরচ, প্রথম run), কোন অনুমান ভাগ্যে মিলেছে (দুটি ভুলের কাটাকাটি), আর কী অনুমানেই ছিল না (retest-এর আসল সংখ্যা)। এই তালিকা না থাকলে metrics-ভিত্তিক অনুমানের ইতিহাসই তৈরি হয় না।

Defect-এর ইতিহাস থেকে শেখা আর root cause analysis পর্ব ৭৫ (Quality metric আর process improvement)-এর বিষয়, আর পুরো test strategy-তে অনুমান ও tracker কীভাবে বসে, তা ক্যাপস্টোনে, পর্ব ৭৭-এ।

আরও গভীরে: PERT-এর মূল নথি ১৯৫০-এর দশকের শেষে যুক্তরাষ্ট্রের নৌবাহিনীর Polaris প্রকল্পে তৈরি; গড়ের সূত্রটি একটি beta বণ্টনের সরল আসন্ন মান, যার যুক্তি নিয়ে পরে অনেক সমালোচনা হয়েছে (যেমন ১৯৬০-এর দশকে MacCrimmon আর Ryavec-এর বিশ্লেষণ)। একটি সুপরিচিত দুর্বলতা হলো merge bias: কয়েকটি সমান্তরাল পথ শেষে মিললে PERT শুধু critical path দেখে, তাই অনুমান আশাবাদী হয়; Monte Carlo সব পথ একসাথে চালিয়ে এই ফাঁক ধরে।

১০ · AI-এর যুগে test management আর estimation

AI assistant এক মিনিটে একটি সুন্দর test plan, একটি estimation টেবিল বা সাপ্তাহিক progress report লিখে দেয়। সমস্যা হলো, সংখ্যাগুলো কোথা থেকে এলো তা প্রায়ই লেখা থাকে না। AI প্রায়ই একটি সংখ্যা দেয়, পরিসর নয়; retest চক্র আর পরিবেশের সমস্যা বাদ দেয়; tool-এর এমন feature বা ISTQB-এর এমন ধারা বানিয়ে বলে, যার অস্তিত্ব নেই। Test-এর বেলায় চেনা দুর্বলতাও থাকে: শুধু সুখী পথ, প্রয়োজনের বদলে কোডের বর্তমান আচরণ যাচাই, sleep দিয়ে অপেক্ষা, এত mock যে আসল কিছুই test হয় না, সীমার মান বাদ, আর না চালিয়েই “সব test পাস” দাবি।

AI-কে অনুমানের সহকারী বানান, অনুমানকারী নয়। আপনার ইতিহাস দিন, আর অনুমানগুলো খোলাখুলি চান:

আমি একটি online shop-এর checkout feature-এর test effort অনুমান করছি। আমাদের আগের তিনটি release-এর আসল তথ্য: (development ঘণ্টা, test ঘণ্টা) = (100, 31), (80, 30), (150, 48). এবার ৪০টি test case, development ১২০ ঘণ্টা। ১. ratio আর three-point দুই পদ্ধতিতে আলাদা অনুমান দাও; প্রতিটি অনুমানের পেছনের ধরে নেওয়া কথা তালিকা করো। ২. কোনো কাজ বাদ পড়ছে কি না দেখো: test analysis, পরিবেশ, retest চক্র, exploratory session, রিপোর্ট। ৩. একটি সংখ্যা নয়, পরিসর দাও, আর বলো কোন অনুমান বদলালে ফল সবচেয়ে বেশি বদলায়। ৪. কোনো শিল্প-গড় বা মানের ধারা উল্লেখ করলে উৎস দাও; নিশ্চিত না হলে বলো “নিশ্চিত নই”। ৫. কোনো কোড লিখলে আমি নিজে চালাব; চালানো হয়েছে বলে দাবি কোরো না।

AI-এর plan, অনুমান বা রিপোর্ট হাতে পেলে — চেকলিস্ট

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

  • Test monitoring আর test control-এর পার্থক্য? Monitoring পরিকল্পনার সাথে অবস্থা মেলায় আর জানায়; control সেই তথ্য থেকে সংশোধনের পদক্ষেপ নেয়।
  • O = 4, M = 6, P = 14 হলে PERT-এর গড় আর σ? (4 + 24 + 14) ÷ 6 = 7; σ = 10 ÷ 6 ≈ 1.67.
  • ISTQB Foundation-এ নাম আছে এমন চারটি estimation কৌশল? Ratio, extrapolation, Wideband Delphi, three-point.
  • Burn-up কেন burndown-এর চেয়ে বেশি তথ্য দেয়? Scope আর সম্পন্ন কাজ আলাদা রেখায় থাকে, তাই scope বাড়া আর ধীর অগ্রগতি আলাদা চেনা যায়।
  • Test completion-এর কাজ কী কী? Completion report, testware সংরক্ষণ, খোলা defect-এর সিদ্ধান্ত, আর শিক্ষা (অনুমান বনাম বাস্তবসহ) লেখা।

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

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

প্র ০১Test-এর অনুমান প্রায়ই কম হয়, আর test-এর সময়ই প্রায়ই কাটা পড়ে। কেন?

দুটি আলাদা শক্তি একসাথে কাজ করে: মানুষের মনের পক্ষপাত, আর project-এর গঠন।

মনের দিক: Daniel Kahneman আর Amos Tversky ১৯৭৯ সালের একটি লেখায় যে প্রবণতার কথা বলেন, পরে তার নাম হয় planning fallacy: অতীতে বারবার দেরি হওয়া সত্ত্বেও নিজের পরের কাজের সময় কম ধরা। Douglas Hofstadter ১৯৭৯ সালের বই Gödel, Escher, Bach-এ রসিকতা করে একটি “সূত্র” লেখেন: কাজে সবসময় প্রত্যাশার চেয়ে বেশি সময় লাগে, এমনকি এই সূত্রটি মাথায় রাখলেও। মানুষ সাধারণত “সব ঠিক গেলে” পথটি কল্পনা করেন; test-এ সেই পথ মানে প্রথমবারেই সব পাস, যা প্রায় কখনো হয় না।

Project-এর গঠন: পর্যায়ক্রমিক project-এ test থাকে শেষে। Development দেরি করলে release-এর তারিখ সাধারণত সরে না; কাটা পড়ে test-এর সময়। এটিকে অনেকে বলেন “test squeeze”. আর C. Northcote Parkinson ১৯৫৫ সালে লেখেন, কাজ বাড়তে বাড়তে যতটা সময় দেওয়া হয় ততটা ভরে ফেলে; তাই আগে শেষ হলে সেই সময় test-এর ভাগে ফেরত আসে না।

প্রতিকার: তিন-বিন্দু অনুমান আর Monte Carlo আশাবাদকে খোলা জায়গায় আনে। Retest চক্র আলাদা ঘরে রাখলে সবচেয়ে বেশি বাদ পড়া কাজটি দৃশ্যমান হয়। Shift-left (পর্ব ০৪) test-কে শেষের একটি ধাপ থেকে পুরো সময়ের কাজে ছড়িয়ে দেয়, ফলে শেষের চাপ কমে। আর completion-এ অনুমান বনাম বাস্তব লিখে রাখলে কয়েক release পরে নিজের পক্ষপাতের মাপ পাওয়া যায়: “আমাদের অনুমান গড়ে ৩০% কম হয়।” তখন অনুমানকে সেই অনুপাতে ঠিক করা যায়, যা reference class forecasting-এর একটি সরল রূপ।

মূল উপলব্ধি: কম অনুমান সাধারণত অসততা নয়, মানুষের স্বাভাবিক মন আর project-এর গঠনের ফল। তাই প্রতিকারও ব্যক্তিগত নয়, পদ্ধতিগত: পরিসর, আলাদা retest-এর ঘর, আর ইতিহাস।

প্র ০২দেরি হলে আরও tester দিলেই তো কাজ দ্রুত হবে — Brooks-এর সূত্র test-এর ক্ষেত্রে কতটা খাটে?

Fred Brooks IBM-এ System/360-এর operating system, OS/360, প্রকল্প পরিচালনার অভিজ্ঞতা থেকে ১৯৭৫ সালে The Mythical Man-Month বই লেখেন। সেখানকার বিখ্যাত বাক্যটির ভাব: দেরি হওয়া software project-এ মানুষ যোগ করলে তা আরও দেরি করে। কারণ দুটি। নতুন মানুষকে শেখাতে পুরোনোদের সময় যায়, আর মানুষ বাড়লে যোগাযোগের পথ বাড়ে প্রায় বর্গের হারে: n জনের দলে জোড়া n(n − 1) ÷ 2. Brooks নিজেও পরে বলেছেন সূত্রটি অতিসরল; এটি প্রতিটি ক্ষেত্রে আইন নয়, সতর্কবাণী।

Test-এ কোথায় কম খাটে: স্বাধীন, ভালো করে লেখা test case অনেকটাই ভাগ করা যায়: দুজন দুটি আলাদা ব্রাউজারে বা দুটি আলাদা feature-এ চালাতে পারেন। পরিষ্কার ধাপ আর প্রত্যাশিত ফলসহ case (পর্ব ১৬) থাকলে নতুন মানুষ দ্রুত কাজে লাগেন। Automation-এ বাড়তি runner যোগ করা আরও সহজ, যদিও সেখানেও critical path-এর সীমা আছে (পর্ব ৬৪)।

কোথায় পুরোপুরি খাটে: exploratory testing, জটিল ব্যবসার নিয়ম, আর এমন পরিবেশ যা একসাথে একজনই ব্যবহার করতে পারেন। বাজারঘরের উদাহরণে mobile-wallet-এর timeout পরীক্ষা fake gateway-এর একটি global mode বদলায়; দুজন একই test environment-এ একসাথে চালালে একজনের test আরেকজনের ফল নষ্ট করবে। মানুষ বাড়ালে এখানে হার বাড়ে না, flaky ফল বাড়ে। আর domain না জানা নতুন tester ভুল “bug” রিপোর্ট করলে triage-এর সময় বাড়ে।

সিদ্ধান্তের প্রশ্ন: নতুন মানুষ কি এই domain জানেন? কাজ কি স্বাধীন টুকরোয় ভাগ করা যায়? পরিবেশ কি ভাগ করা যায়? শেখাতে কে সময় দেবেন, আর তাঁর কাজের কী হবে?

মূল উপলব্ধি: মানুষ যোগ করা সবচেয়ে দৃশ্যমান, কিন্তু প্রায়ই সবচেয়ে কম কার্যকর control. আগে বাধা দূর করুন আর ঝুঁকি অনুযায়ী ক্রম বদলান; মানুষ যোগ করুন আগেভাগে, দেরিতে নয়।

প্র ০৩PERT তো ষাট বছরের পুরোনো — তবু কেন আজও শেখানো হয়, আর কোথায় এটি ভুল পথে নিতে পারে?

PERT তৈরি হয় ১৯৫০-এর দশকের শেষে, যুক্তরাষ্ট্রের নৌবাহিনীর Polaris ক্ষেপণাস্ত্র-ডুবোজাহাজ প্রকল্পে, হাজার হাজার ঠিকাদারের কাজ সমন্বয়ের জন্য। প্রায় একই সময়ে শিল্পে critical path method (CPM) তৈরি হয়। PERT-এর নতুনত্ব ছিল প্রতিটি কাজের জন্য একটির বদলে তিনটি সময়, আর একটি সরল সূত্রে গড় আর বিচ্যুতি। সূত্রটি একটি beta বণ্টনের আসন্ন মান; বেছে নেওয়ার কারণ ছিল হাতে হিসাব করার সুবিধা, কম্পিউটার তখন দুর্লভ।

কেন আজও কাজের: তিনটি সংখ্যা চাওয়াই একটি মানসিক কৌশল। “কতক্ষণ?” প্রশ্নে মানুষ সবচেয়ে সম্ভাব্য সংখ্যাটি বলেন, প্রায়ই আশাবাদী। “সবচেয়ে খারাপ বাস্তব ক্ষেত্রে কত?” জিজ্ঞেস করলে ঝুঁকির কথা মুখে আসে: “staging-এর database আবার reset হলে দুই দিন।” আর সূত্রটি এত সহজ যে পরীক্ষার খাতায়, spreadsheet-এ বা মিটিংয়ে মুখে মুখে করা যায়।

কোথায় ভুল পথে নেয়: প্রথমত, বণ্টনের অনুমান: এই পর্বের Monte Carlo-তে triangular বণ্টনে P50 এসেছে ৪৮.৫, PERT-এর গড় ৪৫.৯; কোনটি ঠিক, তা ঠিক করে আপনার ইতিহাস, সূত্র নয়। দ্বিতীয়ত, স্বাধীনতার অনুমান: একই কারণ বহু কাজকে একসাথে ধীর করলে variance যোগের নিয়ম বিচ্যুতি কম দেখায়। তৃতীয়ত, merge bias: কয়েকটি সমান্তরাল পথ শেষে মিললে প্রকল্প শেষ হয় সবচেয়ে ধীর পথের সাথে; PERT শুধু critical path ধরে, তাই অন্য প্রায়-সমান পথের দেরি উপেক্ষা করে আশাবাদী তারিখ দেয়। ১৯৬০-এর দশকেই MacCrimmon আর Ryavec-এর মতো গবেষকেরা এই ধরনের ভুলের বিশ্লেষণ প্রকাশ করেন। চতুর্থত, P নিজেই প্রায়ই আশাবাদী: মানুষ “সবচেয়ে খারাপ” বলতে সাধারণত “একটু খারাপ” কল্পনা করেন।

আধুনিক পথ: তিন-বিন্দু অনুমান রাখুন, কিন্তু যোগ করার কাজ Monte Carlo-কে দিন, যা নির্ভরতা, সমান্তরাল পথ আর লাফানো সংখ্যা (যেমন retest চক্র) সহজেই ধরে।

মূল উপলব্ধি: PERT-এর সবচেয়ে মূল্যবান অংশ সূত্র নয়, তিনটি প্রশ্ন। গণনার অংশে আজ আরও ভালো উপায় আছে।

প্র ০৪Cone of uncertainty সত্যিই কি তথ্য দিয়ে প্রমাণিত, আর না হলে test lead এটি কীভাবে ব্যবহার করবেন?

Barry Boehm ১৯৮১ সালে Software Engineering Economics বইয়ে project-এর বিভিন্ন পর্যায়ে খরচের অনুমানের ভুলের পরিসরের একটি ছবি দেন: শুরুর ধারণার সময় প্রায় চার গুণ বেশি থেকে চার গুণ কম, তারপর ধাপে ধাপে সরু। Steve McConnell ১৯৯০-এর দশক আর ২০০৬ সালের Software Estimation বইয়ে এটিকে “cone of uncertainty” নামে ব্যাপক পরিচিত করেন, আর জোর দেন যে এটি সেরা অবস্থার সীমা: দক্ষ অনুমানকারী এর চেয়ে ভালো করতে পারেন না, খারাপ করতে পারেন।

সমালোচনা: Laurent Bossavit তাঁর The Leprechauns of Software Engineering বইয়ে এমন কয়েকটি বহুল উদ্ধৃত “তথ্য” খুঁটিয়ে দেখেন, cone-সহ, আর যুক্তি দেন যে এর সংখ্যার পেছনের তথ্যভিত্তি যতটা মনে করা হয় ততটা শক্ত নয়, আর ছবিটি বারবার উদ্ধৃত হতে হতে তথ্যের চেয়ে বিশ্বাসে পরিণত হয়েছে। কিছু দলের আসল তথ্যে দেখা গেছে, অনিশ্চয়তা সবসময় সুন্দর প্রতিসম চোঙার মতো কমে না; অনেক সময় অনুমান একদিকে, সাধারণত কম দিকে, হেলে থাকে।

Test lead-এর জন্য যা টেকে: সংখ্যাগুলো বাদ দিলেও মূল কথাটি সাধারণ বুদ্ধি: যা জানা নেই, তা অনুমানে ধরা যায় না। Test-এর বেলায় তিনটি সিদ্ধান্ত পরিসরকে সবচেয়ে বেশি সরু করে: requirement-এর স্থিরতা (খোলা প্রশ্নগুলো বন্ধ হওয়া), test design শেষে case-এর সংখ্যা, আর প্রথম cycle-এর পরে আসল ব্যর্থতার হার। এই তিন মুহূর্তে আবার অনুমান নির্ধারিত রাখুন, আর প্রতিবার পরিসর লিখুন। দ্বিতীয় অনুমানে পরিসর আগেরটির চেয়ে চওড়া হলে সেটি একটি সতর্ক সংকেত: কোনো বড় অজানা সামনে এসেছে।

নিজের cone বানান: কয়েকটি release-এর completion report-এ প্রতিটি মুহূর্তের অনুমান আর শেষের আসল সময় রাখলে নিজের দলের আসল পরিসর পাওয়া যায়। সেটি বইয়ের ছবির চেয়ে অনেক বেশি কাজের।

মূল উপলব্ধি: বহুল উদ্ধৃত ছবিও প্রশ্ন করার যোগ্য। ধারণাটি রাখুন, সংখ্যাগুলো নিজের ইতিহাস দিয়ে বদলান।

প্র ০৫“কয়টি test case চলেছে” দিয়ে অগ্রগতি মাপা কেন বিপজ্জনক, আর tool এই ফাঁদ কীভাবে বাড়ায়?

Test case গোনা সহজ, তাই প্রায় সব tool-এর dashboard-এ সবার ওপরে থাকে: “৮০০-এর ৬২০ চলেছে, ৭৭.৫%”. সমস্যা হলো, test case কোনো সমান মাপের একক নয়। একটি case হতে পারে “login পাতা খোলে”, আরেকটি হতে পারে “wallet timeout-এর পরে দুবার pay করলে একবারই টাকা কাটে, ledger আর order দুটিতেই”। প্রথমটি এক মিনিটের, দ্বিতীয়টি এক ঘণ্টার, আর ঝুঁকির দিক থেকে তুলনাই হয় না। একটিকে ভেঙে দশটি case বানালে অগ্রগতি দশ গুণ দেখায়, অথচ কাজ একই।

ইতিহাস: প্রসঙ্গনির্ভর testing ধারার লেখকেরা, যেমন Cem Kaner আর James Bach, বহু বছর ধরে test case গোনাকে অগ্রগতি বা দক্ষতার মাপ হিসেবে ব্যবহারের সমালোচনা করেছেন। অর্থনীতিবিদ Charles Goodhart-এর নামে পরিচিত পর্যবেক্ষণটি এখানে সরাসরি খাটে: কোনো মাপ লক্ষ্য হলে সেটি আর ভালো মাপ থাকে না (পর্ব ৬৭)। দলকে “দিনে ৫০টি case” লক্ষ্য দিলে সহজ case আগে চলবে, কঠিন case ভেঙে ছোট হবে, আর exploratory testing কমবে, কারণ সেটি গোনা কঠিন। অংশ ৭-এর SQL উদাহরণে ঠিক এটিই দেখেছেন: দিন ২-এ planned ছোঁয়া হয়েছে, অথচ সবচেয়ে ঝুঁকির দুটি case চলেনি।

Tool-এর ভূমিকা: Tool যা সহজে গোনে, dashboard তাই দেখায়, আর মানুষ dashboard-কে লক্ষ্য বানায়। Session-based exploratory testing (পর্ব ২০) বা risk coverage tool-এ স্বাভাবিকভাবে বসে না, তাই রিপোর্টে অদৃশ্য হয়ে যায়। তাই প্রশ্ন করুন: এই সংখ্যার হর কী, আর কোন ঝুঁকি ঢাকা পড়ছে?

বিকল্প: গুনতির পাশে ঝুঁকি অনুযায়ী ভাগ (high-risk case-এর কত শতাংশ পাস), requirement বা acceptance criteria অনুযায়ী coverage (পর্ব ১৯-এর RTM), blocked-এর কারণ, খোলা গুরুতর defect, আর exploratory session-এর সংখ্যা ও চার্টার। সংখ্যার পাশে একটি ছোট লেখা।

মূল উপলব্ধি: অগ্রগতি মানে কত case চলল তা নয়, কত ঝুঁকি সম্পর্কে আমরা এখন জানি।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলুন।

  1. Test design — tracker-এর progress নিয়মের test case: নিয়মটি এই: “executed = অন্তত একবার pass বা fail হওয়া case; blocked চলা নয়। passing = যে case-এর সর্বশেষ চলা (blocked বাদে) pass.” এই নিয়মের জন্য অন্তত পাঁচটি test case লিখুন: প্রতিটিতে execution-এর ক্রম আর প্রত্যাশিত executed ও passing.

    একটি case (TC-X)-এর ওপর আলাদা আলাদা ইতিহাস, equivalence আর সীমার যুক্তিতে:

    1. কোনো execution নেই → executed ০, passing ০ (খালি ইতিহাস, সীমা)।
    2. শুধু blocked → executed ০, passing ০ (blocked চলা নয়)।
    3. fail তারপর pass → executed ১, passing ১ (retest-এর পরে)।
    4. pass তারপর fail → executed ১, passing ০ (পুরোনো pass নতুন fail ঢাকবে না; regression).
    5. pass তারপর blocked → executed ১, passing ১ (নিয়মে blocked বাদ দিয়ে সর্বশেষ চলা দেখতে বলা হয়েছে)।
    6. একই case তিনবার pass → executed ১, passing ১ (একই case দুবার গোনা যাবে না)।

    খেয়াল করুন, দ্বিতীয় আর পঞ্চম case এই পর্বের progress()-এর দুটি দুর্বলতা ধরে। সেই কোড executed গোনে যেকোনো execution সারি থেকে, তাই শুধু blocked case-কেও চলা ধরে (১ দেয়, ০ নয়); আর passing-এ সর্বশেষ সারি দেখে blocked বাদ না দিয়ে (০ দেয়, ১ নয়)। Lab-এ কোনো blocked হয়নি বলে ধরা পড়েনি; লিখিত নিয়ম থেকে test design করলে পড়ে। Test আগে নিয়ম থেকে, কোড থেকে নয়।

  2. আউটপুট অনুমান করুন: খালি tracker-এ ৪টি case (A, B, C, D) বসানো হলো। তারপর execution এই ক্রমে: A pass, B fail, C pass, B pass, C fail. একটি defect খোলা হয়েছিল B-এর জন্য, B পাস করার পরে বন্ধ; C-এর জন্য নতুন defect খোলা। এই পর্বের progress() কী ফেরত দেবে: (scope, executed, passing, open)?

    (4, 3, 2, 1). Scope ৪ (D সহ, যদিও চলেনি)। Executed হলো আলাদা case-এর সংখ্যা: A, B, C = ৩. Passing: প্রতিটির সর্বশেষ সারি দেখুন। A pass, B-এর সর্বশেষ pass, C-এর সর্বশেষ fail, তাই ২. খোলা defect: B-এরটি বন্ধ, C-এরটি খোলা, তাই ১. রিপোর্টে লিখতে হবে “৪-এর ৩টি চলেছে; ৪-এর ২টি পাস (৫০%); D এখনো চলেনি; C-তে একটি খোলা defect.” মোট execution পাঁচটি, যার ৩টি pass; “৫-এর ৩ = ৬০% পাস” লেখা হবে ভুল হর।

  3. এই test-এ ভুল খুঁজুন: একজন সহকর্মী (বা AI) progress()-এর জন্য এই test লিখেছেন, আর এটি পাস করছে:
    def test_progress_after_regression(con):
        add_case(con, "TC-1")
        record(con, "TC-1", "pass")
        record(con, "TC-1", "fail")
        scope, executed, passing, opened = progress(con)
        assert (scope, executed, passing) == (1, 1, 1)   # matches current output
    ভুলটি কী, আর ঠিক test-টি কী হবে?

    Test-টি প্রয়োজন যাচাই করছে না, কোডের বর্তমান আচরণ লিখে রেখেছে; মন্তব্যটিই তা স্বীকার করছে। নিয়ম অনুযায়ী সর্বশেষ ফল fail, তাই passing হওয়া উচিত ০. Test পাস করছে মানে কোডে bug আছে (যেমন সব pass সারি গোনা, সর্বশেষটি নয়), আর test সেটিকে পাকা করে দিচ্ছে। ঠিক assertion: (1, 1, 0). তারপর test চালালে ফেল করবে, যা bug-এর প্রমাণ। এই পর্বের আসল progress() সর্বশেষ সারি দেখে, তাই সেখানে ঠিক test পাস করবে। শিক্ষা: expected value আসে লিখিত নিয়ম থেকে; “যা বেরোচ্ছে তাই বসাই” golden-master কৌশল (পর্ব ৬১) শুধু তখনই চলে, যখন বর্তমান আচরণ সত্যিই যাচাই করা হয়েছে।

  4. হিসাব আর সিদ্ধান্ত: একটি regression-এর তিনটি কাজ, ঘণ্টায়: পরিবেশ (O 4, M 6, P 14), data (O 2, M 3, P 4), চালানো (O 6, M 8, P 16). (ক) প্রতিটির PERT গড় আর σ, মোট গড় আর মোট σ। (খ) Product owner বললেন, “১৯ ঘণ্টা দিচ্ছি।” আপনি কী বলবেন?

    (ক) পরিবেশ: (৪ + ২৪ + ১৪) ÷ ৬ = ৭, σ = ১০ ÷ ৬ ≈ ১.৬৭. Data: (২ + ১২ + ৪) ÷ ৬ = ৩, σ = ২ ÷ ৬ ≈ ০.৩৩. চালানো: (৬ + ৩২ + ১৬) ÷ ৬ = ৯, σ ≈ ১.৬৭. মোট গড় ৭ + ৩ + ৯ = ১৯ ঘণ্টা। মোট σ = √(১.৬৭² + ০.৩৩² + ১.৬৭²) = √(২.৭৮ + ০.১১ + ২.৭৮) = √৫.৬৭ ≈ ২.৩৮ (σ-এর সরল যোগ ৩.৬৭ হতো, যা ভুল)।

    (খ) ১৯ ঘণ্টা ঠিক গড়; স্বাভাবিক বণ্টন ধরলে এতে শেষ হওয়ার সম্ভাবনা মোটামুটি অর্ধেক। মোটামুটি ৮৫% নিশ্চয়তার জন্য গড় + প্রায় ১σ ≈ ২১.৪, অর্থাৎ ২২ ঘণ্টা। উত্তর: “১৯ ঘণ্টায় অর্ধেক সম্ভাবনা; ২২ ঘণ্টা দিলে বেশ নিশ্চিত। ১৯-এ রাখতে চাইলে পরিবেশের ঝুঁকি কমান: আগের দিন পরিবেশ তৈরি করে smoke test চালিয়ে রাখুন, কারণ মোট অনিশ্চয়তার বড় অংশ সেখান থেকে।”

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

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

ক্রমএকটি release-এর test management-এর কাজগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. 🧩 কাজ ভেঙে তিন-বিন্দু অনুমান আর test plan লেখা
  2. 🚪 Entry criteria যাচাই করে execution শুরু
  3. 📈 প্রতিদিন burn-up আর defect-এর অবস্থা মেলানো
  4. 🧭 পিছিয়ে পড়লে বিকল্প মেপে সিদ্ধান্ত
  5. 📘 Completion report আর residual risk
  6. 🗄️ Testware সংরক্ষণ আর অনুমান বনাম বাস্তব লেখা

একটি test কাজের তিন-বিন্দু অনুমান O = 3, M = 5, P = 13 ঘণ্টা। PERT-এর গড় কত?

  • 5 ঘণ্টা
  • 6 ঘণ্টা
  • 7 ঘণ্টা
  • 8 ঘণ্টা

তিনটি স্বাধীন test কাজের PERT σ যথাক্রমে 3, 4 আর 0 ঘণ্টা। মোট কাজের σ কত?

  • 7 ঘণ্টা
  • 2.33 ঘণ্টা
  • 5 ঘণ্টা
  • 25 ঘণ্টা

একটি release-এর মাঝপথে দুটি নতুন regression test যোগ হলো, কিন্তু সেদিন কোনো test চলেনি। কোন chart এই ঘটনা সবচেয়ে পরিষ্কার দেখায়?

  • Burn-up chart, scope আর সম্পন্ন কাজ আলাদা রেখায়
  • Burndown chart
  • দৈনিক pass rate-এর chart
  • খোলা defect-এর chart

Wideband Delphi-তে প্রথম রাউন্ডের অনুমান গোপনে আর একসাথে দেওয়া হয়। এর প্রধান কারণ কী?

  • মিটিং দ্রুত শেষ করা
  • কে ভুল অনুমান দিয়েছেন তা যেন কেউ না জানে
  • Manager-এর অনুমান সবার আগে জানানো
  • Anchoring এড়ানো, যাতে প্রত্যেকের স্বাধীন মত আর পার্থক্যের কারণ বেরিয়ে আসে

দিন ৩ শেষে ১২০-এর ৪২টি case চলেছে (plan ছিল ৬০), কারণ ৯টি case একটি test environment-এর সমস্যায় blocked. প্রথম কোন control পদক্ষেপ সবচেয়ে যুক্তিসংগত?

  • সাথে সাথে দুজন নতুন tester যোগ করা
  • পরিবেশের বাধা দূর করা আর বাকি case ঝুঁকি অনুযায়ী ক্রমে চালানো
  • Blocked case-গুলোকে “not applicable” চিহ্নিত করা
  • Exit criteria-র pass rate ৯৫% থেকে ৮০%-এ নামানো

নিচের কোনটি test completion-এর অংশ নয়?

  • Test script, data তৈরির script আর পরিবেশের বিবরণ সংরক্ষণ
  • খোলা defect-গুলোর প্রতিটির সিদ্ধান্ত লেখা
  • পরবর্তী sprint শুরুর আগে নতুন feature-এর entry criteria বসানো
  • অনুমান বনাম আসল সময় তুলনা করে শিক্ষা লেখা

শব্দকোষ

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

মনে রাখুন

  1. Test management চারটি কাজ: planning, monitoring, control, completion; tool এর খাতা, চক্রটি নয়।
  2. অনুমান মানে পরিসর আর লেখা অনুমান: অন্তত দুটি পদ্ধতি, বড় পার্থক্যে কারণ খোঁজা, retest চক্র আলাদা ঘরে।
  3. PERT: E = (O + 4M + P) ÷ 6, σ = (P − O) ÷ 6; যোগে variance যোগ হয়। Monte Carlo দেয় P50, P85, P95.
  4. Burn-up scope আর সম্পন্ন কাজ আলাদা দেখায়; প্রতিটি শতাংশে হর, blocked আলাদা, ঝুঁকি অনুযায়ী ভাগ।
  5. পিছিয়ে পড়লে আগে বাধা আর ঝুঁকির ক্রম, তারপর তারিখ বা মানুষ; বাদ পড়া কাজ residual risk হিসেবে লিখুন, আর শেষে অনুমান বনাম বাস্তব রাখুন।

পরের পর্বে: এবার metric থেকে উন্নতির পথে: root cause analysis, 5 Whys, defect-এর শ্রেণি আর Pareto, আর বাজারঘরের আসল খুঁজে পাওয়া defect-এর ইতিহাস থেকে প্রক্রিয়ার কোন জায়গা বদলাতে হবে।

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

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