លំហាត់មេរៀនទី៥៖ Factory Method and Abstract Factory

លំហាត់មេរៀនទី ៥ ផ្ដោតលើ Factory Method និង Abstract Factory ដើម្បីឱ្យនិស្សិតយល់ពីការបំបែក Object Creation ចេញពី Client Code និង Business Logic។ និស្សិតរៀនពី Direct Object Creation Problem, Simple Factory, @classmethod ជា Alternative Constructor, Registry-Based Factory, Factory Method និង Abstract Factory សម្រាប់បង្កើត Concrete Objects ឬ Product Families តាម Runtime Requirement និង Configuration។ ក្នុងការអនុវត្ត និស្សិតបង្កើត NotifierFactory, UserFactory, Report Creators និង Light/Dark UI Factories ហើយភ្ជាប់ Factory ជាមួយ Protocol, Open/Closed Principle និង Dependency Injection ដើម្បីកាត់បន្ថយ Coupling និងធ្វើឱ្យប្រព័ន្ធងាយសាកល្បង និងងាយពង្រីក។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតយល់ថា Factory Pattern មានប្រយោជន៍នៅពេល Object Creation មាន Concrete Implementations ច្រើន ឬត្រូវជ្រើសរើសតាម Runtime ដោយរក្សា Architecture ឱ្យមានភាពបត់បែន និងមានរចនាសម្ព័ន្ធច្បាស់។

08 Sep 2026 0 44

មេរៀនទី ១៣៖ Clean Architecture and Domain-Driven Design Foundations

មេរៀនទី ១៣ ផ្ដោតលើ Clean Architecture និង Domain-Driven Design (DDD) Foundations ដើម្បីឱ្យនិស្សិតយល់ពីការរចនាប្រព័ន្ធដែលដាក់ Business Domain ជាចំណុចកណ្ដាល និងរក្សា Core Business Logic ឱ្យឯករាជ្យពី Flask, Database និង Infrastructure។ និស្សិតរៀនបែងចែក Domain, Application, Infrastructure និង Presentation Layers តាម Dependency Rule ព្រមទាំងសិក្សា Entity, Value Object, Aggregate, Aggregate Root, Business Invariant, Domain Service, Application Service, Repository Contract, Domain Event, Ubiquitous Language និង Bounded Context។ ក្នុងការអនុវត្ត និស្សិតបង្កើត Domain Models ដែលមាន Behavior និង Validation ច្បាស់ បំបែក Use Cases ចេញពី Flask Routes ប្រើ Repository Abstraction និង Dependency Injection ដើម្បីកាត់បន្ថយ Coupling និងធ្វើឱ្យ Testing ងាយស្រួល។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតអាចបង្កើត Software Architecture ដែលមាន Boundaries ច្បាស់ ងាយថែទាំ ងាយសាកល្បង ងាយផ្លាស់ប្ដូរ Framework និងអាចពង្រីកបាននៅពេលប្រព័ន្ធកាន់តែធំ។

20 Aug 2026 0 14

មេរៀនទី ១២៖ Integration, Deployment and Final Project Defense

មេរៀនទី ១២ ផ្ដោតលើ Integration, Deployment និង Final Project Defense ដោយឱ្យនិស្សិតរួមបញ្ចូលគោលគំនិត Advanced OOP និង Architecture ទាំងអស់ពីមេរៀនមុនៗ ដូចជា Domain Models, Repository, Service Layer, Dependency Injection, Design Patterns, Event-Driven OOP, Flask, RBAC និង Testing ទៅជា Application ពេញលេញដែលមាន Responsibility ច្បាស់ និងងាយថែទាំ។ និស្សិតរៀនត្រៀម Application សម្រាប់ Deployment តាមរយៈ Configuration, Environment Variables, Database Setup, Logging, Error Handling និង Security Review ព្រមទាំងរៀបចំ Unit Tests, Integration Tests និង Route Tests ដើម្បីផ្ទៀងផ្ទាត់ Business Rules និង Permission Boundaries។ លើសពីនេះ និស្សិតត្រូវរៀបចំ Documentation, Architecture Diagram, Demo Scenario និងការបកស្រាយ Design Decisions ដើម្បីត្រៀមសម្រាប់ Final Presentation និង Technical Defense។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតមិនត្រឹមតែអាចបង្កើត Project ដែលដំណើរការបានទេ ប៉ុន្តែអាចពន្យល់ និងការពាររចនាសម្ព័ន្ធ Architecture, Security, Testing និងការជ្រើសរើស Design Patterns របស់ខ្លួនបានយ៉ាងច្បាស់។

19 Aug 2026 0 9

មេរៀនទី ១១៖ Flask Application Factory, RBAC and Testing

មេរៀនទី ១១ ផ្ដោតលើការយក Advanced OOP Architecture ទៅអនុវត្តក្នុង Flask Application ដោយប្រើ Application Factory, Blueprints, RBAC និង Testing។ និស្សិតរៀនប្រើ create_app() ជា Composition Root សម្រាប់ Configure Database, Repositories, Services និង Blueprints ព្រមទាំងបែងចែក Authentication និង Authorization ឱ្យច្បាស់ ដោយអនុវត្ត RBAC តាម User, Role និង Permission និងប្រើ Decorators ដូចជា @login_required និង @permission_required(...) សម្រាប់ការពារ Routes។ លើសពីនេះ និស្សិតរៀនរក្សា Flask Routes ឱ្យ Thin, ដាក់ Business Logic នៅ Service Layer, Data Access នៅ Repository Layer និងប្រើ Dependency Injection ដើម្បីធ្វើឱ្យ Application ងាយសាកល្បង។ ក្នុងការអនុវត្ត និស្សិតប្រើ Flask Test Client, Memory/Fake Repositories និង Test Doubles ដើម្បីសាកល្បង Login, Permission, 401/403 Cases និង Business Rules។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតអាចបង្កើត Flask Application ដែលមានរចនាសម្ព័ន្ធច្បាស់ សុវត្ថិភាព ងាយថែទាំ ងាយសាកល្បង និងអាចពង្រីកទៅ Final Project បាន។

19 Aug 2026 0 37

មេរៀនទី ១០៖ Repository, Service Layer and Dependency Injection

មេរៀនទី ១០ ផ្ដោតលើ Repository Pattern, Service Layer និង Dependency Injection ដើម្បីបំបែក Business Logic ចេញពី Data Access និង Infrastructure ឱ្យមានរចនាសម្ព័ន្ធច្បាស់លាស់។ និស្សិតរៀនប្រើ Repository Contract ជាមួយ Protocol, បង្កើត Memory Repository និង SQLite Repository, រៀបចំ Service Layer សម្រាប់គ្រប់គ្រង Use Cases និង Business Rules ព្រមទាំងប្រើ Constructor Dependency Injection ដើម្បីកាត់បន្ថយ Coupling និងធ្វើឱ្យ Testing ងាយស្រួល។ លើសពីនេះ និស្សិតសិក្សា Unit of Work សម្រាប់គ្រប់គ្រង Transaction, commit() និង rollback() និងរៀនឱ្យ Repository Return Domain Objects ជំនួស Raw Database Rows។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតអាចរចនា Layered Architecture ដែលងាយថែទាំ ងាយសាកល្បង ងាយប្ដូរ Database Implementation និងត្រៀមសម្រាប់ Flask Application Factory និង RBAC Integration នៅមេរៀនបន្ទាប់។

19 Aug 2026 0 16

មេរៀនទី ៩៖ Observer Pattern and Event-Driven OOP

មេរៀនទី ៩ ផ្ដោតលើ Observer Pattern និង Event-Driven OOP ដើម្បីឱ្យនិស្សិតយល់ពីរបៀបធ្វើឱ្យ Objects ជាច្រើនអាចឆ្លើយតបទៅនឹង Event មួយដោយមិនចងគ្នាខ្លាំងពេក។ និស្សិតសិក្សាតួនាទីរបស់ Subject/Publisher, Observer/Subscriber, subscribe(), unsubscribe(), notify() និង publish() ព្រមទាំងការបង្កើត Domain Events ដោយប្រើ dataclass និង Event Handler Contracts ដោយប្រើ Protocol។ ក្នុងការអនុវត្ត និស្សិតបង្កើត EventBus សម្រាប់ចែកចាយ Events ដូចជា TaskCreatedEvent, TaskAssignedEvent និង TaskCompletedEvent ទៅកាន់ Audit, Notification, Dashboard និង Activity Feed Handlers ដោយឯករាជ្យ។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតអាចរចនាប្រព័ន្ធដែលមាន Loose Coupling, ងាយពង្រីក, ងាយសាកល្បង និងត្រៀមសម្រាប់ Repository, Service Layer និង Event-Driven Architecture នៅមេរៀនបន្ទាប់។

19 Aug 2026 0 15

មេរៀនទី ៨៖ Strategy, Template Method and Command Patterns

មេរៀនទី ៨ ផ្ដោតលើ Strategy, Template Method និង Command Patterns ដើម្បីឱ្យនិស្សិតយល់ពីការរចនា Behavior និង Workflow ឱ្យមានភាពបត់បែន និងងាយពង្រីក។ Strategy Pattern អនុញ្ញាតឱ្យបំបែក Algorithm ឬ Behavior ដែលអាចជំនួសគ្នាបាន និងអាចប្ដូរនៅ Runtime, Template Method កំណត់ Workflow រួមនៅ Base Class ហើយឱ្យ Subclass កែតែជំហានជាក់លាក់, ចំណែក Command Pattern បម្លែង Action ឬ Request ទៅជា Object ដែលអាច execute(), រក្សាទុក History, Queue និង undo() បាន។ ក្នុងការអនុវត្ត និស្សិតប្រើ Discount/Payment Strategies, Report Export Workflow និង Task Commands ដើម្បីយល់ពី Composition, Inheritance, Loose Coupling និងការបែងចែក Responsibility ឱ្យច្បាស់។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតអាចរចនា Business Behavior ដែលងាយសាកល្បង ងាយថែទាំ និងងាយបន្ថែមមុខងារថ្មីដោយមិនប៉ះពាល់ Core Logic ច្រើន។

19 Aug 2026 0 18

មេរៀនទី ៧៖ SOLID Principles and Refactoring

មេរៀនទី ៧ ផ្ដោតលើ SOLID Principles និង Refactoring ដើម្បីឱ្យនិស្សិតយល់ពីការរចនា Software ឱ្យមាន Responsibility ច្បាស់ មាន Coupling ទាប និងងាយពង្រីក។ និស្សិតសិក្សា SRP សម្រាប់បំបែក Responsibility, OCP សម្រាប់ពង្រីក Behavior ដោយមិនកែ Core Logic, LSP សម្រាប់ធានាថា Subclass អាចជំនួស Base Class បានដោយសុវត្ថិភាព, ISP សម្រាប់បំបែក Interface ធំៗទៅជា Contracts តូចៗ និង DIP សម្រាប់ឱ្យ High-Level Logic ពឹងផ្អែកលើ Abstraction ជំនួស Concrete Implementation។ ក្នុងការអនុវត្ត និស្សិតធ្វើ Refactoring ដោយបំបែក UserService, Repository, Notifier, Auditor និង PasswordHasher, ប្រើ Dependency Injection និង Fake Dependencies សម្រាប់ Testing។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតអាចបម្លែង Code ដែលស្មុគស្មាញទៅជា Structure ដែលងាយអាន ងាយសាកល្បង ងាយថែទាំ និងងាយពង្រីក។

18 Aug 2026 0 22

មេរៀនទី ៦៖ Decorators and Cross-Cutting Concerns

មេរៀនទី ៦ ផ្ដោតលើ Decorators និង Cross-Cutting Concerns ដើម្បីឱ្យនិស្សិតយល់ពីរបៀបបន្ថែម Behavior ទៅ Function ឬ Method ដោយមិនលាយ Logic បន្ថែមចូលក្នុង Core Business Logic។ និស្សិតរៀនពី First-Class Functions, Higher-Order Functions, Closures, Wrapper Functions, *args, **kwargs និង functools.wraps ព្រមទាំង Decorators ដែលមាន Parameter។ ក្នុងការអនុវត្ត និស្សិតប្រើ Decorators សម្រាប់ Logging, Timing, Validation, Authentication, Authorization និង RBAC Permission Checking ដូចជា @require_login និង @require_permission(...) ហើយសិក្សាពីសារៈសំខាន់នៃ Decorator Order និង Separation of Concerns។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតបង្កើត Code ដែលអាចប្រើឡើងវិញបាន ងាយអាន ងាយសាកល្បង និងត្រៀមសម្រាប់ SOLID Principles និង Flask-based application design នៅមេរៀនបន្ទាប់។

18 Aug 2026 0 20

មេរៀនទី ៥៖ Factory Method and Abstract Factory

មេរៀនទី ៥ ផ្ដោតលើ Factory Pattern ដែលជាគន្លឹះសម្រាប់បំបែក Object Creation ចេញពី Business Logic និង Client Code ដើម្បីកាត់បន្ថយ coupling និងធ្វើឱ្យប្រព័ន្ធងាយពង្រីក។ និស្សិតរៀនពី Simple Factory, Factory Method, @classmethod ជា Alternative Constructor, Registry-Based Factory និង Abstract Factory សម្រាប់បង្កើត Product ឬ Product Family ដែលពាក់ព័ន្ធគ្នា។ ក្នុងការអនុវត្ត និស្សិតបង្កើត NotifierFactory, UserFactory និង Report/UI Factory ដើម្បីជ្រើស Concrete Objects តាម runtime requirement ឬ configuration ហើយភ្ជាប់ជាមួយ Abstraction, Protocol និង Dependency Injection។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតយល់ថា Factory Pattern គឺជាវិធីរៀបចំ Object Creation ឱ្យមានរចនាសម្ព័ន្ធច្បាស់ ងាយសាកល្បង ងាយបន្ថែម implementation ថ្មី និងត្រៀមសម្រាប់ SOLID Principles និង Flask Application Factory នៅមេរៀនបន្ទាប់។

18 Aug 2026 0 11

មេរៀនទី ៤៖ Abstraction, Composition, Mixins and Protocols

មេរៀនទី ៤ ផ្ដោតលើ Abstraction, Composition, Mixins និង Protocols ដើម្បីឱ្យនិស្សិតយល់ពីការរចនាទំនាក់ទំនងរវាង Objects និង Classes ឱ្យមានភាពបត់បែន និងងាយពង្រីក។ និស្សិតរៀនប្រើ ABC និង @abstractmethod សម្រាប់កំណត់ Contract, ប្រៀបធៀប is-a និង has-a relationships, ប្រើ Composition និង Dependency Injection ដើម្បីកាត់បន្ថយ coupling, ប្រើ Mixins សម្រាប់ចែករំលែក behavior និងយល់ពី MRO និង super() ក្នុង multiple inheritance។ លើសពីនេះ និស្សិតសិក្សា Protocol និង Structural Typing ដើម្បីអនុញ្ញាតឱ្យ Objects ផ្សេងៗសហការគ្នាតាម behavior ដោយមិនចាំបាច់ inherit ពី Base Class ដូចគ្នា។ ក្នុងការអនុវត្ត និស្សិតបង្កើត Multi-Channel Notification System ដែលមាន Email, SMS, Console និង Service Layer ដោយប្រើ Abstraction, Composition, Protocol និង Dependency Injection ជាគ្រឹះសម្រាប់មេរៀន Design Patterns បន្ទាប់។

18 Aug 2026 0 18

មេរៀនទី ៣៖ Python Object Model and Special Methods

មេរៀនទី ៣ ផ្ដោតលើ Python Object Model និង Special Methods ដើម្បីឱ្យនិស្សិតយល់ពីរបៀបដែល Python គ្រប់គ្រង Object តាម Identity, Type និង Value ព្រមទាំងភាពខុសគ្នារវាង is និង ==។ និស្សិតរៀនប្រើ __str__() និង __repr__() សម្រាប់ការបង្ហាញ Object, __eq__() និង __hash__() សម្រាប់ Equality និង Hashing, __len__(), __iter__(), __contains__() និង __getitem__() សម្រាប់ Collection-Like Behavior, ព្រមទាំង Operator Overloading និង Context Manager តាមរយៈ __enter__() និង __exit__()។ ក្នុងការអនុវត្ត និស្សិតពង្រីក RBAC Model ដោយបង្កើត UserDirectory, PermissionSet និង AuditSession ដើម្បីឱ្យ Custom Objects អាចប្រើ Python Syntax បានយ៉ាងធម្មជាតិ ច្បាស់លាស់ និងមានសុវត្ថិភាព។

18 Aug 2026 0 18

មេរៀនទី ២៖ Smart Class Design with Dataclass and Property

មេរៀនទី ២ ផ្ដោតលើការរចនា Class ឱ្យមានប្រសិទ្ធភាព ដោយប្រើ dataclass សម្រាប់ Data-Centric Models និង Regular Class សម្រាប់ Behavior-Centric Models។ និស្សិតរៀនប្រើ field(default_factory=...), __post_init__(), ClassVar, InitVar, frozen=True, slots=True, kw_only=True និង @property ដើម្បីគ្រប់គ្រង Object State, Validation, Safe Defaults និង Computed Values។ ក្នុងការអនុវត្ត និស្សិតបង្កើត Department, Permission, Role និង User ដោយប្រើ Composition ក្នុង RBAC Model ហើយអនុវត្ត is_admin, remove_role(), from_dict() ព្រមទាំង Valid និង Invalid Test Cases។ សរុបមក មេរៀននេះជួយឱ្យនិស្សិតយល់ថា Smart Class Design គឺធ្វើឱ្យ Object ងាយបង្កើតក្នុងស្ថានភាពត្រឹមត្រូវ ងាយអាន ងាយសាកល្បង និងពិបាកប្រើខុស។

18 Aug 2026 0 27

មេរៀនទី ១៖ Advanced OOP Foundations, Project Structure និង Mini RBAC Model

មេរៀនទី ១ ផ្ដោតលើការពង្រឹងមូលដ្ឋាន Advanced OOP ដោយឱ្យនិស្សិតយល់ច្បាស់អំពី Class, Object, __init__(), self, Instance និង Class Attributes ព្រមទាំង Instance Method, Class Method និង Static Method។ និស្សិតអនុវត្តការរៀបចំ Python Project ជា Modules និង Package ដោយបង្កើត Mini RBAC Model ដែលមាន User, Role និង Permission តាមទំនាក់ទំនង Composition៖ User មាន Roles ហើយ Role មាន Permissions។ លំហាត់ជួយឱ្យនិស្សិតអនុវត្ត Email Validation, Role Assignment និង Removal, Permission Checking និងការសាកល្បងលទ្ធផលទាំង True និង False។ សរុបមក មេរៀននេះបង្រៀនឱ្យនិស្សិតបង្កើត Classes ដែលមានតួនាទីច្បាស់ រៀបចំកូដឱ្យងាយអាន ងាយសាកល្បង និងអាចពង្រីកទៅមេរៀន Advanced OOP បន្ទាប់បាន។

18 Aug 2026 0 83