Add 04_additional/ with 6 programming principles + new _basic.py format

  New principles with instant clarity approach:
  - 01_business_logic/ - "Does it exist without computers?" test
  - 02_tell_dont_ask/ - Object encapsulation patterns
  - 03_law_of_demeter/ - "One dot rule" for loose coupling
  - 04_composition_over_inheritance/ - Flexible behavior composition
  - 05_dependency_injection/ - External dependency management
  - 06_static_vs_runtime/ - Compile-time vs execution-time decisions

  Each principle includes:
  - README.md with concise definitions
  - violation.py + violation_basic.py (10-15 lines, instant problem visibility)
  - solution.py + solution_basic.py (clean approach)
  - exercises.md with hands-on practice

  _basic.py format: Zero cognitive load, 5-second understanding, focus on essence.
  Dual format allows quick learning + detailed exploration.

Author: jgrynczewski

day0.md

@@ -0,0 +1,116 @@
+"""
+DRY Solution - Don't Repeat Yourself
+Eliminacja duplikacji poprzez wydzielenie wspólnej logiki
+"""
+
+from datetime import datetime
+
+
+class UserValidator:
+    def _is_valid_email_format(self, email):
+        # DRY: Jedna implementacja podstawowej walidacji
+        return "@" in email and "." in email and len(email) >= 5
+
+    def validate_email(self, email):
+        return self._is_valid_email_format(email)
+
+    def validate_admin_email(self, email):
+        # Reużywa podstawowej walidacji + dodaje specyficzną logikę
+        return (self._is_valid_email_format(email) and
+                email.endswith("@company.com"))
+
+
+class OrderProcessor:
+    TAX_RATE = 0.23
+    SERVICE_FEE_RATE = 0.05
+
+    def _calculate_base_fees(self, amount):
+        # DRY: Wspólna logika obliczania opłat
+        tax = amount * self.TAX_RATE
+        service_fee = amount * self.SERVICE_FEE_RATE
+        return tax + service_fee
+
+    def _apply_discount(self, amount, discount_rate):
+        # DRY: Wspólna logika aplicacji zniżki
+        base_fees = self._calculate_base_fees(amount)
+        discount = amount * discount_rate
+        return amount - discount + base_fees
+
+    def calculate_discount_for_regular(self, amount):
+        return self._apply_discount(amount, 0.10)
+
+    def calculate_discount_for_premium(self, amount):
+        return self._apply_discount(amount, 0.15)
+
+    def calculate_discount_for_vip(self, amount):
+        return self._apply_discount(amount, 0.20)
+
+
+class DatabaseLogger:
+    def _get_timestamp(self):
+        # DRY: Jedna implementacja timestampu
+        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def _log_message(self, message):
+        # DRY: Wspólna logika logowania
+        timestamp = self._get_timestamp()
+        formatted_message = f"[{timestamp}] {message}"
+        print(f"INSERT INTO logs VALUES('{formatted_message}')")
+
+    def log_user_action(self, user_id, action):
+        self._log_message(f"User {user_id}: {action}")
+
+    def log_system_event(self, event):
+        self._log_message(f"System: {event}")
+
+    def log_error(self, error):
+        self._log_message(f"ERROR: {error}")
+
+
+# Bonus: Configuration-driven approach dla jeszcze lepszego DRY
+class AdvancedOrderProcessor:
+    """Przykład data-driven approach dla eliminacji duplikacji"""
+
+    DISCOUNT_RATES = {
+        'regular': 0.10,
+        'premium': 0.15,
+        'vip': 0.20
+    }
+
+    TAX_RATE = 0.23
+    SERVICE_FEE_RATE = 0.05
+
+    def calculate_discount(self, amount, customer_type):
+        # DRY: Jedna metoda dla wszystkich typów klientów
+        if customer_type not in self.DISCOUNT_RATES:
+            raise ValueError(f"Unknown customer type: {customer_type}")
+
+        discount_rate = self.DISCOUNT_RATES[customer_type]
+        base_fees = amount * (self.TAX_RATE + self.SERVICE_FEE_RATE)
+        discount = amount * discount_rate
+
+        return amount - discount + base_fees
+
+
+if __name__ == "__main__":
+    validator = UserValidator()
+    print(validator.validate_email("test@example.com"))
+    print(validator.validate_admin_email("admin@company.com"))
+
+    processor = OrderProcessor()
+    print(f"Regular: ${processor.calculate_discount_for_regular(100):.2f}")
+    print(f"Premium: ${processor.calculate_discount_for_premium(100):.2f}")
+
+    # Bonus: Data-driven approach
+    advanced = AdvancedOrderProcessor()
+    print(f"VIP (advanced): ${advanced.calculate_discount(100, 'vip'):.2f}")
+
+    logger = DatabaseLogger()
+    logger.log_user_action(123, "login")
+    logger.log_system_event("startup")
+    logger.log_error("Database connection failed")
+
+    print("✅ Jedna implementacja dla każdej logiki")
+    print("✅ Zmiana walidacji = 1 miejsce do edycji")
+    print("✅ Zmiana timestamp = 1 miejsce do edycji")
+    print("✅ Nowe typy klientów = dodanie do dictionary")

day0_principles/03_general_principles/01_dry/README.md

@@ -0,0 +1,83 @@
+"""
+DRY Violation - Don't Repeat Yourself
+Duplikacja kodu w różnych miejscach
+"""
+
+
+class UserValidator:
+    def validate_email(self, email):
+        # PROBLEM: Duplikacja logiki walidacji
+        if "@" not in email or "." not in email:
+            return False
+        if len(email) < 5:
+            return False
+        return True
+
+    def validate_admin_email(self, email):
+        # PROBLEM: Ta sama logika co wyżej - duplikacja!
+        if "@" not in email or "." not in email:
+            return False
+        if len(email) < 5:
+            return False
+        # Plus dodatkowa logika
+        if not email.endswith("@company.com"):
+            return False
+        return True
+
+
+class OrderProcessor:
+    def calculate_discount_for_regular(self, amount):
+        # PROBLEM: Identyczna logika obliczania
+        tax = amount * 0.23
+        service_fee = amount * 0.05
+        total_fees = tax + service_fee
+        return amount - (amount * 0.10) + total_fees
+
+    def calculate_discount_for_premium(self, amount):
+        # PROBLEM: Kopia powyższej metody z innym procentem
+        tax = amount * 0.23
+        service_fee = amount * 0.05
+        total_fees = tax + service_fee
+        return amount - (amount * 0.15) + total_fees  # Tylko ta linijka się różni
+
+    def calculate_discount_for_vip(self, amount):
+        # PROBLEM: Znowu ta sama logika
+        tax = amount * 0.23
+        service_fee = amount * 0.05
+        total_fees = tax + service_fee
+        return amount - (amount * 0.20) + total_fees
+
+
+class DatabaseLogger:
+    def log_user_action(self, user_id, action):
+        timestamp = "2024-01-15 10:30:00"  # PROBLEM: Duplikacja formatowania
+        message = f"[{timestamp}] User {user_id}: {action}"
+        print(f"INSERT INTO logs VALUES('{message}')")
+
+    def log_system_event(self, event):
+        timestamp = "2024-01-15 10:30:00"  # PROBLEM: Ta sama logika timestampu
+        message = f"[{timestamp}] System: {event}"
+        print(f"INSERT INTO logs VALUES('{message}')")
+
+    def log_error(self, error):
+        timestamp = "2024-01-15 10:30:00"  # PROBLEM: Znowu duplikacja
+        message = f"[{timestamp}] ERROR: {error}"
+        print(f"INSERT INTO logs VALUES('{message}')")
+
+
+if __name__ == "__main__":
+    validator = UserValidator()
+    print(validator.validate_email("test@example.com"))
+    print(validator.validate_admin_email("admin@company.com"))
+
+    processor = OrderProcessor()
+    print(f"Regular: ${processor.calculate_discount_for_regular(100)}")
+    print(f"Premium: ${processor.calculate_discount_for_premium(100)}")
+
+    logger = DatabaseLogger()
+    logger.log_user_action(123, "login")
+    logger.log_system_event("startup")
+
+    print("❌ Duplikacja kodu w wielu miejscach - naruszenie DRY")
+    print("❌ Zmiana walidacji email = 2 miejsca do edycji")
+    print("❌ Zmiana formatu timestamp = 3 miejsca do edycji")

day0_principles/03_general_principles/01_dry/exercises.md

@@ -0,0 +1,169 @@
+"""
+KISS Solution - Keep It Simple, Stupid
+Proste rozwiązania dla prostych problemów
+"""
+
+
+def calculate_total(items):
+    """KISS: Prosta funkcja do prostego zadania"""
+    return sum(items)
+
+
+def calculate_weighted_total(items, weights):
+    """KISS: Dodaj złożoność tylko gdy potrzebna"""
+    return sum(item * weight for item, weight in zip(items, weights))
+
+
+def authenticate_user(username, password):
+    """KISS: Prosta autentykacja dla prostej aplikacji"""
+    users = {"admin": "password123", "user": "pass456"}
+    return username in users and users[username] == password
+
+
+class SimpleShoppingCart:
+    """KISS: Prosta implementacja koszyka"""
+
+    def __init__(self):
+        self.items = []
+
+    def add_item(self, name, price):
+        self.items.append({"name": name, "price": price})
+
+    def get_total(self):
+        return sum(item["price"] for item in self.items)
+
+    def get_item_count(self):
+        return len(self.items)
+
+
+class UserManager:
+    """KISS: Proste zarządzanie użytkownikami"""
+
+    def __init__(self):
+        self.users = {}
+        self.logged_in_users = set()
+
+    def register_user(self, username, password):
+        if username in self.users:
+            return False
+        self.users[username] = password
+        return True
+
+    def login(self, username, password):
+        if username in self.users and self.users[username] == password:
+            self.logged_in_users.add(username)
+            return True
+        return False
+
+    def logout(self, username):
+        self.logged_in_users.discard(username)
+
+    def is_logged_in(self, username):
+        return username in self.logged_in_users
+
+
+# Przykład: Kiedy można dodać złożoność (ale tylko gdy potrzebna)
+class UserManagerWithSecurity:
+    """
+    KISS + Security: Dodajemy złożoność tylko tam gdzie jest potrzebna
+    Większość firm potrzebuje basic security, więc to uzasadnione
+    """
+
+    def __init__(self):
+        self.users = {}
+        self.logged_in_users = set()
+        self.failed_attempts = {}  # Dodane tylko dla security
+        self.max_attempts = 3
+
+    def register_user(self, username, password):
+        if username in self.users:
+            return False
+        self.users[username] = password
+        return True
+
+    def login(self, username, password):
+        # Prosta logika, ale z podstawowym security
+        if self.failed_attempts.get(username, 0) >= self.max_attempts:
+            return False  # Account locked
+
+        if username in self.users and self.users[username] == password:
+            self.logged_in_users.add(username)
+            if username in self.failed_attempts:
+                del self.failed_attempts[username]  # Reset on success
+            return True
+
+        # Track failed attempts
+        self.failed_attempts[username] = self.failed_attempts.get(username, 0) + 1
+        return False
+
+    def logout(self, username):
+        self.logged_in_users.discard(username)
+
+    def is_logged_in(self, username):
+        return username in self.logged_in_users
+
+
+# Przykład progresywnej złożoności - zaczynamy prosto, dodajemy gdy potrzeba
+class FileProcessor:
+    """KISS: Start simple, add complexity when needed"""
+
+    def read_file(self, filename):
+        # V1: Najprostsza implementacja
+        with open(filename, 'r') as f:
+            return f.read()
+
+    def read_file_safe(self, filename):
+        # V2: Dodajemy error handling tylko gdy mamy problemy
+        try:
+            with open(filename, 'r') as f:
+                return f.read()
+        except FileNotFoundError:
+            return None
+        except Exception as e:
+            print(f"Error reading file: {e}")
+            return None
+
+    def read_file_with_encoding(self, filename, encoding='utf-8'):
+        # V3: Dodajemy encoding tylko gdy mamy problemy z różnymi plikami
+        try:
+            with open(filename, 'r', encoding=encoding) as f:
+                return f.read()
+        except FileNotFoundError:
+            return None
+        except Exception as e:
+            print(f"Error reading file: {e}")
+            return None
+
+
+if __name__ == "__main__":
+    # Proste rozwiązania dla prostych problemów
+    print(f"Sum: {calculate_total([1, 2, 3, 4])}")
+    print(f"Weighted sum: {calculate_weighted_total([1, 2, 3], [0.5, 1.0, 2.0])}")
+
+    print(f"Auth admin: {authenticate_user('admin', 'password123')}")
+    print(f"Auth wrong: {authenticate_user('admin', 'wrong')}")
+
+    # Prosta klasa zamiast over-engineered patterns
+    cart = SimpleShoppingCart()
+    cart.add_item("Laptop", 1000)
+    cart.add_item("Mouse", 50)
+    print(f"Cart total: ${cart.get_total()}")
+
+    # User management - prosty i czytelny
+    user_mgr = UserManager()
+    user_mgr.register_user("john", "secret123")
+    print(f"Login successful: {user_mgr.login('john', 'secret123')}")
+    print(f"Is logged in: {user_mgr.is_logged_in('john')}")
+
+    # Security tylko tam gdzie potrzebne
+    secure_mgr = UserManagerWithSecurity()
+    secure_mgr.register_user("admin", "admin123")
+    print(f"Login attempts: {secure_mgr.login('admin', 'wrong')}")
+    print(f"Login attempts: {secure_mgr.login('admin', 'wrong')}")
+    print(f"Login attempts: {secure_mgr.login('admin', 'wrong')}")
+    print(f"Account locked: {secure_mgr.login('admin', 'admin123')}")  # Should fail - locked
+
+    print("✅ Proste rozwiązania = łatwe do zrozumienia")
+    print("✅ Dodajemy złożoność tylko gdy rzeczywiście potrzebna")
+    print("✅ 5 linii zamiast 50 dla podstawowych operacji")
+    print("✅ Kod robi dokładnie to co potrzebne, nic więcej")