From b7d9eb04c1c92cf424d1e246645c745cee872330 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Mon, 11 May 2026 13:37:09 +0700
Subject: [PATCH 01/18] refactor

---
 src/dp/behavioral/Command.cpp   |  29 ++++-----
 src/dp/creational/Prototype.cpp |  66 ++++++++++----------
 src/dp/structural/Adapter.cpp   |  66 +++++++++-----------
 src/dp/structural/Bridge.cpp    | 107 +++++++++++++++++---------------
 4 files changed, 135 insertions(+), 133 deletions(-)

diff --git a/src/dp/behavioral/Command.cpp b/src/dp/behavioral/Command.cpp
index f72c3f6..a6a2bfb 100644
--- a/src/dp/behavioral/Command.cpp
+++ b/src/dp/behavioral/Command.cpp
@@ -11,9 +11,9 @@
 
 // UML: docs/uml/patterns_behavioral_command.drawio.svg
 
-#include <iostream>
 #include <string>
 #include <utility>
+#include "Logger.h"
 
 namespace {
 namespace command {
@@ -37,17 +37,17 @@ class ICommand {
 class Receiver {
  public:
   void doCheck() {
-    std::cout << "Receiver checking... \n";
+    LOG("Receiver checking... ");
     dummy_++;
   };
 
   void doInit() {
-    std::cout << "Receiver initializing... \n";
+    LOG("Receiver initializing... ");
     dummy_++;
   };
 
   void doLaunch(const std::string& arg) {
-    std::cout << "Receiver launching... \n\t" << arg << "\n";
+    LOG("Receiver launching...  \n\t" + arg);
     dummy_++;
   };
 
@@ -63,7 +63,7 @@ class Receiver {
  */
 class SimpleConcreteCommand : public ICommand {
  public:
-  void execute() const override { std::cout << "\t SimpleCommand executed \n"; }
+  void execute() const override { LOG("executed"); }
 };
 
 class ComplexConcreteCommand : public ICommand {
@@ -76,7 +76,7 @@ class ComplexConcreteCommand : public ICommand {
       : receiver_{receiver}, payload_{std::move(payload)} {};
 
   void execute() const override {
-    std::cout << "\t ComplexCommand executed \n";
+    LOG("executed");
     this->receiver_->doCheck();
     this->receiver_->doInit();
     this->receiver_->doLaunch(payload_);
@@ -109,6 +109,7 @@ class Invoker {
   void setOnFinish(ICommand* command) { this->on_finish_ = command; }
 
   void invoke() const {
+    LOG("executed");
     if (on_start_ != nullptr) {
       on_start_->execute();
     }
@@ -119,20 +120,20 @@ class Invoker {
   }
 };
 
-namespace client {
-void clientCode(const Invoker* invoker) {
-  invoker->invoke();
-}
-
-}  // namespace client
-
 void run() {
+  auto client_code = [](const Invoker* invoker) {
+    invoker->invoke();
+  };
+
+  // Receiver: UI
   auto* ui = new Receiver();
+
   // How to execute these command when something triggered
   auto* invoker = new Invoker();
   invoker->setOnStart(new SimpleConcreteCommand());
   invoker->setOnFinish(new ComplexConcreteCommand(ui, "cmd --version"));
-  client::clientCode(invoker);
+
+  client_code(invoker);
   delete ui;
 }
 }  // namespace command
diff --git a/src/dp/creational/Prototype.cpp b/src/dp/creational/Prototype.cpp
index fc74230..5cb57bd 100644
--- a/src/dp/creational/Prototype.cpp
+++ b/src/dp/creational/Prototype.cpp
@@ -7,12 +7,15 @@
 
 // UML: docs/uml/patterns_behavioral_prototype.drawio.svg
 
-#include <iostream>
 #include <unordered_map>
 #include <utility>
+#include "Logger.h"
 namespace {
 namespace prototy {
 
+constexpr std::string_view kLoggerEtxId = "logger";
+constexpr std::string_view kAnalyzeId = "analyze";
+
 /*
  * Prototype interface declares the cloning methods.
  * In most cases, it’s a single `clone` method.
@@ -32,17 +35,15 @@ class IExtensionPrototype {
  */
 class LoggerExtension : public IExtensionPrototype {
  private:
-  std::string logLevel_;
+  std::string log_level_;
 
  public:
   explicit LoggerExtension(std::string level = "DEBUG")
-      : logLevel_{std::move(level)} {}
+      : log_level_{std::move(level)} {}
 
   IExtensionPrototype* clone() override { return new LoggerExtension(*this); }
 
-  void execute() const override {
-    std::cout << "[Logger] log level: " << logLevel_ << "\n";
-  }
+  void execute() const override { LOG("log level: " + log_level_); }
 };
 
 class AnalyticsExtension : public IExtensionPrototype {
@@ -56,9 +57,7 @@ class AnalyticsExtension : public IExtensionPrototype {
     return new AnalyticsExtension(*this);
   }
 
-  void execute() const override {
-    std::cout << "[Analytics] sampling rate: " << sRate_ << "\n";
-  }
+  void execute() const override { LOG_S("sampling rate: " << sRate_); }
 };
 
 /**
@@ -78,12 +77,14 @@ class ExtensionPrototypeRegistry {
       it = prototypes_.erase(it);  // erase and move to next
     }
   }
-  void registerExtension(const std::string& id, IExtensionPrototype* proto) {
-    prototypes_[id] = proto;
+  void register_extension(const std::string_view& id,
+                          IExtensionPrototype* proto) {
+    LOG(id);
+    prototypes_[std::string(id)] = proto;
   }
 
-  IExtensionPrototype* create(const std::string& id) const {
-    auto it = prototypes_.find(id);
+  IExtensionPrototype* create(const std::string_view& id) const {
+    auto it = prototypes_.find(std::string(id));
     if (it != prototypes_.end()) {
       return it->second->clone();
     }
@@ -91,27 +92,28 @@ class ExtensionPrototypeRegistry {
   }
 };
 
-/*
- * Client creates a new object by asking a prototype to clone itself
- */
-namespace client {
-void clientCode(const ExtensionPrototypeRegistry* const registry) {
-  IExtensionPrototype* logger_etx = registry->create("logger");
-  logger_etx->execute();
-  IExtensionPrototype* analyx_etx = registry->create("analyze");
-  analyx_etx->execute();
-
-  delete logger_etx;
-  delete analyx_etx;
-}
-
-}  // namespace client
-
 void run() {
+  // Client creates a new object by asking a prototype to clone itself
+  auto client_code = [](const ExtensionPrototypeRegistry* const registry) {
+    IExtensionPrototype* logger_etx = registry->create(prototy::kLoggerEtxId);
+    logger_etx->execute();
+    IExtensionPrototype* analyx_etx = registry->create(prototy::kAnalyzeId);
+    analyx_etx->execute();
+
+    delete logger_etx;
+    delete analyx_etx;
+  };
+
+  // Create a registry
   auto* registry = new ExtensionPrototypeRegistry();
-  registry->registerExtension("logger", new LoggerExtension("DEBUG"));
-  registry->registerExtension("analyze", new AnalyticsExtension(1200));
-  client::clientCode(registry);
+
+  // Register extensions
+  registry->register_extension(prototy::kLoggerEtxId,
+                               new LoggerExtension("DEBUG"));
+  registry->register_extension(prototy::kAnalyzeId,
+                               new AnalyticsExtension(1200));
+
+  client_code(registry);
 
   delete registry;
 }
diff --git a/src/dp/structural/Adapter.cpp b/src/dp/structural/Adapter.cpp
index d4619f7..6ea3755 100644
--- a/src/dp/structural/Adapter.cpp
+++ b/src/dp/structural/Adapter.cpp
@@ -7,7 +7,7 @@
 
 // UML: docs/uml/patterns_structural_adapter.drawio.svg
 
-#include <iostream>
+#include "Logger.h"
 
 namespace adapter_pattern {
 /**
@@ -17,9 +17,9 @@ namespace adapter_pattern {
  */
 class Adaptee {
  public:
-  std::string specificRequest() {
+  void specific_request() {
     dummy_++;
-    return "Adaptee: The adaptee's behavior.";
+    LOG("executed");
   }
 
  private:
@@ -31,7 +31,7 @@ class Adaptee {
  */
 class Target {
  public:
-  virtual std::string request() { return "   Target: The target's behavior."; }
+  virtual void request() { LOG("executed"); }
 };
 
 // ============================================================================================================
@@ -49,40 +49,31 @@ class Adapter : public Target {
   Adaptee* adaptee_;
 
  public:
-  explicit Adapter(Adaptee* adaptee) : adaptee_{adaptee} {
-    std::cout << "Adapter constructer.\n";
-  }
+  explicit Adapter(Adaptee* adaptee) : adaptee_{adaptee} { LOG("constructed"); }
 
-  std::string request() override { return adaptee_->specificRequest(); }
+  void request() override { return adaptee_->specific_request(); }
 };
 
-/**
- * The client code supports all classes that follow the Target interface.
- */
+void run() {
+  LOG("Adapter Example");
 
-namespace client {
-void clientCode(Target* const target) {
-  if (target != nullptr)
-    std::cout << "Output: " << target->request() << "\n";
-}
-}  // namespace client
+  // The client code supports all classes that follow the Target interface.
+  auto client_code = [](Target* target) {
+    LOG("executed");
+    target->request();
+  };
 
-void run() {
-  std::cout << "Client: Can work just fine with the Target objects:\n";
+  LOG("Client: Can work just fine with the Target objects:");
   Target target = Target();
-  std::cout << "Target: " << target.request() << "\n";
-  client::clientCode(&target);
-  std::cout << "\n\n";
+  client_code(&target);
 
-  std::cout << "Client: Cannot work with the Adaptee objects:\n";
+  LOG("Client: Cannot work with the Adaptee objects:");
   Adaptee adaptee = Adaptee();
-  std::cout << "Adaptee: " << adaptee.specificRequest() << "\n";
   // Client::clientCode(&adaptee); // error
 
-  std::cout << "Client: But can work with it via the Adapter:\n";
+  LOG("Client: But can work with it via the Adapter:");
   auto adapter = Adapter(&adaptee);
-  client::clientCode(&adapter);
-  std::cout << "\n";
+  client_code(&adapter);
 }
 }  // namespace adapter_pattern
 
@@ -90,8 +81,8 @@ namespace case_study {
 // Target interface expected by the existing system
 class PaymentSystem {
  public:
-  virtual void payWithCard(const std::string& cardNumber) {
-    std::cout << "Payment using card: " << cardNumber << "\n";
+  virtual void pay_with_card(const std::string& card_number) {
+    LOG_S("Payment using card: " << card_number);
   }
 
   virtual ~PaymentSystem() = default;
@@ -100,8 +91,8 @@ class PaymentSystem {
 // Adaptee: a new payment API with an incompatible interface
 class PayPalAPI {
  public:
-  void sendPayment(const std::string& email) {
-    std::cout << "Payment sent via PayPal to " << email << "\n";
+  void send_payment(const std::string& email) {
+    LOG_S("Payment sent via PayPal to " << email);
     dummy_++;
   }
 
@@ -115,14 +106,15 @@ class PayPalAdapter : public PaymentSystem {
   PayPalAPI paypal_;
 
  public:
-  void payWithCard(const std::string& cardNumber) override {
+  void pay_with_card(const std::string& cardNumber) override {
     // Treat the cardNumber parameter as a PayPal email
-    paypal_.sendPayment(cardNumber);
+    paypal_.send_payment(cardNumber);
   }
 };
 
 // Client code: uses the old interface without modification
 void run() {
+  LOG("Case Study Example");
   std::string method;
   std::string input;
   method = std::string("card") + std::string("");
@@ -130,18 +122,18 @@ void run() {
   // method = std::string("paypal") + std::string("");input =
   // "user@example.com";
 
-  std::cout << "Choose payment method (card/paypal): " << method << "\n";
+  LOG_S("Choose payment method (card/paypal): " << method);
 
   PaymentSystem* payment_system = nullptr;
 
   if (method == "card") {
     payment_system = new PaymentSystem();
-    payment_system->payWithCard(input);
+    payment_system->pay_with_card(input);
   } else if (method == "paypal") {
     payment_system = new PayPalAdapter();
-    payment_system->payWithCard(input);
+    payment_system->pay_with_card(input);
   } else {
-    std::cout << "Unsupported payment method!\n";
+    LOG("Unsupported payment method!");
   }
 
   delete payment_system;
diff --git a/src/dp/structural/Bridge.cpp b/src/dp/structural/Bridge.cpp
index 7998e47..bceb942 100644
--- a/src/dp/structural/Bridge.cpp
+++ b/src/dp/structural/Bridge.cpp
@@ -11,70 +11,77 @@
 
 // UML: docs/uml/patterns_structural_bridge.drawio.svg
 
-#include <iostream>
-
+#include <memory>
+#include <utility>
 #include "ExampleRegistry.h"
+#include "Logger.h"
 
 namespace {
 namespace problem {
 class Widget {
  public:
   virtual ~Widget() = default;
-  virtual std::string clickOn() const = 0;
+  virtual void click_on() const = 0;
 };
 
 /* Concrete variations for Button */
 class Button : public Widget {
  public:
-  std::string clickOn() const override { return "Click on: Button\n"; }
+  void click_on() const override { LOG("executed"); }
 };
 
 class ButtonWindows : public Button {
  public:
-  std::string clickOn() const override { return "[Linux]" + Button::clickOn(); }
+  void click_on() const override {
+    LOG("executed");
+    Button::click_on();
+  }
 };
 
 class ButtonLinux : public Button {
  public:
-  std::string clickOn() const override {
-    return "[Windows]" + Button::clickOn();
+  void click_on() const override {
+    LOG("executed");
+    Button::click_on();
   }
 };
 
 /* Concrete variations for Label */
 class Label : public Widget {
  public:
-  std::string clickOn() const override { return "Click on: Label\n"; }
+  void click_on() const override { LOG("executed"); }
 };
 
 class LabelWindows : public Label {
  public:
-  std::string clickOn() const override {
-    return "[Windows]" + Label::clickOn();
+  void click_on() const override {
+    LOG("executed");
+    Label::click_on();
   }
 };
 
 class LabelLinux : public Label {
  public:
-  std::string clickOn() const override { return "[Linux]" + Label::clickOn(); }
+  void click_on() const override {
+    LOG("executed");
+    Label::click_on();
+  }
 };
 
-/* Concrete variations for others widgets like Text,CCombo  or new platform
+void run() {
+  LOG("Problem");
+  /* Concrete variations for others widgets like Text,CCombo  or new platform
  * macOS etc*/
-// [Problem 1] We have to write the Text/TextLinux ...
+  // [Problem 1] We have to write the Text/TextLinux ...
+  auto client_code = [](const Widget* widget) {
+    if (widget != nullptr)
+      widget->click_on();
+  };
 
-namespace client {
-void clientCode(const Widget* widget) {
-  if (widget != nullptr)
-    std::cout << widget->clickOn();
-}
-}  // namespace client
-
-void run() {
   // [Problem 2] : Use the Bridge if you need to be able to switch
   // implementations at runtime. how to exmaple for this still don't know
   Widget* button = new ButtonWindows();
-  client::clientCode(button);
+  client_code(button);
   delete button;
 }
 }  // namespace problem
@@ -89,18 +96,18 @@ namespace bridge_pattern {
  */
 class OsImplemetation {
  public:
-  virtual std::string clickOnImplement() const = 0;
+  virtual void click_on_ipl() const = 0;
   virtual ~OsImplemetation() = default;
 };
 
 class WindowsImplemetation : public OsImplemetation {
  public:
-  std::string clickOnImplement() const override { return "[Windows]"; }
+  void click_on_ipl() const override { LOG("[Windows]"); }
 };
 
 class LinuxImplemetation : public OsImplemetation {
  public:
-  std::string clickOnImplement() const override { return "[Linux]"; }
+  void click_on_ipl() const override { LOG("[Linux]"); }
 };
 
 /**
@@ -110,14 +117,14 @@ class LinuxImplemetation : public OsImplemetation {
  */
 class WidgetAbstraction {
  protected:
-  OsImplemetation* implementation_;
+  std::shared_ptr<OsImplemetation> implementation_;
 
  public:
-  explicit WidgetAbstraction(OsImplemetation* implemetation)
-      : implementation_{implemetation} {}
+  explicit WidgetAbstraction(std::shared_ptr<OsImplemetation> implemetation)
+      : implementation_{std::move(implemetation)} {}
   virtual ~WidgetAbstraction() = default;
 
-  virtual std::string clickOn() const = 0;
+  virtual void click_on() const = 0;
 };
 
 /**
@@ -125,40 +132,40 @@ class WidgetAbstraction {
  */
 class ButtonAbstraction : public WidgetAbstraction {
  public:
-  explicit ButtonAbstraction(OsImplemetation* implemetation)
-      : WidgetAbstraction{implemetation} {}
-  std::string clickOn() const override {
-    return this->implementation_->clickOnImplement() + "Click on: Button\n";
+  explicit ButtonAbstraction(std::shared_ptr<OsImplemetation> implemetation)
+      : WidgetAbstraction{std::move(implemetation)} {}
+  void click_on() const override {
+    LOG("executed");
+    this->implementation_->click_on_ipl();
   }
 };
 
 class LabelAbstraction : public WidgetAbstraction {
  public:
-  explicit LabelAbstraction(OsImplemetation* implemetation)
-      : WidgetAbstraction{implemetation} {}
-  std::string clickOn() const override {
-    return this->implementation_->clickOnImplement() + "Click on: Label\n";
+  explicit LabelAbstraction(std::shared_ptr<OsImplemetation> implemetation)
+      : WidgetAbstraction{std::move(implemetation)} {}
+  void click_on() const override {
+    LOG("executed");
+    this->implementation_->click_on_ipl();
   }
 };
 
-namespace client {
-void clientCode(const WidgetAbstraction* widget) {
-  if (widget != nullptr)
-    std::cout << widget->clickOn();
-}
-}  // namespace client
-
 void run() {
-  // TODO(phong-nguyen): check memory leak here
-  OsImplemetation* os = new WindowsImplemetation();
+  LOG("Bridge Example");
+  auto client_code = [](const WidgetAbstraction* widget) {
+    if (widget != nullptr)
+      widget->click_on();
+  };
+
+  std::shared_ptr<OsImplemetation> os =
+      std::make_shared<WindowsImplemetation>();
   WidgetAbstraction* widget = new ButtonAbstraction(os);
-  client::clientCode(widget);
+  client_code(widget);
 
-  os = new LinuxImplemetation();
+  os = std::make_shared<LinuxImplemetation>();
   widget = new LabelAbstraction(os);
-  client::clientCode(widget);
+  client_code(widget);
 
-  delete os;
   delete widget;
 }
 }  // namespace bridge_pattern

From 8b7932b576126c37138844660dd5c0a1dd2630fc Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 24 May 2026 12:16:31 +0700
Subject: [PATCH 02/18] Typo fix

---
 src/core/concurrency/ConditionVariable.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/concurrency/ConditionVariable.cpp b/src/core/concurrency/ConditionVariable.cpp
index 80bbf2f..05cfe3d 100644
--- a/src/core/concurrency/ConditionVariable.cpp
+++ b/src/core/concurrency/ConditionVariable.cpp
@@ -25,7 +25,7 @@ void worker_thread() {
   // The thread continues only when 'ready' becomes true.
   cv.wait(lock, []() { return ready; });
 
-  LOG("Proccessing data");
+  LOG("Processing data");
 
   data += " after processing";
   finish = true;

From 996f70ee516ac5f6047ea2355dcfd2131eb43b9f Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 24 May 2026 12:16:43 +0700
Subject: [PATCH 03/18] Update

---
 src/core/basics/ControlFlow.cpp | 48 ++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/core/basics/ControlFlow.cpp b/src/core/basics/ControlFlow.cpp
index fd381ef..d46440c 100644
--- a/src/core/basics/ControlFlow.cpp
+++ b/src/core/basics/ControlFlow.cpp
@@ -1,47 +1,47 @@
-#include <iostream>
 #include "ExampleRegistry.h"
+#include "Logger.h"
 
 namespace {
 void conditionals() {
-  std::cout << "\n--- Conditional Examples ---\n";
+  LOG("Conditional Examples");
   // if-else
   int x = rand();
-  std::cout << "x = " << x << "\n";
+  LOG_S("x = " << x);
   if (x > 0) {
-    std::cout << "x is positive\n";
+    LOG("x is positive");
   } else if (x < 0) {
-    std::cout << "x is negative\n";
+    LOG("x is negative");
   } else {
-    std::cout << "x is zero\n";
+    LOG("x is zero");
   }
 
   // switch
   int choice = rand() % 2 + 1;
-  std::cout << "choice = " << x << "\n";
+  LOG_S("Choice = " << std::to_string(x));
   switch (choice) {
     case 1:
-      std::cout << "Choice is 1\n";
+      LOG("Choice is 1");
       break;
     case 2:
-      std::cout << "Choice is 2\n";
+      LOG("Choice is 2");
       break;
     default:
-      std::cout << "Choice is something else\n";
+      LOG("Choice is something else");
       break;
   }
 }
 
 void jumps() {
-  std::cout << "\n--- Jump Statement Examples ---\n";
+  LOG("Jump Statement Examples");
 
   // goto
   int num = rand();
   if (num == 3)
     goto jumpLabel;
-  std::cout << "This line will be skipped.\n";
+  LOG("This line will be skipped.");
 
 jumpLabel:
-  std::cout << "Jumped here using goto!\n";
+  LOG("Jumped here using goto!");
 
   // break / continue
   for (int i = 0; i < 5; ++i) {
@@ -49,7 +49,7 @@ void jumps() {
       continue;  // skip 2
     if (i == 4)
       break;  // stop loop at 4
-    std::cout << "i = " << i << "\n";
+    LOG_S("i = " << i);
   }
 }
 
@@ -59,43 +59,43 @@ int square(int n) {
 }
 
 void functionCalls() {
-  std::cout << "\n--- Function Call Examples ---\n";
+  LOG("Function Call Examples");
   // function call
   int result = square(5);
-  std::cout << "square(5) = " << result << "\n";
+  LOG_S("square(5) = " << result);
 }
 
 void loops() {
-  std::cout << "\n--- Loop Examples ---\n";
+  LOG("Loop Examples");
 
   // while
   int i = 0;
   while (i < 3) {
-    std::cout << "while loop i = " << i << "\n";
+    LOG_S("while loop i = " << i);
     ++i;
   }
 
   // do-while
   int j = 0;
   do {
-    std::cout << "do-while loop j = " << j << "\n";
+    LOG_S("do-while loop j = " << j);
     ++j;
   } while (j < 2);
 
   // for(initialization; condition; update)
   for (int k = 0; k < 3; ++k) {
-    std::cout << "for loop k = " << k << "\n";
+    LOG_S("for loop k = " << k);
   }
 
   // ranged-for
   const int arr[] = {10, 20, 30};
   for (int value : arr) {
-    std::cout << "ranged-for value = " << value << "\n";
+    LOG_S("ranged-for value = " << value);
   }
 }
 
 void halts() {
-  std::cout << "\n--- Halt Examples ---\n";
+  LOG("Halt Examples");
 
   // std::exit() — terminates the program normally
   // std::abort() — terminates abnormally (no cleanup)
@@ -106,13 +106,13 @@ void halts() {
 }
 
 void exceptions() {
-  std::cout << "\n--- Exception Handling Examples ---\n";
+  LOG("Exception Handling Examples");
 
   // try - catch - throw
   try {
     throw std::runtime_error("Something went wrong!");
   } catch (const std::exception& e) {
-    std::cout << "Caught exception: " << e.what() << "\n";
+    LOG_S("Caught exception: " << e.what());
   }
 }
 }  // namespace

From 32e41da69e410798f8b8506592244d20d111cf51 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 24 May 2026 12:47:41 +0700
Subject: [PATCH 04/18] Add an example for <chrono>

---
 src/core/CMakeLists.txt         |  1 +
 src/core/concurrency/README.md  |  9 ++++++++-
 src/core/concurrency/Timing.cpp | 28 ++++++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 1 deletion(-)
 create mode 100644 src/core/concurrency/Timing.cpp

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 57ca20c..a60525a 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -97,6 +97,7 @@ set(CORE_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrency/RaceCondition.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrency/ConditionVariable.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/concurrency/FuturePromise.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/concurrency/Timing.cpp
 
     # Utils
     ${CMAKE_CURRENT_SOURCE_DIR}/utils/Algorithm.cpp
diff --git a/src/core/concurrency/README.md b/src/core/concurrency/README.md
index 537416f..8237806 100644
--- a/src/core/concurrency/README.md
+++ b/src/core/concurrency/README.md
@@ -227,4 +227,11 @@ auto future = std::async(std::launch::async, SomeFunctionObject(), arg_1);
 
 // Lambda function
 auto future = std::async(std::launch::async, [](){});
-```
\ No newline at end of file
+```
+
+## 4. Date and time library
+- The `chrono` (since c++11) library defines several main types as well as utility functions and common typedefs:
+  - clocks
+  - time points
+  - durations
+  - calender/timezone (c++ 20);
\ No newline at end of file
diff --git a/src/core/concurrency/Timing.cpp b/src/core/concurrency/Timing.cpp
new file mode 100644
index 0000000..f8b6582
--- /dev/null
+++ b/src/core/concurrency/Timing.cpp
@@ -0,0 +1,28 @@
+#include <thread>
+#include "ExampleRegistry.h"
+#include "Logger.h"
+
+#include <chrono>
+
+void run() {
+  const auto start = std::chrono::steady_clock::now();
+  std::this_thread::sleep_for(std::chrono::seconds(5));
+  const auto finished = std::chrono::steady_clock::now();
+
+  const std::chrono::duration<double> elapsed =
+      finished - start;  // default unit is second
+  LOG_S("Elapsed time: " << elapsed);
+}
+
+class Timing : public IExample {
+ public:
+  std::string group() const override { return "core/concurrency"; }
+  std::string name() const override { return "Timing"; }
+  std::string description() const override {
+    return "The examples for <chrono> code timing";
+  }
+
+  void execute() override { run(); }
+};
+
+REGISTER_EXAMPLE(Timing);
\ No newline at end of file

From 12a7435cb2432d25753684fa79a4e9e54ce96bb4 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 24 May 2026 16:11:14 +0700
Subject: [PATCH 05/18] Update

---
 src/core/basics/ControlFlow.cpp        |   2 +-
 src/core/basics/InitializeVariable.cpp |  13 +-
 src/core/basics/Operations.cpp         |  82 +++--
 src/core/basics/README.md              | 426 ++++++++++++++++++++++---
 src/core/basics/TypeQualifier.cpp      |  67 ++--
 src/core/class/RoleOfThreeFiveZero.cpp |   2 +-
 6 files changed, 469 insertions(+), 123 deletions(-)

diff --git a/src/core/basics/ControlFlow.cpp b/src/core/basics/ControlFlow.cpp
index d46440c..5fca0c7 100644
--- a/src/core/basics/ControlFlow.cpp
+++ b/src/core/basics/ControlFlow.cpp
@@ -119,7 +119,7 @@ void exceptions() {
 
 class ControlFlow : public IExample {
  public:
-  std::string group() const override { return "core"; }
+  std::string group() const override { return "core/basics"; }
   std::string name() const override { return "ControlFlow"; }
   std::string description() const override { return "ControlFlow"; }
   void execute() override {
diff --git a/src/core/basics/InitializeVariable.cpp b/src/core/basics/InitializeVariable.cpp
index 33df35a..57c5163 100644
--- a/src/core/basics/InitializeVariable.cpp
+++ b/src/core/basics/InitializeVariable.cpp
@@ -1,38 +1,39 @@
 // cppcheck-suppress-file [unreadVariable, unusedVariable, functionStatic]
-#include <iostream>
 
+#include "Logger.h"
 #include "ExampleRegistry.h"
 
 void initialize_variable();
 
 class InitializeVariable : public IExample {
  public:
-  std::string group() const override { return "core"; }
+  std::string group() const override { return "core/basics"; }
   std::string name() const override { return "InitializeVariable"; }
   std::string description() const override { return "InitializeVariable"; }
+
   void execute() override { initialize_variable(); }
 };
 
 REGISTER_EXAMPLE(InitializeVariable);
 
 struct Foo {
-  Foo() { std::cout << "Default constructor/ default init\n"; }
+  Foo() { LOG("Default constructor/ default init"); }
 
   // Foo(int)
   explicit Foo(int) {
-    std::cout << "Constructor called with int / copy init\n";
+    LOG( "Constructor called with int / copy init");
   }
 
   Foo(const Foo& other) {
     other.dump();
-    std::cout << "Copy constructor called\n";
+    LOG( "Copy constructor called");
   }
 
   void dump() const {}
 };
 
 void initialize_variable() {
-  std::cout << "\n--- Variable Initialization Examples ---\n";
+  LOG( "\n--- Variable Initialization Examples ---");
   // * 1) Default-initialization
   int init_default_var;
   Foo init_default_obj;
diff --git a/src/core/basics/Operations.cpp b/src/core/basics/Operations.cpp
index 1eea0c3..b393c8d 100644
--- a/src/core/basics/Operations.cpp
+++ b/src/core/basics/Operations.cpp
@@ -1,7 +1,7 @@
-#include <iostream>
 #include <bitset>
 
 #include "ExampleRegistry.h"
+#include "Logger.h"
 
 void arithmeticOperator();
 void logicalOperator();
@@ -9,7 +9,7 @@ void bitWiseOperator();
 
 class Operations : public IExample {
  public:
-  std::string group() const override { return "core"; }
+  std::string group() const override { return "core/basics"; }
   std::string name() const override { return "Operations"; }
   std::string description() const override { return "Operation"; }
   void execute() override {
@@ -22,107 +22,105 @@ class Operations : public IExample {
 REGISTER_EXAMPLE(Operations);
 
 void arithmeticOperator() {
-  std::cout << "\n--- ArithmeticOperator Examples ---\n";
+  LOG_S("\n--- ArithmeticOperator Examples ---\n");
   int a{100};
   int b{200};
 
   // Addition
-  std::cout << "a = " << a << ", b = " << b << "\n";
+  LOG_S("a = " << a << ", b = " << b);
   int sum = a + b;
-  std::cout << "sum = " << sum << "\n";
+  LOG_S("sum = " << sum);
 
   // Subtraction
-  std::cout << "a = " << a << ", b = " << b << "\n";
-  int different = a - b;
-  std::cout << "different = " << different << "\n";
+  LOG_S("a = " << a << ", b = " << b);
+  uint32_t different = a - b;
+  LOG_S("different = " << different);
 
   // Multiplication
-  std::cout << "a = " << a << ", b = " << b << "\n";
+  LOG_S("a = " << a << ", b = " << b);
   int product = a * b;
-  std::cout << "product = " << product << "\n";
+  LOG_S("product = " << product);
 
   // Division
-  std::cout << "a = " << a << ", b = " << b << "\n";
+  LOG_S("a = " << a << ", b = " << b);
   int quotient = a / b;
-  std::cout << "quotient = " << quotient << "\n";
+  LOG_S("quotient = " << quotient);
 
   // Modulus
-  std::cout << "a = " << a << ", b = " << b << "\n";
+  LOG_S("a = " << a << ", b = " << b);
   int remainder = a % b;
-  std::cout << "remainder = " << remainder << "\n";
+  LOG_S("remainder = " << remainder);
 
   // Increment
-  std::cout << "a = " << a << "\n";
+  LOG_S("a = " << a);
   int pre_in = ++a;  // increase a, return a
-  std::cout << "preIn = " << pre_in << "\n";
+  LOG_S("preIn = " << pre_in);
 
-  std::cout << "a = " << a << "\n";
+  LOG_S("a = " << a);
   int post_in = a++;  // copy a to a copy, then increase a, return copy
-  std::cout << "postIn = " << post_in << "\n";
+  LOG_S("postIn = " << post_in);
 
   // Decrement
-  std::cout << "b = " << b << "\n";
+  LOG_S("b = " << b);
   int pre_de = --b;
-  std::cout << "preDe = " << pre_de << "\n";
+  LOG_S("preDe = " << pre_de);
 
-  std::cout << "b = " << b << "\n";
+  LOG_S("b = " << b);
   int post_de = b--;
-  std::cout << "postDe = " << post_de << "\n";
+  LOG_S("postDe = " << post_de);
 
   // Comma:
   int value = (a++, b);  // a is incremented, then b is returned
-  std::cout << "a = " << a << ", b = " << b << "\n";
-  std::cout << "comma(a++, b) = " << value << "\n";
+  LOG_S("a = " << a << ", b = " << b);
+  LOG_S("comma(a++, b) = " << value);
 }
 
-void logicalOperator() {
-  std::cout << "\n--- LogicalOperator Examples ---\n";
+void LOG_SicalOperator() {
+  LOG("\n--- LOG_SicalOperator Examples ---");
   bool a = true;
   bool b = false;
   bool c = true;
 
-  std::cout << std::boolalpha;  // show true/false instead of 1/0
-  std::cout << "a = " << a << ", b = " << b << ", c = " << c << "\n\n";
+  // show true/false instead of 1/0
+  LOG_S(std::boolalpha << "a = " << a << ", b = " << b << ", c = " << c);
 
   // AND (&&)
-  std::cout << "[AND] a && b = " << (a && b) << "\n";
+  LOG_S("[AND] a && b = " << (a && b));
 
   // OR (||)
-  std::cout << "[OR ] a || b = " << (a || b) << "\n";
+  LOG_S("[OR ] a || b = " << (a || b));
 
   // NOT (!)
-  std::cout << "[NOT] !c = " << (!c) << "\n";
+  LOG_S("[NOT] !c = " << (!c));
 }
 
 void bitWiseOperator() {
-  std::cout << "\n--- BitWiseOperator Examples ---\n";
-  std::bitset<8> bits_a {0b1111'1111};
-  std::bitset<8> bits_b {0b1111'0000};
+  LOG("\n--- BitWiseOperator Examples ---");
+  std::bitset<8> bits_a = 0b1111'1111;  std::bitset<8> bits_b = 0b1111'0000;
 
-  std::cout
-  << "bitA = " << bits_a << ", bitB = " << bits_b << "\n";
+  LOG_S("bitA = " << bits_a << ", bitB = " << bits_b);
 
   // AND
   std::bitset<8> result = bits_a & bits_b;
-  std::cout << "bitA && bitB= " << result << "\n";
+  LOG_S("bitA && bitB= " << result);
 
   // OR
   result = bits_a | bits_b;
-  std::cout << "bitA | bitB= " << result << "\n";
+  LOG_S("bitA | bitB= " << result);
 
   // XOR
   result = bits_a ^ bits_b;
-  std::cout << "bitA ^ bitB= " << result << "\n";
+  LOG_S("bitA ^ bitB= " << result);
 
   // NOT
   result = ~bits_a;
-  std::cout << "~bitA = " << result << "\n";
+  LOG_S("~bitA = " << result);
 
   // LEFT SHIFT
   result = bits_a << 1;
-  std::cout << "bitA << 1 = " << result << "\n";
+  LOG_S("bitA << 1 = " << result);
 
   // RIGHT SHIFT
   result = bits_a >> 1;
-  std::cout << "bitA >> 1 = " << result << "\n";
+  LOG_S("bitA >> 1 = " << result);
 }
\ No newline at end of file
diff --git a/src/core/basics/README.md b/src/core/basics/README.md
index e6c1d1c..e810be3 100644
--- a/src/core/basics/README.md
+++ b/src/core/basics/README.md
@@ -1,48 +1,67 @@
-# Basic C++
+---
+author: "Phong Nguyen"
+title: "C++ - Chapter 2: Fundamentals"
+date: "2026-05-24"
+description: "C++ Notes"
+tags: ["cpp"]   #tags search
+FAcategories: ["syntax"]    #The category of the post, similar to tags but usually for broader classification.
+FAseries: ["Themes Guide"]    #indicates that this post is part of a series of related posts
+aliases: ["migrate-from-jekyl"]    #Alternative URLs or paths that can be used to access this post, useful for redirects from old posts or similar content.
+ShowToc: true    # Determines whether to display the Table of Contents (TOC) for the post.
+TocOpen: true    # Controls whether the TOC is expanded when the post is loaded. 
+weight: 1    # The order in which the post appears in a list of posts. Lower numbers make the post appear earlier.
+---
 
-## 1. Initialization in C++
-C++ provides several ways to initialize objects. Each form has different semantics and use cases.
+C++ Basic Concepts
+- `Data` is any information processed or stored by a computer.
+- A `Value` is a specific piece of data (e.g. `42`, `'A'`, `3.14`).
+- An `Object` is a region of storage (memory) with a type and a value.
+- A `Variable` is a named object used to store data.
+- `Initialization` is the process of giving an initial value to an object or variable.
+- `Literals`: fixed values like 42, 3.14, 'A', "Hello", true, nullptr.
+- `Operators`: symbols that act on values (+ - * / %, == != < >, && || !, = += -=, etc.).
+- An `Expression` is a combination of operators, constants and variables that evaluate to a value.
+- A `function` is a reusable block of code that performs a specific task.
 
-### 1.1 Default Initialization
-Performed when an object is created **without any initializer**.
+---
+## 1. Initialization
+C++ provides several ways to initialize objects. Each form has different semantics and use cases.
 
+### 1.1. Default Initialization
 ```cpp
+int a;
 T object;
 new T;
 ```
 
-- Built-in types: uninitialized
-- Class types: default constructor is called
-
----
+Performed when an object is created **without any initializer**.
+  - **Built-in types:** uninitialized
+  - **Class types:** default constructor is called
 
-### 1.2 Value Initialization
-Performed when an object is created with an **empty initializer**.
+<br>
 
+### 1.2. Value Initialization
 ```cpp
+int a{};
+
 T();
 new T();
 T object{};
 T{};
 new T{};
-```
 
-Also used in constructors:
-
-```cpp
+/// @brief Also used in constructors
 Class::Class() : member() {}
 Class::Class() : member{} {}
 ```
 
-- Built-in types: zero-initialized
-- Class types: default constructor is called
+Performed when an object is created with an **empty initializer**.
+  - **Built-in types**: zero-initialized
+  - **Class types**: default constructor is called
 
----
+<br>
 
 ### 1.3 Direct Initialization
-
-Initializes an object using **explicit constructor arguments**.
-
 ```cpp
 T object(arg);
 T object(arg1, arg2);
@@ -50,81 +69,384 @@ T object(arg1, arg2);
 T object{arg};          // since C++11
 new T(args...);
 static_cast<T>(other);
-```
 
-Used in constructors and lambdas:
-
-```cpp
+/// @brief Used in constructors and lambdas:
 Class::Class() : member(args...) {}
 [arg]() {};
 ```
 
----
-
-### 1.4 Copy Initialization
+Initializes an object using **explicit constructor arguments**.
 
-Initializes an object **from another object or expression**.
+<br>
 
+### 1.4 Copy Initialization
 ```cpp
 T object = other;
 f(other);
 return other;
 throw object;
 catch (T object);
+
+/// @brief Also used for arrays
+T array[N] = { /* values */ };
 ```
+Initializes an object **from another object or expression**.
 
-Also used for arrays:
+### 1.5 List Initialization (since C++11)
+```cpp
+/// @brief Direct List Initialization
+T object{arg1, arg2};
+new T{arg1, arg2};
+
+Class::Class() : member{arg1, arg2} {}
+
+/// @brief Copy List Initialization
+T object = {arg1, arg2};
+return {arg1, arg2};
+function({arg1, arg2});
+
+
+/// @brief Designated Initializers (since C++20)
+T object{ .des1 = arg1, .des2 = arg2 };
+T object = { .des1 = arg1, .des2 = arg2 };
+```
 
+Initializes objects using **brace-enclosed initializer lists { }**.
+
+<br>
+
+### 1.6 Aggregate Initialization
 ```cpp
-T array[N] = { /* values */ };
+T object = {arg1, arg2};
+T object{arg1, arg2};          // since C++11
+
+/// @brief Designated initializers for aggregates (since C++20)
+T object = { .des1 = arg1, .des2 = arg2 };
+T object{ .des1 = arg1, .des2 = arg2 };
 ```
+Initializes **aggregate types** (no user-defined constructors).
 
 ---
+## 2. Functions and Files
+### 2.1. Function
+```cpp
 
-### 1.5 List Initialization (since C++11)
+returnType functionName(); ///< Forward Declaration
+
+/// @brief Function Definition
+returnType functionName(){
+    
+
+} 
+```
 
-Initializes objects using **brace-enclosed initializer lists**.
+- A `forward declaration` allows us to tell the compiler about the existence of an identifier before actually defining the identifier.
 
-#### Direct List Initialization
+<br>
 
+### 2.2. Namespace
 ```cpp
-T object{arg1, arg2};
-new T{arg1, arg2};
+namespace nested_config{
+    namespace config{
+        int value = 1;
+    }
+}
 
-Class::Class() : member{arg1, arg2} {}
+using namespace cfg = nested_config::config;
+
+void f(){
+    std::cout << cfg::value;
+}
 ```
+- `namespace` is a way to group names (variables, functions, classes, ...) together and avoid name conflicts. It guarantees that all identifiers within the namespace are unique
+- `using namespace`: this is a using-directive that allows us to access names in the std namespace with no namespace prefix
+- The `scope resolution operator (::)` used to access namespace member
+- Can create `namespace aliases`, which allow us to temporarily shorten a long sequence of namespaces into something shorter.
+- namespaces can be nested inside other namespaces.
 
-#### Copy List Initialization
+<br>
 
+### 2.3. Preprocessor
+The `preprocessor` is a process that runs on the code before it is compiled.
 ```cpp
-T object = {arg1, arg2};
-return {arg1, arg2};
-function({arg1, arg2});
+#include <iostream>     // insert file contents
+#define NAME "Alex"     // replace NAME -> "Alex"
+
+#ifdef NAME_DEFINED     // only compile if defined
+std::cout << NAME;
+#endif
 ```
 
-#### Designated Initializers (since C++20)
+<br>
 
+### 2.3. Header Files
 ```cpp
-T object{ .des1 = arg1, .des2 = arg2 };
-T object = { .des1 = arg1, .des2 = arg2 };
+#include <iostream>     // search system only 
+#include "my_header.h"  // search local first, then system
+
+/// @brief Add include directories with -I
+// g++ -o main -I./source/includes -I/home/abc/moreHeaders main.cpp
 ```
 
+`Header files` are files designed to propagate declarations to code files. 
+- `Header guards` prevent the contents of a header from being included more than once into a given code file. 
+- For cross-platform library code, `#ifndef` is safest.
+- For modern projects, `#pragma once` is simpler and safe.
+
 ---
+## 3. Fundamental Data Types
+Memory can only store bits. `Data type` help compiler and CPU take care of encoding the value into the sequence of bits.
+    - Fundamental Data Types
+    - Compound Data Types
+
+### 3.1 Primitive Type
+| Types                                                              | Category             | Meaning                                          | Example |
+| ------------------------------------------------------------------ | -------------------- | ------------------------------------------------ | ------- |
+| float, double, long double                                         | Floating Point       | a number with a fractional part                  | 3.14159 |
+| bool                                                               | Integral (Boolean)   | true or false                                    | true    |
+| char, wchar_t, char8_t (C++20), char16_t (C++11), char32_t (C++11) | Integral (Character) | a single character of text                       | 'c'     |
+| short int, int, long int, long long int (C++11)                    | Integral (Integer)   | positive and negative whole numbers, including 0 | 64      |
+| std::nullptr_t (C++11)                                             | Null Pointer         | a null pointer                                   | nullptr |
+| void                                                               | Void                 | no type                                          | n/a     |
+
+- `sizeof` used to get the size of a type in bytes. (pointer has 4 or 8 bytes based on the arch)
+- `signed integers` can hold both positive and negative numbers (and 0). 
+- `unsigned integers` can only hold non-negative whole numbers.
+- `fixed-width integers` are the  set of integer types that are guaranteed to be the same size on any architecture **`#include <cstdint>`**
+  - `fast integers`: guarantee at least # bits, but pick the type that the CPU can process fastest (even if it uses more memory).
+  - `least integers`: guarantee at least # bits, but pick the type that uses the least memory (even if it’s slower).
+- `size_t` vs `std::size_t` is an unsigned integral type that is used to represent the size or length of objects. (<stddef.h>,  <cstddef>)
+- `scientific notation e/E` used to present the times 10 to the power of the equation. e.g.  **(e.g. 5.9722 x 10²⁴ -> 5.9722e24)**
+- `Inf` represents infinity. Inf is signed, and can be positive (+Inf) or negative (-Inf). (5/0)
+- `NaN` stands for “Not a Number”. (mathematically invalid)
+
+<br>
+
+### 3.2. Chars
+- A `char` variable are interpreted as an `ASCII character`.
+- `'t'`: Text between single quotes is treated as a char literal, which represents a single character.
+- `"text"`: Text between double quotes (e.g. “Hello, world!”) is treated as a C-style string literal, which can contain multiple characters.
+- **Escape sequences:**
+    | Name            | Symbol       | Meaning                                        |
+    | --------------- | ------------ | ---------------------------------------------- |
+    | Alert           | `\a`         | Makes an alert, such as a beep                 |
+    | Backspace       | `\b`         | Moves the cursor back one space                |
+    | Formfeed        | `\f`         | Moves the cursor to next logical page          |
+    | Newline         | `\n`         | Moves cursor to next line                      |
+    | Carriage return | `\r`         | Moves cursor to beginning of line              |
+    | Horizontal tab  | `\t`         | Prints a horizontal tab                        |
+    | Vertical tab    | `\v`         | Prints a vertical tab                          |
+    | Single quote    | `\'`         | Prints a single quote                          |
+    | Double quote    | `\"`         | Prints a double quote                          |
+    | Backslash       | `\\`         | Prints a backslash                             |
+    | Question mark   | `\?`         | Prints a question mark *(no longer relevant)*  |
+    | Octal number    | `\{number}`  | Translates into char represented by octal      |
+    | Hex number      | `\x{number}` | Translates into char represented by hex number |
 
-### 1.6 Aggregate Initialization
+---
+## 4. Constant
+- A `constant` is a value that is not be changed during the program’s execution. There are two types of constants:
+  - **Named constants**: are constant values that are associated with an identifier.
+    - Constant variables
+    - Macros with substitution text
+    - Enumerated constant
+  - **Literal** are constant values that are not associated with an identifier.Literals are values that are inserted directly into the code.
 
-Initializes **aggregate types** (no user-defined constructors).
+<br>
 
+### 4.1. Named constants
 ```cpp
-T object = {arg1, arg2};
-T object{arg1, arg2};          // since C++11
+const double gravity = 9.8; ///< Const variable
+
+#define MY_NAME "Phong"  ///< Object-like macros with substitution text
+
+enum Color {
+    RED,    // Assigned 0
+    GREEN,  // Assigned 1
+    BLUE = 5, // Manually assigned 5
+    YELLOW  // Assigned 6 (5 + 1)
+};///< Enumerated constant
 ```
 
-Designated initializers for aggregates (since C++20):
+### 4.2. Literals
 
 ```cpp
-T object = { .des1 = arg1, .des2 = arg2 };
-T object{ .des1 = arg1, .des2 = arg2 };
+return 5;                       ///< 5 is an integer literal -> type: int
+bool myNameIsAlex { true };     ///< true is a boolean literal -> type: bool
+double d { 3.4 };               ///< 3.4 is a double literal -> type: double
+cout << "Hello, world!";        ///< "Hello, world!" is a C-style string literal -> type: const char[14]
+cout << 5.0 << '\n';            ///< 5.0 (no suffix) is type double (by default)
+cout << 5.0f << '\n';           ///< 5.0f is type float
+```
+
+- `Type of a literal` is deduced from the literal's value.
+- `Literal suffixes` used to explicitly declare the type for a literal.
+
+<br>
+
+### 4.3.  Numeral systems (decimal, binary, hexadecimal, and octal)
+- Numeral system literals:
+    - Decimal (no prefix, 42)
+    - Binary (0b101010) `b`
+    - Hexadecimal (0x2A) `x`
+    - Octal (052) — all represent the same value.
+- Can change the output format via use of the `std::dec, std::oct, and std::hex` I/O manipulators:
+- Can define a `std::bitset` variable and tell `std::bitset` how many bits we want to store.
+```cpp
+    int bin{};          // assume 16-bit int
+    bin = 0x0001;       // assign binary 0000 0000 0000 0001 to the variable
+    bin = 0b1;          // assign binary 0000 0000 0000 0001 to the variable
+    bin = 0b11;         // assign binary 0000 0000 0000 0011 to the variable
+
+    cout << std::bitset<4>{ 0b1010 } << '\n'; // create a temporary std::bitset and print it
+
+    // C++14: quotation mark (‘) as a digit separator
+    int bin { 0b1011'0010 };        // assign binary 1011 0010 to the variable
+    long value { 2'132'673'462 };   // much easier to read than 2132673462
+```
+
+<br>
+
+### 4.4.  Constant Expression
+- `Constant expressions` is an expressions whose values can be fully determined at **compile time**.
+- `constexpr` is used to declare compile-time constants
+- Benefits:
+  - Safer code
+  - Optimizations
+  - Compile-time evaluation
+
+- `constexpr` function is is a function that is allowed to be called in a constant expression, can be evaluated at compile time or runtime.
+- `consteval` function is a function that must evaluate at compile-time.
+
+```cpp
+constexpr int square(int x) {
+    return x * x;
+}
+
+consteval int cube(int x) {
+    return x * x * x;
+}
+
+constexpr int a = square(5); // compile-time
+int b = square(5);           // runtime allowed
+
+constexpr int c = cube(5);   // OK
+// int d = cube(5);          // Error if not compile-time
+```
+
+---
+## 5. Operators & Bit Manipulation
+### 5.1. Operators
+- Refer : https://www.learncpp.com/cpp-tutorial/operator-precedence-and-associativity/
+- `Increment/decrement`:
+  -  `++x`: increment x, then return x
+  -  `x++`: copy x, then increment x, return the copy
+- `Comma`: 
+  - `(x, y)`: Evaluate x then y, returns value of y
+  - avoid use this
+
+### 5.2. Bit manipulation.
+- To define a set of bit flags, use `uint8/16/32`... or `std::bitset`
+- Refers: https://www.learncpp.com/cpp-tutorial/bit-flags-and-bit-manipulation-via-stdbitset/
+
+---
+## 6. Control Flows
+### 6.1. Constexpr if statement (C++17)
+- Condition will be evaluated at runtime.
+- e.g. 
+```cpp
+int main()
+{
+	constexpr double gravity{ 9.8 };
+
+	if constexpr (gravity == 9.8) // now using constexpr if
+		std::cout << "Gravity is normal.\n";
+	else
+		std::cout << "We are not on Earth.\n";
+
+	return 0;
+}
 ```
 
-- A specialized form of list-initialization
\ No newline at end of file
+<br>
+
+### 6.2. Switch fallthrough and scoping
+- The `[[fallthrough]]` attribute modifies a null statement to indicate that fallthrough is intentional (and no warnings should be triggered).
+- Initialization is not allowed before case labels because control flow in a switch may jump over the initializer, leaving the variable uninitialized.
+- Declarations without an initializer are allowed before case labels because they only reserve space for the variable in the function’s stack frame (decided at compile time). No runtime initialization code is generated, so nothing can be “skipped” by jumping to a case.
+- e.g.
+```cpp
+int main() {
+    int x = 2;
+
+    switch (x) {
+        int a;       //  allowed (no initializer, just reserves space)
+        // int b{5}; //  not allowed (initializer may be skipped)
+
+    case 1:
+        a = 10; // safe: 'a' exists, we assign here
+        std::cout << "Case 1, a = " << a << '\n';
+        [[fallthrough]]; //  intentional fallthrough to case 2
+
+    case 2:
+        a = 20; // reassign
+        std::cout << "Case 2, a = " << a << '\n';
+        break;
+
+    default:
+        std::cout << "Default case\n";
+        break;
+    }
+
+    return 0;
+}
+```
+
+<br>
+
+### 6.3. Halts
+- Halts allow us to terminate our program.Only use a halt if there is no safe or reasonable way to return normally from the main function. If you haven’t disabled exceptions, prefer using exceptions for handling errors safely.
+- `std::exit` is called implicitly when main() returns, it does not clean up local variables in the current function or up the call stack.
+- `std::abort()` function causes your program to terminate abnormally. Abnormal termination means the program had some kind of unusual runtime error and the program couldn’t continue to run. 
+- `std::terminate()` function is typically used in conjunction with exceptions . By default, it calls `std::abort()`
+- e.g.
+```cpp
+#include <iostream>
+#include <cstdlib>    // for std::exit, std::abort
+#include <exception>  // for std::terminate
+
+void cleanup() {
+    std::cout << "Cleaning up...\n";
+}
+
+void riskyFunction(bool fatalError) {
+    if (fatalError) {
+        std::cout << "Fatal error occurred!\n";
+
+        // std::abort: abnormal termination, no cleanup
+        std::abort();
+
+        // Or: std::terminate(); // usually called when exception handling fails
+    }
+}
+
+int main() {
+    cleanup(); // local function call
+
+    // Example 1: return normally from main
+    std::cout << "Program running normally...\n";
+
+    // Example 2: using std::exit (implicit when main returns)
+    if (false) {
+        std::cout << "Exiting via std::exit...\n";
+        std::exit(0); // does not call destructors of locals in main()
+    }
+
+    // Example 3: risky code that might abort/terminate
+    riskyFunction(true);
+
+    // Example 4: normal end of main calls std::exit implicitly
+    std::cout << "Main returns normally.\n";
+    return 0; // std::exit(0) is called implicitly here
+}
+```
\ No newline at end of file
diff --git a/src/core/basics/TypeQualifier.cpp b/src/core/basics/TypeQualifier.cpp
index c456f75..1044f29 100644
--- a/src/core/basics/TypeQualifier.cpp
+++ b/src/core/basics/TypeQualifier.cpp
@@ -1,32 +1,56 @@
 // cppcheck-suppress-file [unreadVariable]
-// A function declared constexpr is implicitly an inline function.
-// A static member variable (but not a namespace-scope variable) declared constexpr is implicitly an inline variable.
 
-#include <iostream>
-using namespace std;
+// A constexpr function is implicitly inline.
+// A constexpr static data member is implicitly an inline variable (since C++17).
+
+#include "Logger.h"
 
 namespace {
-namespace Constant {
+constexpr int square(int x) {
+  return x * x;
+}
+
+consteval int cube(int x) {
+  return x * x * x;
+}
+
 void run() {
-  // 1. Name constants
+  // 1. Named constants
   const double const_var_g{9.8};
+
 #define NAME "Phong"
 
-  // 2. Literals constants
-  bool myNameIsAlex{true};  // true is a boolean literal -> type: bool
-  double d{3.4};            // 3.4 is a double literal -> type: double
-  std::cout
-      << "Hello, world!";  // "Hello, world!" is a C-style string literal -> type: const char[14]
+  // 2. Literal constants
+  bool my_name_is_alex{true};  ///< true is a boolean literal -> type: bool
+  double d{3.4};  ///< 3.4 is a floating-point literal -> type: double
+
+  // "Hello, world!" is a string literal -> type: const char[14]
+  LOG("Hello, world!");
 
-  // 3. Constexpr variables
-  constexpr double constexpr_var_g{9.8};  // compile-time constant
+  // 3. constexpr variables
+  constexpr double kConstexprVarG{9.8};  // compile-time constant
 
-  // 4. Constant expression
-  constexpr double something{
-      constexpr_var_g};  // ok: sum is a constant expression
-  // constexpr double something2{const_var_g}; // error because const_var_g is not the constexprs
+  // 4. Constant expressions
+  constexpr double kSomething{kConstexprVarG};
+
+  // Error:
+  // constexpr double something2{const_var_g};
+  // const_var_g is const, but not guaranteed to be a constant expression
+
+  if constexpr (kConstexprVarG != 9.8) {
+    LOG("kConstexprVarG != 9.8");
+  } else {
+    LOG("kConstexprVarG == 9.8");
+  }
+
+  // 5. Const expression function
+
+  constexpr int a = square(5);  // compile-time
+  int b = square(5);            // runtime allowed
+
+  constexpr int c = cube(5);  // OK
+  // int d = cube(5);          // Error if not compile-time
 }
-}  // namespace Constant
 
 }  // namespace
 
@@ -34,10 +58,11 @@ void run() {
 
 class TypeQualifier : public IExample {
  public:
-  std::string group() const override { return "core"; }
+  std::string group() const override { return "core/basics"; }
   std::string name() const override { return "TypeQualifier"; }
   std::string description() const override { return "TypeQualifier"; }
-  void execute() override { Constant::run(); }
+
+  void execute() override { run(); }
 };
 
-REGISTER_EXAMPLE(TypeQualifier);
+REGISTER_EXAMPLE(TypeQualifier);
\ No newline at end of file
diff --git a/src/core/class/RoleOfThreeFiveZero.cpp b/src/core/class/RoleOfThreeFiveZero.cpp
index c7602c9..e055742 100644
--- a/src/core/class/RoleOfThreeFiveZero.cpp
+++ b/src/core/class/RoleOfThreeFiveZero.cpp
@@ -276,7 +276,7 @@ void run() {
 
 class RoleOfThreeFiveZero : public IExample {
  public:
-  std::string group() const override { return "core"; }
+  std::string group() const override { return "core/class"; }
   std::string name() const override { return "RoleOfThreeFiveZero"; }
   std::string description() const override { return ""; }
   void execute() override {

From afd45c964c9e8584ab94252fa50ba95544004858 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Mon, 25 May 2026 11:05:06 +0700
Subject: [PATCH 06/18] Refactor and update readme for Strign

---
 src/core/basics/Operations.cpp       |   2 +-
 src/core/string/CString.cpp          | 205 +++++++------
 src/core/string/README.md            | 441 +++++++++++++++------------
 src/core/string/StdString.cpp        | 231 ++++++++------
 src/core/string/StringFormatting.cpp |  63 ++--
 5 files changed, 535 insertions(+), 407 deletions(-)

diff --git a/src/core/basics/Operations.cpp b/src/core/basics/Operations.cpp
index b393c8d..5287455 100644
--- a/src/core/basics/Operations.cpp
+++ b/src/core/basics/Operations.cpp
@@ -75,7 +75,7 @@ void arithmeticOperator() {
   LOG_S("comma(a++, b) = " << value);
 }
 
-void LOG_SicalOperator() {
+void logicalOperator() {
   LOG("\n--- LOG_SicalOperator Examples ---");
   bool a = true;
   bool b = false;
diff --git a/src/core/string/CString.cpp b/src/core/string/CString.cpp
index 3ec28cf..26ee4af 100644
--- a/src/core/string/CString.cpp
+++ b/src/core/string/CString.cpp
@@ -1,12 +1,14 @@
 #include <string.h>  // C-String
-#include <iostream>
+#include "Logger.h"
 
 namespace {
+void log_string_info(const char* label, const char* str, size_t size) {
+  LOG_S(label << ": \"" << str << "\"" << " | size=" << size
+              << " | length=" << strlen(str));
+}
 
-namespace initialize_string {
-
-// Memory layout (addresses are illustrative):
-// Stack (modifiable array)
+namespace create {
+/// @brief Stack (modifiable array)
 // 0x7fffc000: str2[0] = 'H'
 // 0x7fffc001: str2[1] = 'e'
 // 0x7fffc002: str2[2] = 'l'
@@ -15,7 +17,7 @@ namespace initialize_string {
 // 0x7fffc005: str2[5] = '\0'
 // (str2 starts at 0x7fffc000)
 
-// Data / Read-only segment (string literal)
+/// @brief String literal (Data / Read-only segment)
 // 0x00403000: 'H'
 // 0x00403001: 'e'
 // 0x00403002: 'l'
@@ -27,165 +29,177 @@ namespace initialize_string {
 // Pointer variable
 // 0x7fffbff0: str1 = 0x00403000   // str1 holds address of string literal
 void run() {
-  // **1. As a character array (modifiable)**
-  char str_array[] = "this is a strArray literal";
-  std::cout << str_array << " - size " << sizeof(str_array) << " - length "
-            << strlen(str_array) << "\n";
-  str_array[0] ^= ' ';
-  std::cout << str_array << "\n";
-
-  // **2. As a a pointer to a string literal const (read-only)**
-  // Literal is const char*
-  char* str_ptr = "this is a strPtr literal";
-  std::cout << str_ptr << " - size " << sizeof(str_ptr) << " - length "
-            << strlen(str_ptr) << "\n";
-  //   strPtr[0] ^= ' '; // ERROR
-
-  // **3. Using sprintf / snprintf (string formatting)**
+  LOG("=== create ===");
+
+  /// @brief Create a string as a character array (modifiable)
+  char str_array[] = "this is a string array literal";
+  log_string_info("str_array", str_array, sizeof(str_array));
+  str_array[0] ^= ' ';  // modify first character
+  log_string_info("modified str_array", str_array, sizeof(str_array));
+
+  /// @brief Create a pointer to a string literal const (read-only)
+  const char* str_ptr = "this is a strPtr literal";
+  log_string_info("str_ptr", str_ptr, sizeof(str_ptr));
+  // str_ptr[0] ^= ' '; // ERROR
+
+  /// @brief Create a string using sprintf / snprintf
   char str_formatted[50];
   int num_var = 21;
+  const char text[] = "example";
 
-  // sprintf (unsafe if buffer too small)
-  sprintf(str_formatted, "sprintf: %d", num_var);
-  std::cout << str_formatted << " - size " << sizeof(str_formatted)
-            << " - length " << strlen(str_formatted) << "\n";
+  sprintf(str_formatted, "sprintf: %d",
+          num_var);  // sprintf (unsafe if buffer too small)
+  log_string_info("sprintf", str_formatted, sizeof(str_formatted));
 
-  // snprintf (safer, limits buffer size)
-  snprintf(str_formatted, sizeof(str_formatted), "snprintf %s %d", str_array,
-           num_var);
-  std::cout << str_formatted << " - size " << sizeof(str_formatted)
-            << " - length " << strlen(str_formatted) << "\n";
+  snprintf(str_formatted, sizeof(str_formatted), "snprintf %s %d", text,
+           num_var);  // snprintf (safer, limits buffer size)
+  log_string_info("snprintf", str_formatted, sizeof(str_formatted));
 }
-}  // namespace initialize_string
+}  // namespace create
 
-namespace copy_string {
+namespace copy {
 void run() {
+  LOG("=== copy ===");
+
   const char src[] = "CopyStr";
   char dst[50];
 
-  // **1. Copy full string**
+  /// @brief Copy full string
   strcpy(dst, src);
+  log_string_info("strcpy", dst, sizeof(dst));
 
-  std::cout << dst << " - size " << sizeof(dst) << " - length " << strlen(dst)
-            << "\n";
-
-  // **2. Copy the number of charactor**
+  /// @brief Copy first N characters
   strncpy(dst, "Hello123", 5);
-  dst[5] = '\0';  // ensure null-termination
-
-  std::cout << dst << " - size " << sizeof(dst) << " - length " << strlen(dst)
-            << "\n";
+  dst[5] = '\0';  // strncpy may not append '\0'
+  log_string_info("strncpy", dst, sizeof(dst));
 }
-}  // namespace copy_string
+}  // namespace copy
 
-namespace concat_string {
+namespace concat {
 void run() {
+  LOG("=== concat ===");
+
   const char part1[] = "Hello";
   const char part2[] = "World";
   char dst[50] = "";
 
-  // **1. Append full str**
+  /// @brief Append full strings
   strcat(dst, part1);
   strcat(dst, part2);
   strcat(dst, " !!");
-  std::cout << dst << " - size " << sizeof(dst) << " - length " << strlen(dst)
-            << "\n";
+  log_string_info("strcat", dst, sizeof(dst));
 
-  // **2. Append the number of charactors**
+  /// @brief Append first N characters
   strncat(dst, "1234", 3);
-  std::cout << dst << " - size " << sizeof(dst) << " - length " << strlen(dst)
-            << "\n";
+  log_string_info("strncat", dst, sizeof(dst));
 }
-}  // namespace concat_string
+}  // namespace concat
 
-namespace compare_string {
+namespace compare {
 void run() {
+  LOG("=== compare ===");
+
   const char str1[] = "abc";
   const char str2[] = "abcde";
-  // **0. Compare memory**
-  // int memcmp ( const void * ptr1, const void * ptr2, size_t num );
+
+  /// @brief Compare memory
+  // int memcmp(const void* ptr1, const void* ptr2, size_t num);
   int result0 = memcmp(str1, str2, sizeof(str1));
-  std::cout << "strcmp(str1, \"abcde\") = " << result0 << "\n";
+  LOG_S("memcmp(str1, str2, sizeof(str1)) = " << result0);
 
-  // **1. Compare full str**
+  /// @brief Compare full string
   int result1 = strcmp(str1, "abc");
   int result2 = strcmp(str1, str2);
-  std::cout << "strcmp(str1, \"abc\") = " << result1 << "\n";
-  std::cout << "strcmp(str1, str2) = " << result2 << "\n";
+  LOG_S("strcmp(str1, \"abc\") = " << result1);
+  LOG_S("strcmp(str1, str2) = " << result2);
 
-  // **2. Compare first N characters**
+  /// @brief Compare first N characters
   int result3 = strncmp(str1, str2, 3);
-  std::cout << "strncmp(str1, str2, 3) = " << result3 << "\n";
+  LOG_S("strncmp(str1, str2, 3) = " << result3);
 }
-}  // namespace compare_string
+}  // namespace compare
 
-namespace parse_string {
+namespace parse {
 void run() {
-  char str[] = "A,B,C,D,";  // OK
-                            //   char* str = "A,B,C,D,"; // ERROR - const
+  LOG("=== compare ===");
 
-  // **1. Splitting a string by some delimiter**
-  // 1.1. strtok - not safe
-  char* delimiter = ",";
+  char str[] = "A,B,C,D,";
+  // char* str = "A,B,C,D,"; // ERROR - string literal is read-only
+
+  const char* delimiter = ",";
+
+  /// @brief strtok (NOT thread-safe)
+  LOG_S("=== strtok ===");
   const char* token = strtok(str, delimiter);
   while (token != nullptr) {
-    std::cout << "strtok - token :" << token << "\n";
+    LOG_S("token = " << token);
+
     token = strtok(nullptr, delimiter);
   }
+
+  /// @brief strtok problem example
   {
-    std::cout << " === problem === \n";
+    LOG_S("=== strtok problem example ===");
+
     char str1[] = "a,b,c";
     char str2[] = "1,2,3";
 
     // Parse str1
-    const char* token1 = strtok(str1, delimiter);  // token1 = "a"
-    std::cout << "str1 first token: " << token1 << "\n";
+    const char* token1 = strtok(str1, delimiter);
+    LOG_S("str1 first token  = " << token1);
 
     // Parse str2
-    const char* token2 = strtok(str2, delimiter);  // token2 = "1"
-    std::cout << "str2 first token: " << token2 << "\n";
+    const char* token2 = strtok(str2, delimiter);
+    LOG_S("str2 first token  = " << token2);
 
     // Continue parsing str1
-    token1 = strtok(nullptr, delimiter);  //  Unexpected!
-    std::cout << "str1 second token: " << token1 << "\n";
+    token1 = strtok(nullptr, delimiter);
+    LOG_S("str1 second token = " << token1 << " (unexpected)");
   }
 
-  // Have to Reset string for the next handle because strtok
+  /// @brief strtok_r (thread-safe / reentrant)
+  LOG_S("=== strtok_r ===");
+
   char str2[] = "one,two,three";
-  // 1.2. strtok_r - safe
   char* saveptr;
   const char* token2 = strtok_r(str2, delimiter, &saveptr);
+
   while (token2 != nullptr) {
-    std::cout << "strtok - token :" << token2 << "\n";
+    LOG_S("token = " << token2);
     token2 = strtok_r(nullptr, delimiter, &saveptr);
   }
 
-  // **2. strcspn: find first occurrence of any chars in reject set**
-  const char sample[] = "hello123world";
-  size_t pos = strcspn(sample, "0123456789");  // pos = 5
+  /// @brief strcspn
+  // Find first occurrence of any character in reject set
+  LOG_S("=== strcspn ===");
 
-  std::cout << "Sample string: " << sample << "\n";
-  std::cout << "First digit from \"0123456789\" found at index: " << pos
-            << "\n";
-  std::cout << "The digit is: " << sample[pos] << "\n";
+  const char sample[] = "hello123world";
+  size_t pos = strcspn(sample, "0123456789");
+  LOG_S("sample = " << sample);
+  LOG_S("first digit index = " << pos);
+  LOG_S("digit = " << sample[pos]);
 }
-}  // namespace parse_string
+}  // namespace parse
 
 namespace number_conversion {
 void run() {
-  // **1. string to integer**
+  LOG_S("=== number_conversion ===");
+
+  /// @brief String to integer
   const char str_num[] = "100";
   int num = atoi(str_num);
-  std::cout << num << "\n";
+  LOG_S("atoi(\"100\") = " << num);
 
-  // **2. string to double**
+  /// @brief String to double
   const char str_num_d[] = "100.1234__123";
   double num_d = atof(str_num_d);
-  std::cout << num_d << "\n";
+  LOG_S("atof(\"100.1234__123\") = " << num_d);
 
+  /// @brief strtod
   char* end;
   num_d = strtod(str_num_d, &end);
-  std::cout << num_d << " end part:" << end << "\n";
+  LOG_S("strtod = " << num_d);
+  LOG_S("remaining string = " << end);
 }
 }  // namespace number_conversion
 }  // namespace
@@ -198,12 +212,11 @@ class CString : public IExample {
   std::string name() const override { return "C-String"; }
   std::string description() const override { return "C-String Example"; }
   void execute() override {
-    initialize_string::run();
-    copy_string::run();
-    concat_string::run();
-    compare_string::run();
-    parse_string::run();
-
+    create::run();
+    copy::run();
+    concat::run();
+    compare::run();
+    parse::run();
     number_conversion::run();
   }
 };
diff --git a/src/core/string/README.md b/src/core/string/README.md
index 45dc79a..3e6afef 100644
--- a/src/core/string/README.md
+++ b/src/core/string/README.md
@@ -1,27 +1,195 @@
-# 1. String Formatting
+# String
+
+## 1. C-Style String
+A C-Style string is any **null-terminated byte string**, where this is a sequence of nonzero bytes followed by a byte with zero (0) value (the terminating null character).
+- The terminating null character is represented as the character literal **'\0'**;
+- The length of an NTBS is the number of elements that precede the terminating null character. An empty NTBS has a length of zero.
+- The size of an NTBS is the size of the entire array, including the terminating null character.
+- A single quotes `(')` are used to identify **character literals**.
+- A double quotes `('')` are used to identify **string literals**. String literals are stored in your program image, usually in a read-only section (.data),
+
+<br>
+
+### 1.1. Create a String
+```c
+// *1. Ptr
+char* strMessagePtr= "abc";
+// sizeof(strMessage) = 32 or 64 (ptr)
+strMessagePtr[0] = 1; // error, ptr to const
+
+// *2. Arrays
+char strMessage[] = "abc";
+// sizeof(strMessage ) = 4 
+strMessage[1] = 'a'; // OK
+```
+- For `strMessage`, the memory for the array is allocated on the stack at runtime. The compiler initializes it from the string literal. At runtime, the program memory copies the string literal into the array 
+- For `strMessagePtr`, only the address of the string literal is held on the stack, and there is no copying of string literal.
+
+<br>
+
+### 1.2. Characters
+- Null: `\0`, `0x00`, `NULL`
+- Carriage Return And New Line: `\r\n`
+- Case switching: `'A' ^ ' '` & `'a' ^ ' '`
+- Special: `\\`, 
+- **Escape sequences:**
+    | Name            | Symbol       | Meaning                                        |
+    | --------------- | ------------ | ---------------------------------------------- |
+    | Alert           | `\a`         | Makes an alert, such as a beep                 |
+    | Backspace       | `\b`         | Moves the cursor back one space                |
+    | Formfeed        | `\f`         | Moves the cursor to next logical page          |
+    | Newline         | `\n`         | Moves cursor to next line                      |
+    | Carriage return | `\r`         | Moves cursor to beginning of line              |
+    | Horizontal tab  | `\t`         | Prints a horizontal tab                        |
+    | Vertical tab    | `\v`         | Prints a vertical tab                          |
+    | Single quote    | `\'`         | Prints a single quote                          |
+    | Double quote    | `\"`         | Prints a double quote                          |
+    | Backslash       | `\\`         | Prints a backslash                             |
+    | Question mark   | `\?`         | Prints a question mark *(no longer relevant)*  |
+    | Octal number    | `\{number}`  | Translates into char represented by octal      |
+    | Hex number      | `\x{number}` | Translates into char represented by hex number |
+
+<br>
+
+### 1.3. C String Libraries
+- Copying strings : `strcpy`, `strncpy`
+- Concatenating strings: `strcat`, `strncat`
+- Comparing strings: `strcmp`, `strncmp`
+- Parsing strings: `strtok`, `strcspn`
+- Length: `strlen`
+- Examples:
+```cpp
+#include <stdio.h>
+#include <string.h>
+
+int main() {
+    // -------------------------------
+    // 1. Copying strings
+    // -------------------------------
+    char src[] = "Hello";
+    char dst[20];
+
+    strcpy(dst, src);           // copy full string
+    // dst = "Hello"
+
+    strncpy(dst, "World", 3);   // copy only 3 chars
+    dst[3] = '\0';              // ensure null-termination
+    // dst = "Wor"
+
+    // -------------------------------
+    // 2. Concatenating strings
+    // -------------------------------
+    char text[20] = "Hi";
+    strcat(text, " there");     // append full string
+    // text = "Hi there"
+
+    strncat(text, "!!!", 2);    // append only 2 chars
+    // text = "Hi there!!"
+
+    // -------------------------------
+    // 3. Comparing strings
+    // -------------------------------
+    int r1 = strcmp("abc", "abc");   // r1 = 0  (equal)
+    int r2 = strcmp("abc", "abd");   // r2 < 0  (abc < abd)
+    int r3 = strncmp("abcdef", "abcxyz", 3); // r3 = 0 (first 3 chars equal)
+
+    // -------------------------------
+    // 4. Parsing strings
+    // -------------------------------
+    char line[] = "A,B,C";
+    char* token = strtok(line, ",");  // first token: "A"
+    while (token != NULL) {
+        printf("token: %s\n", token);
+        token = strtok(NULL, ",");
+    }
+
+    // strcspn: find first occurrence of any chars in reject set
+    char sample[] = "hello123world";
+    size_t pos = strcspn(sample, "0123456789");
+    // pos = 5 (first digit is at index 5)
+
+    // -------------------------------
+    // 5. Length
+    // -------------------------------
+    size_t len = strlen("abc");  // len = 3
+
+    return 0;
+}
+```
 
-| Method            | Standard | Pros                     | Cons                         |
-|------------------|----------|--------------------------|------------------------------|
-| `std::format`     | C++20    | Clean, safe, Python-like | Needs newer compiler         |
-| `+` concatenation | C++98    | Simple                   | Hard to format numbers       |
-| `stringstream`    | C++98    | Flexible streaming       | Slow, verbose                |
-| `snprintf`        | C        | Very fast, classic       | Unsafe if misused            |
-https://www.geeksforgeeks.org/cpp/strings-in-cpp/
-https://hackingcpp.com/cpp/std/string_basics
+<br>
+
+### 1.4. String/Numbers Conversion
+- Integer to String: `itoa()` (non-standard)
+- String to Double: `atof()`
+- String to Double (with error checking): `strtod()`
+- String to Long (with base + error checking): `strtol()`
+- e.g.
+```c
+#include <stdio.h>
+#include <stdlib.h>   // atof, strtod, strtol
+#include <string.h>   // itoa (non-standard on some compilers)
+
+int main() {
+    // -------------------------------
+    // 1. Integer → String (itoa)
+    // -------------------------------
+    char buf[32];
+    itoa(1234, buf, 10);   // convert integer to string in base 10
+    // buf = "1234"
+
+    itoa(255, buf, 16);    // convert to hex
+    // buf = "ff"
+
+    // -------------------------------
+    // 2. String → Double (atof)
+    // -------------------------------
+    double d1 = atof("3.14159");
+    // d1 = 3.14159
+
+    double d2 = atof("12.5xyz"); 
+    // d2 = 12.5 (atof stops at non-numeric chars)
+
+    // -------------------------------
+    // 3. String → Double (strtod)
+    // -------------------------------
+    char* end;
+    double d3 = strtod("45.67abc", &end);
+    // d3 = 45.67
+    // end -> "abc"
+
+    // -------------------------------
+    // 4. String → Long (strtol)
+    // -------------------------------
+    long v1 = strtol("1234", NULL, 10);
+    // v1 = 1234 (decimal)
+
+    long v2 = strtol("FF", NULL, 16);
+    // v2 = 255 (hex → decimal)
+
+    char* end2;
+    long v3 = strtol("100xyz", &end2, 10);
+    // v3 = 100
+    // end2 -> "xyz"
+
+    return 0;
+}
+```
 
----
+<br>
 
-# 2. Create Strings
+---
+## 2. C++ String **<string>**
+Strings are objects that represent sequences of characters.
 
+### 2.1. Create a String
 ```cpp
-std::string s = "hello";
-std::string s2("hello");
-std::string s3(5, 'a');     // "aaaaa"
+std::string s = "hello";    ///< initialize from a string literal
+std::string s2("hello");    ///< direct initialization from a string literal
+std::string s3(5, 'a');     ///< create a string with 5 copies of 'a' -> "aaaaa"
 ```
----
-
-# 3. Basic Properties
 
+### 2.2. Basic Properties
 | Function     | Description           |
 | ------------ | --------------------- |
 | `s.size()`   | number of characters  |
@@ -29,191 +197,89 @@ std::string s3(5, 'a');     // "aaaaa"
 | `s.empty()`  | check empty           |
 | `s.clear()`  | remove all characters |
 
----
-
-# 4. Access Characters
-
+### 2.3. Access Characters
 ```cpp
 s[0]        // no bounds check
 s.at(0)     // bounds check
 s.front()   // first char
 s.back()    // last char
 ```
-
----
-
-# 5. Modify String
-
-## append
-
+### 2.4. Modify String
 ```cpp
+/// @brief append
 s.append(" world");
 s += " world";
-```
-
-## insert
 
-```cpp
+/// @brief insert
 s.insert(5, "XXX");
-```
 
-## erase
-
-```cpp
+/// @brief erase
 s.erase(0,2);
-```
-
-## replace
 
-```cpp
+/// @brief replace
 s.replace(0,5,"hi");
-```
-
-## remove `\n`
-
-```cpp
-    std::string s = "hello\nworld\n";
-    auto new_end = std::remove(s.begin(), s.end(), '\n');
-    s.erase(new_end)
-    // std::erase(s,'\n')
-    s.erase(std::remove(s.begin(), s.end(), '\n'), s.end());
-```
-
-
----
 
-# 6. Substring
-
-```cpp
-std::string sub = s.substr(pos, len);
+/// @brief remove `\n`
+std::string s = "hello\nworld\n";
+auto new_end = std::remove(s.begin(), s.end(), '\n');
+s.erase(new_end)
+// std::erase(s,'\n')
+s.erase(std::remove(s.begin(), s.end(), '\n'), s.end());
 ```
-
-Example:
-
+### 2.5. Substring
 ```cpp
+/// @brief std::string sub = s.substr(pos, len); , substr() does NOT modify original string
 std::string s = "abcdef";
-
 s.substr(2,3);   // "cde"
 ```
+### 2.6. Find / Search
+```cpp
+/// @brief find character
+s.find('a');
 
-Important:
-
-```
-substr() does NOT modify original string
-```
-
----
 
-# 7. Find / Search
+/// @brief find last
+s.find('a');
 
-## find substring
 
-```cpp
+/// @brief find substring
 size_t pos = s.find("abc");
-
 if (pos != std::string::npos)
     std::cout << "found";
 ```
-
-## find char
-
-```cpp
-s.find('a');
-```
-
-## find last
-
-```cpp
-s.rfind("abc");
-```
-
----
-
-# 8. Compare Strings
-
+### 2.6. Compare Strings
 ```cpp
 if (a == b)
 if (a != b)
 if (a < b)
-```
-
-Using compare:
 
-```cpp
-a.compare(b)
-```
-
-Return:
-
-```
-0  -> equal
-<0 -> smaller
->0 -> larger
+// 0  -> equal
+// <0 -> smaller
+// >0 -> larger
+auto ret = a.compare(b);
 ```
-
-### C++20
-
+### 2.7. Start/End Checking
 ```cpp
+/// @brief C++20
 s.starts_with("abc");
 s.ends_with("xyz");
-```
-
-### Before C++20
 
-#### starts_with
-
-```cpp
+/// @brief before c++ 20
 s.rfind("abc",0) == 0
-```
-
-#### ends_with
-
-```cpp
 s.size() >= 3 &&
 s.compare(s.size()-3,3,"xyz") == 0
 ```
-
----
-
-# 9. Convert String
-
-## string → int
-
-### C++11
-
+### 2.8. Convert String
 ```cpp
+/// @brief string to int
 int n = std::stoi(s);
-```
-
-Other:
-
-```
-stol
-stoll
-stof
-stod
-```
-
-Example:
-
-```cpp
 double x = std::stod("3.14");
-```
-
----
-
-## number → string
 
-```cpp
+/// @brief int to string
 std::string s = std::to_string(123);
 ```
 
----
-
-# 10. String Parsing
-
-## split using stringstream
-
+### 2.9. String Parsing
 ```cpp
 #include <sstream>
 
@@ -226,31 +292,13 @@ while(std::getline(ss,item,',')) {
 }
 ```
 
-Result
-
-```
-a
-b
-c
-```
-
----
-
-# 11. Trim Whitespace (manual)
-
-Common pattern:
-
+### 2.10. Trim Whitespace
 ```cpp
 s.erase(0, s.find_first_not_of(" \t\n\r"));
 s.erase(s.find_last_not_of(" \t\n\r") + 1);
 ```
 
-Removes leading/trailing spaces.
-
----
-
-# 12. Convert Case
-
+### 2.11. Convert Case
 ```cpp
 #include <algorithm>
 
@@ -258,38 +306,27 @@ std::transform(s.begin(), s.end(), s.begin(), ::tolower);
 std::transform(s.begin(), s.end(), s.begin(), ::toupper);
 ```
 
----
-
-# 20. Functions Modify the String
-
-Modify:
-
-```
-append
-insert
-erase
-replace
-clear
-push_back
-pop_back
-```
-
-Do NOT modify:
+### 2.12. String Formatting
 
-```
-substr
-find
-compare
-size
-empty
-```
-
-Rule:
+| Method            | Standard | Pros                     | Cons                         |
+|------------------|----------|--------------------------|------------------------------|
+| `std::format`     | C++20    | Clean, safe, Python-like | Needs newer compiler         |
+| `+` concatenation | C++98    | Simple                   | Hard to format numbers       |
+| `stringstream`    | C++98    | Flexible streaming       | Slow, verbose                |
+| `snprintf`        | C        | Very fast, classic       | Unsafe if misused            |
 
-```
-method() const  -> does NOT modify object
-```
+---
+## 3. std::cout << , std::cin >> , std::getLine(std::cin >> std::ws, std::string string)
+- `std::ws` tells `std::cin` to ignore leading whitespace(tab/enter/newline(s)) before extraction.  
+- `std::string::length` returns length of a string that does not included the null terminator character.
+- `s` suffix is a `std::string` literally, no suffix is a C-style string literally. e.g. `std::cout << "goo\n"s`
+> Initializing and copy a `std::string` is slow. That's inefficient 
 
 ---
+## 4. std::string_view  (C++17)
+`std::string_view` provides read-only access to an existing string (a C-style string literal, a std::string, or a char array) without making a copy. 
+- A std::string_view that is viewing a string that has been destroyed is sometimes called a dangling view. When a std::string is modified, all views into that std::string are invalidated, meaning those views are now invalid. Using an invalidated view (other than to revalidate it) will produce undefined behavior.
 
-# 21. Common Bugs
\ No newline at end of file
+- `sv` suffix is a `std::string_view` literally
+- Modify a std::string is likely to invalidate all std::string_view that view into that.
+- It may or may not be null-terminated.
\ No newline at end of file
diff --git a/src/core/string/StdString.cpp b/src/core/string/StdString.cpp
index 4b42b66..3f7281b 100644
--- a/src/core/string/StdString.cpp
+++ b/src/core/string/StdString.cpp
@@ -1,159 +1,213 @@
 #include <algorithm>
+#include <cctype>
 #include <iomanip>
-#include <iostream>
+#include <sstream>
 #include <string>
+
 #include "ExampleRegistry.h"
+#include "Logger.h"
+
+namespace {
+
+void log_string_info(const char* label, const std::string& str) {
+  LOG_S(label << ": \"" << str << "\"" << " | size=" << str.size()
+              << " | empty=" << std::boolalpha << str.empty());
+}
+
+}  // namespace
 
 namespace create {
+
 void run() {
-  // 1. Direct initialization with literal
+  LOG("=== create ===");
+
+  /// @brief Direct initialization with literal
   std::string s1 = "string 1";
 
-  // 2. Constructor initialization
+  /// @brief Constructor initialization
   std::string s2("string 2");
 
-  // 3. Repeat character constructor
+  /// @brief Repeat character constructor
   std::string s3(5, 's');  // "sssss"
 
-  // 4. Concatenated string literals (compile-time)
+  /// @brief Concatenated string literals (compile-time)
   std::string s4 =
       "First "
-      "Second";  // -> "First Second"
+      "Second";
 
-  // 5. Raw string literal (no escaping needed)
+  /// @brief Raw string literal (no escaping needed)
   std::string s5 = R"(C:\folder\file.txt)";
 
-  // Print results
-  std::cout << "s1: " << s1 << '\n';
-  std::cout << "s2: " << s2 << '\n';
-  std::cout << "s3: " << s3 << '\n';
-  std::cout << "s4: " << s4 << '\n';
-  std::cout << "s5: " << s5 << '\n';
+  log_string_info("s1", s1);
+  log_string_info("s2", s2);
+  log_string_info("s3", s3);
+  log_string_info("s4", s4);
+  log_string_info("s5", s5);
 }
+
 }  // namespace create
 
 namespace modify {
+
 void run() {
-  std::string ss = "xPhong";
-  std::cout << "init      : " << ss << '\n';
-
-  // append
-  ss.append("Nguyen");
-  std::cout << "append    : " << ss << '\n';
-
-  // insert at position
-  ss.insert(6, "Vanxx");
-  std::cout << "insert    : " << ss << '\n';
-
-  // erase (pos, length)
-  ss.erase(9, 2);
-  std::cout << "erase     : " << ss << '\n';
-
-  // erase char using pos
-  auto new_end = std::remove(ss.begin(), ss.end(), 'O');
-  ss.erase(new_end, ss.end());
-  std::cout << "erase 'O')  : " << ss << '\n';
-  // #include <algorithm>
-  // std::erase(ss, '\n');
-
-  // replace (pos, length, new_string)
-  ss.replace(0, 1, "My name is ");
-  std::cout << "replace   : " << ss << '\n';
-
-  // convert case
-  std::transform(ss.begin(), ss.end(), ss.begin(), ::tolower);
-  std::cout << "tolower   : " << ss << '\n';
-  std::transform(ss.begin(), ss.end(), ss.begin(), ::toupper);
-  std::cout << "toupper   : " << ss << '\n';
-
-  // trim white
-  ss.erase(0, ss.find_first_not_of(" \t\n\r"));
-  std::cout << "trim first   : " << ss << '\n';
-  ss.erase(ss.find_last_not_of(" \t\n\r") + 1);
-  std::cout << "trim last   : " << ss << '\n';
+  LOG("=== modify ===");
+
+  std::string str = "xPhong";
+  log_string_info("init", str);
+
+  /// @brief Append
+  str.append("Nguyen");
+  log_string_info("append", str);
+
+  /// @brief Insert at position
+  str.insert(6, "Vanxx");
+  log_string_info("insert", str);
+
+  /// @brief Erase by position and length
+  str.erase(9, 2);
+  log_string_info("erase", str);
+
+  /// @brief Erase character using remove + erase idiom
+  auto new_end = std::remove(str.begin(), str.end(), 'O');
+  str.erase(new_end, str.end());
+  log_string_info("erase 'O'", str);
+
+  // C++20
+  // std::erase(str, 'O');
+
+  /// @brief Replace sub
+  str.replace(0, 1, "My name is ");
+  log_string_info("replace", str);
+
+  /// @brief Convert to lowercase
+  std::transform(str.begin(), str.end(), str.begin(),
+                 [](unsigned char c) { return std::tolower(c); });
+  log_string_info("tolower", str);
+
+  /// @brief Convert to uppercase
+  std::transform(str.begin(), str.end(), str.begin(),
+                 [](unsigned char c) { return std::toupper(c); });
+  log_string_info("toupper", str);
+
+  /// @brief Trim leading whitespace
+  str = "   Hello World   ";
+  log_string_info("before trim", str);
+
+  str.erase(0, str.find_first_not_of(" \t\n\r"));
+  log_string_info("trim first", str);
+
+  /// @brief Trim trailing whitespace
+  str.erase(str.find_last_not_of(" \t\n\r") + 1);
+  log_string_info("trim last", str);
 }
+
 }  // namespace modify
 
 namespace sub {
+
 void run() {
-  std::string ss = "PhongNguyen";
-  std::cout << "init      : " << ss << '\n';
-  std::string first_name = ss.substr(0, 5);
-  std::cout << "sub     : " << first_name << '\n';
+  LOG("=== sub ===");
+
+  std::string str = "PhongNguyen";
+  log_string_info("init", str);
+
+  /// @brief Extract sub
+  std::string first_name = str.substr(0, 5);
+  log_string_info("substr", first_name);
 }
+
 }  // namespace sub
 
 namespace search {
+
 void run() {
-  std::string ss = "PhongNguyen";
-  std::cout << "init           : " << ss << '\n';
+  LOG("=== search ===");
+
+  std::string str = "PhongNguyen";
+  log_string_info("init", str);
 
-  // find char
-  size_t pos = ss.find('N');
+  /// @brief Find character
+  size_t pos = str.find('N');
   if (pos != std::string::npos) {
-    std::string second_name = ss.substr(pos);  // from pos to end (default)
-    std::cout << "find 'N'       : at " << pos << " -> " << second_name << '\n';
+    std::string last_name = str.substr(pos);
+
+    LOG_S("find('N')" << " | pos=" << pos << " | result=\"" << last_name
+                      << "\"");
   }
 
-  // find substring
-  pos = ss.find("ong");
+  /// @brief Find sub
+  pos = str.find("ong");
   if (pos != std::string::npos) {
-    std::cout << "find \"ong\"    : at " << pos << '\n';
+    LOG_S("find(\"ong\")" << " | pos=" << pos);
   }
 
-  // find last occurrence
-  pos = ss.rfind('n');
+  /// @brief Find last occurrence
+  pos = str.rfind('n');
   if (pos != std::string::npos) {
-    std::cout << "rfind 'n'      : at " << pos << '\n';
+    LOG_S("rfind('n')" << " | pos=" << pos);
   }
 }
+
 }  // namespace search
 
 namespace compare {
+
 void run() {
-  std::string ss1 = "PhongNguyen";
-  std::string ss2 = "PhongNguyen";
+  LOG("=== compare ===");
 
-  int result = ss1.compare(ss2);
+  std::string str1 = "PhongNguyen";
+  std::string str2 = "PhongNguyen";
 
-  std::cout << "compare result : " << result << '\n';
-  std::cout << "equal ?        : " << std::boolalpha << (result == 0) << '\n';
+  /// @brief Compare strings
+  int result = str1.compare(str2);
+  LOG_S("compare result = " << result);
+  LOG_S("equal = " << std::boolalpha << (result == 0));
 }
 
 }  // namespace compare
 
 namespace convert {
+
 void run() {
-  // string -> int
-  std::string sint = "3";
-  int ivalue = std::stoi(sint);
-  std::cout << "stoi           : " << ivalue << '\n';
+  LOG("=== convert ===");
+
+  /// @brief String to integer
+  std::string str_int = "3";
+  int ivalue = std::stoi(str_int);
+  LOG_S("stoi(\"3\") = " << ivalue);
 
-  // string -> double
-  std::string sdouble = "3.3";
-  double dvalue = std::stod(sdouble);
-  std::cout << "stod           : " << std::setprecision(4) << dvalue << '\n';
+  /// @brief String to double
+  std::string str_double = "3.3";
+  double dvalue = std::stod(str_double);
+  LOG_S("stod(\"3.3\") = " << std::setprecision(4) << dvalue);
 
-  // number -> string
+  /// @brief Number to string
   int value = 999;
-  std::string svalue = std::to_string(value);
-  std::cout << "to_string      : " << svalue << '\n';
+  std::string str_value = std::to_string(value);
+  log_string_info("to_string", str_value);
 }
+
 }  // namespace convert
 
 namespace parsing {
+
 void run() {
+  LOG("=== parsing ===");
+
   std::string line = "a,b,c";
-  std::cout << "init      : " << line << '\n';
-  char deli = ',';
+  log_string_info("init", line);
+
+  /// @brief Parse CSV-like string
+  char delimiter = ',';
   std::stringstream ss(line);
   std::string item;
 
-  std::cout << "Parsing with delimiter ',': \n";
-  while (std::getline(ss, item, deli)) {
-    std::cout << item << std::endl;
+  LOG_S("Parsing with delimiter ','");
+  while (std::getline(ss, item, delimiter)) {
+    LOG_S("token = " << item);
   }
 }
+
 }  // namespace parsing
 
 class StdString : public IExample {
@@ -161,6 +215,7 @@ class StdString : public IExample {
   std::string group() const override { return "core/string"; }
   std::string name() const override { return "StdString"; }
   std::string description() const override { return "StdString Example"; }
+
   void execute() override {
     create::run();
     modify::run();
@@ -172,4 +227,4 @@ class StdString : public IExample {
   }
 };
 
-REGISTER_EXAMPLE(StdString);
+REGISTER_EXAMPLE(StdString);
\ No newline at end of file
diff --git a/src/core/string/StringFormatting.cpp b/src/core/string/StringFormatting.cpp
index e8167b7..e82f132 100644
--- a/src/core/string/StringFormatting.cpp
+++ b/src/core/string/StringFormatting.cpp
@@ -1,70 +1,93 @@
 #include <cstdio>
 #include <format>
-#include <iostream>
+#include <iomanip>
 #include <sstream>
 #include <string>
 
 #include "ExampleRegistry.h"
+#include "Logger.h"
+
+namespace {
+
+void log_formatted(const char* method, const std::string& text) {
+  LOG_S(method << ": \"" << text << "\"" << " | size=" << text.size());
+}
+
+}  // namespace
 
 namespace std_format {
+
 void run() {
+  LOG("=== std_format ===");
+
   std::string name{"Phong"};
   int score = 100;
 
-  std::string s =
-      std::format("User {} has {} points, Pi: {:.2f}\n", name, score, 3.14159);
-
-  std::cout << s;
+  /// @brief C++20 std::format
+  std::string str =
+      std::format("User {} has {} points, Pi: {:.2f}", name, score, 3.14159);
+  log_formatted("std::format", str);
 }
+
 }  // namespace std_format
 
 namespace concatenation {
+
 void run() {
+  LOG("=== concatenation ===");
+
   std::string name{"Phong"};
   int score = 100;
 
-  std::string s = "User " + name + " has " + std::to_string(score) +
-                  " points, Pi: " + std::to_string(3.14159) + "\n";
-
-  std::cout << s;
+  /// @brief String concatenation using operator+
+  std::string str = "User " + name + " has " + std::to_string(score) +
+                    " points, Pi: " + std::to_string(3.14159);
+  log_formatted("concatenation", str);
 }
+
 }  // namespace concatenation
 
 namespace stream {
+
 void run() {
+  LOG("=== stream ===");
+
   std::string name{"Phong"};
   int score = 100;
 
+  /// @brief String formatting using stringstream
   std::stringstream ss;
-  ss << "User " << name << " has " << score << " points, Pi: " << 3.14159
-     << "\n";
-
-  std::cout << ss.str();
+  ss << "User " << name << " has " << score << " points, Pi: " << std::fixed
+     << std::setprecision(2) << 3.14159;
+  log_formatted("stringstream", ss.str());
 }
+
 }  // namespace stream
 
 namespace c_style {
+
 void run() {
+  LOG("=== c_style ===");
+
   std::string name{"Phong"};
   int score = 100;
 
+  /// @brief C-style formatting using snprintf
   char buffer[128];
-  std::snprintf(buffer, sizeof(buffer), "User %s has %d points, Pi: %.2f\n",
+  std::snprintf(buffer, sizeof(buffer), "User %s has %d points, Pi: %.2f",
                 name.c_str(), score, 3.14159);
-
-  std::cout << buffer;
+  log_formatted("snprintf", buffer);
 }
+
 }  // namespace c_style
 
 class StringFormatting : public IExample {
  public:
   std::string group() const override { return "core/string"; }
-
   std::string name() const override { return "StringFormatting"; }
-
   std::string description() const override {
-    return "String formatting examples (format, concatenation, stream, "
-           "C-style)";
+    return "String formatting examples "
+           "(std::format, concatenation, stringstream, C-style)";
   }
 
   void execute() override {

From 7d9909e857d960825491aa17d318dfcb797050cc Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 31 May 2026 14:35:25 +0700
Subject: [PATCH 07/18] update

---
 src/core/CMakeLists.txt                       |  31 +--
 src/core/expression/README.md                 |  86 -------
 .../FunctionPointer.cpp                       |  32 +--
 src/core/function/Functional.cpp              |  52 ++++
 src/core/{expression => function}/Lambda.cpp  |  22 +-
 src/core/function/README.md                   | 238 ++++++++++++++++++
 .../AllocationOperator.cpp                    |   2 +-
 .../ArithmeticOperator.cpp                    |   2 +-
 .../AssignmentOperator.cpp                    |  52 ++++
 .../ClassMemberAccessOperator.cpp             |   2 +-
 .../ComparisonOperator.cpp                    |   2 +-
 .../FunctionCallOperator.cpp                  |  37 +++
 .../operator_overloading}/InDecOperator.cpp   |  32 ++-
 .../operator_overloading/StreamOperator.cpp}  |  32 +--
 .../SubscriptOperator.cpp                     |   2 +-
 .../operator_overloading}/TypeCast.cpp        |   2 +-
 .../operator_overloading}/UnaryOperator.cpp   |   2 +-
 src/core/overloading/AssignmentOperator.cpp   |  51 ----
 src/core/overloading/ParenthesisOperator.cpp  |  49 ----
 19 files changed, 469 insertions(+), 259 deletions(-)
 delete mode 100644 src/core/expression/README.md
 rename src/core/{expression => function}/FunctionPointer.cpp (64%)
 create mode 100644 src/core/function/Functional.cpp
 rename src/core/{expression => function}/Lambda.cpp (74%)
 create mode 100644 src/core/function/README.md
 rename src/core/{overloading => function/operator_overloading}/AllocationOperator.cpp (96%)
 rename src/core/{overloading => function/operator_overloading}/ArithmeticOperator.cpp (96%)
 create mode 100644 src/core/function/operator_overloading/AssignmentOperator.cpp
 rename src/core/{overloading => function/operator_overloading}/ClassMemberAccessOperator.cpp (94%)
 rename src/core/{overloading => function/operator_overloading}/ComparisonOperator.cpp (95%)
 create mode 100644 src/core/function/operator_overloading/FunctionCallOperator.cpp
 rename src/core/{overloading => function/operator_overloading}/InDecOperator.cpp (71%)
 rename src/core/{overloading/IOOperator.cpp => function/operator_overloading/StreamOperator.cpp} (65%)
 rename src/core/{overloading => function/operator_overloading}/SubscriptOperator.cpp (93%)
 rename src/core/{overloading => function/operator_overloading}/TypeCast.cpp (94%)
 rename src/core/{overloading => function/operator_overloading}/UnaryOperator.cpp (91%)
 delete mode 100644 src/core/overloading/AssignmentOperator.cpp
 delete mode 100644 src/core/overloading/ParenthesisOperator.cpp

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index a60525a..2cd55ad 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -67,26 +67,27 @@ set(CORE_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/container/sequence/Deque.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/container/associative/Set.cpp
 
-    ${CMAKE_CURRENT_SOURCE_DIR}/expression/Lambda.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/expression/FunctionPointer.cpp
-
     # Smart pointers
     ${CMAKE_CURRENT_SOURCE_DIR}/smart_pointer/Unique.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/smart_pointer/Shared.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/smart_pointer/Weak.cpp
 
-    # Operator overloading
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/ArithmeticOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/IOOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/UnaryOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/ComparisonOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/InDecOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/SubscriptOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/ParenthesisOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/TypeCast.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/AssignmentOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/ClassMemberAccessOperator.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/overloading/AllocationOperator.cpp
+    # Function
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/Lambda.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/FunctionPointer.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/Functional.cpp
+    ## Operator overloading
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/ArithmeticOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/StreamOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/UnaryOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/ComparisonOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/InDecOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/SubscriptOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/FunctionCallOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/TypeCast.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/AssignmentOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/ClassMemberAccessOperator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/function/operator_overloading/AllocationOperator.cpp
 
     # Date and time
     ${CMAKE_CURRENT_SOURCE_DIR}/datetime/Time.cpp
diff --git a/src/core/expression/README.md b/src/core/expression/README.md
deleted file mode 100644
index b31d604..0000000
--- a/src/core/expression/README.md
+++ /dev/null
@@ -1,86 +0,0 @@
-# Theory
-
-## 1. Lambda Expressions
-- In C++11 and later, lambda is a convenient way of defining an anonymous function object right at the location where it's involked or passed as an argument to a function.
-
-- Syntax:
-```cpp
-[=] () mutable throw() -> int
-{
-    int n = x + y;
-    return n;
-}
-
-```
-- `[=]`: capture clause a.k.a lambda introducer
-- `()`: (O) pararam list a.k.a lambda declarator
-- `mutable`: (O)
-- `throw()`: (O)
-- `-> int`: (O) trailing-return-type
-- body
-- `[](){ ... }`defines a lambda
-- `[](){ ... }()` defines and immediately CALLS it
-
-### 1.1 Capture Clause
-- It uses to introduce new variables in its body, specifics which vars are captured, and whether the capture is `by value[=]` or `by reference [&]`. 
-- An empty capture clause `[]` indicates that the body accesses no vars in the enclosing scope.
-- An identifier or `this` cannot appear more than once in a capture scope.
-- Since C++14, we can introduce and initialize new vars in the capture scope.
-- E.g.
-```cpp
-int a{};
-int b{};
-
-auto f = []{    // no capture
-    return 1; 
-}
-
-auto f0 = [a]{   // capture by value
-    return a+1;
-}
-
-auto f1 = [&a]{
-    return a+=1;    // capture by reference (a = 1)
-}
-
-auto f2 = [=]{
-    return a + b; // all capture by value
-}
-
-auto f3 = [&]{
-    a+=1;
-    b+=1;
-    return a + b; // all capture by reference
-}
-
-auto f4 = [int a{}]{    // no capture
-    return a; 
-}
-```
-
-## 2. Function Pointers
-- A function pointer is a pointer variable that stores the address of a function with a specific return type and parameter list.
-- Syntax:
-```cpp
-// Declare
-return_type (*FuncPtr) (parameter type, ....);
-
-// Referencing: Assigning a function’s address to the function pointer.
-FuncPtr = function_name; 
-
-// 3) Dereferencing: Invoking the function using the pointer. The dereference operator * is optional during function calls.
-FuncPtr(10, 20);     // Preferred
-(*FuncPtr)(10, 20); // Also valid
-```
-
-- e.g.
-```cpp
-void print(int a){
-    std::cout << a;
-}
-
-void (*FuncPtr)(int a);
-FuncPtr = print;
-FuncPtr(1);
-```
-
diff --git a/src/core/expression/FunctionPointer.cpp b/src/core/function/FunctionPointer.cpp
similarity index 64%
rename from src/core/expression/FunctionPointer.cpp
rename to src/core/function/FunctionPointer.cpp
index bbc2e09..c50b6b6 100644
--- a/src/core/expression/FunctionPointer.cpp
+++ b/src/core/function/FunctionPointer.cpp
@@ -1,14 +1,16 @@
 #include <algorithm>
-#include <iostream>
 #include <vector>
+#include "Logger.h"
 
 namespace {
 
 int increase(int a, int b) {
+  LOG("");
   return static_cast<int>(a > b);
 }
 
 int decrease(int a, int b) {
+  LOG("");
   return static_cast<int>(a < b);
 }
 
@@ -16,37 +18,39 @@ int decrease(int a, int b) {
 // // Declaring
 // return_type (*FuncPtr) (parameter type, ....);
 // typedef int (*SortFcn)(int a, int b);
-using SortFcn = int (*)(int, int);
 
-void run() {
-  std::vector<int> vect{1, 6, 4, 22, 0, 6, 33, 39, -5};
+/// @brief Function Pointer
+using sort_function_ptr = int (*)(int, int);
 
+void run() {
+  std::vector<int> vect{-1, -6, 4, 2, 0, 6, 3, 9, -5};
   auto f_print = [](const std::vector<int>& vec) {
+    std::ostringstream oss;
     for (const auto& e : vec) {
-      std::cout << e << " ";
+      oss << e << " ";
     }
-    std::cout << "\n";
+    LOG(oss.str());
   };
 
-  std::cout << "Before sorting : \n";
+  LOG("Before sorting : ");
   f_print(vect);
 
-  std::cout << "Sorting in descending " << "order \n";
-
+  LOG("Sorting in descending order");
   // Use auto
   auto sort_type_auto = increase;
   std::sort(vect.begin(), vect.end(), sort_type_auto);
 
   // Use pointer
-  SortFcn sort_type_ptr = decrease;
+  sort_function_ptr sort_type_ptr = decrease;
   f_print(vect);
 
-  std::cout << "Sorting with absolute " << "value as parameter\n ";
+  LOG("Sorting with absolute value as parameter");
   std::sort(vect.begin(), vect.end(), sort_type_ptr);
 
+  std::ostringstream oss;
   for (auto i : vect)
-    std::cout << i << " ";
-  std::cout << "\n";
+    oss << i << " ";
+  LOG(oss.str());
 }
 }  // namespace
 
@@ -54,7 +58,7 @@ void run() {
 
 class FunctionPointer : public IExample {
  public:
-  std::string group() const override { return "core/expression"; }
+  std::string group() const override { return "core/function"; }
   std::string name() const override { return "FunctionPointer"; }
   std::string description() const override {
     return "Function Pointer Example";
diff --git a/src/core/function/Functional.cpp b/src/core/function/Functional.cpp
new file mode 100644
index 0000000..1c59db8
--- /dev/null
+++ b/src/core/function/Functional.cpp
@@ -0,0 +1,52 @@
+#include <functional>
+#include "Logger.h"
+
+namespace {
+// Functions for simple math operations
+int add(int a, int b) {
+  LOG("");
+  return a + b;
+}
+int sub(int a, int b) {
+  LOG("");
+  return a - b;
+}
+int mul(int a, int b) {
+  LOG("");
+  return a * b;
+}
+int divs(int a, int b) {
+  LOG("");
+  return a / b;
+}
+
+void func(int a, int b, const std::function<int(int, int)>& calc) {
+  if (!calc) {
+    LOG("No function provided");
+    return;
+  }
+
+  int result = calc(a, b);
+  LOG_S(result);
+}
+
+void run() {
+  func(8, 2, add);
+  func(8, 2, sub);
+  func(8, 2, mul);
+  func(8, 2, divs);
+  func(8, 2, [](int a, int b) { return a % b; });  // 0
+}
+}  // namespace
+
+#include "ExampleRegistry.h"
+
+class Functional : public IExample {
+ public:
+  std::string group() const override { return "core/function"; }
+  std::string name() const override { return "Functional"; }
+  std::string description() const override { return "Functional Example"; }
+  void execute() override { run(); }
+};
+
+REGISTER_EXAMPLE(Functional);
diff --git a/src/core/expression/Lambda.cpp b/src/core/function/Lambda.cpp
similarity index 74%
rename from src/core/expression/Lambda.cpp
rename to src/core/function/Lambda.cpp
index 47e5064..63aee7e 100644
--- a/src/core/expression/Lambda.cpp
+++ b/src/core/function/Lambda.cpp
@@ -5,34 +5,36 @@
 // custom (2)
 // template <class RandomAccessIterator, class Compare>  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
 
-#include <iostream>
+#include <sstream>
 #include <vector>
+#include "Logger.h"
 
 namespace {
 void run() {
   std::vector<int> vect{-1, -6, 4, 2, 0, 6, 3, 9, -5};
-
   auto f_print = [](const std::vector<int>& vec) {
+    std::ostringstream oss;
     for (const auto& e : vec) {
-      std::cout << e << " ";
+      oss << e << " ";
     }
-    std::cout << "\n";
+    LOG(oss.str());
   };
 
-  std::cout << "Before sorting : \n";
+  LOG("Before sorting : ");
   f_print(vect);
 
-  std::cout << "Sorting in descending " << "order \n";
+  LOG("Sorting in descending order");
   std::sort(vect.begin(), vect.end(), [](int a, int b) { return a > b; });
 
   f_print(vect);
 
-  std::cout << "Sorting with absolute " << "value as parameter\n ";
+  LOG("Sorting with absolute value as parameter");
   std::sort(vect.begin(), vect.end(), [](int a, int b) { return a < b; });
 
+  std::ostringstream oss;
   for (auto i : vect)
-    std::cout << i << " ";
-  std::cout << "\n";
+    oss << i << " ";
+  LOG(oss.str());
 }
 }  // namespace
 
@@ -40,7 +42,7 @@ void run() {
 
 class Lambda : public IExample {
  public:
-  std::string group() const override { return "core/expression"; }
+  std::string group() const override { return "core/function"; }
   std::string name() const override { return "Lambda"; }
   std::string description() const override {
     return "Lambda Expression Example";
diff --git a/src/core/function/README.md b/src/core/function/README.md
new file mode 100644
index 0000000..62eaba6
--- /dev/null
+++ b/src/core/function/README.md
@@ -0,0 +1,238 @@
+
+---
+# Functions
+Functions are self-contained blocks of code designed to perform specific tasks. They promote code reusability, modularity, and abstraction.
+Functions can participate in polymorphism through:
+- **Compile-time polymorphism (Static Polymorphism)**
+  - Function overloading
+  - Operator overloading
+  - Function templates
+- **Runtime polymorphism**
+  - Virtual functions
+
+---
+## 1. Function Overloading
+- `function overloading` allows us to create multiple functions with the same name, so long as each identically named function has different parameter types/numbers.  Return types are not considered for 
+- `function delete` using `delete` keyword. delete means "I forbid this", not "this doesn’t exist". 
+- `default-arguments`: is a default value provided for a function parameter. Parameters with default arguments must always be the rightmost parameters, and they are not used to differentiate functions when resolving overloaded functions.
+```cpp
+void printInt(int x)
+{
+    std::cout << x << '\n';
+}
+
+void printIntOrDefault(int x, int y = 2)
+{
+    std::cout << x << ", " << y << '\n';
+}
+
+template <typename T>
+void printInt(T) = delete;
+
+int main()
+{
+    printInt(97);             // okay
+
+    // printInt('a');         // compile error
+    // printInt(true);        // compile error
+
+    printIntOrDefault(5);     // prints: 5, 2
+    printIntOrDefault(5, 10); // prints: 5, 10
+
+    return 0;
+}
+```
+
+---
+## 2. Operator Overloading
+
+- **Operator overloading** allows C++ operators to be customized for user-defined types.
+- An overloaded operator is implemented as a special function called an **operator function**.
+
+- Operator Function Names:
+    ```cpp
+    operator op
+
+    operator new
+    operator new[]
+    operator delete
+    operator delete[]
+
+    operator co_await // C++20
+    ```
+
+- Operator Syntax:
+    | Expression | Member Function      | Non-member Function | Example                                             |
+    | ---------- | -------------------- | ------------------- | --------------------------------------------------- |
+    | `@a`       | `a.operator@()`      | `operator@(a)`      | `!a` calls `a.operator!()`                          |
+    | `a@b`      | `a.operator@(b)`     | `operator@(a, b)`   | `std::cout << 42` calls  `std::cout.operator<<(42)` |
+    | `a=b`      | `a.operator=(b)`     | N/A                 | `s = "abc"` calls `s.operator=("abc")`              |
+    | `a(b...)`  | `a.operator()(b...)` | N/A                 | `r(1)` calls `r.operator()(1)`                      |
+    | `a[b]`     | `a.operator[](b)`    | N/A                 | `m[1]` calls `m.operator[](1)`                      |
+    | `a->`      | `a.operator->()`     | N/A                 | `p->do()` calls `p.operator->()`                    |
+    | `a@`       | `a.operator@(0)`     | `operator@(a, 0)`   | `i++` calls `i.operator++(0)`                       |
+
+- Restrictions:
+    The following operators **cannot be overloaded**:
+        ```cpp
+        ::   // scope resolution
+        .    // member access
+        .*   // member access through pointer-to-member
+        ?:   // conditional operator
+        ```
+    - New operators cannot be created.
+    - Operators such as `**`, `<>`, or `&|` are invalid.
+    - At least one operand must be a user-defined type.
+    - Overloading does not change an operator's precedence, associativity, or number of operands.
+
+
+#### Assignment Operator (`=`)
+- Return the lhs by reference
+```cpp
+// copy assignment
+T& operator=(const T& other)
+{
+    // Guard self assignment
+    if (this == &other)
+        return *this;
+    
+    // 
+    
+    return *this;
+}
+
+// move assignment
+T& operator=(T&& other) noexcept
+{
+    // Guard self assignment
+    if (this == &other)
+        return *this; // delete[]/size=0 would also be ok
+    
+    //
+
+    return *this;
+}
+```
+
+#### Stream Extraction and Insertion (`>>`, `<<`)
+- Must be implemented as non-members cause that take a `std::istream&` or `std::ostream&` as the left hand argument `std::cout << a; std::cout.operator << (a)`
+```cpp
+std::ostream& operator<<(std::ostream& os, const T& obj)
+{
+    // write obj to stream
+    return os;
+}
+
+std::istream& operator>>(std::istream& is, T& obj)
+{
+    // read obj from stream
+    if (/* T could not be constructed */)
+        is.setstate(std::ios::failbit);
+    return is;
+}
+```
+
+#### Function Call Operator (`()`)
+
+#### Increment and Decrement (`++`, `--`)
+
+#### Binary Arithmetic Operators (`+`, `-`, `*`, `/`)
+
+#### Comparison Operators (`==`, `!=`, `<`, `>`, `<=`, `>=`)
+
+#### Array Subscript Operator (`[]`)
+
+#### Bitwise Operators (`&`, `|`, `^`, `~`, `<<`, `>>`)
+
+#### Boolean Negation Operator (`!`)
+
+---
+## 3. Lambda
+- In C++11 and later, lambda is a convenient way of defining an anonymous function object right at the location where it's involked or passed as an argument to a function.
+
+- Syntax:
+    ```cpp
+    [=] () mutable throw() -> int
+    {
+        int n = x + y;
+        return n;
+    }
+
+    ```
+  - `[=]`: capture clause a.k.a lambda introducer
+  - `()`: *(Optional)* pararam list a.k.a lambda declarator
+  - `mutable`: *(Optional)*
+  - `throw()`: *(Optional)*
+  - `-> int`: *(Optional)* trailing-return-type
+  - `[](){ ... }` defines a lambda
+  - `[](){ ... }()` defines and immediately CALLS it
+
+### Capture Clause
+- It uses to introduce new variables in its body, specifics which vars are captured, and whether the capture is `by value[=]` or `by reference [&]`. 
+- An empty capture clause `[]` indicates that the body accesses no vars in the enclosing scope.
+- An identifier or `this` cannot appear more than once in a capture scope.
+- Since C++14, we can introduce and initialize new vars in the capture scope.
+- e.g.
+    ```cpp
+    int a{};
+    int b{};
+
+    auto f = []{    // no capture
+        return 1; 
+    }
+
+    auto f0 = [a]{   // capture by value
+        return a+1;
+    }
+
+    auto f1 = [&a]{
+        return a+=1;    // capture by reference (a = 1)
+    }
+
+    auto f2 = [=]{
+        return a + b; // all capture by value
+    }
+
+    auto f3 = [&]{
+        a+=1;
+        b+=1;
+        return a + b; // all capture by reference
+    }
+
+    auto f4 = [int a{}]{    // no capture
+        return a; 
+    }
+    ```
+
+---
+## 4. Function Pointers
+- A function pointer is a pointer variable that stores the address of a function with a specific return type and parameter list.
+- Syntax: `return_type (*FuncPtr) (parameter type, ....);`
+```cpp
+// @brief Declaration
+rtype (*FuncPtr) (atype..);
+
+// @brief Referencing: Assigning a function’s address to the function pointer.
+FuncPtr = function_name; 
+
+// @brief Dereferencing: Invoking the function using the pointer. The dereference operator * is optional during function calls.
+FuncPtr(10, 20);     // Preferred
+(*FuncPtr)(10, 20); // Also valid
+```
+
+---
+## 5. **`<functional>`**
+- `std::function` is a general-purpose polymorphic function wrapper introduced in C++11.
+  - It can store and invoke any callable object:
+    - Functions
+    - Lambda expressions
+    - Functors (objects that overload `operator()`)
+    - Member functions (with binding)
+  - It provides a common interface for different callable types.
+  - Commonly used for callbacks, event handling, task dispatching, and functional-style programming.
+  - Improves code flexibility, reusability, and maintainability.
+
+- Syntax: `std::function<rtype(atype..)> name()` / `std::function< ret_t (args_t)> name = f;` / `std::function< ret_t (args_t)> name(f);`
+
+
+---
\ No newline at end of file
diff --git a/src/core/overloading/AllocationOperator.cpp b/src/core/function/operator_overloading/AllocationOperator.cpp
similarity index 96%
rename from src/core/overloading/AllocationOperator.cpp
rename to src/core/function/operator_overloading/AllocationOperator.cpp
index c599e9f..d2c44e3 100644
--- a/src/core/overloading/AllocationOperator.cpp
+++ b/src/core/function/operator_overloading/AllocationOperator.cpp
@@ -89,7 +89,7 @@ void run() {
 
 class AllocationOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "AllocationOperator"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/overloading/ArithmeticOperator.cpp b/src/core/function/operator_overloading/ArithmeticOperator.cpp
similarity index 96%
rename from src/core/overloading/ArithmeticOperator.cpp
rename to src/core/function/operator_overloading/ArithmeticOperator.cpp
index 9997921..dd5080d 100644
--- a/src/core/overloading/ArithmeticOperator.cpp
+++ b/src/core/function/operator_overloading/ArithmeticOperator.cpp
@@ -72,7 +72,7 @@ void run() {
 
 class ArithmeticOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "ArithmeticOperator"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/function/operator_overloading/AssignmentOperator.cpp b/src/core/function/operator_overloading/AssignmentOperator.cpp
new file mode 100644
index 0000000..65f85f5
--- /dev/null
+++ b/src/core/function/operator_overloading/AssignmentOperator.cpp
@@ -0,0 +1,52 @@
+// cppcheck-suppress-file [unreadVariable]
+
+// Overloading operator=
+
+#include "ExampleRegistry.h"
+#include "Logger.h"
+
+namespace {
+class Cents {
+ public:
+  explicit Cents(int cents = 0) : cent_{cents} {}
+
+  /// @brief Copy constructor
+  Cents(const Cents& other) {
+    LOG("");
+    cent_ = other.cent_;
+  }
+
+  /// @brief Copy assignment
+  Cents& operator=(const Cents& cents) {
+    // do the copy
+    LOG("");
+    cent_ = cents.cent_;
+    return *this;
+  }
+
+ private:
+  int cent_;
+};
+
+void run() {
+  Cents c1(100);  
+  Cents c2;
+  
+  LOG("c2 = c1;");
+  c2 = c1;        // c2.operator=(c1)
+
+  LOG("Cents c3 = c1;");
+  Cents c3 = c1;  // c3(c1)
+}
+}  // namespace
+
+class AssignmentOperator : public IExample {
+ public:
+  std::string group() const override { return "core/overloading_operator"; }
+  std::string name() const override { return "Assignment Operator"; }
+  std::string description() const override { return ""; }
+
+  void execute() override { run(); }
+};
+
+REGISTER_EXAMPLE(AssignmentOperator);
\ No newline at end of file
diff --git a/src/core/overloading/ClassMemberAccessOperator.cpp b/src/core/function/operator_overloading/ClassMemberAccessOperator.cpp
similarity index 94%
rename from src/core/overloading/ClassMemberAccessOperator.cpp
rename to src/core/function/operator_overloading/ClassMemberAccessOperator.cpp
index 70c7fa1..6147732 100644
--- a/src/core/overloading/ClassMemberAccessOperator.cpp
+++ b/src/core/function/operator_overloading/ClassMemberAccessOperator.cpp
@@ -54,7 +54,7 @@ void run() {
 
 class ClassMemberAccessOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "ClassMemberAccessOperator"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/overloading/ComparisonOperator.cpp b/src/core/function/operator_overloading/ComparisonOperator.cpp
similarity index 95%
rename from src/core/overloading/ComparisonOperator.cpp
rename to src/core/function/operator_overloading/ComparisonOperator.cpp
index f69d79d..ac77598 100644
--- a/src/core/overloading/ComparisonOperator.cpp
+++ b/src/core/function/operator_overloading/ComparisonOperator.cpp
@@ -37,7 +37,7 @@ void run() {
 
 class ComparisonOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "ComparisonOperator"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/function/operator_overloading/FunctionCallOperator.cpp b/src/core/function/operator_overloading/FunctionCallOperator.cpp
new file mode 100644
index 0000000..fe3b4d0
--- /dev/null
+++ b/src/core/function/operator_overloading/FunctionCallOperator.cpp
@@ -0,0 +1,37 @@
+// cppcheck-suppress-file []
+
+// operator()
+
+#include <iostream>
+#include "ExampleRegistry.h"
+#include "Logger.h"
+
+namespace {
+#include <cassert>  // for assert()
+
+struct Linear {
+  double a, b;
+
+  double operator()(double x) const {
+    LOG("");
+    return a * x + b;
+  }
+};
+
+void run() {
+  Linear f{2, 1};  // Represents function 2x + 1.
+  double f_0 = f(0);
+  LOG_S(f_0);
+}
+}  // namespace
+
+class FunctionCallOperator : public IExample {
+ public:
+  std::string group() const override { return "core/overloading_operator"; }
+  std::string name() const override { return "FunctionCallOperator"; }
+  std::string description() const override { return ""; }
+
+  void execute() override { run(); }
+};
+
+REGISTER_EXAMPLE(FunctionCallOperator);
\ No newline at end of file
diff --git a/src/core/overloading/InDecOperator.cpp b/src/core/function/operator_overloading/InDecOperator.cpp
similarity index 71%
rename from src/core/overloading/InDecOperator.cpp
rename to src/core/function/operator_overloading/InDecOperator.cpp
index f093340..f5f284e 100644
--- a/src/core/overloading/InDecOperator.cpp
+++ b/src/core/function/operator_overloading/InDecOperator.cpp
@@ -1,17 +1,14 @@
 // cppcheck-suppress-file [postfixOperator]
 
 // prefix/posfix
-#include <iostream>
 #include "ExampleRegistry.h"
+#include "Logger.h"
 
 namespace {
 class Cents {
- private:
-  int m_cents_{};
-
  public:
-  explicit Cents(int cents) : m_cents_{cents} {}
-  int getCents() const { return m_cents_; }
+  explicit Cents(int cents) : cents_{cents} {}
+  int getCents() const { return cents_; }
 
   // pre: inc -> return new
   Cents& operator++();
@@ -20,25 +17,36 @@ class Cents {
   // return old -> inc
   Cents operator++(int);
   Cents operator--(int);
+
+ private:
+  int cents_{};
 };
 
-// pre ++x/--x
+/// @brief pre ++x
 Cents& Cents::operator++() {
-  ++m_cents_;
+  LOG("");
+  ++cents_;
   return *this;
 }
+
+/// @brief pre ++x
 Cents& Cents::operator--() {
-  --m_cents_;
+  LOG("");
+  --cents_;
   return *this;
 }
 
-// pos x++/x--
+/// @brief pos x++
 Cents Cents::operator++(int) {
+  LOG("");
   Cents temp{*this};  // create copy
   ++(*this);          // increase origin
   return temp;        // return old
 }
+
+/// @brief pos x--
 Cents Cents::operator--(int) {
+  LOG("");
   Cents temp{*this};
   --(*this);
   return temp;
@@ -50,13 +58,13 @@ void run() {
   ++cent;
   cent--;
   --cent;
-  std::cout << cent.getCents() << "\n";
+  LOG_S(cent.getCents());
 }
 }  // namespace
 
 class InDecOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "InDecOperator"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/overloading/IOOperator.cpp b/src/core/function/operator_overloading/StreamOperator.cpp
similarity index 65%
rename from src/core/overloading/IOOperator.cpp
rename to src/core/function/operator_overloading/StreamOperator.cpp
index 3ef19f2..905dd31 100644
--- a/src/core/overloading/IOOperator.cpp
+++ b/src/core/function/operator_overloading/StreamOperator.cpp
@@ -1,17 +1,14 @@
 // cppcheck-suppress-file[]
 
-// >> <<
-#include <iostream>
+// operator>> and operator<<
 #include "ExampleRegistry.h"
+#include "Logger.h"
 
 namespace {
 class Cents {
- private:
-  int m_cents_{};
-
  public:
-  explicit Cents(int cents) : m_cents_{cents} {}
-  int getCents() const { return m_cents_; }
+  explicit Cents(int cents) : cents_{cents} {}
+  int getCents() const { return cents_; }
 
   //   // We won’t be able to use a member overload if the left operand is either not a class (e.g. int),
   //   // or it is a class that we can’t modify (e.g. std::ostream).
@@ -21,14 +18,21 @@ class Cents {
   //     out << m_cents;
   //     return out;
   //   }
+
+ private:
+  int cents_{};
 };
 
+/// @brief Write obj to stream
 std::ostream& operator<<(std::ostream& out, const Cents& c) {
+  LOG("");
   out << c.getCents();
   return out;
 }
 
+/// @brief Read obj from stream
 std::istream& operator>>(std::istream& in, Cents& c) {
+  LOG("");
   int cents{};
   in >> cents;
   c = in ? Cents{cents} : Cents{0};
@@ -38,12 +42,10 @@ std::istream& operator>>(std::istream& in, Cents& c) {
 void run() {
   Cents c1{25};
   // out >>
-  std::cout
-      << c1
-      << "\n";  // operator<<(std::cout, c1) -> operator<<(std::ostream,Cents)
+  std::cout << c1 << "\n";
 
   // in >>
-  std::cin >> c1;  // operator>>(std::cin,c1) -> operator<<(std::istream,Cents)
+  std::cin >> c1;
   std::cout << c1 << "\n";
 
   // clearing lefover newline
@@ -52,13 +54,13 @@ void run() {
 }
 }  // namespace
 
-class IOOperator : public IExample {
+class StreamOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
-  std::string name() const override { return "IOOperator"; }
+  std::string group() const override { return "core/overloading_operator"; }
+  std::string name() const override { return "StreamOperator"; }
   std::string description() const override { return ""; }
 
   void execute() override { run(); }
 };
 
-REGISTER_EXAMPLE(IOOperator);
\ No newline at end of file
+REGISTER_EXAMPLE(StreamOperator);
\ No newline at end of file
diff --git a/src/core/overloading/SubscriptOperator.cpp b/src/core/function/operator_overloading/SubscriptOperator.cpp
similarity index 93%
rename from src/core/overloading/SubscriptOperator.cpp
rename to src/core/function/operator_overloading/SubscriptOperator.cpp
index e2105e2..06e74a8 100644
--- a/src/core/overloading/SubscriptOperator.cpp
+++ b/src/core/function/operator_overloading/SubscriptOperator.cpp
@@ -34,7 +34,7 @@ void run() {
 
 class SubscriptOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "SubscriptOperator"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/overloading/TypeCast.cpp b/src/core/function/operator_overloading/TypeCast.cpp
similarity index 94%
rename from src/core/overloading/TypeCast.cpp
rename to src/core/function/operator_overloading/TypeCast.cpp
index eb1d677..7ac3233 100644
--- a/src/core/overloading/TypeCast.cpp
+++ b/src/core/function/operator_overloading/TypeCast.cpp
@@ -51,7 +51,7 @@ void run() {
 
 class TypeCast : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "TypeCast"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/overloading/UnaryOperator.cpp b/src/core/function/operator_overloading/UnaryOperator.cpp
similarity index 91%
rename from src/core/overloading/UnaryOperator.cpp
rename to src/core/function/operator_overloading/UnaryOperator.cpp
index a7322b4..020ccf4 100644
--- a/src/core/overloading/UnaryOperator.cpp
+++ b/src/core/function/operator_overloading/UnaryOperator.cpp
@@ -31,7 +31,7 @@ void run() {
 
 class UnaryOperator : public IExample {
  public:
-  std::string group() const override { return "core/overloading"; }
+  std::string group() const override { return "core/overloading_operator"; }
   std::string name() const override { return "UnaryOperator"; }
   std::string description() const override { return ""; }
 
diff --git a/src/core/overloading/AssignmentOperator.cpp b/src/core/overloading/AssignmentOperator.cpp
deleted file mode 100644
index e0c60e7..0000000
--- a/src/core/overloading/AssignmentOperator.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// cppcheck-suppress-file [unreadVariable]
-
-// Overloading operator=
-
-#include <iostream>
-#include "ExampleRegistry.h"
-
-namespace {
-class Cents {
- private:
-  int m_cents_{};
-
- public:
-  explicit Cents(int cents = 0) : m_cents_{cents} {}
-
-  int getCents() const { return m_cents_; }
-  void setCents(int cents) { m_cents_ = cents; }
-
-  // Copy constructor
-  Cents(const Cents& other) {
-    std::cout << "Cents(const Cents& other)\n";
-    m_cents_ = other.m_cents_;
-  }
-
-  // Overload copy assignment
-  Cents& operator=(const Cents& cents) {
-    // do the copy
-    std::cout << "Cents& operator=(const Cents& cents)\n";
-    m_cents_ = cents.m_cents_;
-    return *this;
-  }
-};
-
-void run() {
-  Cents c1{100};
-  Cents c2;
-  c2 = c1;        // calls overloaded copy assignment
-  Cents c3 = c1;  // calls copy constructor because c3 didn't exist yet
-}
-}  // namespace
-
-class AssignmentOperator : public IExample {
- public:
-  std::string group() const override { return "core/overloading"; }
-  std::string name() const override { return "AssignmentOperator"; }
-  std::string description() const override { return ""; }
-
-  void execute() override { run(); }
-};
-
-REGISTER_EXAMPLE(AssignmentOperator);
\ No newline at end of file
diff --git a/src/core/overloading/ParenthesisOperator.cpp b/src/core/overloading/ParenthesisOperator.cpp
deleted file mode 100644
index acf133c..0000000
--- a/src/core/overloading/ParenthesisOperator.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-// cppcheck-suppress-file []
-
-// operator()
-#include <iostream>
-#include "ExampleRegistry.h"
-
-namespace {
-#include <cassert>  // for assert()
-
-class Matrix {
- private:
-  double m_data_[4][4]{};
-
- public:
-  double& operator()(int row, int col);
-  double operator()(int row, int col) const;  // for const objects
-};
-
-double& Matrix::operator()(int row, int col) {
-  assert(row >= 0 && row < 4);
-  assert(col >= 0 && col < 4);
-
-  return m_data_[row][col];
-}
-
-double Matrix::operator()(int row, int col) const {
-  assert(row >= 0 && row < 4);
-  assert(col >= 0 && col < 4);
-
-  return m_data_[row][col];
-}
-
-void run() {
-  Matrix matrix;
-  matrix(1, 2) = 4.5;
-  std::cout << matrix(1, 2) << '\n';
-}
-}  // namespace
-
-class ParenthesisOperator : public IExample {
- public:
-  std::string group() const override { return "core/overloading"; }
-  std::string name() const override { return "ParenthesisOperator"; }
-  std::string description() const override { return ""; }
-
-  void execute() override { run(); }
-};
-
-REGISTER_EXAMPLE(ParenthesisOperator);
\ No newline at end of file

From c3adeb9b95c0bf3ab9fea438fb9f49c3328b25c2 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sat, 6 Jun 2026 23:16:01 +0700
Subject: [PATCH 08/18] Add an example

---
 src/embedded/README.md      | 261 ++++++++++++++++++++++++++++++++++++
 src/embedded/main.c         |  75 +++++++++++
 src/embedded/run.sh         |  61 +++++++++
 src/embedded/startup.c      |  78 +++++++++++
 src/embedded/stm32_flash.ld |  70 ++++++++++
 5 files changed, 545 insertions(+)
 create mode 100644 src/embedded/README.md
 create mode 100644 src/embedded/main.c
 create mode 100755 src/embedded/run.sh
 create mode 100644 src/embedded/startup.c
 create mode 100644 src/embedded/stm32_flash.ld

diff --git a/src/embedded/README.md b/src/embedded/README.md
new file mode 100644
index 0000000..e8fed9a
--- /dev/null
+++ b/src/embedded/README.md
@@ -0,0 +1,261 @@
+# Embedded Bare-Metal: Build, Link, Boot, and Debug
+#### Env
+```bash
+$ sudo apt install gcc-arm-none-eabi
+$ apt-get install qemu-system
+```
+
+## 1. Building Process
+```bash
+#Sources files      #Toolchain                 #Object files
++-----------+       +------------------+       +-----------+
+| startup.c | ----> |                  | ----> | startup.o |
++-----------+       | arm-none-eabi-gcc|       +-----------+
+                    |                  |
++-----------+ ----> |                  | ----> +-----------+
+|  main.c   |       +------------------+       |  main.o   |
++-----------+                                  +-----------+
+                                                      |
+#Linker script                                        |
++------------------+                                  |
+| linker_script.ld | ---------------------------------+
++------------------+                                  |
+                                                      v
+                                            +----------------+
+                                            |arm-none-eabi-ld| #Linker
+                                            +----------------+
+                                                      |
+                                                      v
+                                            +----------------+
+                                            |   blink.elf    | #Executable
+                                            +----------------+
+```
+### 1.1. Compiler
+A compiler is a software program that translates source code written in a high-level programming language into a lower-level form, such as assembly code, object code, or machine code, while preserving the program's functionality.
+```bash
+$ gcc # native
+$ g++
+$ clang
+$ arm-none-eabi-gcc # cross
+$ aarch64-none-elf-gcc
+```
+
+### 1.2. Cross Compiler
+A cross compiler is a compiler that runs on one platform (host) but generates executable code for a different platform (target).
+An ARM cross compiler can run on a Linux PC and generate binaries that execute on an ARM-based embedded system.
+```bash
+$ arm-none-eabi-gcc
+$ aarch64-none-elf-gcc
+```
+
+### 1.3. Toolchain
+A toolchain is a collection of software development tools used to build, debug, and analyze software.
+A typical embedded ARM toolchain includes:
+```bash
+$ arm-none-eabi-gcc      # Compiler
+$ arm-none-eabi-as       # Assembler
+$ arm-none-eabi-ld       # Linker
+$ arm-none-eabi-objcopy  # ELF to BIN converter
+$ arm-none-eabi-gdb      # Debugger
+```
+
+`$ qemu-system-arm -M stm32vldiscovery -kernel firmware.bin`
+### 1.4. Linker Script
+**Linker Script** is a configuration file that tells the linker how to place the program into the mcu memory.
+- Define the memory layout: Flash, RAM, Stack, Heap
+- Specify available memory regions
+- Place the code/data in the correct memory location
+- Set the program entry point
+- Optimize memory usage
+  
+Reference: https://sourceware.org/binutils/docs/ld/Scripts.html
+
+#### Concept
+The linker combines multiple object files into a single executable file.
+Object files are stored in a special format called an `object file format` (such as ELF). Each object file contains several `sections`, and each section has a name and a size (e.g., .text, .data, .bss).
+For each loadable output section, the linker defines two addresses:
+- VMA (Virtual Memory Address): The address where the section will reside when the program is running.
+- LMA (Load Memory Address): The address from which the section is loaded at startup.
+
+#### Format
+- Linker scripts are text files. e.g. `stm32_flash.ld`
+- Whitespace is generally ignored.
+- Include comments in linker scripts just as in C
+
+#### Example
+The simplest possible linker script has just one command: `SECTION` to describe the memory layout of the output file.
+
+```ld
+/*stm32_flash.ld*/
+SECTIONS
+{
+    . = 0x10000; # the code should be loaded at address 0x10000
+    .text : { *(.text)}
+    . = 0x8000000; # that the data should start at address 0x8000000
+    .data : { *{.data}}
+    .bss : { *(.bss) }
+}
+```
+- Symbols:
+  - `.`: location counter
+  - `.text`, `.data`, and `.bss` are the sections of the output file
+  - `*(.text)` means all `.text` input sections in all input files.
+
+### 1.5. Startup Code
+A microcontroller does not start executing from `main()` after power-up or reset. Instead, it begins execution at the reset vector, which points to the startup code (typically `Reset_Handler`).
+- Setting initial data values in SRAM, for global variables for example.
+- Zero initialization of data memory for variables that are uninitialized at load time.
+- Initializing the data variables controlling heap memory, for malloc() for example.
+- Performing any required system initialization.
+- Calling main().
+
+---
+### 2. Flashing Process
+```bash
+
+                                            +----------------+
+                                            |   blink.elf    | #Executable
+                                            +----------------+
+                                                      |
+                                                      v
+                                            +----------------+
+                                            |    OpenOCD     | #Tool to download/Debug
+                                            +----------------+
+                                                      |
+                                                      v
+                                            +----------------+
+                                            |    ST-LINK     | #Debug probe
+                                            +----------------+
+                                                      |
+                                                      v
+                +--------------------------------------------------+
+                |                   STM32 FLASH                    |
+                |--------------------------------------------------|
+                | .isr_vector                                      |
+                | .text                                            |
+                | .rodata                                          |
+                | Initial .data image                              |
+                +--------------------------------------------------+
+                                      |
+                                      | RESET
+                                      v
+                            +---------------------+
+                            |   Reset_Handler()   |
+                            +---------------------+
+                                      |
+                                      +----------------------+
+                                      | Copy .data           |
+                                      | Flash --> SRAM       |
+                                      v
+                +--------------------------------------------------+
+                |                    STM32 SRAM                    |
+                |--------------------------------------------------|
+                | .data                                            |
+                | .bss   <-- zero-filled                           |
+                |                                                  |
+                | Heap (optional)                                  |
+                |                                                  |
+                | Stack (grows downward)                           |
+                +--------------------------------------------------+
+                                      |
+                                      v
+                                 +---------+
+                                 | main()  |
+                                 +---------+
+                                      |
+                                      v
+                              #Application Runs#
+```
+
+### 2.1. Build executable
+Compile the source files and link them into the `firmware.elf`
+```bash
+$ arm-none-eabi-gcc \
+    -mcpu=cortex-m3 \
+    -mthumb \
+    -nostdlib \
+    -ffreestanding \
+    startup.c main.c \
+    -T stm32_flash.ld \
+    -Wl,-Map=firmware.map \
+    -o build/firmware.elf
+```
+- **Options:**
+    - `-mcpu=cortex-m3` : Generate code for the ARM Cortex-M3 processor.
+    - `-mthumb `: Use the Thumb instruction set.
+    - `-nostdlib` : Do not link the standard C runtime libraries.
+    - `-ffreestanding` : Compile for a freestanding environment (bare-metal system).
+    - `-T stm32_flash.ld` : Use the specified linker script.
+    - `-Wl,-Map=firmware.map` : Generate a linker map file.
+    - `-o build/firmware.elf` : Output executable file.
+- **ELF file** does include symbol tables, debug information, or other metadata.
+### 2.2. Generate a Binary Image
+Convert the ELF executable into a raw binary image that contains only the program data that will be stored in Flash memory.
+```bash
+$ arm-none-eabi-objcopy \
+    -O binary \
+    build/firmware.elf \
+    build/firmware.bin
+```
+
+### 2.3. Boot and Debug with QEMU
+QEMU can emulate the `STM32VLDISCOVERY` board and load firmware
+#### Start QEMU
+```bash
+$ qemu-system-arm \
+    -M stm32vldiscovery \
+    -kernel firmware.bin
+```
+
+### Connect with GDB
+- Launch QEMU and wait for a debugger connection:
+    ```bash
+    $ qemu-system-arm \
+        -M stm32vldiscovery \
+        -kernel firmware.elf \
+        -nographic \
+        -S \
+        -gdb tcp::1234
+    ```
+  - **Options:**
+      `-M stm32vldiscovery` : Emulate the STM32VLDISCOVERY board.
+      `-kernel firmware.elf` : Load the firmware image.
+      `-nographic` : Disable graphical output and use the terminal.
+      `-S` : Pause the CPU at reset.
+      `-gdb tcp::1234` : Start a GDB server on port 1234.
+
+- Start GDB using the ELF file so that symbol and debug information are available:
+    ```bash
+    $ arm-none-eabi-gdb firmware.elf
+    ```
+- Connect to the QEMU GDB server:
+    ```bash
+    target remote :1234
+    ```
+
+- **Useful commands:**
+```bash
+monitor reset     # Reset the emulated target
+load              # Load firmware into target memory
+continue          # Start execution
+
+p counter   # Inspect variables and symbols
+
+break main # set breakpoints
+continue
+```
+
+### Quit QEMU
+When running QEMU with `-nographic`, use:
+```text
+Ctrl + A, then X
+
+to exit the emulator.
+
+Other useful shortcuts:
+Ctrl + A, then C    Open QEMU monitor
+Ctrl + A, then H    Show help
+Ctrl + A, then X    Exit QEMU
+```
+
+---
\ No newline at end of file
diff --git a/src/embedded/main.c b/src/embedded/main.c
new file mode 100644
index 0000000..e353ce8
--- /dev/null
+++ b/src/embedded/main.c
@@ -0,0 +1,75 @@
+#include <stdint.h>
+
+#define SYST_CSR (*(volatile uint32_t*)0xE000E010)
+#define SYST_RVR (*(volatile uint32_t*)0xE000E014)
+#define SYST_CVR (*(volatile uint32_t*)0xE000E018)
+
+#define RCC_APB2ENR (*(volatile uint32_t*)0x40021018)
+
+#define USART1_SR (*(volatile uint32_t*)0x40013800)
+#define USART1_DR (*(volatile uint32_t*)0x40013804)
+#define USART1_BRR (*(volatile uint32_t*)0x40013808)
+#define USART1_CR1 (*(volatile uint32_t*)0x4001380C)
+
+/// @brief Generate a blocking delay using the Cortex-M SysTick timer.
+/// @param ms Delay duration in milliseconds.
+static void delay_ms(uint32_t ms) {
+  while (ms--) {
+    SYST_RVR = 8000 - 1;  // 8 MHz -> 1 ms
+    SYST_CVR = 0;
+    SYST_CSR = 5;  // ENABLE + CPU clock
+
+    while (!(SYST_CSR & (1 << 16))) {}
+
+    SYST_CSR = 0;
+  }
+}
+
+/// @brief Send a null-terminated string to the host using semihosting.
+/// @param s String to transmit.
+static void semihost_write0(const char* s) {
+  register int op asm("r0") = 0x04;
+  register const char* msg asm("r1") = s;
+
+  asm volatile("bkpt 0xAB" : : "r"(op), "r"(msg) : "memory");
+}
+
+static void uart_init(void) {
+  // Enable USART1 clock
+  RCC_APB2ENR |= (1 << 14);
+
+  // 8 MHz PCLK -> 115200 baud
+  USART1_BRR = 0x45;
+
+  // UE + TE
+  USART1_CR1 = (1 << 13) | (1 << 3);
+}
+
+/// @brief
+static void uart_putc(char c) {
+  while (!(USART1_SR & (1 << 7))) {}
+
+  USART1_DR = c;
+}
+
+/// @brief Transmit a null-terminated string over USART1.
+/// @param s String to transmit.
+static void uart_puts(const char* s) {
+  while (*s) {
+    if (*s == '\n')
+      uart_putc('\r');
+
+    uart_putc(*s++);
+  }
+}
+
+int main(void) {
+  uart_init();
+
+  while (1) {
+    uart_puts("Hello STM32-QEMU UART1\n");
+    delay_ms(1000);
+    semihost_write0("Hello STM32-QEMU semihosting\n");
+    delay_ms(1000);
+  }
+}
\ No newline at end of file
diff --git a/src/embedded/run.sh b/src/embedded/run.sh
new file mode 100755
index 0000000..afc89d2
--- /dev/null
+++ b/src/embedded/run.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+
+set -e
+
+BUILD_DIR=build
+TARGET=firmware
+
+mkdir -p ${BUILD_DIR}
+
+echo "[1/3] Building ELF..."
+
+arm-none-eabi-gcc \
+    -mcpu=cortex-m3 \
+    -mthumb \
+    -nostdlib \
+    -ffreestanding \
+    startup.c main.c \
+    -T stm32_flash.ld \
+    -Wl,-Map=${BUILD_DIR}/${TARGET}.map \
+    -o ${BUILD_DIR}/${TARGET}.elf
+
+echo "[2/3] Generating BIN..."
+
+arm-none-eabi-objcopy \
+    -O binary \
+    ${BUILD_DIR}/${TARGET}.elf \
+    ${BUILD_DIR}/${TARGET}.bin
+
+QEMU_ARGS="
+    -M stm32vldiscovery
+    -kernel ${BUILD_DIR}/${TARGET}.elf
+    -semihosting-config enable=on,target=native
+"
+
+case "$1" in
+    gui)
+        echo "[3/3] Starting QEMU (GUI)..."
+
+        qemu-system-arm ${QEMU_ARGS}
+        ;;
+
+    debug)
+        echo "[3/3] Starting QEMU (Debug Mode)..."
+        echo "Connect with:"
+        echo "  arm-none-eabi-gdb ${BUILD_DIR}/${TARGET}.elf"
+        echo "  target remote :1234"
+
+        qemu-system-arm \
+            ${QEMU_ARGS} \
+            -S \
+            -gdb tcp::1234
+        ;;
+
+    *)
+        echo "[3/3] Starting QEMU (Terminal)..."
+
+        qemu-system-arm \
+            ${QEMU_ARGS} \
+            -nographic
+        ;;
+esac
diff --git a/src/embedded/startup.c b/src/embedded/startup.c
new file mode 100644
index 0000000..9fbfb2f
--- /dev/null
+++ b/src/embedded/startup.c
@@ -0,0 +1,78 @@
+#include <stdint.h>
+
+/// @brief Symbols defined by the linker script.
+extern uint32_t _sidata;  ///< Start address of initialized data in Flash (LMA)
+extern uint32_t _sdata;   ///< Start address of .data section in RAM (VMA)
+extern uint32_t _edata;   ///< End address of .data section in RAM
+extern uint32_t _sbss;    ///< Start address of .bss section
+extern uint32_t _ebss;    ///< End address of .bss section
+extern uint32_t _estack;  ///< Initial stack pointer (top of RAM)
+
+extern int main(void);
+
+void Reset_Handler(void);
+void Default_Handler(void);
+
+/// @brief Weak aliases allow users to override handlers bydefining their own implementation with the same name.
+void NMI_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void HardFault_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void MemManage_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void BusFault_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void UsageFault_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void SVC_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void DebugMon_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void PendSV_Handler(void) __attribute__((weak, alias("Default_Handler")));
+void SysTick_Handler(void) __attribute__((weak, alias("Default_Handler")));
+
+/// @brief Interrupt Vector Table
+__attribute__((section(".isr_vector"))) const void* vector_table[] = {
+    &_estack,  // Initial SP
+    Reset_Handler,
+
+    NMI_Handler,
+    HardFault_Handler,
+    MemManage_Handler,
+    BusFault_Handler,
+    UsageFault_Handler,
+
+    0,
+    0,
+    0,
+    0,
+
+    SVC_Handler,
+    DebugMon_Handler,
+    0,
+    PendSV_Handler,
+    SysTick_Handler,
+};
+
+/// @brief Executed immediately after reset.
+/// Responsible for initializing the C runtime environment
+void Reset_Handler(void) {
+  // Copy initialized data (.data) * from Flash to RAM.
+  uint32_t* src = &_sidata;
+  uint32_t* dst = &_sdata;
+
+  while (dst < &_edata) {
+    *dst++ = *src++;
+  }
+
+  dst = &_sbss;
+
+  // Clear uninitialized data (.bss)
+  while (dst < &_ebss) {
+    *dst++ = 0;
+  }
+
+  // Jump to the application entry point
+  main();
+
+  // main() should never return
+  while (1) {}
+}
+
+/// @brief Default handler for unimplemented exceptions.
+void Default_Handler(void) {
+  while (1) {}
+}
\ No newline at end of file
diff --git a/src/embedded/stm32_flash.ld b/src/embedded/stm32_flash.ld
new file mode 100644
index 0000000..3c7c2af
--- /dev/null
+++ b/src/embedded/stm32_flash.ld
@@ -0,0 +1,70 @@
+/* Reference:
+* https://kleinembedded.com/stm32-without-cubeide-part-1-the-bare-necessities
+FLASH (0x08000000)
++------------------+
+| .isr_vector      |
++------------------+
+| .text            |
+| .rodata          |
++------------------+
+| Initial .data    |  <-- _sidata (LMA)
++------------------+
+
+RAM (0x20000000)
++------------------+
+| .data            |  <-- _sdata
++------------------+
+| .bss             |  <-- _sbss
++------------------+
+| Heap (optional)  |  <-- end
+|                  |
++------------------+
+|      Stack       |
++------------------+
+|     _estack      |
++------------------+
+*/
+
+ENTRY(Reset_Handler)
+
+MEMORY
+{
+    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 128K
+    RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 8K
+}
+
+_estack = ORIGIN(RAM) + LENGTH(RAM);
+
+SECTIONS
+{
+    .isr_vector :
+    {
+        KEEP(*(.isr_vector))
+    } > FLASH
+
+    .text :
+    {
+        *(.text*)
+        *(.rodata*)
+    } > FLASH
+
+    _sidata = LOADADDR(.data);
+
+    .data :
+    {
+        _sdata = .;
+        *(.data*)
+        _edata = .;
+    } > RAM AT > FLASH
+
+    .bss :
+    {
+        _sbss = .;
+        *(.bss*)
+        *(COMMON)
+        _ebss = .;
+    } > RAM
+
+    . = ALIGN(8);
+    end = .;
+}
\ No newline at end of file

From 7c1de38d7b619bf502b4f2c44f444d5511784145 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 14 Jun 2026 15:27:51 +0700
Subject: [PATCH 09/18] remove docs

---
 docs/image/future_promis.png      | Bin 121085 -> 0 bytes
 docs/image/future_promis_flow.png | Bin 36392 -> 0 bytes
 src/core/basics/README.md         | 452 ------------------------------
 src/core/concurrency/README.md    | 237 ----------------
 src/core/exception/README.md      |  14 -
 src/core/function/README.md       | 238 ----------------
 src/core/smart_pointer/README.md  | 164 -----------
 src/core/string/README.md         | 332 ----------------------
 8 files changed, 1437 deletions(-)
 delete mode 100644 docs/image/future_promis.png
 delete mode 100644 docs/image/future_promis_flow.png
 delete mode 100644 src/core/basics/README.md
 delete mode 100644 src/core/concurrency/README.md
 delete mode 100644 src/core/exception/README.md
 delete mode 100644 src/core/function/README.md
 delete mode 100644 src/core/smart_pointer/README.md
 delete mode 100644 src/core/string/README.md

diff --git a/docs/image/future_promis.png b/docs/image/future_promis.png
deleted file mode 100644
index 73da3f7816f8e4bf289d61c1980c3ad97f473335..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 121085
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
Xe0kw$kAi0~&_88)4Y@iQ^H2W|)mhrv

diff --git a/docs/image/future_promis_flow.png b/docs/image/future_promis_flow.png
deleted file mode 100644
index 1942fba927f86678d1c6eba54d9e05103093cf72..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 36392
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

diff --git a/src/core/basics/README.md b/src/core/basics/README.md
deleted file mode 100644
index e810be3..0000000
--- a/src/core/basics/README.md
+++ /dev/null
@@ -1,452 +0,0 @@
----
-author: "Phong Nguyen"
-title: "C++ - Chapter 2: Fundamentals"
-date: "2026-05-24"
-description: "C++ Notes"
-tags: ["cpp"]   #tags search
-FAcategories: ["syntax"]    #The category of the post, similar to tags but usually for broader classification.
-FAseries: ["Themes Guide"]    #indicates that this post is part of a series of related posts
-aliases: ["migrate-from-jekyl"]    #Alternative URLs or paths that can be used to access this post, useful for redirects from old posts or similar content.
-ShowToc: true    # Determines whether to display the Table of Contents (TOC) for the post.
-TocOpen: true    # Controls whether the TOC is expanded when the post is loaded. 
-weight: 1    # The order in which the post appears in a list of posts. Lower numbers make the post appear earlier.
----
-
-C++ Basic Concepts
-- `Data` is any information processed or stored by a computer.
-- A `Value` is a specific piece of data (e.g. `42`, `'A'`, `3.14`).
-- An `Object` is a region of storage (memory) with a type and a value.
-- A `Variable` is a named object used to store data.
-- `Initialization` is the process of giving an initial value to an object or variable.
-- `Literals`: fixed values like 42, 3.14, 'A', "Hello", true, nullptr.
-- `Operators`: symbols that act on values (+ - * / %, == != < >, && || !, = += -=, etc.).
-- An `Expression` is a combination of operators, constants and variables that evaluate to a value.
-- A `function` is a reusable block of code that performs a specific task.
-
----
-## 1. Initialization
-C++ provides several ways to initialize objects. Each form has different semantics and use cases.
-
-### 1.1. Default Initialization
-```cpp
-int a;
-T object;
-new T;
-```
-
-Performed when an object is created **without any initializer**.
-  - **Built-in types:** uninitialized
-  - **Class types:** default constructor is called
-
-<br>
-
-### 1.2. Value Initialization
-```cpp
-int a{};
-
-T();
-new T();
-T object{};
-T{};
-new T{};
-
-/// @brief Also used in constructors
-Class::Class() : member() {}
-Class::Class() : member{} {}
-```
-
-Performed when an object is created with an **empty initializer**.
-  - **Built-in types**: zero-initialized
-  - **Class types**: default constructor is called
-
-<br>
-
-### 1.3 Direct Initialization
-```cpp
-T object(arg);
-T object(arg1, arg2);
-
-T object{arg};          // since C++11
-new T(args...);
-static_cast<T>(other);
-
-/// @brief Used in constructors and lambdas:
-Class::Class() : member(args...) {}
-[arg]() {};
-```
-
-Initializes an object using **explicit constructor arguments**.
-
-<br>
-
-### 1.4 Copy Initialization
-```cpp
-T object = other;
-f(other);
-return other;
-throw object;
-catch (T object);
-
-/// @brief Also used for arrays
-T array[N] = { /* values */ };
-```
-Initializes an object **from another object or expression**.
-
-### 1.5 List Initialization (since C++11)
-```cpp
-/// @brief Direct List Initialization
-T object{arg1, arg2};
-new T{arg1, arg2};
-
-Class::Class() : member{arg1, arg2} {}
-
-/// @brief Copy List Initialization
-T object = {arg1, arg2};
-return {arg1, arg2};
-function({arg1, arg2});
-
-
-/// @brief Designated Initializers (since C++20)
-T object{ .des1 = arg1, .des2 = arg2 };
-T object = { .des1 = arg1, .des2 = arg2 };
-```
-
-Initializes objects using **brace-enclosed initializer lists { }**.
-
-<br>
-
-### 1.6 Aggregate Initialization
-```cpp
-T object = {arg1, arg2};
-T object{arg1, arg2};          // since C++11
-
-/// @brief Designated initializers for aggregates (since C++20)
-T object = { .des1 = arg1, .des2 = arg2 };
-T object{ .des1 = arg1, .des2 = arg2 };
-```
-Initializes **aggregate types** (no user-defined constructors).
-
----
-## 2. Functions and Files
-### 2.1. Function
-```cpp
-
-returnType functionName(); ///< Forward Declaration
-
-/// @brief Function Definition
-returnType functionName(){
-    
-
-} 
-```
-
-- A `forward declaration` allows us to tell the compiler about the existence of an identifier before actually defining the identifier.
-
-<br>
-
-### 2.2. Namespace
-```cpp
-namespace nested_config{
-    namespace config{
-        int value = 1;
-    }
-}
-
-using namespace cfg = nested_config::config;
-
-void f(){
-    std::cout << cfg::value;
-}
-```
-- `namespace` is a way to group names (variables, functions, classes, ...) together and avoid name conflicts. It guarantees that all identifiers within the namespace are unique
-- `using namespace`: this is a using-directive that allows us to access names in the std namespace with no namespace prefix
-- The `scope resolution operator (::)` used to access namespace member
-- Can create `namespace aliases`, which allow us to temporarily shorten a long sequence of namespaces into something shorter.
-- namespaces can be nested inside other namespaces.
-
-<br>
-
-### 2.3. Preprocessor
-The `preprocessor` is a process that runs on the code before it is compiled.
-```cpp
-#include <iostream>     // insert file contents
-#define NAME "Alex"     // replace NAME -> "Alex"
-
-#ifdef NAME_DEFINED     // only compile if defined
-std::cout << NAME;
-#endif
-```
-
-<br>
-
-### 2.3. Header Files
-```cpp
-#include <iostream>     // search system only 
-#include "my_header.h"  // search local first, then system
-
-/// @brief Add include directories with -I
-// g++ -o main -I./source/includes -I/home/abc/moreHeaders main.cpp
-```
-
-`Header files` are files designed to propagate declarations to code files. 
-- `Header guards` prevent the contents of a header from being included more than once into a given code file. 
-- For cross-platform library code, `#ifndef` is safest.
-- For modern projects, `#pragma once` is simpler and safe.
-
----
-## 3. Fundamental Data Types
-Memory can only store bits. `Data type` help compiler and CPU take care of encoding the value into the sequence of bits.
-    - Fundamental Data Types
-    - Compound Data Types
-
-### 3.1 Primitive Type
-| Types                                                              | Category             | Meaning                                          | Example |
-| ------------------------------------------------------------------ | -------------------- | ------------------------------------------------ | ------- |
-| float, double, long double                                         | Floating Point       | a number with a fractional part                  | 3.14159 |
-| bool                                                               | Integral (Boolean)   | true or false                                    | true    |
-| char, wchar_t, char8_t (C++20), char16_t (C++11), char32_t (C++11) | Integral (Character) | a single character of text                       | 'c'     |
-| short int, int, long int, long long int (C++11)                    | Integral (Integer)   | positive and negative whole numbers, including 0 | 64      |
-| std::nullptr_t (C++11)                                             | Null Pointer         | a null pointer                                   | nullptr |
-| void                                                               | Void                 | no type                                          | n/a     |
-
-- `sizeof` used to get the size of a type in bytes. (pointer has 4 or 8 bytes based on the arch)
-- `signed integers` can hold both positive and negative numbers (and 0). 
-- `unsigned integers` can only hold non-negative whole numbers.
-- `fixed-width integers` are the  set of integer types that are guaranteed to be the same size on any architecture **`#include <cstdint>`**
-  - `fast integers`: guarantee at least # bits, but pick the type that the CPU can process fastest (even if it uses more memory).
-  - `least integers`: guarantee at least # bits, but pick the type that uses the least memory (even if it’s slower).
-- `size_t` vs `std::size_t` is an unsigned integral type that is used to represent the size or length of objects. (<stddef.h>,  <cstddef>)
-- `scientific notation e/E` used to present the times 10 to the power of the equation. e.g.  **(e.g. 5.9722 x 10²⁴ -> 5.9722e24)**
-- `Inf` represents infinity. Inf is signed, and can be positive (+Inf) or negative (-Inf). (5/0)
-- `NaN` stands for “Not a Number”. (mathematically invalid)
-
-<br>
-
-### 3.2. Chars
-- A `char` variable are interpreted as an `ASCII character`.
-- `'t'`: Text between single quotes is treated as a char literal, which represents a single character.
-- `"text"`: Text between double quotes (e.g. “Hello, world!”) is treated as a C-style string literal, which can contain multiple characters.
-- **Escape sequences:**
-    | Name            | Symbol       | Meaning                                        |
-    | --------------- | ------------ | ---------------------------------------------- |
-    | Alert           | `\a`         | Makes an alert, such as a beep                 |
-    | Backspace       | `\b`         | Moves the cursor back one space                |
-    | Formfeed        | `\f`         | Moves the cursor to next logical page          |
-    | Newline         | `\n`         | Moves cursor to next line                      |
-    | Carriage return | `\r`         | Moves cursor to beginning of line              |
-    | Horizontal tab  | `\t`         | Prints a horizontal tab                        |
-    | Vertical tab    | `\v`         | Prints a vertical tab                          |
-    | Single quote    | `\'`         | Prints a single quote                          |
-    | Double quote    | `\"`         | Prints a double quote                          |
-    | Backslash       | `\\`         | Prints a backslash                             |
-    | Question mark   | `\?`         | Prints a question mark *(no longer relevant)*  |
-    | Octal number    | `\{number}`  | Translates into char represented by octal      |
-    | Hex number      | `\x{number}` | Translates into char represented by hex number |
-
----
-## 4. Constant
-- A `constant` is a value that is not be changed during the program’s execution. There are two types of constants:
-  - **Named constants**: are constant values that are associated with an identifier.
-    - Constant variables
-    - Macros with substitution text
-    - Enumerated constant
-  - **Literal** are constant values that are not associated with an identifier.Literals are values that are inserted directly into the code.
-
-<br>
-
-### 4.1. Named constants
-```cpp
-const double gravity = 9.8; ///< Const variable
-
-#define MY_NAME "Phong"  ///< Object-like macros with substitution text
-
-enum Color {
-    RED,    // Assigned 0
-    GREEN,  // Assigned 1
-    BLUE = 5, // Manually assigned 5
-    YELLOW  // Assigned 6 (5 + 1)
-};///< Enumerated constant
-```
-
-### 4.2. Literals
-
-```cpp
-return 5;                       ///< 5 is an integer literal -> type: int
-bool myNameIsAlex { true };     ///< true is a boolean literal -> type: bool
-double d { 3.4 };               ///< 3.4 is a double literal -> type: double
-cout << "Hello, world!";        ///< "Hello, world!" is a C-style string literal -> type: const char[14]
-cout << 5.0 << '\n';            ///< 5.0 (no suffix) is type double (by default)
-cout << 5.0f << '\n';           ///< 5.0f is type float
-```
-
-- `Type of a literal` is deduced from the literal's value.
-- `Literal suffixes` used to explicitly declare the type for a literal.
-
-<br>
-
-### 4.3.  Numeral systems (decimal, binary, hexadecimal, and octal)
-- Numeral system literals:
-    - Decimal (no prefix, 42)
-    - Binary (0b101010) `b`
-    - Hexadecimal (0x2A) `x`
-    - Octal (052) — all represent the same value.
-- Can change the output format via use of the `std::dec, std::oct, and std::hex` I/O manipulators:
-- Can define a `std::bitset` variable and tell `std::bitset` how many bits we want to store.
-```cpp
-    int bin{};          // assume 16-bit int
-    bin = 0x0001;       // assign binary 0000 0000 0000 0001 to the variable
-    bin = 0b1;          // assign binary 0000 0000 0000 0001 to the variable
-    bin = 0b11;         // assign binary 0000 0000 0000 0011 to the variable
-
-    cout << std::bitset<4>{ 0b1010 } << '\n'; // create a temporary std::bitset and print it
-
-    // C++14: quotation mark (‘) as a digit separator
-    int bin { 0b1011'0010 };        // assign binary 1011 0010 to the variable
-    long value { 2'132'673'462 };   // much easier to read than 2132673462
-```
-
-<br>
-
-### 4.4.  Constant Expression
-- `Constant expressions` is an expressions whose values can be fully determined at **compile time**.
-- `constexpr` is used to declare compile-time constants
-- Benefits:
-  - Safer code
-  - Optimizations
-  - Compile-time evaluation
-
-- `constexpr` function is is a function that is allowed to be called in a constant expression, can be evaluated at compile time or runtime.
-- `consteval` function is a function that must evaluate at compile-time.
-
-```cpp
-constexpr int square(int x) {
-    return x * x;
-}
-
-consteval int cube(int x) {
-    return x * x * x;
-}
-
-constexpr int a = square(5); // compile-time
-int b = square(5);           // runtime allowed
-
-constexpr int c = cube(5);   // OK
-// int d = cube(5);          // Error if not compile-time
-```
-
----
-## 5. Operators & Bit Manipulation
-### 5.1. Operators
-- Refer : https://www.learncpp.com/cpp-tutorial/operator-precedence-and-associativity/
-- `Increment/decrement`:
-  -  `++x`: increment x, then return x
-  -  `x++`: copy x, then increment x, return the copy
-- `Comma`: 
-  - `(x, y)`: Evaluate x then y, returns value of y
-  - avoid use this
-
-### 5.2. Bit manipulation.
-- To define a set of bit flags, use `uint8/16/32`... or `std::bitset`
-- Refers: https://www.learncpp.com/cpp-tutorial/bit-flags-and-bit-manipulation-via-stdbitset/
-
----
-## 6. Control Flows
-### 6.1. Constexpr if statement (C++17)
-- Condition will be evaluated at runtime.
-- e.g. 
-```cpp
-int main()
-{
-	constexpr double gravity{ 9.8 };
-
-	if constexpr (gravity == 9.8) // now using constexpr if
-		std::cout << "Gravity is normal.\n";
-	else
-		std::cout << "We are not on Earth.\n";
-
-	return 0;
-}
-```
-
-<br>
-
-### 6.2. Switch fallthrough and scoping
-- The `[[fallthrough]]` attribute modifies a null statement to indicate that fallthrough is intentional (and no warnings should be triggered).
-- Initialization is not allowed before case labels because control flow in a switch may jump over the initializer, leaving the variable uninitialized.
-- Declarations without an initializer are allowed before case labels because they only reserve space for the variable in the function’s stack frame (decided at compile time). No runtime initialization code is generated, so nothing can be “skipped” by jumping to a case.
-- e.g.
-```cpp
-int main() {
-    int x = 2;
-
-    switch (x) {
-        int a;       //  allowed (no initializer, just reserves space)
-        // int b{5}; //  not allowed (initializer may be skipped)
-
-    case 1:
-        a = 10; // safe: 'a' exists, we assign here
-        std::cout << "Case 1, a = " << a << '\n';
-        [[fallthrough]]; //  intentional fallthrough to case 2
-
-    case 2:
-        a = 20; // reassign
-        std::cout << "Case 2, a = " << a << '\n';
-        break;
-
-    default:
-        std::cout << "Default case\n";
-        break;
-    }
-
-    return 0;
-}
-```
-
-<br>
-
-### 6.3. Halts
-- Halts allow us to terminate our program.Only use a halt if there is no safe or reasonable way to return normally from the main function. If you haven’t disabled exceptions, prefer using exceptions for handling errors safely.
-- `std::exit` is called implicitly when main() returns, it does not clean up local variables in the current function or up the call stack.
-- `std::abort()` function causes your program to terminate abnormally. Abnormal termination means the program had some kind of unusual runtime error and the program couldn’t continue to run. 
-- `std::terminate()` function is typically used in conjunction with exceptions . By default, it calls `std::abort()`
-- e.g.
-```cpp
-#include <iostream>
-#include <cstdlib>    // for std::exit, std::abort
-#include <exception>  // for std::terminate
-
-void cleanup() {
-    std::cout << "Cleaning up...\n";
-}
-
-void riskyFunction(bool fatalError) {
-    if (fatalError) {
-        std::cout << "Fatal error occurred!\n";
-
-        // std::abort: abnormal termination, no cleanup
-        std::abort();
-
-        // Or: std::terminate(); // usually called when exception handling fails
-    }
-}
-
-int main() {
-    cleanup(); // local function call
-
-    // Example 1: return normally from main
-    std::cout << "Program running normally...\n";
-
-    // Example 2: using std::exit (implicit when main returns)
-    if (false) {
-        std::cout << "Exiting via std::exit...\n";
-        std::exit(0); // does not call destructors of locals in main()
-    }
-
-    // Example 3: risky code that might abort/terminate
-    riskyFunction(true);
-
-    // Example 4: normal end of main calls std::exit implicitly
-    std::cout << "Main returns normally.\n";
-    return 0; // std::exit(0) is called implicitly here
-}
-```
\ No newline at end of file
diff --git a/src/core/concurrency/README.md b/src/core/concurrency/README.md
deleted file mode 100644
index 8237806..0000000
--- a/src/core/concurrency/README.md
+++ /dev/null
@@ -1,237 +0,0 @@
-## 1. Concurrency
-- **Concurrency** `refers to the ability` `to proccess` `multiple tasks` `at the same time.` 
-`On a single core`, it uses `context-switching`, `on multi-core systems`, it can run in parallel.
-- It's `used to improve` the `program performance` and `response time`.
-- In C/C++, we can archive concurrency by using `threads`.
-
-(`<chrono>` is a C++ header that provide `a collection of types and functions` to work with time.)
-
----
-## 2. Thread <thread>
-- Threads are `the basic unit of` multitasking.
-- There are many errors and risks associated with concurrency, including:
-    - `Deadlocks`: `refers to the situation where` two or more threads are blocked, `waiting for each other indefinitely`.
-    - `Race condition`: `refers to the situation where` two or more threads access `shared data` concurrently, leading to the `undefined behavior`.
-    - `Starvation`: `refer to the situation where` a thread `is unable to gain` regular access to the shared resources.
-=> We can avoid these problems by `proper synchronization` between the threads.
-- Use threads if we need to run long-lived and complex tasks. 
-
-### 2.2. Thead Synchronization
-- The synchronization can be done by using the following components:
-    - `Mutex/Lock`: `<mutex>` they are used to protect the shared resouces, ensure that only one thread can access `the critical sections` at a time.
-    - `Semaphore`: 
-    - `Futures and Promises`: `<future>`, `<promise>` are used for the asynchronous task execution.
-    - `Condition variable`: `<condition_variable>`
-### 2.3. Thread Management
-- `thread`: an `OS thread` `managed by` the kernel.
-- Each `thread` has it own `call stack`, but all `threads` share the **heap**.
-- `thread object`: refers to a C++ instance `that associated with` an `active thread` of execution in hardware level.
-- `std::thread(callable)`: request the kernel OS to create a thread.
-- `std::this_thread`: refer to the current thread
-- `join`: blocks the current thread until the thread that identified by *this (a.ka. object thread) finished its execution. Note that if the exception
-is throw before `join`, `std::terminate` might be called, and will kill the entire program process, not an invidual thread.
-- `detach`: separates the `thread of the execution` from the `thread object`, allowing the execution to continue running.
-- `yield`: give priority to other threads, pause its execution
-- Use `return` to kill a thread.
-### 2.4. Sharing Data
-- `Global/Static Variable`: can be accessed by all threads.
-- `Pass By Reference`: we need to explicitly wrap the args in `std::ref` to pass by reference and is the only way to properly get data out of a thread
-- `thread_local` to create a static variable per thread.
-
-### 2.5. Atomic <std::atomic>
-- An atomic type is a type that implements atomic operations. It's used to guarantee no race conditions will occur.
-- e.g.
-`std::atomic<bool>` - `std::atomic_bool`
-- e.g.
-```cpp
-#include <atomic>
-#include <iostream>
-#include <thread>
-#include <vector>
- 
-std::atomic_int acnt;
-int cnt;
- 
-void f()
-{
-    for (auto n{10000}; n; --n)
-    {
-        ++acnt;
-        ++cnt;
-        // Note: for this example, relaxed memory order is sufficient,
-        // e.g. acnt.fetch_add(1, std::memory_order_relaxed);
-    }
-}
- 
-int main()
-{
-    {
-        std::vector<std::jthread> pool;
-        for (int n = 0; n < 10; ++n)
-            pool.emplace_back(f);
-    }
- 
-    std::cout << "The atomic counter is " << acnt << '\n'
-              << "The non-atomic counter is " << cnt << '\n';
-}
-```
-
-### 2.6. Mutex/Locks
-- Mutexs are mutual exclusion objects, are owned by the thread that takes it.
-- e.g.
-```cpp
-#include <mutex>
-
-// Create your mutex here
-std::mutex my_mutex;
-
-thread_function()
-{
-  my_mutex.lock(); // Acquire lock
-  // Do some non-thread safe stuff...
-  my_mutex.unlock(); // Release lock
-}
-```
-
-- There are serveral types of mutex, including:
-    - `mutex`
-    - `timed_mutex`
-    - `recursive_mutex`
-    - `recursive_timed_mutex`
-    - `shared_timed_mutex`
-
-- **Lock Guard Type** is a wrapper mutex that provides a convinient RAII-style mechanism.
-- They are several `lock guard types`, including:
-    - `std::lock_guard`<mutex>: basic RAII lock for a single mutex. Locks immediately on construction, unlocks on destruction.
-    - `std::scoped_lock`<mutex1,mutex2,...>:  RAII lock for multiple mutexes
-    - `std::unique_lock`<mutex>: Flexible RAII lock for a single mutex. Supports deferred/manual locking, unlocking, and use with condition variables, has unlock() / lock()
-    - `shared_lock`: RAII lock for shared access (readers) on a std::shared_mutex. Allows multiple concurrent readers.
-
-### 2.7. Condition Variable for event handling - <condition_variable>
-- `std::condition_variable` is a synchronization primitive used with a `std::mutex` to block one or more threads until another thread both modifies a `shared variable` (the condition) and `notifies` the `std::condition_variable`.
-- `wait` will releases the lock and blocks the thread until the condition is fullfilled.
-- e.g.
-```cpp
-#include <condition_variable>
-#include <iostream>
-#include <mutex>
-#include <string>
-#include <thread>
- 
-std::mutex m;
-std::condition_variable cv;
-std::string data;
-bool ready = false;
-bool processed = false;
- 
-void worker_thread()
-{
-    // 1. wait until main() sends data
-    std::unique_lock lk(m);
-    cv.wait(lk, []{ return ready; });
- 
-    // after the wait, we own the lock
-    std::cout << "Worker thread is processing data\n";
-    data += " after processing";
- 
-    // send data back to main()
-    processed = true;
-    std::cout << "Worker thread signals data processing completed\n";
- 
-    // manual unlocking is done before notifying, to avoid waking up
-    // the waiting thread only to block again (see notify_one for details)
-    lk.unlock();
-    cv.notify_one();
-}
- 
-int main()
-{
-    std::thread worker(worker_thread);
- 
-    data = "Example data";
-    // send data to the worker thread
-    {
-        std::lock_guard lk(m);
-        ready = true;
-        std::cout << "main() signals data ready for processing\n";
-    }
-    cv.notify_one();
- 
-    // wait for the worker
-    {
-        std::unique_lock lk(m);
-        cv.wait(lk, []{ return processed; });
-    }
-    std::cout << "Back in main(), data = " << data << '\n';
- 
-    worker.join();
-}
-
-Output:
-main() signals data ready for processing
-Worker thread is processing data
-Worker thread signals data processing completed
-Back in main(), data = Example data after processing
-```
-
----
-## 3. Task
-- A `task` is a unit of asynchronous work that can be scheduled for execution.
-- It is a higher-level abstraction than a thread.
-- `It's generally considered` faster to work with tasks `as opposed to` threads, because the runtime can reuse threads and manage scheduling more efficiently.
-- We use `task` if we want fairly simple code and don't care for managing threads, and are running shorts tasks.
-
-### 3.1. Promises and Futures <future>
-- `std::future` is a class template that stores a value that will be assigned in the future, and provide a way to access that value.
-    - It will also block if its value is accessed before the value is assigned.
-    - `Futures` are the objects that are returned by async operations (`std::async, std::promise, std::packaged_task`)
-- `std::shared_future`: works the same way as `std::future`, except it is copytable, so multiple threads are allowed to wait for the same shared state.
-- `std::promise` provides a way to store a value or an exception that will be retrieved asynchronously via a `std::future`.
-    - It is commonly used to pass results between threads.
-    - It creates a `std::future` using `get_future()`.
-    - The `std::promise` and the `std::future` share a common shared state.
-    - The `std::promise` sets the value of the shared state using `set_value()`.
-    - The associated `std::future` retrieves the value using `get()`.
-
-
-### 3.2. Async
-- `Async` is a function template allows we to spawn threads to do work async, then collect the results from them via the `future` mechanism.
-- A call to `std::async` returns a `std::future` object.
-- The future can later be used to retrieve the result of the asynchronous computation.
-    ```cpp
-    auto future = std::async(some_function, arg_1, arg_2);
-    ```
-- `std::async` may run the function in a `new thread` or `defer execution` until the result is requested.
-    - `std::launch::async`: launch in a separated thread
-    - `std::launch::deferred`: only be called on `get()`
-    - default: defer to system 
-    ```cpp
-    auto future = std::async(std::launch::async,some_function, arg_1, arg_2);
-    ```
-![future](../../../docs/image/future_promis.png)
-![future_flow](../../../docs/image/future_promis_flow.png)
-- e.g.
-```cpp
-// Pass in function pointer
-auto future = std::async(std::launch::async, some_function, arg_1, arg_2);
-
-// Pass in function reference
-auto future = std::async(std::launch::async, &some_function, arg_1, arg_2);
-
-// Pass in function object
-struct SomeFunctionObject
-{
-	void operator() (int arg_1){}
-};
-auto future = std::async(std::launch::async, SomeFunctionObject(), arg_1);
-
-// Lambda function
-auto future = std::async(std::launch::async, [](){});
-```
-
-## 4. Date and time library
-- The `chrono` (since c++11) library defines several main types as well as utility functions and common typedefs:
-  - clocks
-  - time points
-  - durations
-  - calender/timezone (c++ 20);
\ No newline at end of file
diff --git a/src/core/exception/README.md b/src/core/exception/README.md
deleted file mode 100644
index 353894a..0000000
--- a/src/core/exception/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Exception handling
-**- We prefer using exceptions with the following reasons:**
-   - Forces the caller to recognize an error condition and handle it rather than stopping program.
-   - Let exceptions propagate in the call stack where they can be handled probably (e.g destroys all the objects in scope error )
-   - TBD
----
-The exception mechanism has a minimal performance cost if no exception is thrown. If an exception is thrown, the cost of the stack traversal and unwinding is roughly comparable to the cost of a function call.
-
-**- Design for exception safe:**
-   - Low/ middle layers: catch and rethrow an exception  if they do not have enough context to handle.  This way, the exceptions will propagate up the call stack.
-   - Highest layers: let an unhandled exception terminate a program. (`exit(-1)`)
-
----
-- *Resource Acquisition Is Initialization (RAII) (resource lifetime = object lifetime)*
\ No newline at end of file
diff --git a/src/core/function/README.md b/src/core/function/README.md
deleted file mode 100644
index 62eaba6..0000000
--- a/src/core/function/README.md
+++ /dev/null
@@ -1,238 +0,0 @@
-
----
-# Functions
-Functions are self-contained blocks of code designed to perform specific tasks. They promote code reusability, modularity, and abstraction.
-Functions can participate in polymorphism through:
-- **Compile-time polymorphism (Static Polymorphism)**
-  - Function overloading
-  - Operator overloading
-  - Function templates
-- **Runtime polymorphism**
-  - Virtual functions
-
----
-## 1. Function Overloading
-- `function overloading` allows us to create multiple functions with the same name, so long as each identically named function has different parameter types/numbers.  Return types are not considered for 
-- `function delete` using `delete` keyword. delete means "I forbid this", not "this doesn’t exist". 
-- `default-arguments`: is a default value provided for a function parameter. Parameters with default arguments must always be the rightmost parameters, and they are not used to differentiate functions when resolving overloaded functions.
-```cpp
-void printInt(int x)
-{
-    std::cout << x << '\n';
-}
-
-void printIntOrDefault(int x, int y = 2)
-{
-    std::cout << x << ", " << y << '\n';
-}
-
-template <typename T>
-void printInt(T) = delete;
-
-int main()
-{
-    printInt(97);             // okay
-
-    // printInt('a');         // compile error
-    // printInt(true);        // compile error
-
-    printIntOrDefault(5);     // prints: 5, 2
-    printIntOrDefault(5, 10); // prints: 5, 10
-
-    return 0;
-}
-```
-
----
-## 2. Operator Overloading
-
-- **Operator overloading** allows C++ operators to be customized for user-defined types.
-- An overloaded operator is implemented as a special function called an **operator function**.
-
-- Operator Function Names:
-    ```cpp
-    operator op
-
-    operator new
-    operator new[]
-    operator delete
-    operator delete[]
-
-    operator co_await // C++20
-    ```
-
-- Operator Syntax:
-    | Expression | Member Function      | Non-member Function | Example                                             |
-    | ---------- | -------------------- | ------------------- | --------------------------------------------------- |
-    | `@a`       | `a.operator@()`      | `operator@(a)`      | `!a` calls `a.operator!()`                          |
-    | `a@b`      | `a.operator@(b)`     | `operator@(a, b)`   | `std::cout << 42` calls  `std::cout.operator<<(42)` |
-    | `a=b`      | `a.operator=(b)`     | N/A                 | `s = "abc"` calls `s.operator=("abc")`              |
-    | `a(b...)`  | `a.operator()(b...)` | N/A                 | `r(1)` calls `r.operator()(1)`                      |
-    | `a[b]`     | `a.operator[](b)`    | N/A                 | `m[1]` calls `m.operator[](1)`                      |
-    | `a->`      | `a.operator->()`     | N/A                 | `p->do()` calls `p.operator->()`                    |
-    | `a@`       | `a.operator@(0)`     | `operator@(a, 0)`   | `i++` calls `i.operator++(0)`                       |
-
-- Restrictions:
-    The following operators **cannot be overloaded**:
-        ```cpp
-        ::   // scope resolution
-        .    // member access
-        .*   // member access through pointer-to-member
-        ?:   // conditional operator
-        ```
-    - New operators cannot be created.
-    - Operators such as `**`, `<>`, or `&|` are invalid.
-    - At least one operand must be a user-defined type.
-    - Overloading does not change an operator's precedence, associativity, or number of operands.
-
-
-#### Assignment Operator (`=`)
-- Return the lhs by reference
-```cpp
-// copy assignment
-T& operator=(const T& other)
-{
-    // Guard self assignment
-    if (this == &other)
-        return *this;
-    
-    // 
-    
-    return *this;
-}
-
-// move assignment
-T& operator=(T&& other) noexcept
-{
-    // Guard self assignment
-    if (this == &other)
-        return *this; // delete[]/size=0 would also be ok
-    
-    //
-
-    return *this;
-}
-```
-
-#### Stream Extraction and Insertion (`>>`, `<<`)
-- Must be implemented as non-members cause that take a `std::istream&` or `std::ostream&` as the left hand argument `std::cout << a; std::cout.operator << (a)`
-```cpp
-std::ostream& operator<<(std::ostream& os, const T& obj)
-{
-    // write obj to stream
-    return os;
-}
-
-std::istream& operator>>(std::istream& is, T& obj)
-{
-    // read obj from stream
-    if (/* T could not be constructed */)
-        is.setstate(std::ios::failbit);
-    return is;
-}
-```
-
-#### Function Call Operator (`()`)
-
-#### Increment and Decrement (`++`, `--`)
-
-#### Binary Arithmetic Operators (`+`, `-`, `*`, `/`)
-
-#### Comparison Operators (`==`, `!=`, `<`, `>`, `<=`, `>=`)
-
-#### Array Subscript Operator (`[]`)
-
-#### Bitwise Operators (`&`, `|`, `^`, `~`, `<<`, `>>`)
-
-#### Boolean Negation Operator (`!`)
-
----
-## 3. Lambda
-- In C++11 and later, lambda is a convenient way of defining an anonymous function object right at the location where it's involked or passed as an argument to a function.
-
-- Syntax:
-    ```cpp
-    [=] () mutable throw() -> int
-    {
-        int n = x + y;
-        return n;
-    }
-
-    ```
-  - `[=]`: capture clause a.k.a lambda introducer
-  - `()`: *(Optional)* pararam list a.k.a lambda declarator
-  - `mutable`: *(Optional)*
-  - `throw()`: *(Optional)*
-  - `-> int`: *(Optional)* trailing-return-type
-  - `[](){ ... }` defines a lambda
-  - `[](){ ... }()` defines and immediately CALLS it
-
-### Capture Clause
-- It uses to introduce new variables in its body, specifics which vars are captured, and whether the capture is `by value[=]` or `by reference [&]`. 
-- An empty capture clause `[]` indicates that the body accesses no vars in the enclosing scope.
-- An identifier or `this` cannot appear more than once in a capture scope.
-- Since C++14, we can introduce and initialize new vars in the capture scope.
-- e.g.
-    ```cpp
-    int a{};
-    int b{};
-
-    auto f = []{    // no capture
-        return 1; 
-    }
-
-    auto f0 = [a]{   // capture by value
-        return a+1;
-    }
-
-    auto f1 = [&a]{
-        return a+=1;    // capture by reference (a = 1)
-    }
-
-    auto f2 = [=]{
-        return a + b; // all capture by value
-    }
-
-    auto f3 = [&]{
-        a+=1;
-        b+=1;
-        return a + b; // all capture by reference
-    }
-
-    auto f4 = [int a{}]{    // no capture
-        return a; 
-    }
-    ```
-
----
-## 4. Function Pointers
-- A function pointer is a pointer variable that stores the address of a function with a specific return type and parameter list.
-- Syntax: `return_type (*FuncPtr) (parameter type, ....);`
-```cpp
-// @brief Declaration
-rtype (*FuncPtr) (atype..);
-
-// @brief Referencing: Assigning a function’s address to the function pointer.
-FuncPtr = function_name; 
-
-// @brief Dereferencing: Invoking the function using the pointer. The dereference operator * is optional during function calls.
-FuncPtr(10, 20);     // Preferred
-(*FuncPtr)(10, 20); // Also valid
-```
-
----
-## 5. **`<functional>`**
-- `std::function` is a general-purpose polymorphic function wrapper introduced in C++11.
-  - It can store and invoke any callable object:
-    - Functions
-    - Lambda expressions
-    - Functors (objects that overload `operator()`)
-    - Member functions (with binding)
-  - It provides a common interface for different callable types.
-  - Commonly used for callbacks, event handling, task dispatching, and functional-style programming.
-  - Improves code flexibility, reusability, and maintainability.
-
-- Syntax: `std::function<rtype(atype..)> name()` / `std::function< ret_t (args_t)> name = f;` / `std::function< ret_t (args_t)> name(f);`
-
-
----
\ No newline at end of file
diff --git a/src/core/smart_pointer/README.md b/src/core/smart_pointer/README.md
deleted file mode 100644
index c57d5da..0000000
--- a/src/core/smart_pointer/README.md
+++ /dev/null
@@ -1,164 +0,0 @@
-## 1. Smart Pointers
-- The STL includes smart pointers, which are defined in the <memory> to help ensure that programs are free of memory and resource leaks.
-- Raw pointers are only used in small code blocks where performance is critical and we can control the ownership stuff.
-- e.g.
-```cpp
-void UseRawPointer()
-{
-    // Using a raw pointer -- not recommended.
-    Song* pSong = new Song(L"Nothing on You", L"Bruno Mars"); 
-
-    // Use pSong...
-
-    // Delete
-    delete pSong;   
-}
-
-void UseSmartPointer()
-{
-    // Declare a smart pointer on stack and pass it the raw pointer.
-    unique_ptr<Song> song2(new Song(L"Nothing on You", L"Bruno Mars"));
-
-    // Use song2...
-    wstring s = song2->duration_;
-    //...
-
-} // song2 is deleted automatically here.
-```
-
-- After being initialized, the smart pointer owns the raw pointer.
-- Use the overloaded `->` and `*` operators to access the object.
-- Use `get()` to access the raw pointer directly.
-- There are some kinds of the smart pointer:
-    - `unique_ptr`: this is the default choice for POCO, **one owner**
-    - `shared_ptr`: **multiple owners**, the raw pointer deleted when all owners have gone out of scope or have otherwise given up ownership.
-    - `weak_ptr`: provides access to an object that is owned by one or more `shared_ptr`, but holds a **non-owning** reference to this object.
-
----
-## 2. std::unique_ptr
-- It can **only be moved** and cannot be passed by value, copied.
-- e.g.
-```cpp
-unique_ptr<Song> SongFactory(const std::wstring& artist, const std::wstring& title)
-{
-    // Implicit move operation into the variable that stores the result.
-    return make_unique<Song>(artist, title);
-}
-
-void MakeSongs()
-{
-    // Create a new unique_ptr with a new object.
-    auto song = make_unique<Song>(L"Mr. Children", L"Namonaki Uta");
-
-    // Use the unique_ptr.
-    vector<wstring> titles = { song->title };
-
-    // Move raw pointer from one unique_ptr to another.
-    unique_ptr<Song> song2 = std::move(song);
-
-    // Obtain unique_ptr from function that returns by value.
-    auto song3 = SongFactory(L"Michael Jackson", L"Beat It");
-}
-
-// Create a unique_ptr to an array of 5 integers.
-auto p = make_unique<int[]>(5);
-
-// Initialize the array.
-for (int i = 0; i < 5; ++i)
-{
-    p[i] = i;
-    wcout << p[i] << endl;
-}
-```
-
-## 3. std::shared_ptr
-- It is designed for scenarios in which more than one owner needs to manage the lifetime of an object.
-- It can be copied, passed by value in function arguments, and assigned to other `shared_ptr` instances.
-- All the instances point to the same object, and share access to one "control block" that increments and decrements the reference count whenever a new shared_ptr is added, goes out of scope, or is reset. **When the reference count reaches zero, the control block deletes the memory resource and itself**.
-- e.g.
-```cpp
-// Use make_shared function when possible.
-auto sp1 = make_shared<Song>(L"The Beatles", L"Im Happy Just to Dance With You");
-
-// Ok, but slightly less efficient. 
-// Note: Using new expression as constructor argument
-// creates no named variable for other code to access.
-shared_ptr<Song> sp2(new Song(L"Lady Gaga", L"Just Dance"));
-
-// When initialization must be separate from declaration, e.g. class members, 
-// initialize with nullptr to make your programming intent explicit.
-shared_ptr<Song> sp5(nullptr);
-//Equivalent to: shared_ptr<Song> sp5;
-//...
-sp5 = make_shared<Song>(L"Elton John", L"I'm Still Standing");
-
-//Initialize with copy constructor. Increments ref count.
-auto sp3(sp2);
-
-//Initialize via assignment. Increments ref count.
-auto sp4 = sp2;
-
-//Initialize with nullptr. sp7 is empty.
-shared_ptr<Song> sp7(nullptr);
-
-// Initialize with another shared_ptr. sp1 and sp2
-// swap pointers as well as ref counts.
-sp1.swap(sp2);
-```
-
-## 4. std::weak_ptr
-- It's used to to access the underlying object of a shared_ptr without causing the reference count to be incremented.
-- If the memory has already been deleted, the weak_ptr's bool operator returns false.
-- e.g. 
-> std::weak_ptr is a very good way to solve the dangling pointer problem. By just using raw pointers it is impossible to know if the referenced data has been deallocated or not. Instead, by letting a std::shared_ptr manage the data, and supplying std::weak_ptr to users of the data, the users can check validity of the data by calling expired() or lock().
-You could not do this with std::shared_ptr alone, because all std::shared_ptr instances share the ownership of the data which is not removed before all instances of std::shared_ptr are removed. Here is an example of how to check for dangling pointer using lock():
-```cpp
-// Source - https://stackoverflow.com/a/21877073
-// Posted by sunefred, modified by community. See post 'Timeline' for change history
-// Retrieved 2026-02-06, License - CC BY-SA 4.0
-
-#include <iostream>
-#include <memory>
-
-int main()
-{
-    // OLD, problem with dangling pointer
-    // PROBLEM: ref will point to undefined data!
-
-    int* ptr = new int(10);
-    int* ref = ptr;
-    delete ptr;
-
-    // NEW
-    // SOLUTION: check expired() or lock() to determine if pointer is valid
-
-    // empty definition
-    std::shared_ptr<int> sptr;
-
-    // takes ownership of pointer
-    sptr.reset(new int);
-    *sptr = 10;
-
-    // get pointer to data without taking ownership
-    std::weak_ptr<int> weak1 = sptr;
-
-    // deletes managed object, acquires new pointer
-    sptr.reset(new int);
-    *sptr = 5;
-
-    // get pointer to new data without taking ownership
-    std::weak_ptr<int> weak2 = sptr;
-
-    // weak1 is expired!
-    if(auto tmp = weak1.lock())
-        std::cout << "weak1 value is " << *tmp << '\n';
-    else
-        std::cout << "weak1 is expired\n";
-    
-    // weak2 points to new data (5)
-    if(auto tmp = weak2.lock())
-        std::cout << "weak2 value is " << *tmp << '\n';
-    else
-        std::cout << "weak2 is expired\n";
-}
-```
\ No newline at end of file
diff --git a/src/core/string/README.md b/src/core/string/README.md
deleted file mode 100644
index 3e6afef..0000000
--- a/src/core/string/README.md
+++ /dev/null
@@ -1,332 +0,0 @@
-# String
-
-## 1. C-Style String
-A C-Style string is any **null-terminated byte string**, where this is a sequence of nonzero bytes followed by a byte with zero (0) value (the terminating null character).
-- The terminating null character is represented as the character literal **'\0'**;
-- The length of an NTBS is the number of elements that precede the terminating null character. An empty NTBS has a length of zero.
-- The size of an NTBS is the size of the entire array, including the terminating null character.
-- A single quotes `(')` are used to identify **character literals**.
-- A double quotes `('')` are used to identify **string literals**. String literals are stored in your program image, usually in a read-only section (.data),
-
-<br>
-
-### 1.1. Create a String
-```c
-// *1. Ptr
-char* strMessagePtr= "abc";
-// sizeof(strMessage) = 32 or 64 (ptr)
-strMessagePtr[0] = 1; // error, ptr to const
-
-// *2. Arrays
-char strMessage[] = "abc";
-// sizeof(strMessage ) = 4 
-strMessage[1] = 'a'; // OK
-```
-- For `strMessage`, the memory for the array is allocated on the stack at runtime. The compiler initializes it from the string literal. At runtime, the program memory copies the string literal into the array 
-- For `strMessagePtr`, only the address of the string literal is held on the stack, and there is no copying of string literal.
-
-<br>
-
-### 1.2. Characters
-- Null: `\0`, `0x00`, `NULL`
-- Carriage Return And New Line: `\r\n`
-- Case switching: `'A' ^ ' '` & `'a' ^ ' '`
-- Special: `\\`, 
-- **Escape sequences:**
-    | Name            | Symbol       | Meaning                                        |
-    | --------------- | ------------ | ---------------------------------------------- |
-    | Alert           | `\a`         | Makes an alert, such as a beep                 |
-    | Backspace       | `\b`         | Moves the cursor back one space                |
-    | Formfeed        | `\f`         | Moves the cursor to next logical page          |
-    | Newline         | `\n`         | Moves cursor to next line                      |
-    | Carriage return | `\r`         | Moves cursor to beginning of line              |
-    | Horizontal tab  | `\t`         | Prints a horizontal tab                        |
-    | Vertical tab    | `\v`         | Prints a vertical tab                          |
-    | Single quote    | `\'`         | Prints a single quote                          |
-    | Double quote    | `\"`         | Prints a double quote                          |
-    | Backslash       | `\\`         | Prints a backslash                             |
-    | Question mark   | `\?`         | Prints a question mark *(no longer relevant)*  |
-    | Octal number    | `\{number}`  | Translates into char represented by octal      |
-    | Hex number      | `\x{number}` | Translates into char represented by hex number |
-
-<br>
-
-### 1.3. C String Libraries
-- Copying strings : `strcpy`, `strncpy`
-- Concatenating strings: `strcat`, `strncat`
-- Comparing strings: `strcmp`, `strncmp`
-- Parsing strings: `strtok`, `strcspn`
-- Length: `strlen`
-- Examples:
-```cpp
-#include <stdio.h>
-#include <string.h>
-
-int main() {
-    // -------------------------------
-    // 1. Copying strings
-    // -------------------------------
-    char src[] = "Hello";
-    char dst[20];
-
-    strcpy(dst, src);           // copy full string
-    // dst = "Hello"
-
-    strncpy(dst, "World", 3);   // copy only 3 chars
-    dst[3] = '\0';              // ensure null-termination
-    // dst = "Wor"
-
-    // -------------------------------
-    // 2. Concatenating strings
-    // -------------------------------
-    char text[20] = "Hi";
-    strcat(text, " there");     // append full string
-    // text = "Hi there"
-
-    strncat(text, "!!!", 2);    // append only 2 chars
-    // text = "Hi there!!"
-
-    // -------------------------------
-    // 3. Comparing strings
-    // -------------------------------
-    int r1 = strcmp("abc", "abc");   // r1 = 0  (equal)
-    int r2 = strcmp("abc", "abd");   // r2 < 0  (abc < abd)
-    int r3 = strncmp("abcdef", "abcxyz", 3); // r3 = 0 (first 3 chars equal)
-
-    // -------------------------------
-    // 4. Parsing strings
-    // -------------------------------
-    char line[] = "A,B,C";
-    char* token = strtok(line, ",");  // first token: "A"
-    while (token != NULL) {
-        printf("token: %s\n", token);
-        token = strtok(NULL, ",");
-    }
-
-    // strcspn: find first occurrence of any chars in reject set
-    char sample[] = "hello123world";
-    size_t pos = strcspn(sample, "0123456789");
-    // pos = 5 (first digit is at index 5)
-
-    // -------------------------------
-    // 5. Length
-    // -------------------------------
-    size_t len = strlen("abc");  // len = 3
-
-    return 0;
-}
-```
-
-<br>
-
-### 1.4. String/Numbers Conversion
-- Integer to String: `itoa()` (non-standard)
-- String to Double: `atof()`
-- String to Double (with error checking): `strtod()`
-- String to Long (with base + error checking): `strtol()`
-- e.g.
-```c
-#include <stdio.h>
-#include <stdlib.h>   // atof, strtod, strtol
-#include <string.h>   // itoa (non-standard on some compilers)
-
-int main() {
-    // -------------------------------
-    // 1. Integer → String (itoa)
-    // -------------------------------
-    char buf[32];
-    itoa(1234, buf, 10);   // convert integer to string in base 10
-    // buf = "1234"
-
-    itoa(255, buf, 16);    // convert to hex
-    // buf = "ff"
-
-    // -------------------------------
-    // 2. String → Double (atof)
-    // -------------------------------
-    double d1 = atof("3.14159");
-    // d1 = 3.14159
-
-    double d2 = atof("12.5xyz"); 
-    // d2 = 12.5 (atof stops at non-numeric chars)
-
-    // -------------------------------
-    // 3. String → Double (strtod)
-    // -------------------------------
-    char* end;
-    double d3 = strtod("45.67abc", &end);
-    // d3 = 45.67
-    // end -> "abc"
-
-    // -------------------------------
-    // 4. String → Long (strtol)
-    // -------------------------------
-    long v1 = strtol("1234", NULL, 10);
-    // v1 = 1234 (decimal)
-
-    long v2 = strtol("FF", NULL, 16);
-    // v2 = 255 (hex → decimal)
-
-    char* end2;
-    long v3 = strtol("100xyz", &end2, 10);
-    // v3 = 100
-    // end2 -> "xyz"
-
-    return 0;
-}
-```
-
-<br>
-
----
-## 2. C++ String **<string>**
-Strings are objects that represent sequences of characters.
-
-### 2.1. Create a String
-```cpp
-std::string s = "hello";    ///< initialize from a string literal
-std::string s2("hello");    ///< direct initialization from a string literal
-std::string s3(5, 'a');     ///< create a string with 5 copies of 'a' -> "aaaaa"
-```
-
-### 2.2. Basic Properties
-| Function     | Description           |
-| ------------ | --------------------- |
-| `s.size()`   | number of characters  |
-| `s.length()` | same as size          |
-| `s.empty()`  | check empty           |
-| `s.clear()`  | remove all characters |
-
-### 2.3. Access Characters
-```cpp
-s[0]        // no bounds check
-s.at(0)     // bounds check
-s.front()   // first char
-s.back()    // last char
-```
-### 2.4. Modify String
-```cpp
-/// @brief append
-s.append(" world");
-s += " world";
-
-/// @brief insert
-s.insert(5, "XXX");
-
-/// @brief erase
-s.erase(0,2);
-
-/// @brief replace
-s.replace(0,5,"hi");
-
-/// @brief remove `\n`
-std::string s = "hello\nworld\n";
-auto new_end = std::remove(s.begin(), s.end(), '\n');
-s.erase(new_end)
-// std::erase(s,'\n')
-s.erase(std::remove(s.begin(), s.end(), '\n'), s.end());
-```
-### 2.5. Substring
-```cpp
-/// @brief std::string sub = s.substr(pos, len); , substr() does NOT modify original string
-std::string s = "abcdef";
-s.substr(2,3);   // "cde"
-```
-### 2.6. Find / Search
-```cpp
-/// @brief find character
-s.find('a');
-
-
-/// @brief find last
-s.find('a');
-
-
-/// @brief find substring
-size_t pos = s.find("abc");
-if (pos != std::string::npos)
-    std::cout << "found";
-```
-### 2.6. Compare Strings
-```cpp
-if (a == b)
-if (a != b)
-if (a < b)
-
-// 0  -> equal
-// <0 -> smaller
-// >0 -> larger
-auto ret = a.compare(b);
-```
-### 2.7. Start/End Checking
-```cpp
-/// @brief C++20
-s.starts_with("abc");
-s.ends_with("xyz");
-
-/// @brief before c++ 20
-s.rfind("abc",0) == 0
-s.size() >= 3 &&
-s.compare(s.size()-3,3,"xyz") == 0
-```
-### 2.8. Convert String
-```cpp
-/// @brief string to int
-int n = std::stoi(s);
-double x = std::stod("3.14");
-
-/// @brief int to string
-std::string s = std::to_string(123);
-```
-
-### 2.9. String Parsing
-```cpp
-#include <sstream>
-
-std::string line = "a,b,c";
-std::stringstream ss(line);
-std::string item;
-
-while(std::getline(ss,item,',')) {
-    std::cout << item << std::endl;
-}
-```
-
-### 2.10. Trim Whitespace
-```cpp
-s.erase(0, s.find_first_not_of(" \t\n\r"));
-s.erase(s.find_last_not_of(" \t\n\r") + 1);
-```
-
-### 2.11. Convert Case
-```cpp
-#include <algorithm>
-
-std::transform(s.begin(), s.end(), s.begin(), ::tolower);
-std::transform(s.begin(), s.end(), s.begin(), ::toupper);
-```
-
-### 2.12. String Formatting
-
-| Method            | Standard | Pros                     | Cons                         |
-|------------------|----------|--------------------------|------------------------------|
-| `std::format`     | C++20    | Clean, safe, Python-like | Needs newer compiler         |
-| `+` concatenation | C++98    | Simple                   | Hard to format numbers       |
-| `stringstream`    | C++98    | Flexible streaming       | Slow, verbose                |
-| `snprintf`        | C        | Very fast, classic       | Unsafe if misused            |
-
----
-## 3. std::cout << , std::cin >> , std::getLine(std::cin >> std::ws, std::string string)
-- `std::ws` tells `std::cin` to ignore leading whitespace(tab/enter/newline(s)) before extraction.  
-- `std::string::length` returns length of a string that does not included the null terminator character.
-- `s` suffix is a `std::string` literally, no suffix is a C-style string literally. e.g. `std::cout << "goo\n"s`
-> Initializing and copy a `std::string` is slow. That's inefficient 
-
----
-## 4. std::string_view  (C++17)
-`std::string_view` provides read-only access to an existing string (a C-style string literal, a std::string, or a char array) without making a copy. 
-- A std::string_view that is viewing a string that has been destroyed is sometimes called a dangling view. When a std::string is modified, all views into that std::string are invalidated, meaning those views are now invalid. Using an invalidated view (other than to revalidate it) will produce undefined behavior.
-
-- `sv` suffix is a `std::string_view` literally
-- Modify a std::string is likely to invalidate all std::string_view that view into that.
-- It may or may not be null-terminated.
\ No newline at end of file

From bb5caa69d3337742f0755522c112cb2a5446d9a7 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 21 Jun 2026 21:00:17 +0700
Subject: [PATCH 10/18] fix doc issue

---
 src/embedded/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/embedded/README.md b/src/embedded/README.md
index e8fed9a..8cc4058 100644
--- a/src/embedded/README.md
+++ b/src/embedded/README.md
@@ -146,6 +146,7 @@ A microcontroller does not start executing from `main()` after power-up or reset
                                       +----------------------+
                                       | Copy .data           |
                                       | Flash --> SRAM       |
+                                      +----------------------+
                                       v
                 +--------------------------------------------------+
                 |                    STM32 SRAM                    |

From f4a6b9b40546ef507b32dd2b3df43d2ede967cee Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Mon, 22 Jun 2026 09:56:41 +0700
Subject: [PATCH 11/18] Update for initialization

---
 src/core/CMakeLists.txt                |   2 +-
 src/core/basics/Initialization.cpp     | 114 +++++++++++++++++++++++++
 src/core/basics/InitializeVariable.cpp |  69 ---------------
 3 files changed, 115 insertions(+), 70 deletions(-)
 create mode 100644 src/core/basics/Initialization.cpp
 delete mode 100644 src/core/basics/InitializeVariable.cpp

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 2cd55ad..0da196b 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -7,7 +7,7 @@
 set(CORE_SOURCES
 
     # Basic C++ language features
-    ${CMAKE_CURRENT_SOURCE_DIR}/basics/InitializeVariable.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/basics/Initialization.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/basics/Operations.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/basics/TypeQualifier.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/basics/ControlFlow.cpp
diff --git a/src/core/basics/Initialization.cpp b/src/core/basics/Initialization.cpp
new file mode 100644
index 0000000..7e3b473
--- /dev/null
+++ b/src/core/basics/Initialization.cpp
@@ -0,0 +1,114 @@
+// cppcheck-suppress-file [unreadVariable, unusedVariable, functionStatic]
+
+#include "ExampleRegistry.h"
+#include "Logger.h"
+
+/// @brief Dummy class
+struct Dummy {
+  Dummy() { LOG("Default ctor"); }
+  explicit Dummy(int value) { LOG_S("Int ctor: " << value); }
+  Dummy(const Dummy&) { LOG("Copy ctor"); }
+};
+
+/// @brief Aggregate type
+struct Aggregate {
+  int x;
+  int y;
+};
+
+/// @brief Default Initialization
+void default_ini() {
+  int a;
+  LOG_S("a = " << a);
+
+  Dummy object;
+
+  auto* p1 = new int;
+  LOG_S("*p1 = " << *p1);
+  auto* p2 = new Dummy;
+
+  delete p1;
+  delete p2;
+}
+
+/// @brief Value Initialization
+void value_ini() {
+  // int x();Dummy obj();      // Most Vexing Parse:function declaration
+
+  int a = int();
+  int b{};
+
+  LOG_S("a = " << a);
+  LOG_S("b = " << b);
+
+  Dummy object1 = Dummy();  // value initialization x copy-initialization
+  Dummy object2{};
+
+  auto* p1 = new int();
+  LOG_S("*p1 = " << *p1);
+
+  auto* p2 = new Dummy();
+
+  delete p1;
+  delete p2;
+}
+
+/// @brief Direct Initialization
+void direct_ini() {
+  int a(42);
+
+  Dummy object1(1);
+  Dummy object2(static_cast<int>(2));
+
+  LOG_S("a = " << a);
+}
+
+/// @brief Copy Initialization
+void copy_ini() {
+  Dummy source{1};
+
+  Dummy object1 = source;
+  Dummy object2 = Dummy{2};
+
+  int value = 42;
+
+  LOG_S("value = " << value);
+}
+
+/// @brief List Initialization (since C++11)
+void list_ini() {
+  Dummy object1{1};                         // direct-list-init
+  Dummy object2 = {static_cast<Dummy>(2)};  // copy-list-init
+
+  int values1[]{1, 2, 3};
+  int values2[] = {4, 5, 6};
+}
+
+/// @brief Aggregate Initialization
+void aggregate_ini() {
+  Aggregate a1 = {1, 2};
+  Aggregate a2{3, 4};
+  Aggregate a3{.x = 3, .y = 4};
+
+  LOG_S("a1 = {" << a1.x << ", " << a1.y << "}");
+  LOG_S("a2 = {" << a2.x << ", " << a2.y << "}");
+  LOG_S("a3 = {" << a3.x << ", " << a3.y << "}");
+}
+
+class Initialization : public IExample {
+ public:
+  std::string group() const override { return "core/basics"; }
+  std::string name() const override { return "Initialization"; }
+  std::string description() const override { return "Initialization Examples"; }
+
+  void execute() override {
+    default_ini();
+    value_ini();
+    direct_ini();
+    copy_ini();
+    list_ini();
+    aggregate_ini();
+  }
+};
+
+REGISTER_EXAMPLE(Initialization);
\ No newline at end of file
diff --git a/src/core/basics/InitializeVariable.cpp b/src/core/basics/InitializeVariable.cpp
deleted file mode 100644
index 57c5163..0000000
--- a/src/core/basics/InitializeVariable.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// cppcheck-suppress-file [unreadVariable, unusedVariable, functionStatic]
-
-#include "Logger.h"
-#include "ExampleRegistry.h"
-
-void initialize_variable();
-
-class InitializeVariable : public IExample {
- public:
-  std::string group() const override { return "core/basics"; }
-  std::string name() const override { return "InitializeVariable"; }
-  std::string description() const override { return "InitializeVariable"; }
-
-  void execute() override { initialize_variable(); }
-};
-
-REGISTER_EXAMPLE(InitializeVariable);
-
-struct Foo {
-  Foo() { LOG("Default constructor/ default init"); }
-
-  // Foo(int)
-  explicit Foo(int) {
-    LOG( "Constructor called with int / copy init");
-  }
-
-  Foo(const Foo& other) {
-    other.dump();
-    LOG( "Copy constructor called");
-  }
-
-  void dump() const {}
-};
-
-void initialize_variable() {
-  LOG( "\n--- Variable Initialization Examples ---");
-  // * 1) Default-initialization
-  int init_default_var;
-  Foo init_default_obj;
-
-  auto* c = new unsigned char;
-  *c = 0xF;  // actual init at this point for c
-  delete c;
-
-  // * 2) Value-initialization
-  int init_value_var1();
-  int init_value_var2{};
-
-  // * 3) direct-init: Type var(value);
-  Foo direct_init_obj(4);  // call Foo(int)
-  Foo direct_init_obj2(4.3);  // look for constructor -> implicit 4.3(float) -> 4(int) -> call Foo(int)
-
-  // * 4) Copy-init: Type var = other;
-  //     1. Compiler tries to convert the value to a temporary Foo.
-  //     2. If the constructor is explicit, implicit conversion is blocked -> compilation error.
-  //     3. Otherwise, a temporary Foo is created and then copied/moved into the variable.
-  Foo copy_init_obj = (Foo)2.3;
-  // explicit cast: double 2.3 -> int 2 (implicit narrowing) -> Foo(int)
-  // -> temporary Foo -> copied/moved into copyInitObj
-  // Foo copyInitObjError = 2.3; // ERROR: implicit conversion blocked by explicit constructor
-  // We can explicitly prevent certain conversions using = delete or using {}
-
-  //  * 5) List-initialization (Brace init)
-  // calls the constructor directly without allowing implicit conversions.
-  Foo brace_init{3};
-  // Foo braceInit2{3.3}; // ERORR => Prefer this way
-  int ar[] = {1, 2, 3};  // aggregate init
-  int ar2[]{1, 2, 3};
-}
\ No newline at end of file

From b6ddcee98e8c5b1458e4d49ebee29452ea9e14ec Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Wed, 24 Jun 2026 13:19:59 +0700
Subject: [PATCH 12/18] Update script to ignore static check embedded stuffs

---
 scripts/run.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/scripts/run.sh b/scripts/run.sh
index a15e535..6383704 100755
--- a/scripts/run.sh
+++ b/scripts/run.sh
@@ -45,7 +45,8 @@ cppcheck \
     --inline-suppr \
     --quiet \
     --error-exitcode=1 \
-    ./src ./include
+    ./src ./include \
+    -isrc/embedded/
 
 echo "[OK] Static analysis passed"
 

From 98a3fdf5acf428b840c48b7d8ff6422cb4ad832c Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Wed, 24 Jun 2026 13:20:15 +0700
Subject: [PATCH 13/18] refactor

---
 src/core/basics/Initialization.cpp |  2 +-
 src/core/utils/Variadic.cpp        | 29 ++++++++++-------------------
 src/embedded/README.md             |  1 -
 3 files changed, 11 insertions(+), 21 deletions(-)

diff --git a/src/core/basics/Initialization.cpp b/src/core/basics/Initialization.cpp
index 7e3b473..853af7e 100644
--- a/src/core/basics/Initialization.cpp
+++ b/src/core/basics/Initialization.cpp
@@ -1,4 +1,4 @@
-// cppcheck-suppress-file [unreadVariable, unusedVariable, functionStatic]
+// cppcheck-suppress-file [unreadVariable, unusedVariable, uninitdata, uninitvar, unassignedVariable]
 
 #include "ExampleRegistry.h"
 #include "Logger.h"
diff --git a/src/core/utils/Variadic.cpp b/src/core/utils/Variadic.cpp
index 57a0519..3f02483 100644
--- a/src/core/utils/Variadic.cpp
+++ b/src/core/utils/Variadic.cpp
@@ -5,14 +5,12 @@
 #include "Logger.h"
 
 namespace c_variadic_style {
-/**
- * @brief Simple C-style variadic function example.
- *
- * The format string controls how arguments are read:
- *   d -> int
- *   c -> char
- *   f -> double
- */
+
+/// @brief Simple C-style variadic function
+/// The format string controls how arguments are read:
+///   d -> int
+///   c -> char
+///   f -> double
 void simple_printf(const char* fmt, ...) {
   // Holds all unnamed arguments
   va_list args;
@@ -53,14 +51,11 @@ void run() {
 }  // namespace c_variadic_style
 
 namespace modern_variadic_style {
-/**
- * @brief Base case for recursion.
- */
+
+/// @brief Base case for recursion
 inline void simple_printf(const char* /*fmt*/) {}
 
-/**
- * @brief Print one argument based on format specifier.
- */
+/// @brief Print one argument based on format specifier
 template <typename T>
 void print_arg(char fmt, const T& value) {
   switch (fmt) {
@@ -81,9 +76,7 @@ void print_arg(char fmt, const T& value) {
   }
 }
 
-/**
- * @brief Recursive variadic template implementation.
- */
+/// @brief Recursive variadic template implementation
 template <typename T, typename... Args>
 void simple_printf(const char* fmt, T value, Args... args) {
   if (*fmt == '\0') {
@@ -107,9 +100,7 @@ void run() {
 class Variadic : public IExample {
  public:
   std::string group() const override { return "core/utils"; }
-
   std::string name() const override { return "Variadic"; }
-
   std::string description() const override {
     return "Examples for C-style variadic arguments";
   }
diff --git a/src/embedded/README.md b/src/embedded/README.md
index 8cc4058..917b832 100644
--- a/src/embedded/README.md
+++ b/src/embedded/README.md
@@ -59,7 +59,6 @@ $ arm-none-eabi-objcopy  # ELF to BIN converter
 $ arm-none-eabi-gdb      # Debugger
 ```
 
-`$ qemu-system-arm -M stm32vldiscovery -kernel firmware.bin`
 ### 1.4. Linker Script
 **Linker Script** is a configuration file that tells the linker how to place the program into the mcu memory.
 - Define the memory layout: Flash, RAM, Stack, Heap

From 864f46b415809cf978f0d6029290403ec5ea85c8 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Thu, 23 Jul 2026 14:26:27 +0700
Subject: [PATCH 14/18] Update gitignore

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index d2d49df..e84cd09 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,5 @@ coverage_gcovr
 coverage_lcov
 !.vscode/launch.json
 !.vscode/tasks.json
-.cache
\ No newline at end of file
+.cache
+__pycache__/
\ No newline at end of file

From 061f35059c7da036c49c6bb078e6e1b2a5eae778 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 26 Jul 2026 20:36:00 +0700
Subject: [PATCH 15/18] Update for Abstract factory

---
 src/dp/creational/AbstractFactory.cpp | 100 +++++++++++--------------
 src/dp/creational/FactoryMethod.cpp   | 101 +++++++++-----------------
 2 files changed, 74 insertions(+), 127 deletions(-)

diff --git a/src/dp/creational/AbstractFactory.cpp b/src/dp/creational/AbstractFactory.cpp
index e2f51f0..e9bb9f4 100644
--- a/src/dp/creational/AbstractFactory.cpp
+++ b/src/dp/creational/AbstractFactory.cpp
@@ -2,15 +2,7 @@
 
 // Abstract Factory is a creational design pattern that lets you produce
 // families of related objects without specifying their concrete classes.
-// Appicability:
-// (*)  when your code needs to work with various families of related products,
-//      but you don’t want it to depend on the concrete classes
-//      of those products—they might be unknown beforehand or you simply want to
-//      allow for future extensibility.
-// (**) when you have a class with a set of Factory Methods that blur its
-//      primary responsibility.
-
-// UML: docs/uml/patterns_creational_abstractfactory.drawio.svg
+
 #include <memory>
 #include <string>
 #include "ExampleRegistry.h"
@@ -18,19 +10,16 @@
 
 namespace {
 namespace abstract_factory {
-/**
- * The Product interface declares the operations that all concrete products must
- * implement.
- */
+
+/// @class Product Interface
+/// @brief Declares the operations that all concrete products must implement
 class IGdbProduct {
  public:
   virtual ~IGdbProduct() = default;
   virtual void launch() const = 0;
 };
 
-/**
- * Concrete Products provide various implementations of the Product interface.
- */
+/// @brief The concrete product
 class LinuxGdbProduct : public IGdbProduct {
  public:
   void launch() const override {
@@ -75,60 +64,62 @@ class MacOsCMakeProduct : public ICMakeProduct {
   }
 };
 
-// ===================================================================================
-
-/*
- * Abstract Factory
- * provides an abstract interface for creating a family of products
- */
+/// @class Abstract Factory
+/// @brief Provide abstract interface for creating a family of products
 class IProductAbstractFactory {
  public:
   virtual ~IProductAbstractFactory() = default;
-  virtual IGdbProduct* create_gdb_product() = 0;
-  virtual ICMakeProduct* create_cmake_product() = 0;
+  virtual std::unique_ptr<IGdbProduct> create_gdb_product() = 0;
+  virtual std::unique_ptr<ICMakeProduct> create_cmake_product() = 0;
 };
 
-/*
- * Concrete Factory
- * each concrete factory create a family of products and client uses
- * one of these factories so it never has to instantiate a product object
- */
+/// @class Concrete Factory
+/// @brief concrete factory create a family of products and client uses
+/// one of these factories so it never has to instantiate a product object
 class WindowsProductFactory : public IProductAbstractFactory {
  public:
-  IGdbProduct* create_gdb_product() override { return new WindowsGdbProduct(); }
-  ICMakeProduct* create_cmake_product() override {
-    return new WindowsCMakeProduct();
+  std::unique_ptr<IGdbProduct> create_gdb_product() override {
+    return std::make_unique<WindowsGdbProduct>();
+  }
+  std::unique_ptr<ICMakeProduct> create_cmake_product() override {
+    return std::make_unique<WindowsCMakeProduct>();
   }
 };
 
 class LinuxProductFactory : public IProductAbstractFactory {
  public:
-  IGdbProduct* create_gdb_product() override { return new LinuxGdbProduct(); }
-  ICMakeProduct* create_cmake_product() override {
-    return new LinuxCMakeProduct();
+  std::unique_ptr<IGdbProduct> create_gdb_product() override {
+    return std::make_unique<LinuxGdbProduct>();
+  }
+
+  std::unique_ptr<ICMakeProduct> create_cmake_product() override {
+    return std::make_unique<LinuxCMakeProduct>();
   }
 };
 
 class MacOsProductFactory : public IProductAbstractFactory {
  public:
-  IGdbProduct* create_gdb_product() override { return new MacOsGdbProduct(); }
-  ICMakeProduct* create_cmake_product() override {
-    return new MacOsCMakeProduct();
+  std::unique_ptr<IGdbProduct> create_gdb_product() override {
+    return std::make_unique<MacOsGdbProduct>();
   }
-};
 
-// ===================================================================================
+  std::unique_ptr<ICMakeProduct> create_cmake_product() override {
+    return std::make_unique<MacOsCMakeProduct>();
+  }
+};
 
-// static redudant inside anonymous namespace
-IProductAbstractFactory* create_product_factory(const std::string& os) {
+/// @brief Factory selector
+/// static redudant inside anonymous namespace
+std::unique_ptr<IProductAbstractFactory> create_product_factory(
+    const std::string& os) {
   if (os == "linux") {
-    return new LinuxProductFactory();
+    return std::make_unique<LinuxProductFactory>();
   }
   if (os == "windows") {
-    return new WindowsProductFactory();
+    return std::make_unique<WindowsProductFactory>();
   }
   if (os == "macos") {
-    return new MacOsProductFactory();
+    return std::make_unique<MacOsProductFactory>();
   }
   LOG("OS not support yet - " + os);
 
@@ -138,25 +129,16 @@ IProductAbstractFactory* create_product_factory(const std::string& os) {
 void run() {
   LOG("Abstract Factory Pattern Example");
 
-  /**
-  * The client code works with factories and products only through abstract
-  * types: AbstractFactory and AbstractProduct. This lets you pass any factory or
-  * product subclass to the client code without breaking it.
-  */
   auto client_code = [](IProductAbstractFactory* f) {
-    ICMakeProduct* cmake = f->create_cmake_product();
-    IGdbProduct* gdb = f->create_gdb_product();
+    auto cmake = f->create_cmake_product();
+    auto gdb = f->create_gdb_product();
     cmake->launch();
     gdb->launch();
-
-    delete cmake;
-    delete gdb;
   };
 
-  std::string os = "linux";
-  IProductAbstractFactory* factory = create_product_factory(os);
-  client_code(factory);
-  delete factory;
+  const std::string os = "linux";
+  auto factory = create_product_factory(os);
+  client_code(factory.get());
 }
 }  // namespace abstract_factory
 }  // namespace
diff --git a/src/dp/creational/FactoryMethod.cpp b/src/dp/creational/FactoryMethod.cpp
index f099ff1..16e897a 100644
--- a/src/dp/creational/FactoryMethod.cpp
+++ b/src/dp/creational/FactoryMethod.cpp
@@ -1,35 +1,20 @@
 // cppcheck-suppress-file [functionStatic]
 
-// Factory Method is a creational design pattern that provides an interface for
-// creating objects in a superclass, but allows subclasses to alter the type of
-// objects that will be created. Appicability:
-// (*)  when you don’t know beforehand the exact types and dependencies of the
-// objects your code should work with.
-// (**) when you want to provide users of your library or framework with a way
-// to extend its internal components.
-// (***)when you want to save system resources by reusing existing objects
-// instead of rebuilding them each time.
-
-// UML: docs/uml/patterns_creational_factorymethod.drawio.svg
-
+#include <memory>
 #include <string>
+#include "ExampleRegistry.h"
 #include "Logger.h"
 
 namespace {
 namespace factory_method {
-/**
- * The Product interface declares the operations that all concrete products must
- * implement.
- */
+
+/// @class Product Interface
 class IGdbProduct {
  public:
   virtual ~IGdbProduct() = default;
   virtual void launch() const = 0;
 };
 
-/**
- * Concrete Products provide various implementations of the Product interface.
- */
 class LinuxGdbProduct : public IGdbProduct {
  public:
   void launch() const override {
@@ -49,115 +34,95 @@ class MacOsGdbProduct : public IGdbProduct {
   void launch() const override { LOG("brew install gdb && gdb --version"); }
 };
 
-// ===================================================================================
-
-/**
- * The Creator class declares the factory method that is supposed to return an
- * object of a Product class. The Creator's subclasses usually provide the
- * implementation of this method. (a.k.a IGdbFactory)
- */
+/// @class Creator Interface
 class IGdbFactory {
  public:
   virtual ~IGdbFactory() = default;
-  virtual IGdbProduct* factory_method() = 0;
+  virtual std::unique_ptr<IGdbProduct> factory_method() = 0;
   virtual void launch_gdb() = 0;
 };
 
 class AbstractGdbFactory : public IGdbFactory {
  public:
-  // Call the factory method to create a Product object.
+  /// @brief call the factory method to create a Product object
+  /// execute operation
   void launch_gdb() final {
-    IGdbProduct* gdb = this->factory_method();
+    auto gdb = this->factory_method();
     gdb->launch();
-    delete gdb;
   }
 };
 
-/**
- * Concrete Creators override the factory method in order to change the
- * resulting product's type.
- */
 class WindowsGdbFactory : public AbstractGdbFactory {
  public:
-  IGdbProduct* factory_method() override { return new WindowsGdbProduct(); }
+  std::unique_ptr<IGdbProduct> factory_method() override {
+    return std::make_unique<WindowsGdbProduct>();
+  }
 };
 
 class LinuxGdbFactory : public AbstractGdbFactory {
  public:
-  IGdbProduct* factory_method() override { return new LinuxGdbProduct(); }
+  std::unique_ptr<IGdbProduct> factory_method() override {
+    return std::make_unique<LinuxGdbProduct>();
+  }
 };
 
 class MacOsGdbFactory : public AbstractGdbFactory {
  public:
-  IGdbProduct* factory_method() override { return new MacOsGdbProduct(); }
+  std::unique_ptr<IGdbProduct> factory_method() override {
+    return std::make_unique<MacOsGdbProduct>();
+  }
 };
 
-// ===================================================================================
-
-IGdbFactory* create_gdb_factory(const std::string& os) {
+/// @brief selector
+std::unique_ptr<IGdbFactory> create_gdb_factory(const std::string& os) {
   if (os == "linux") {
-    return new LinuxGdbFactory();
+    return std::make_unique<LinuxGdbFactory>();
   }
   if (os == "windows") {
-    return new WindowsGdbFactory();
+    return std::make_unique<WindowsGdbFactory>();
   }
   if (os == "macos") {
-    return new MacOsGdbFactory();
+    return std::make_unique<MacOsGdbFactory>();
   }
   LOG("OS not support yet - " + os);
   return nullptr;
 }
 
 void run() {
-  /**
-  * The client code works with an instance of a concrete creator, albeit through
-  * its base interface. As long as the client keeps working with the creator via
-  * the base interface, you can pass it any creator's subclass.
-  */
   auto client_code = [](IGdbFactory* gdb) {
-    if (gdb != nullptr)
+    if (gdb != nullptr) {
       gdb->launch_gdb();
+    }
   };
 
   // Create factory base on the os
   {
     const std::string os = "linux";
-    IGdbFactory* gdb = create_gdb_factory(os);
+    auto gdb = create_gdb_factory(os);
 
-    client_code(gdb);
-
-    delete gdb;
+    client_code(gdb.get());
   }
   {
     const std::string os = "windows";
-    IGdbFactory* gdb = create_gdb_factory(os);
-
-    client_code(gdb);
+    auto gdb = create_gdb_factory(os);
 
-    delete gdb;
+    client_code(gdb.get());
   }
   {
     const std::string os = "macos";
-    IGdbFactory* gdb = create_gdb_factory(os);
+    auto gdb = create_gdb_factory(os);
 
-    client_code(gdb);
-
-    delete gdb;
+    client_code(gdb.get());
   }
   {
     const std::string os = "unknown";
-    IGdbFactory* gdb = create_gdb_factory(os);
-
-    client_code(gdb);
-
-    delete gdb;
+    auto gdb = create_gdb_factory(os);
+    client_code(gdb.get());
   }
 }
 }  // namespace factory_method
 }  // namespace
 
-#include "ExampleRegistry.h"
-
 class FactoryMethodExample : public IExample {
  public:
   std::string group() const override { return "dp/creational"; }

From fb694bb82ae201477680b9eca4c5b1946f477c56 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 26 Jul 2026 20:54:35 +0700
Subject: [PATCH 16/18] Update for builder

---
 src/dp/creational/Builder.cpp | 79 +++++++++++------------------------
 1 file changed, 24 insertions(+), 55 deletions(-)

diff --git a/src/dp/creational/Builder.cpp b/src/dp/creational/Builder.cpp
index c9ee38e..cee7339 100644
--- a/src/dp/creational/Builder.cpp
+++ b/src/dp/creational/Builder.cpp
@@ -1,20 +1,14 @@
 // cppcheck-suppress-file [functionStatic]
 
-// Builder is a creational design pattern that lets you construct complex
-// objects step by step. The pattern allows you to produce different types and
-// representations of an object using the same construction code. Appicability:
-// (*)  Use the Builder pattern to get rid of a “telescoping constructor”.
-// (**) when you want your code to be able to create different representations
-// of some product (for example, stone and wooden houses).
-
-// UML: docs/uml/patterns_behavioral_iterator.drawio.svg
-
+#include <memory>
 #include <ostream>
 #include <sstream>
 #include <string>
 #include <vector>
 #include "Logger.h"
 
+#include "ExampleRegistry.h"
+
 namespace {
 namespace builder_pattern {
 class Product {
@@ -37,10 +31,8 @@ class Product {
   }
 };
 
-/**
- * The Builder interface specifies methods for creating the different parts of
- * the Product objects.
- */
+/// @class Builder Interface
+/// @brief specifics methods for creating the different parts
 class IBuilder {
  public:
   virtual ~IBuilder() = default;
@@ -49,53 +41,30 @@ class IBuilder {
   virtual IBuilder& produce_part_2() = 0;
   virtual IBuilder& produce_part_3() = 0;
 
-  virtual Product* build() = 0;
+  virtual std::unique_ptr<Product> build() = 0;
 };
 
 class AbstractBuilder : public IBuilder {
  protected:
-  Product* product_;
+  std::unique_ptr<Product> product_;
 
  public:
-  explicit AbstractBuilder() { product_ = new Product(); }
-
-  ~AbstractBuilder() override { delete product_; }
-
-  AbstractBuilder(const AbstractBuilder& other) {
-
-    delete product_;
-
-    product_ = new Product();
-    *product_ = *other.product_;
-  }
-
-  AbstractBuilder& operator=(const AbstractBuilder& other) {
-    if (this == &other) {
-      return *this;
-    }
+  explicit AbstractBuilder() : product_{std::make_unique<Product>()} {}
 
-    delete product_;
-    product_ = new Product();
-    *product_ = *other.product_;
+  AbstractBuilder(const AbstractBuilder&) = delete;
+  AbstractBuilder& operator=(const AbstractBuilder&) = delete;
 
-    return *this;
-  }
+  AbstractBuilder(AbstractBuilder&&) = default;
+  AbstractBuilder& operator=(AbstractBuilder&&) = default;
 
-  // the child classes are no longer override this function
+  /// @brief the child classes are no longer override this function
   IBuilder& reset() final {
-
-    delete product_;
-    product_ = new Product();
-
+    product_ = std::make_unique<Product>();
     return *this;
   }
 };
 
-/**
- * The Concrete Builder classes follow the Builder interface and provide
- * specific implementations of the building steps. Your program may have several
- * variations of Builders, implemented differently.
- */
+/// @class Concrete Builder
 class SimpleBuilder : public AbstractBuilder {
  public:
   IBuilder& produce_part_1() override {
@@ -113,7 +82,7 @@ class SimpleBuilder : public AbstractBuilder {
     return *this;
   }
 
-  Product* build() override { return product_; }
+  std::unique_ptr<Product> build() override { return std::move(product_); }
 };
 
 class ComplexBuilder : public AbstractBuilder {
@@ -133,23 +102,25 @@ class ComplexBuilder : public AbstractBuilder {
     return *this;
   }
 
-  Product* build() override { return product_; }
+  std::unique_ptr<Product> build() override { return std::move(product_); }
 };
 
 void run() {
   auto client_code = [](IBuilder* const builder) {
-    const Product* p1 =
+    // product 1
+    auto p1 =
         (*builder).produce_part_1().produce_part_2().produce_part_3().build();
     p1->print();
-    const Product* p2 = (*builder).reset().produce_part_1().build();
+
+    // product 2
+    auto p2 = (*builder).reset().produce_part_1().build();
     p2->print();
   };
 
   {
     LOG("ConcreteBuilder: Simple");
-    IBuilder* builder = new SimpleBuilder();
-    client_code(builder);
-    delete builder;
+    auto builder = std::make_unique<SimpleBuilder>();
+    client_code(builder.get());
   }
   {
     LOG("ConcreteBuilder: Complex");
@@ -161,8 +132,6 @@ void run() {
 }  // namespace builder_pattern
 }  // namespace
 
-#include "ExampleRegistry.h"
-
 class BuilderExample : public IExample {
  public:
   std::string group() const override { return "dp/creational"; }

From 1beb831490dcc409848ca8f928bdddfbe4e5fad8 Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 26 Jul 2026 21:09:38 +0700
Subject: [PATCH 17/18] Update for singleton

---
 src/dp/creational/Singleton.cpp | 73 ++++++++++++---------------------
 1 file changed, 27 insertions(+), 46 deletions(-)

diff --git a/src/dp/creational/Singleton.cpp b/src/dp/creational/Singleton.cpp
index 1165215..d9a695d 100644
--- a/src/dp/creational/Singleton.cpp
+++ b/src/dp/creational/Singleton.cpp
@@ -1,69 +1,52 @@
 // cppcheck-suppress-file [functionStatic]
 
-// Singleton is a creational design pattern that lets you ensure that a class
-// has only one instance, while providing a global access point to this
-// instance. Appicability:
-// (*)  when a class in your program should have just a single instance
-// available to all clients; for example, a single database object shared by
-// different parts of the program.
-// (**) when you need stricter control over global variables.
-
-// UML: docs/uml/patterns_creational_singleton.drawio.svg
-
 #include <string>
+#include "ExampleRegistry.h"
 #include "Logger.h"
 
 namespace {
 namespace singleton_pattern {
 
-/**
- * The Singleton class defines the `GetInstance` method that serves as an
- * alternative to constructor and lets clients access the same instance of this
- * class over and over.
- */
-class Singleton {
- private:
-  static inline Singleton* instance_ = nullptr;
-  static inline int id_ = 0;
-  int dummy_{};
-  /**
-   * The Singleton's constructor should always be private to prevent direct
-   * construction calls with the `new` operator.
-   */
-  Singleton() = default;
+/// @class Singleton class
+/// @brief defines the `GetInstance` method that serves as an alternative to constructor
+class SingletonConfig {
 
  public:
   // 1. Should not be cloneable.
-  Singleton(const Singleton& other) = delete;
+  SingletonConfig(const SingletonConfig& other) = delete;
 
   // 2. Should not be assignable
-  Singleton& operator=(const Singleton& other) = delete;
+  SingletonConfig& operator=(const SingletonConfig& other) = delete;
 
-  static Singleton* get_instance() {
-    if (instance_ == nullptr) {
-      instance_ = new Singleton();
-      id_++;
-    }
-    LOG("id: " + std::to_string(id_));
-    return instance_;
+  static SingletonConfig& get_instance() {
+    static SingletonConfig instance;
+    return instance;
   }
 
-  void operation() {
-    LOG("id: " + std::to_string(id_));
-    dummy_++;
+  void init(const std::string& input) {
+    LOG(input);
+    value_ = input;
   }
+
+  const std::string& get_value() const {
+    LOG("");
+    return value_;
+  };
+
+ private:
+  /// @brief Default constructor should always be private
+  SingletonConfig() = default;
+  std::string value_;
 };
 
 void run() {
-  auto client_code = [](Singleton* s) {
-    s->operation();
+  auto client_code = []() {
+    LOG(SingletonConfig::get_instance().get_value());
   };
 
-  Singleton* s1 = Singleton::get_instance();
-  client_code(s1);
-
-  Singleton* s2 = Singleton::get_instance();
-  client_code(s2);
+  SingletonConfig& s1 = SingletonConfig::get_instance();
+  s1.init("0x001");
+  client_code();
 
   // Singleton* s3 = new Singleton(); // ERROR
 }
@@ -71,8 +54,6 @@ void run() {
 }  // namespace singleton_pattern
 }  // namespace
 
-#include "ExampleRegistry.h"
-
 class SingletonExample : public IExample {
  public:
   std::string group() const override { return "dp/creational"; }

From c524c818f4c57742fac00752f6a586bb332da06f Mon Sep 17 00:00:00 2001
From: Phong Nguyen <nphong2103@gmail.com>
Date: Sun, 26 Jul 2026 21:22:42 +0700
Subject: [PATCH 18/18] Update descriptions

---
 src/dp/creational/AbstractFactory.cpp |  10 +-
 src/dp/creational/Builder.cpp         |   7 ++
 src/dp/creational/FactoryMethod.cpp   |   7 ++
 src/dp/creational/Prototype.cpp       | 148 +++++++++++++-------------
 src/dp/creational/Singleton.cpp       |   8 ++
 5 files changed, 102 insertions(+), 78 deletions(-)

diff --git a/src/dp/creational/AbstractFactory.cpp b/src/dp/creational/AbstractFactory.cpp
index e9bb9f4..ffb5626 100644
--- a/src/dp/creational/AbstractFactory.cpp
+++ b/src/dp/creational/AbstractFactory.cpp
@@ -1,7 +1,13 @@
 // cppcheck-suppress-file [functionStatic]
 
-// Abstract Factory is a creational design pattern that lets you produce
-// families of related objects without specifying their concrete classes.
+// Abstract Factory — create families of related products without concrete types.
+//
+// Flow in this file:
+//   1. Define product interfaces             -> IGdbProduct, ICMakeProduct
+//   2. Implement concrete products per OS    -> Linux / Windows / MacOs variants
+//   3. Define an abstract factory            -> IProductAbstractFactory
+//   4. Implement concrete factories          -> one factory = one matching family
+//   5. Client uses one factory for all products -> products stay consistent (same OS)
 
 #include <memory>
 #include <string>
diff --git a/src/dp/creational/Builder.cpp b/src/dp/creational/Builder.cpp
index cee7339..ae861a2 100644
--- a/src/dp/creational/Builder.cpp
+++ b/src/dp/creational/Builder.cpp
@@ -1,5 +1,12 @@
 // cppcheck-suppress-file [functionStatic]
 
+// Flow in this file:
+//   1. Define the product being built        -> Product (parts list)
+//   2. Define a builder interface            -> IBuilder (produce_part_N / build)
+//   3. Share common builder state            -> AbstractBuilder (reset / product_)
+//   4. Implement concrete builders           -> SimpleBuilder / ComplexBuilder
+//   5. Client chains steps, then build()     -> same steps, different representations
+
 #include <memory>
 #include <ostream>
 #include <sstream>
diff --git a/src/dp/creational/FactoryMethod.cpp b/src/dp/creational/FactoryMethod.cpp
index 16e897a..5c13432 100644
--- a/src/dp/creational/FactoryMethod.cpp
+++ b/src/dp/creational/FactoryMethod.cpp
@@ -1,5 +1,12 @@
 // cppcheck-suppress-file [functionStatic]
 
+// Flow in this file:
+//   1. Define a product interface            -> IGdbProduct
+//   2. Implement concrete products           -> Linux / Windows / MacOs Gdb
+//   3. Define a creator interface            -> IGdbFactory (+ AbstractGdbFactory)
+//   4. Implement concrete creators           -> Linux / Windows / MacOs factories
+//   5. Client picks a factory, then uses it  -> never constructs products directly
+
 #include <memory>
 #include <string>
 #include "ExampleRegistry.h"
diff --git a/src/dp/creational/Prototype.cpp b/src/dp/creational/Prototype.cpp
index 5cb57bd..3816684 100644
--- a/src/dp/creational/Prototype.cpp
+++ b/src/dp/creational/Prototype.cpp
@@ -1,135 +1,131 @@
 // cppcheck-suppress-file [functionStatic]
 
-// Prototype is a creational design pattern that lets you "copy existing objects" without making your code "dependent on their classes".
-// Appicability:
-// (*)  when your code shouldn’t depend on the concrete classes of objects that you need to copy.
-// (**) when you want to reduce the number of subclasses that only differ in the way they initialize their respective objects.
-
-// UML: docs/uml/patterns_behavioral_prototype.drawio.svg
-
+// Prototype = create new objects by cloning existing ones.
+//
+// Flow in this file:
+//   1. Define a cloneable interface          -> IExtensionPrototype
+//   2. Implement concrete prototypes         -> Logger / Analytics
+//   3. (Optional) Store named presets        -> ExtensionPrototypeRegistry
+//   4. Client asks registry to clone by id   -> never mentions concrete types
+
+#include <memory>
+#include <string>
+#include <string_view>
 #include <unordered_map>
 #include <utility>
+
+#include "ExampleRegistry.h"
 #include "Logger.h"
+
 namespace {
 namespace prototy {
 
-constexpr std::string_view kLoggerEtxId = "logger";
+constexpr std::string_view kLoggerExtId = "logger";
 constexpr std::string_view kAnalyzeId = "analyze";
 
-/*
- * Prototype interface declares the cloning methods.
- * In most cases, it’s a single `clone` method.
- */
+/// @class Prototype interface: "I know how to copy myself."
+/// @brief client code only depends on this class
 class IExtensionPrototype {
  public:
   virtual ~IExtensionPrototype() = default;
-  virtual IExtensionPrototype* clone() = 0;
+
+  /// return a new object
+  virtual std::unique_ptr<IExtensionPrototype> clone() const = 0;
+
   virtual void execute() const = 0;
 };
 
-/*
- * Concrete Prototype implement an operation for cloning itself
- * In addition to copying the original object’s data to the clone,
- * this method may also handle some edge cases of the cloning process related to cloning linked objects,
- * untangling recursive dependencies, etc.
- */
+/// @class Concrete Prototype
+/// @brief each class copies itself
 class LoggerExtension : public IExtensionPrototype {
- private:
-  std::string log_level_;
-
  public:
   explicit LoggerExtension(std::string level = "DEBUG")
       : log_level_{std::move(level)} {}
 
-  IExtensionPrototype* clone() override { return new LoggerExtension(*this); }
+  std::unique_ptr<IExtensionPrototype> clone() const override {
+    return std::make_unique<LoggerExtension>(*this);
+  }
 
   void execute() const override { LOG("log level: " + log_level_); }
-};
 
-class AnalyticsExtension : public IExtensionPrototype {
  private:
-  int sRate_;
+  std::string log_level_;
+};
 
+class AnalyticsExtension : public IExtensionPrototype {
  public:
-  explicit AnalyticsExtension(int level = 1) : sRate_{level} {}
+  explicit AnalyticsExtension(int sampling_rate = 1)
+      : sampling_rate_{sampling_rate} {}
 
-  IExtensionPrototype* clone() override {
-    return new AnalyticsExtension(*this);
+  std::unique_ptr<IExtensionPrototype> clone() const override {
+    return std::make_unique<AnalyticsExtension>(*this);
   }
 
-  void execute() const override { LOG_S("sampling rate: " << sRate_); }
-};
+  void execute() const override { LOG_S("sampling rate: " << sampling_rate_); }
 
-/**
- * Prototype Registry provides an easy way to access frequently-used prototypes.
- * It stores a set of pre-built objects that are ready to be copied.
- * The simplest prototype registry is a name ^ prototype hash map.
- * However, if you need better search criteria than a simple name, you can build a much more robust version of the registry.
- */
-class ExtensionPrototypeRegistry {
  private:
-  std::unordered_map<std::string, IExtensionPrototype*> prototypes_;
+  int sampling_rate_;
+};
 
+/// @class Prototype Registry
+/// @brief a map of named presets ready to be cloned.
+class ExtensionPrototypeRegistry {
  public:
-  ~ExtensionPrototypeRegistry() {
-    for (auto it = prototypes_.begin(); it != prototypes_.end();) {
-      delete it->second;           // free the pointer
-      it = prototypes_.erase(it);  // erase and move to next
-    }
-  }
-  void register_extension(const std::string_view& id,
-                          IExtensionPrototype* proto) {
+  void register_extension(std::string_view id,
+                          std::unique_ptr<IExtensionPrototype> proto) {
     LOG(id);
-    prototypes_[std::string(id)] = proto;
+    prototypes_[std::string(id)] = std::move(proto);
   }
 
-  IExtensionPrototype* create(const std::string_view& id) const {
+  /// clone the preset for `id`. Returns nullptr if the id is unknown.
+  std::unique_ptr<IExtensionPrototype> create(std::string_view id) const {
     auto it = prototypes_.find(std::string(id));
-    if (it != prototypes_.end()) {
-      return it->second->clone();
+    if (it == prototypes_.end()) {
+      return nullptr;
     }
-    return nullptr;
+    return it->second->clone();  // copy the template, leave the original intact
   }
+
+ private:
+  std::unordered_map<std::string, std::unique_ptr<IExtensionPrototype>>
+      prototypes_;
 };
 
 void run() {
-  // Client creates a new object by asking a prototype to clone itself
-  auto client_code = [](const ExtensionPrototypeRegistry* const registry) {
-    IExtensionPrototype* logger_etx = registry->create(prototy::kLoggerEtxId);
-    logger_etx->execute();
-    IExtensionPrototype* analyx_etx = registry->create(prototy::kAnalyzeId);
-    analyx_etx->execute();
-
-    delete logger_etx;
-    delete analyx_etx;
+  // build presets once, register by name
+  ExtensionPrototypeRegistry registry;
+  registry.register_extension(kLoggerExtId,
+                              std::make_unique<LoggerExtension>("DEBUG"));
+  registry.register_extension(kAnalyzeId,
+                              std::make_unique<AnalyticsExtension>(1200));
+
+  // create-by-clone
+  auto client_code = [](const ExtensionPrototypeRegistry& reg) {
+    auto logger_ext = reg.create(kLoggerExtId);
+    auto analytics_ext = reg.create(kAnalyzeId);
+
+    if (logger_ext) {
+      logger_ext->execute();
+    }
+    if (analytics_ext) {
+      analytics_ext->execute();
+    }
   };
 
-  // Create a registry
-  auto* registry = new ExtensionPrototypeRegistry();
-
-  // Register extensions
-  registry->register_extension(prototy::kLoggerEtxId,
-                               new LoggerExtension("DEBUG"));
-  registry->register_extension(prototy::kAnalyzeId,
-                               new AnalyticsExtension(1200));
-
   client_code(registry);
-
-  delete registry;
 }
+
 }  // namespace prototy
 }  // namespace
 
-#include "ExampleRegistry.h"
-
 class PrototypeExample : public IExample {
  public:
   std::string group() const override { return "dp/creational"; }
   std::string name() const override { return "Prototype"; }
   std::string description() const override {
-    return "Prototype Pattern Example";
+    return "Clone configured objects via a prototype interface + registry";
   }
   void execute() override { prototy::run(); }
 };
 
-REGISTER_EXAMPLE(PrototypeExample);
\ No newline at end of file
+REGISTER_EXAMPLE(PrototypeExample);
diff --git a/src/dp/creational/Singleton.cpp b/src/dp/creational/Singleton.cpp
index d9a695d..b3bc6ac 100644
--- a/src/dp/creational/Singleton.cpp
+++ b/src/dp/creational/Singleton.cpp
@@ -1,5 +1,13 @@
 // cppcheck-suppress-file [functionStatic]
 
+// Singleton — ensure a class has only one instance, accessed globally.
+//
+// Flow in this file:
+//   1. Hide the constructor                  -> private SingletonConfig()
+//   2. Ban copy / assign                     -> deleted special members
+//   3. Expose a single access point          -> get_instance() (Meyers' singleton)
+//   4. Client always uses get_instance()     -> same object everywhere
+
 #include <string>
 #include "ExampleRegistry.h"
 #include "Logger.h"