Structuring Your IA (IA ကို ဖွဲ့စည်း တည်ဆောက်ခြင်း)

IA ပြင်ဆင်ခြင်း: ဒီစာမျက်နှာက OOP (object တွေကို အခြေခံပြီး program ရေးနည်း) နဲ့ JavaFX (Java နဲ့ desktop app တည်ဆောက်တဲ့ library) စာမျက်နှာတွေက အရာအားလုံးကို စုစည်းပြီး ကိုယ့် Internal Assessment project ကို စီစဉ်၊ တည်ဆောက်ပြီး စနစ်တကျ စီဖို့ လက်တွေ့ လမ်းညွှန် တစ်ခုအဖြစ် ပြပါတယ်။ Internal Assessment (IA) ဆိုတာ IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) သင်တန်းမှာ ကျောင်းသားတစ်ယောက်ချင်း ကိုယ်တိုင် တည်ဆောက်ရပြီး ကျောင်းက ဆရာက အမှတ်ပေးတဲ့ အပိုင်းပါ: ကိုယ်ရွေးထားတဲ့ ပြဿနာ တစ်ခုအတွက် product (program ဒါမှမဟုတ် app) တစ်ခုကို တည်ဆောက်ရပြီး criterion (အမှတ်ပေး စံနှုန်း) ငါးခုနဲ့ အမှတ်ပေးပါတယ်။ IB သင်တန်း မတက်တဲ့သူတွေအတွက်လည်း programming project တစ်ခုကို ဖွဲ့စည်း တည်ဆောက်ပုံ အကြံဉာဏ်တွေက အသုံးဝင်ပါတယ်။

ခြုံငုံ မိတ်ဆက်

အစိတ်အပိုင်း တစ်ခုချင်းစီကို လေ့လာခဲ့ပြီးပါပြီ: class (object တွေ ဖန်တီးဖို့ ပုံစံခွက်)၊ encapsulation (ဒေတာနဲ့ method ကို တစ်စုတည်း ထုပ်ပိုးခြင်း)၊ MVC (app ကို Model၊ View၊ Controller ဆိုပြီး အပိုင်းသုံးပိုင်း ခွဲရေးတဲ့ ပုံစံ)၊ JavaFX၊ FXML (screen ပုံစံကို ဖော်ပြတဲ့ file)၊ file I/O (file ဖတ်ခြင်း၊ ရေးခြင်း) တို့ပါ။ ဒီစာမျက်နှာက အဲဒါတွေ အားလုံးကို ပေါင်းစပ်ပြီး စနစ်တကျ ဖွဲ့စည်းထားတဲ့ IA project တစ်ခု ဘယ်လို တည်ဆောက်မလဲ ပြပါတယ်။ အဲဒီ project က:

Criteria A ကနေ E အထိအတွက် examiner (အမှတ်ပေးသူ) ရဲ့ မျှော်လင့်ချက်တွေနဲ့ ကိုက်ညီပါတယ်
အဆင့်ဆင့် တိုးပြီး တည်ဆောက်နိုင်၊ debug (program ထဲက အမှားကို ရှာပြီး ပြင်ခြင်း) လုပ်နိုင်လောက်အောင် modular (သီးခြား အပိုင်းငယ်တွေ ခွဲရေးထားတဲ့) ဖြစ်ပါတယ်
OOP ကို တကယ် နားလည်ကြောင်း ပြပါတယ်: procedural code (class မသုံးဘဲ အဆင့်လိုက် ရေးထားတဲ့ code) ကို GUI (window၊ button တွေကို မြင်ရပြီး နှိပ်သုံးရတဲ့ user interface) နဲ့ အပြင်က ထုပ်ထားရုံ မဟုတ်ပါဘူး

Class တွေကို စီစဉ်ခြင်း

GUI ကနေ မစဘဲ ပြဿနာကနေ စပါ

ကျောင်းသား တော်တော်များများက interface (user မြင်ပြီး သုံးရတဲ့ မျက်နှာပြင်) ကို တည်ဆောက်တာကနေ တန်းစကြပါတယ်။ အဲဒီအစား ဒေတာ ကနေ စပါ:

ပြဿနာထဲမှာ ဘယ် object (class တစ်ခုကနေ ဖန်တီးထားတဲ့ instance) တွေ ရှိလဲ။ (ကျောင်းသားတွေ၊ စာအုပ်တွေ၊ ချက်ပြုတ်နည်းတွေ၊ ကုန်ပစ္စည်းတွေ…)
Object တစ်ခုစီမှာ ဘယ် attribute (object တစ်ခုရဲ့ ဒေတာကို သိမ်းထားတဲ့ variable) တွေ ရှိလဲ။
Object တစ်ခုစီပေါ်မှာ ဘယ်လို လုပ်ဆောင်ချက်တွေ လုပ်နိုင်လဲ။
ဘယ် collection (ဒေတာအစု) တွေ လိုလဲ။ (ကျောင်းသား စာရင်း၊ ကုန်ပစ္စည်း စာရင်း…)

ဒီမေးခွန်းတွေကို ဖြေပြီးမှပဲ interface အကြောင်း စဉ်းစားပါ။

The Three-Layer Architecture (အလွှာ သုံးလွှာ ဖွဲ့စည်းပုံ)

စနစ်တကျ ဖွဲ့စည်းထားတဲ့ IA တိုင်းမှာ အနည်းဆုံး ဒီ အလွှာတွေ ပါပါတယ်:

┌─────────────────────────────────────────────────┐
│                   Application                    │
│            (creates and wires everything)         │
├─────────────────────────────────────────────────┤
│                   Controller(s)                  │
│         (event handlers, coordinates M↔V)         │
├──────────────────────┬──────────────────────────┤
│       Model(s)       │          View(s)          │
│   data + logic +     │     FXML + UI controls    │
│   file I/O           │                           │
└──────────────────────┴──────────────────────────┘

ပုံထဲက စာတွေက ဒီလို ဆိုလိုပါတယ်: Application က အရာအားလုံးကို ဖန်တီးပြီး ချိတ်ဆက်ပေးပါတယ် (creates and wires everything)။ Controller(s) မှာ event handler (button နှိပ်တာလို event ဖြစ်တဲ့အခါ run တဲ့ code) တွေ ပါပြီး Model နဲ့ View ကြားကို ညှိပေးပါတယ် (coordinates M↔V)။ Model(s) မှာ ဒေတာ၊ logic နဲ့ file I/O ပါပြီး View(s) မှာ FXML နဲ့ UI control (button၊ text box စတဲ့ user သုံးတဲ့ အစိတ်အပိုင်း) တွေ ပါပါတယ်။

ဥပမာ: Recipe Manager (ချက်ပြုတ်နည်း စီမံ app)

အဆင့် 1: Object တွေကို ခွဲခြား ဖော်ထုတ်ပါ:

Object	Attribute များ	အဓိက method (သီးခြား အလုပ်တစ်ခု လုပ်ပေးတဲ့ code အပိုင်း) များ
Recipe	name (နာမည်)၊ category (အမျိုးအစား)၊ servings (စားနိုင်တဲ့ လူဦးရေ)၊ ingredients (ပါဝင်ပစ္စည်းများ) ArrayList (ကြီးလာ၊ သေးသွားနိုင်တဲ့ list)၊ instructions (ချက်ပြုတ်ပုံ အဆင့်များ)	getter (private attribute ရဲ့ တန်ဖိုးကို ပြန်ပေးတဲ့ method) များ၊ setter (private attribute ရဲ့ တန်ဖိုးကို ပြောင်းတဲ့ method) များ၊ toString
Ingredient	name (နာမည်)၊ quantity (ပမာဏ)၊ unit (ယူနစ်)	getter များ၊ toString
RecipeList	Recipe object တွေပါတဲ့ ArrayList	add၊ remove၊ findByName၊ filterByCategory၊ sortByName

အဆင့် 2: File တွေကို စီစဉ်ပါ:

src/
├── RecipeApp.java              // Application
├── model/
│   ├── Recipe.java             // data class
│   ├── Ingredient.java         // data class
│   ├── RecipeList.java         // collection + business logic
│   └── RecipeFileHandler.java  // CSV load/save
├── controller/
│   ├── MainController.java     // main screen logic
│   └── AddRecipeController.java // add/edit form logic
└── view/
    ├── main-view.fxml          // main screen layout
    └── add-recipe-view.fxml    // add/edit form layout

File စာရင်းထဲက comment တွေက file တစ်ခုစီရဲ့ တာဝန်ကို ပြပါတယ်: data class (ဒေတာ သိမ်းတဲ့ class)၊ collection + business logic (ဒေတာအစုနဲ့ app ရဲ့ စည်းမျဉ်းတွေ)၊ CSV load/save၊ main screen logic (main screen ကို ကိုင်တွယ်တဲ့ code)၊ add/edit form logic၊ main screen layout (main screen ရဲ့ ပုံစံ) နဲ့ add/edit form layout ပါ။

အဆင့် 3: Screen တွေကို စီစဉ်ပါ:

Screen	ရည်ရွယ်ချက်	အဓိက control များ
Main	Recipe list ကို ပြခြင်း၊ ရှာခြင်း၊ စစ်ထုတ်ခြင်း	ListView၊ search TextField၊ category ComboBox၊ button များ
Add/Edit	Recipe အသစ် ထည့်ခြင်း ဒါမှမဟုတ် ပြင်ခြင်း	name/servings အတွက် TextField များ၊ instructions အတွက် TextArea၊ ingredient ထည့်ခြင်း

အမှတ်ပေးသူတွေ ဘာကို ကြည့်လဲ

ဒီစာမျက်နှာက လက်ရှိ syllabus ရဲ့ criterion နာမည်တွေနဲ့ အမှတ် စုစုပေါင်းတွေကို သုံးပါတယ်။ Criterion တစ်ခုချင်းစီအတွက် အတိကျဆုံး လမ်းညွှန်ချက်ကို Internal Assessment စာမျက်နှာတွေမှာ ကြည့်ပါ။ Criterion နာမည်တွေနဲ့ အမှတ်တွေကို IB ရဲ့ English အတိုင်း ထားပါတယ်: criterion A ကနေ E အထိ ငါးခု ရှိပြီး စုစုပေါင်း 30 marks ပါ။

Criterion A: Problem specification (ပြဿနာကို တိတိကျကျ ဖော်ပြချက်၊ 4 marks)

Problem scenario (ပြဿနာ ဖြစ်နေတဲ့ အခြေအနေ) ကို တိုင်းတာနိုင်တဲ့ ဖြေရှင်းချက် လိုအပ်ချက်တွေနဲ့ ဖော်ပြထားခြင်း
Success criteria (အောင်မြင်မှု စံနှုန်းများ): product အောင်မြင်ကြောင်း ပြတဲ့ တိကျပြီး တိုင်းတာနိုင်၊ စမ်းသပ်နိုင်တဲ့ ရလဒ်များ
Computational context (ဖြေရှင်းချက် ပါဝင်တဲ့ computing နယ်ပယ်): ဖြေရှင်းချက်က ပါဝင်တဲ့ computing နယ်ပယ် (desktop OOP GUI၊ database (ဒေတာ သိမ်းဆည်းတဲ့ စနစ်) ပါတဲ့ web app စသဖြင့်) နဲ့ အဲဒီ ရွေးချယ်မှုအတွက် အကြောင်းပြချက်

Criterion B: Planning (စီမံကိန်း ရေးဆွဲခြင်း၊ 4 marks)

ပြဿနာကို အစိတ်အပိုင်းတွေအဖြစ် Decomposition (ပြဿနာကို အပိုင်းငယ်တွေ ခွဲခြင်း) လုပ်ထားခြင်း။ Structure chart၊ mind map ဒါမှမဟုတ် အလားတူ ပုံ တစ်ခုနဲ့ ပြနိုင်ပါတယ် (structure chart က အပိုင်းတွေကို အဆင့်လိုက် ခွဲပြတဲ့ ပုံ၊ mind map က အဓိက အကြောင်းအရာကနေ အကိုင်းအခက် ခွဲပြတဲ့ ပုံပါ)
Planning၊ designing၊ developing၊ testing နဲ့ evaluating အဆင့်တွေ ပါဝင်တဲ့ Chronology (အချိန်ဇယား အစီအစဉ်): Gantt chart (အလုပ်တစ်ခုစီကို အချိန်ဘားတွေနဲ့ ပြတဲ့ ဇယား) ဒါမှမဟုတ် Agile ပုံစံ (အလုပ်ကို အပိုင်းတိုလေးတွေ ခွဲပြီး ထပ်ခါထပ်ခါ တိုးတက်အောင် လုပ်တဲ့ နည်း) ကို များသောအားဖြင့် သုံးကြပါတယ်
သုံးဖို့ စီစဉ်ထားတဲ့ ရှိပြီးသား library (အသင့်ရေးထားတဲ့ code အစု) တွေ ဒါမှမဟုတ် research (သုတေသန) တွေကို ဖော်ပြထားခြင်း

Criterion C: System overview (စနစ်တစ်ခုလုံးကို ခြုံငုံ ဖော်ပြချက်၊ 6 marks)

အဓိက အစိတ်အပိုင်းတွေ၊ ဆက်နွယ်မှုတွေ၊ UI (user interface၊ user နဲ့ program ကြားက မြင်ကွင်း) နဲ့ အပြန်အလှန် ဆက်သွယ်ပုံ စည်းမျဉ်းတွေ ပါတဲ့ System model (စနစ်ကို ပုံနဲ့ ဖော်ပြချက်): class diagram၊ ERD (entity တွေနဲ့ ဆက်နွယ်မှုတွေကို ပြတဲ့ ပုံ)၊ wireframe (screen ပုံစံ ကြမ်း)
အစိတ်အပိုင်း တစ်ခုစီအတွက် pseudocode (program ပုံစံ ရိုးရိုးစာနဲ့ ရေးတဲ့ algorithm) ဒါမှမဟုတ် flowchart (လုပ်ငန်းစဉ်ကို သင်္ကေတတွေနဲ့ ဆွဲပြတဲ့ ပုံ) နဲ့ ရေးထားတဲ့ Algorithms (အယ်လ်ဂိုရီသမ်၊ ပြဿနာကို အဆင့်ဆင့် ဖြေရှင်းတဲ့ နည်းလမ်း)
Success criterion တိုင်းနဲ့ ကိုက်ညီပြီး မှန်ကန်မှု (correctness) နဲ့ စိတ်ချရမှု (reliability) ကို စစ်ဆေးတဲ့ Testing strategy (စမ်းသပ်ပုံ အစီအစဉ်)

Criterion D: Development (product တည်ဆောက်ခြင်း၊ 12 marks၊ အမှတ် အများဆုံး criterion)

ကိုယ့် code ရဲ့ ဖွဲ့စည်းပုံက ဒီ criterion မှာ အရေးအကြီးဆုံးပါ။

အမှတ်ပေးသူတွေ လိုချင်တာ	ပြသပုံ
Algorithm တွေအတွက် သင့်တော်တဲ့ technique တွေ	Class အများ ပါတဲ့ OOP၊ encapsulation၊ သေချာ ရွေးထားတဲ့ data structure (ဒေတာ သိမ်းဆည်းပုံ) တွေ၊ သင့်တော်တဲ့ library တွေ
ဖွဲ့စည်းပုံနဲ့ ရွေးချယ်မှုတွေအတွက် အကြောင်းပြချက် (justification)	Technique တစ်ခုစီကို ဘာကြောင့် ရွေးခဲ့လဲ ရှင်းပြပါ: ဘာလုပ်ခဲ့လဲ ပြောပြရုံ မဟုတ်ဘဲ trade-off (တစ်ခု ရဖို့ တစ်ခု အလျှော့ပေးရတာ) တွေကို အကဲဖြတ်ပါ
အလုပ်လုပ်တဲ့ product	Success criterion တိုင်း တကယ့် ဒေတာနဲ့ အလုပ်လုပ်ကြောင်း ပြတဲ့ video အထောက်အထား
စေ့စပ်သေချာတဲ့ testing	မှန်ကန်မှု၊ စိတ်ချရမှုနဲ့ efficiency (ထိရောက်မှု) အတွက် testing၊ video ထဲမှာ ဥပမာတွေနဲ့ ပြထားခြင်း

အမှတ် လျော့စေတဲ့ အဖြစ်များတဲ့ အမှားများ:

တာဝန် တစ်ခုစီကို အာရုံစိုက်တဲ့ class အများ မရေးဘဲ class ကြီး တစ်ခုတည်း ရေးခြင်း
Encapsulation မရှိခြင်း (private field (object ထဲက အချက်အလက် အကွက်) နဲ့ getter/setter အစား public field တွေ သုံးခြင်း)
GUI code ကို ဒေတာ logic နဲ့ ရောရေးခြင်း (MVC ခွဲခြားမှု မရှိခြင်း)
Input validation (ထည့်ပေးတဲ့ ဒေတာ မှန်မမှန် စစ်ခြင်း) မရှိခြင်း (ဘယ် input ကိုမဆို မစစ်ဘဲ လက်ခံခြင်း)
File persistence (program ပိတ်သွားပြီးနောက်မှာလည်း ဒေတာ ဆက်ရှိနေအောင် သိမ်းထားခြင်း) မရှိခြင်း (app ပိတ်ရင် ဒေတာ ပျောက်သွားခြင်း)
Source code အပြည့်အစုံ ပါတဲ့ appendix (နောက်ဆက်တွဲ) မပါခြင်း (technique တွေအတွက် အမှတ်ပြည့် မရအောင် ကန့်သတ်ခံရပါတယ်)

Criterion E: Evaluation (အကဲဖြတ်ခြင်း၊ 4 marks)

Test ရလဒ်တွေနဲ့ video အထောက်အထားကို သုံးပြီး success criterion တစ်ခုချင်းစီနဲ့ ယှဉ်ကာ product ကို Evaluate (အားသာချက်နဲ့ အားနည်းချက်တွေကို ချိန်ဆပြီး အကဲဖြတ်ပါ)
Justify improvements (product ကို ဘယ်လို ပိုကောင်းအောင် လုပ်မလဲ အကြောင်းပြချက်နဲ့ ပြပါ): ပြင်ဆင်ချက်တွေက လက်တွေ့ကျ၊ တိကျပြီး evaluation မှာ တွေ့ခဲ့တာတွေကနေ ပေါ်လာတာ ဖြစ်ရပါမယ်
လက်ရှိ syllabus မှာ user ဒါမှမဟုတ် advisor (လမ်းညွှန်ပေးသူ) ရဲ့ feedback က မဖြစ်မနေ မလိုပါဘူး၊ ဒါပေမယ့် ရှိရင် evaluation ကို ပိုခိုင်မာစေပါတယ်

အဆင့်ဆင့် တိုးပြီး တည်ဆောက်ခြင်း

မှန်ကန်တဲ့ အစဉ်

အရာအားလုံးကို တစ်ပြိုင်နက် တည်ဆောက်ဖို့ မကြိုးစားပါနဲ့။ ဒီအစဉ်အတိုင်း လုပ်ပါ:

Phase 1 (အဆင့် 1): Model သက်သက် (GUI မပါ)

ကိုယ့် data class တွေကို ရေးပါ (ဥပမာ Recipe၊ Ingredient)
ကိုယ့် collection class ကို ရေးပါ (ဥပမာ RecipeList)
ရိုးရှင်းတဲ့ main (program စ run တဲ့ method) method နဲ့ စမ်းသပ်ပါ: object တွေ ထည့်၊ ရှာ၊ print ထုတ်ပါ
Model မှန်မှန်ကန်ကန် အလုပ်လုပ်မှပဲ ရှေ့ဆက်ပါ

Phase 2: File I/O

File handler (file ဖတ်တာ၊ ရေးတာကို တာဝန်ယူတဲ့ class) ကို ရေးပါ (save နဲ့ load)
ကိုယ့် main method နဲ့ save/load ကို စမ်းသပ်ပါ
App ကို “ပိတ်ပြီး ပြန်ဖွင့်” လိုက်တဲ့အခါ ဒေတာ ကျန်နေလား စစ်ပါ

Phase 3: အခြေခံ GUI

Main FXML layout ကို ဖန်တီးပါ
Event handler တွေ ပါတဲ့ Controller ကို ရေးပါ
Application class ထဲမှာ အရာအားလုံးကို ချိတ်ဆက်ပါ
စမ်းသပ်ပါ: GUI ကနေ ဒေတာ ထည့်၊ ကြည့်၊ save လုပ်နိုင်လား

Phase 4: Screen အပိုများ

Add/edit form တွေအတွက် popup window (main window ရှေ့မှာ ပွင့်လာတဲ့ သီးခြား window) တွေ ထည့်ပါ
Search၊ filter၊ sort feature တွေ ထည့်ပါ
Validation နဲ့ error feedback တွေ ထည့်ပါ

Phase 5: Polish (သေသပ်အောင် ပြင်ဆင်ခြင်း)

Edge case (ပုံမှန် မဟုတ်တဲ့ အစွန်း အခြေအနေ) တွေကို ကိုင်တွယ်ပါ (input ဗလာ၊ file မရှိခြင်း၊ နာမည် ထပ်နေခြင်း)
Window ပိတ်ချိန်မှာ အလိုအလျောက် save လုပ်တာကို ထည့်ပါ
ကိုယ့် client (product ကို သုံးမယ့်သူ) နဲ့ စမ်းသပ်ပါ

Model ကို အရင် တည်ဆောက်ပါ။ ကိုယ့် data class တွေ အလုပ်မလုပ်ရင် GUI က ဘာမှ ကူညီနိုင်မှာ မဟုတ်ပါဘူး။

OOP ကို ပြသခြင်း

အလုပ်လုပ်တဲ့ GUI တစ်ခုတည်းနဲ့ OOP ကို နားလည်ကြောင်း မပြနိုင်ပါဘူး။ ကိုယ့် application လိုအပ်တဲ့ ဒေတာနဲ့ အပြုအမူကို class တွေနဲ့ ကိုယ်စားပြုပါ။ IA project တစ်ခုမှာ အဲဒါ ဘယ်လို ပုံစံ ဖြစ်လဲ ဆိုတာ အောက်က ဥပမာတွေ ပြပါတယ်:

Encapsulation (ဒေတာနဲ့ method ကို တစ်စုတည်း ထုပ်ပိုးခြင်း)

// Good: private fields with validated setters
public class Recipe {
    private String name;
    private int servings;

    public void setServings(int servings) {
        if (servings < 1) {
            throw new IllegalArgumentException("Servings must be at least 1");
        }
        this.servings = servings;
    }
}

Code ထဲက comment က ဒါကို ကောင်းတဲ့ ပုံစံလို့ ပြောပါတယ်: private field တွေနဲ့ တန်ဖိုးကို စစ်ပြီးမှ ထည့်တဲ့ setter တွေပါ။

Collections of Objects (object တွေကို စုထားတဲ့ ဒေတာအစုများ)

// Good: a dedicated class managing a collection
public class RecipeList {
    private ArrayList<Recipe> recipes;

    public ArrayList<Recipe> filterByCategory(String category) {
        ArrayList<Recipe> results = new ArrayList<>();
        for (int i = 0; i < recipes.size(); i++) {
            if (recipes.get(i).getCategory().equals(category)) {
                results.add(recipes.get(i));
            }
        }
        return results;
    }
}

Code ထဲက comment က ဒါကို ကောင်းတဲ့ ပုံစံလို့ ပြောပါတယ်: collection တစ်ခုကို စီမံဖို့ သီးသန့် class တစ်ခု ရေးထားတာပါ။

MVC Separation (Model၊ View၊ Controller ကို ခွဲထားခြင်း)

// Good: Controller handles the event, delegates to Model
@FXML
private void handleSearch() {
    String query = searchField.getText().trim();
    if (query.isEmpty()) {
        refreshDisplay(model.getAll());  // show all
    } else {
        refreshDisplay(model.filterByCategory(query));
    }
}

Code ထဲက comment က ဒါကို ကောင်းတဲ့ ပုံစံလို့ ပြောပါတယ်: Controller က event ကို ကိုင်တွယ်ပြီး အလုပ်ကို Model ဆီ လွှဲပေးပါတယ်။ // show all က အားလုံးကို ပြပါလို့ ဆိုလိုပါတယ်။

Aggregation (သီးခြား ရှိနေနိုင်တဲ့ has-a ဆက်နွယ်မှု)

// Good: Recipe HAS ingredients (composition/aggregation)
public class Recipe {
    private String name;
    private ArrayList<Ingredient> ingredients;

    public void addIngredient(Ingredient i) {
        ingredients.add(i);
    }
}

Code ထဲက comment က ဒါကို ကောင်းတဲ့ ပုံစံလို့ ပြောပါတယ်: Recipe မှာ ingredient တွေ ရှိပါတယ် (HAS ingredients)၊ ဒါက composition (ပိုခိုင်မာတဲ့ has-a ဆက်နွယ်မှု) ဒါမှမဟုတ် aggregation ပါ။

IA မှာ အဖြစ်များတဲ့ အမှားများ

Scope (project ရဲ့ အတိုင်းအတာ): ကြီးလွန်းခြင်းနဲ့ သေးလွန်းခြင်း

ကြီးလွန်းရင်: ကျောင်းသား မှတ်တမ်း၊ grade၊ ကျောင်းတက် မှတ်တမ်း၊ အချိန်ဇယားနဲ့ report တွေ ပါတဲ့ ကျောင်း စီမံခန့်ခွဲမှု စနစ် အပြည့်အစုံ။ အချိန် မလောက်ဖြစ်ပြီး မပြီးသေးတဲ့ အလုပ်ကို တင်သွင်းရပါလိမ့်မယ်။

သေးလွန်းရင်: ရိုးရိုး calculator ဒါမှမဟုတ် ယူနစ် ပြောင်းပေးတဲ့ app။ OOP ကို ပြနိုင်လောက်တဲ့ ရှုပ်ထွေးမှု မရှိပါဘူး။

သင့်တော်ရင်: add/edit/delete/search/sort နဲ့ file persistence ပါပြီး ဒေတာ အမျိုးအစား တစ်ခုကို စီမံတဲ့ အာရုံစိုက်ထားတဲ့ app။ ဥပမာ: recipe manager (ချက်ပြုတ်နည်း စီမံ app)၊ book catalogue (စာအုပ် စာရင်း)၊ fitness tracker (ကိုယ်လက်လှုပ်ရှားမှု မှတ်တမ်း)၊ inventory system (ကုန်ပစ္စည်း လက်ကျန် စာရင်း စနစ်)၊ quiz maker (မေးခွန်း ဖန်တီးတဲ့ app)။

Model class 3 ကနေ 5 ခု၊ screen 2 ကနေ 3 ခုနဲ့ အဓိပ္ပာယ်ရှိတဲ့ feature 3 ကနေ 4 ခု (search၊ filter၊ sort စသဖြင့်) ကို ရည်မှန်းပါ။

ကိုယ် မရှင်းပြနိုင်တဲ့ code

Tutorial (အဆင့်ဆင့် သင်ပြတဲ့ လမ်းညွှန်) တစ်ခုကနေ code ကို copy ကူးခဲ့ပြီး line တိုင်းကို မရှင်းပြနိုင်ရင် အဲဒီ code ကို မထည့်ပါနဲ့။ ကိုယ့် ဆရာက IA က ကိုယ်တိုင် လုပ်ထားတဲ့ အလုပ် ဖြစ်ကြောင်း အတည်ပြုရမှာဖြစ်ပြီး ကိုယ့် code ကို ရှင်းပြခိုင်းပြီး စစ်ဆေးနိုင်ပါတယ်။ ကိုယ် မရှင်းပြနိုင်တဲ့ code က အဲဒီ အတည်ပြုချက်ကို အန္တရာယ် ဖြစ်စေပါတယ်။

ကိုယ် နားလည်တဲ့ code ကို ရေးပါ။ Copy ကူးထားတဲ့ ရှုပ်ထွေးတဲ့ ဖြေရှင်းချက်ထက် အပြည့်အဝ ရှင်းပြနိုင်တဲ့ ပိုရိုးရှင်းတဲ့ ဖြေရှင်းချက်က ပိုကောင်းပါတယ်။

Validation (ထည့်ပေးတဲ့ ဒေတာ မှန်မမှန် စစ်ခြင်း) မပါခြင်း

Text input တိုင်းကို validate (မှန်မမှန် စစ်) လုပ်သင့်ပါတယ်:

ဗလာ ဖြစ်နေလား။
Type မှန်လား (ဂဏန်း၊ ရက်စွဲ စသဖြင့်)။
လက်ခံနိုင်တဲ့ အပိုင်းအခြားထဲမှာ ရှိလား။
ရှိပြီးသား entry တစ်ခုနဲ့ ထပ်နေလား။

Validation က ထည့်ရ လွယ်ပြီး ကောင်းမွန်တဲ့ code ရေးနည်းတွေကို ပြသပါတယ်။

IA ဖွဲ့စည်းပုံ စစ်ဆေးစာရင်း

မတင်သွင်းခင် ကိုယ့် project က ဒီ ဖွဲ့စည်းပုံ လိုအပ်ချက်တွေနဲ့ ကိုက်ညီလား စစ်ပါ:

အမျိုးအစား	စစ်ရမယ့် အချက်
Model	Private field တွေနဲ့ getter/setter တွေ ပါတဲ့ data class အနည်းဆုံး 2 ခု
Model	add/remove/search method တွေ ပါတဲ့ collection class အနည်းဆုံး 1 ခု
Model	Persistence အတွက် file I/O (app စတဲ့အခါ load၊ ပိတ်တဲ့အခါ save)
Model	Constructor (object ဖန်တီးချိန် attribute တွေကို စတင် သတ်မှတ်ပေးတဲ့ method) တွေ ဒါမှမဟုတ် setter တွေထဲမှာ input validation
View	Java logic နဲ့ သီးခြား ခွဲထားတဲ့ FXML file တွေ
View	Screen အနည်းဆုံး 2 ခု (main + add/edit popup)
Controller	Event handler တွေက View ဒါမှမဟုတ် Model ထဲမှာ မဟုတ်ဘဲ Controller class တွေထဲမှာ
Controller	User ကို error message တွေ ပြခြင်း (status label ဒါမှမဟုတ် alert တွေနဲ့)
MVC	Model မှာ `javafx.*` import မပါ
MVC	View မှာ business logic (app ရဲ့ ဒေတာဆိုင်ရာ စည်းမျဉ်းတွေ) မပါ (ဒေတာနဲ့ ပတ်သက်တဲ့ `if` statement တွေ)
MVC	Controller တွေက Model နဲ့ View ကို ချိတ်ဆက်ပေး
အထွေထွေ	အဓိပ္ပာယ်ရှိတဲ့ variable နဲ့ method နာမည်များ
အထွေထွေ	Line 200 ကျော်တဲ့ method ကြီးတွေ မရှိရ: logic ကို helper method (အလုပ်တစ်စိတ်တစ်ပိုင်းကို ကူလုပ်ပေးတဲ့ method ငယ်) တွေအဖြစ် ခွဲပါ
အထွေထွေ	Code ကို ကြည့်ရုံနဲ့ logic မရှင်းတဲ့ နေရာတွေမှာပဲ comment ရေးပါ

Quick Check (အမြန် စစ်ဆေးမေးခွန်း)

Q1. IA project တစ်ခု တည်ဆောက်တဲ့အခါ ဘာကို အရင်ဆုံး ရေးသင့်သလဲ။

Q2. IA criterion တွေထဲမှာ ဘယ် criterion က အမှတ် အများဆုံး ရသလဲ။

Q3. IA အတွက် ဘယ် project scope က အသင့်တော်ဆုံးလဲ။

Q4. ကိုယ့် MVC ခွဲခြားမှု မှန်မမှန် ဘယ်လို စစ်နိုင်သလဲ။

Q5. MVC architecture က Criterion D: Development အတွက် ဘယ်လို အထောက်အကူ ဖြစ်သလဲ။

Fill in the Blanks (ကွက်လပ် ဖြည့်ခြင်း)

IA project တစ်ခုအတွက် class စီစဉ်ချက်ကို ဖြည့်ပါ။

ကွက်လပ် ဖြည့်ပါ: Book Catalogue (စာအုပ် စာရင်း) IA တစ်ခုထဲက class တစ်ခုစီရဲ့ မှန်ကန်တဲ့ MVC role (တာဝန်) ကို Identify (ဖြစ်နိုင်တဲ့ အဖြေတွေထဲက ရွေးပြီး ဖော်ပြပါ)။ Comment တွေက file တစ်ခုစီ ဘာလုပ်လဲ ပြောပြပါတယ်: Book.java က title၊ author၊ genre၊ rating ကို သိမ်းပါတယ်၊ BookList.java က Book တွေပါတဲ့ ArrayList ကို စီမံပါတယ် (ထည့်၊ ရှာ၊ စီ)၊ main-view.fxml က ListView နဲ့ button တွေ ပါတဲ့ layout ကို သတ်မှတ်ပါတယ်၊ MainController.java က button click တွေကို ကိုင်တွယ်ပြီး display ကို update လုပ်ပါတယ်၊ BookFileHandler.java က Book တွေကို CSV file ထဲ ဖတ်၊ ရေးပါတယ်။ အဖြေကို Model၊ View ဒါမှမဟုတ် Controller လို့ English နဲ့ ရိုက်ထည့်ပါ။

// Book.java stores title, author, genre, rating
// Role: 

// BookList.java manages an ArrayList of Books (add, search, sort)
// Role: 

// main-view.fxml defines the layout with a ListView and buttons
// Role: 

// MainController.java handles button clicks and updates the display
// Role: 

// BookFileHandler.java reads/writes Books to a CSV file
// Role:

Spot the Error (အမှား ရှာခြင်း)

ကျောင်းသား တစ်ယောက်ရဲ့ IA မှာ ဒီ class ဖွဲ့စည်းပုံ ရှိပါတယ်။ Class တစ်ခုက MVC စည်းမျဉ်းတွေကို ချိုးဖောက်နေပါတယ်။

အမှား ရှာပါ: ဒီ Model class ထဲက MVC ချိုးဖောက်မှုကို ရှာပါ။

1import javafx.scene.control.Alert; 2 3public class Product { 4 private String name; 5 private double price; 6 7 public Product(String name, double price) { 8 if (price < 0) { 9 Alert a = new Alert(Alert.AlertType.ERROR); 10 a.setContentText("Price cannot be negative"); 11 a.showAndWait(); 12 return; 13 } 14 this.name = name; 15 this.price = price; 16 } 17}

မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:

Practice Exercises (လေ့ကျင့်ခန်းများ)

Core (အခြေခံ အဆင့်)

Class စီစဉ်ခြင်း: IA ခေါင်းစဉ် တစ်ခု ရွေးပါ (ဥပမာ အားကစား အသင်း စီမံ app၊ ရုပ်ရှင် စုစည်းမှု၊ စာကျက် အစီအစဉ် app)။ Model class 2 ကနေ 3 ခုကို သူတို့ရဲ့ attribute တွေ၊ method တွေနဲ့အတူ စာရင်းပြုစုပါ။ Class တစ်ခုစီအတွက် UML class diagram (class တစ်ခုကို အကွက် သုံးကွက်နဲ့ ပြတဲ့ ပုံ) တစ်ခုစီ ဆွဲပါ။
တည်ဆောက်မယ့် အစဉ်: အဲဒီ project အတွက်ပဲ development phase (တည်ဆောက်မှု အဆင့်) 5 ခု (Model၊ File I/O၊ Basic GUI၊ Additional Screens၊ Polish) ကို phase တစ်ခုစီအတွက် တိကျတဲ့ အလုပ်တွေနဲ့အတူ ရေးချပါ။

Extension (တိုးချဲ့ အဆင့်)

Prototype (စမ်းသပ် ပုံစံ) တစ်ခု တည်ဆောက်ခြင်း: ကိုယ် စီစဉ်ထားတဲ့ IA အတွက် Model layer (data class တွေ + collection class + file handler) ကို ရေးပါ။ နမူနာ ဒေတာ ထည့်၊ file ထဲ save လုပ်၊ ပြန် load လုပ်ပြီး ရလဒ်တွေကို print ထုတ်တဲ့ ရိုးရှင်းတဲ့ main method နဲ့ စမ်းသပ်ပါ။ GUI မလိုပါဘူး။
GUI ထည့်ခြင်း: လေ့ကျင့်ခန်း 3 က အလုပ်လုပ်တဲ့ Model ကို ယူပြီး main screen တစ်ခု (list view + add button) ပါတဲ့ အခြေခံ GUI တစ်ခု တည်ဆောက်ပါ။ MVC ကို သုံးပြီး Controller တစ်ခုနဲ့ ချိတ်ဆက်ပါ။ App စတဲ့အခါနဲ့ ပိတ်တဲ့အခါမှာ file persistence ထည့်ပါ။

Challenge (စိန်ခေါ်မှု အဆင့်)

Mini-IA အပြည့်အစုံ: ဒီအချက်တွေ ပါတဲ့ အသေးစား IA project အပြည့်အစုံ တစ်ခုကို တည်ဆောက်ပါ:
- Encapsulation နဲ့ validation ပါတဲ့ model class အနည်းဆုံး 2 ခု
- Search နဲ့ sort method တွေ ပါတဲ့ collection class တစ်ခု
- CSV file persistence
- Main screen တစ်ခုနဲ့ အနည်းဆုံး popup form တစ်ခု
- FXML view တွေ ပါတဲ့ MVC architecture
- Input validation နဲ့ error feedback
ဒီလေ့ကျင့်ခန်းက IA တည်ဆောက်မှု လုပ်ငန်းစဉ် အပြည့်အစုံကို အတုယူ လေ့ကျင့်ပေးပါတယ်။ Code ရေးတဲ့ အကြိမ် 2 ကနေ 3 ကြိမ်အတွင်း ပြီးနိုင်မယ့် project ကို ရည်မှန်းပါ။

ဆက်စပ် ခေါင်းစဉ်များ

အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: Classes and Objects (class နဲ့ object များ)၊ Encapsulation (ဒေတာနဲ့ method ကို တစ်စုတည်း ထုပ်ပိုးခြင်း): Model ဒီဇိုင်း
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: Aggregation (သီးခြား ရှိနေနိုင်တဲ့ has-a ဆက်နွယ်မှု): Model ထဲက object collection တွေ
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: UML Class Diagrams (class တစ်ခုကို အကွက် သုံးကွက်နဲ့ ပြတဲ့ ပုံများ): class တွေကို စီစဉ်ခြင်း
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: JavaFX Basics (JavaFX အခြေခံများ): control တွေနဲ့ event handling (user က နှိပ်တာ ဒါမှမဟုတ် စာရိုက်တာကို program က တုံ့ပြန်အောင် လုပ်ခြင်း)
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: MVC Architecture (MVC ဖွဲ့စည်းပုံ): တာဝန်တွေကို ခွဲခြားခြင်း
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: FXML and Controllers (FXML နဲ့ controller များ): View layer
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: Multi-Window Apps (Window အများ ပါတဲ့ app များ): screen အများ
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: File I/O in Apps (App တွေထဲမှာ file ဖတ်ခြင်း၊ ရေးခြင်း): data persistence
ဆက်စပ် ခေါင်းစဉ်: OOP Method Patterns (OOP method ပုံစံများ): IA code မှာ သုံးလေ့ရှိတဲ့ method ပုံစံများ