Data Analytics

🚀 Kafka Tutorial – Part 5: Kafka Schema Management & Serialization – Mastering Avro, Protobuf, JSON Schema & Schema Registry Let's start: https://hackmd.io/@husseinsheikho/kafka-part5 #KafkaSchema #SchemaRegistry #Avro #Protobuf #JSONSchema #EventSourcing #DataContracts #KafkaTutorial #DataEngineering #StreamingArchitecture

✉️ Our Telegram channels: https://t.me/addlist/0f6vfFbEMdAwODBk 📱 Our WhatsApp channel: https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 Kafka Tutorial – Part 4: Kafka Topics, Partitions & Replication Deep Dive – Mastering Scalability, Durability & Data Management Let's start: https://hackmd.io/@husseinsheikho/kafka-part4

#ApacheKafka #KafkaTopics #Partitioning #Replication #DataRetention #LogCompaction #KafkaAdmin #KafkaTutorial #DataEngineering #StreamingArchitecture

✉️ Our Telegram channels: https://t.me/addlist/0f6vfFbEMdAwODBk 📱 Our WhatsApp channel: https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 Kafka Tutorial – Part 3: Kafka Consumers Deep Dive – Mastering Message Consumption & Event Processing Let's start: https://hackmd.io/@husseinsheikho/kafka-part3 #ApacheKafka #KafkaConsumers #EventProcessing #RealTimeStreaming #ConsumerGroups #OffsetManagement #KafkaTutorial #DataEngineering #StreamingArchitecture

🚀 Kafka Tutorial – Part 2: Kafka Producers Deep Dive – Mastering Message Publishing Let's start: https://hackmd.io/@husseinsheikho/kafka-part2 #ApacheKafka #KafkaProducers #EventStreaming #RealTimeData #ProducerConfiguration #KafkaTutorial #DataEngineering #StreamingArchitecture

🚀 Kafka Tutorial – Part 1: Introduction to Apache Kafka – The Ultimate Guide for Beginners Let's Start: https://hackmd.io/@husseinsheikho/Kafka-part1

#ApacheKafka #KafkaTutorial #StreamingData #BigData #RealTimeProcessing #EventDrivenArchitecture #KafkaBasics

Can your money really work for you—even in a volatile market? Discover how disciplined investors are building wealth safely with the Wheel Strategy and global ETFs. Get real trade results and weekly lessons—no hype, just proven strategies for growing long-term income. Start controlling your financial future right here before your next investment decision! #إعلان InsideAds - ترويج

I recommend you to join @TradingNewsIO for Global & Economic News 24/7 ⚡️Stay up-to-date with real-time updates on global events. ➡️ Click Here and JOIN NOW ! #إعلان InsideAds - ترويج

There’s a simple method to make daily money online… And almost no one knows about it. 😈 @TaniaTradingAcademy reveals EVERYTHING. ✅ Zero experience needed ✅ Just follow… and profit 💸 People are joining fast… before it blows up, get in 👇 ➡️ @TaniaTradingAcademy #إعلان InsideAds - ترويج

Tired of endless job boards and low offers? Unlock access to exclusive remote jobs from top startups—some with salaries $100k+ and early-bird roles at $50/h and above. New high-paying openings posted daily—tech, marketing, design, and more. Ready to upgrade your career from anywhere? Check today’s top jobs now before they’re gone! #إعلان InsideAds - ترويج

No skills? No problem. Just copy-paste and GET PAID. ➡️ 22,000+ already started… YOU'RE NEXT! Click here @NPFXSignals #إعلان InsideAds - ترويج

This channels is for Programmers, Coders, Software Engineers. 0️⃣ Python 1️⃣ Data Science 2️⃣ Machine Learning 3️⃣ Data Visualization 4️⃣ Artificial Intelligence 5️⃣ Data Analysis 6️⃣ Statistics 7️⃣ Deep Learning 8️⃣ programming Languages ✅ https://t.me/addlist/8_rRW2scgfRhOTc0 ✅ https://t.me/Codeprogrammer

I spent $0 and unlocked courses people pay $499 for. No joke. Ever wondered how I got certified by top Udemy instructors without spending a cent? My friends kept asking, “Where are you getting these premium courses for free?” Here’s the secret link I wish I’d found sooner: discover it before they fix the loophole ⏳ Spots update daily – don’t miss the next hidden gem. #إعلان InsideAds - ترويج

Can your money really work for you—even in a volatile market? Discover how disciplined investors are building wealth safely with the Wheel Strategy and global ETFs. Get real trade results and weekly lessons—no hype, just proven strategies for growing long-term income. Start controlling your financial future right here before your next investment decision! #إعلان InsideAds - ترويج

### 2. WebAssembly Integration

// Load WASM module
WebAssembly.instantiateStreaming(fetch('module.wasm'))
  .then(obj => {
    const result = obj.instance.exports.add(1, 2);
    console.log(result); // 3
  });

### 3. Worker Pools

class WorkerPool {
  constructor(size = navigator.hardwareConcurrency) {
    this.workers = Array(size).fill().map(() => new Worker('task.js'));
    this.queue = [];
  }

  execute(data) {
    return new Promise((resolve) => {
      const worker = this.workers.pop() || this.queue.push(resolve);
      if (worker) this.runTask(worker, data, resolve);
    });
  }

  runTask(worker, data, resolve) {
    worker.onmessage = (e) => {
      resolve(e.data);
      this.workers.push(worker);
      if (this.queue.length) {
        this.runTask(worker, this.queue.shift());
      }
    };
    worker.postMessage(data);
  }
}

--- ## 🔹 Where to Go From Here? ### 1. Recommended Learning Paths - Frontend Masters: Advanced JavaScript courses - TypeScript Docs: Full language reference - ECMAScript Proposals: GitHub tc39/proposals ### 2. Must-Read Books - "JavaScript: The Definitive Guide" by David Flanagan - "Eloquent JavaScript" by Marijn Haverbeke - "Effective TypeScript" by Dan Vanderkam ### 3. Open Source Contribution - First Timers Only: Beginner-friendly issues - Good First Issue: Curated list for new contributors - Your Favorite Libraries: Check their GitHub issues ### 4. Project Ideas 1. Build a compiler (Babel plugin) 2. Create a state management library 3. Develop a browser extension 4. Contribute to Node.js core 5. Build a WebGL visualization --- ## 🔹 Final Project: Full-Stack TypeScript App

// Backend (Node.js + Express)
import express from 'express';
import { createUser, getUsers } from './database';

const app = express();
app.use(express.json());

app.get('/users', async (req, res) => {
  const users = await getUsers();
  res.json(users);
});

app.post('/users', async (req, res) => {
  const newUser = await createUser(req.body);
  res.status(201).json(newUser);
});

// Frontend (React + TypeScript)
interface User {
  id: string;
  name: string;
  email: string;
}

function UserList() {
  const [users, setUsers] = useState<User[]>([]);
  
  useEffect(() => {
    fetch('/users')
      .then(res => res.json())
      .then(data => setUsers(data));
  }, []);

  return (
    <ul>
      {users.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

--- ## 🔹 JavaScript Ecosystem Checklist 1. Master the Browser API - DOM, Fetch, Storage, Workers, etc. 2. Learn Node.js Internals - Event Loop, Streams, Clusters 3. Explore Build Tools - Webpack, Vite, Rollup, esbuild 4. Understand Testing - Jest, Vitest, Cypress, Playwright 5. Follow Trends - Web Components, WASM, Edge Computing --- ### 🎉 Congratulations on Completing the Series! You've now covered: 1. JavaScript Fundamentals 2. Control Flow & Functions 3. Arrays & Objects 4. DOM Manipulation 5. Asynchronous JS 6. Modules & Tooling 7. OOP & Prototypes 8. Functional Programming 9. Error Handling & Debugging 10. Modern JS & Beyond #JavaScriptMastery #FullStackDeveloper #CareerGrowth 🚀 Final Challenge: 1. Build a TS library with tests and docs 2. Optimize a slow web app using profiling 3. Contribute to an open-source project Remember: The best way to learn is by building real projects! Keep coding! 👨‍💻👩‍💻

# 📚 JavaScript Tutorial - Part 10/10: Modern JavaScript & Beyond #JavaScript #ES2023 #TypeScript #AdvancedPatterns #WebDev Welcome to the final part of our comprehensive JavaScript series! This ultimate lesson explores cutting-edge JavaScript features, TypeScript fundamentals, advanced patterns, and pathways for continued learning. --- ## 🔹 Modern JavaScript Features (ES2023+) ### 1. Top-Level Await (ES2022)

// Module.js
const data = await fetch('https://api.example.com/data');
export { data };

// No need for async wrapper!

### 2. Array Find from Last (ES2023)

const numbers = [10, 20, 30, 20, 40];
numbers.findLast(n => n === 20); // 20 (last occurrence)
numbers.findLastIndex(n => n === 20); // 3

### 3. Hashbang Support (ES2023)

#!/usr/bin/env node
// Now executable directly via ./script.js
console.log('Hello from executable JS!');

### 4. WeakRef & FinalizationRegistry (ES2021)

const weakRef = new WeakRef(domElement);
const registry = new FinalizationRegistry(heldValue => {
  console.log(`${heldValue} was garbage collected`);
});

registry.register(domElement, "DOM Element");

### 5. Error Cause (ES2022)

try {
  await fetchData();
} catch (error) {
  throw new Error('Processing failed', { cause: error });
}

--- ## 🔹 TypeScript Fundamentals ### 1. Basic Types

let username: string = "Ali";
let age: number = 25;
let isActive: boolean = true;
let scores: number[] = [90, 85, 95];
let user: { name: string; age?: number } = { name: "Ali" };

### 2. Interfaces & Types

interface User {
  id: number;
  name: string;
  email: string;
}

type Admin = User & { 
  permissions: string[];
};

function createUser(user: User): Admin {
  // ...
}

### 3. Generics

function identity<T>(arg: T): T {
  return arg;
}

const result = identity<string>("Hello");

### 4. Type Inference & Utility Types

const user = {
  name: "Ali",
  age: 25
}; // Type inferred as { name: string; age: number }

type PartialUser = Partial<typeof user>;
type ReadonlyUser = Readonly<typeof user>;

--- ## 🔹 Advanced Patterns ### 1. Dependency Injection

class Database {
  constructor(private connection: Connection) {}
  
  query(sql: string) {
    return this.connection.execute(sql);
  }
}

const db = new Database(new MySQLConnection());

### 2. Proxy API

const validator = {
  set(target, property, value) {
    if (property === 'age' && typeof value !== 'number') {
      throw new TypeError('Age must be a number');
    }
    target[property] = value;
    return true;
  }
};

const user = new Proxy({}, validator);
user.age = 25; // OK
user.age = "25"; // Throws error

### 3. Observable Pattern

class Observable<T> {
  private subscribers: ((value: T) => void)[] = [];

  subscribe(callback: (value: T) => void) {
    this.subscribers.push(callback);
  }

  next(value: T) {
    this.subscribers.forEach(cb => cb(value));
  }
}

const clicks = new Observable<MouseEvent>();
clicks.subscribe(e => console.log(e.clientX));
document.addEventListener('click', e => clicks.next(e));

--- ## 🔹 Web Components ### 1. Custom Elements

class PopupAlert extends HTMLElement {
  constructor() {
    super();
    this.attachShadow({ mode: 'open' });
    this.shadowRoot.innerHTML = `
      <style>
        .alert { /* styles */ }
      </style>
      <div class="alert">
        <slot></slot>
      </div>
    `;
  }
}

customElements.define('popup-alert', PopupAlert);

### 2. Template Literals for HTML

function html(strings, ...values) {
  let str = '';
  strings.forEach((string, i) => {
    str += string + (values[i] || '');
  });
  const template = document.createElement('template');
  template.innerHTML = str;
  return template.content;
}

const fragment = html`<div>Hello ${name}</div>`;

--- ## 🔹 Performance Patterns ### 1. Virtualization

function renderVirtualList(items, container, renderItem) {
  const visibleItems = getVisibleItems(items, container);
  container.replaceChildren(
    ...visibleItems.map(item => renderItem(item))
  );
}

### 3. Caching Strategies

// Service Worker caching
self.addEventListener('fetch', (event) => {
  event.respondWith(
    caches.match(event.request)
      .then(response => response || fetch(event.request))
  );
});

--- ## 🔹 Security Best Practices ### 1. Input Sanitization

function sanitizeInput(input) {
  return input.replace(/</g, '&lt;').replace(/>/g, '&gt;');
}

### 2. Content Security Policy (CSP)

<meta http-equiv="Content-Security-Policy" 
      content="default-src 'self'; script-src 'self' 'unsafe-inline'">

### 3. Secure Authentication

// Never store tokens in localStorage
const auth = {
  getToken() {
    return window.sessionStorage.getItem('token');
  },
  setToken(token) {
    window.sessionStorage.setItem('token', token);
  }
};

--- ## 🔹 Practical Example: Robust API Wrapper

class ApiClient {
  constructor(baseUrl) {
    this.baseUrl = baseUrl;
    this.cache = new Map();
  }

  async request(endpoint, options = {}) {
    const cacheKey = JSON.stringify({ endpoint, options });
    
    try {
      // Cache-first strategy
      if (this.cache.has(cacheKey)) {
        return this.cache.get(cacheKey);
      }

      const response = await fetch(`${this.baseUrl}${endpoint}`, {
        headers: { 'Content-Type': 'application/json' },
        ...options
      });

      if (!response.ok) {
        throw new ApiError(
          endpoint, 
          response.status, 
          await response.text()
        );
      }

      const data = await response.json();
      this.cache.set(cacheKey, data); // Cache response
      return data;

    } catch (error) {
      if (error instanceof ApiError) {
        console.error(`API Error: ${error.message}`);
      } else {
        console.error(`Network Error: ${error.message}`);
      }
      throw error;
    }
  }
}

--- ## 🔹 Best Practices Checklist 1. Error Handling - [ ] Use specific error types - [ ] Implement global error handlers - [ ] Validate API responses 2. Debugging - [ ] Utilize source maps - [ ] Leverage browser dev tools - [ ] Add strategic debugger statements 3. Performance - [ ] Audit bundle size regularly - [ ] Implement lazy loading - [ ] Debounce rapid events 4. Security - [ ] Sanitize user input - [ ] Use secure token storage - [ ] Implement CSP headers --- ### 📌 What's Next? In Final Part 10, we'll cover: ➡️ Modern JavaScript (ES2023+) ➡️ TypeScript Fundamentals ➡️ Advanced Patterns ➡️ Where to Go From Here #JavaScript #ProfessionalDevelopment #WebDev 🚀 Practice Exercise: 1. Implement error boundaries in a React/Vue app 2. Profile a slow function using Chrome DevTools 3. Create a memory leak and detect it

# 📚 JavaScript Tutorial - Part 9/10: Error Handling & Debugging #JavaScript #Debugging #ErrorHandling #Performance #BestPractices Welcome to Part 9 of our JavaScript series! Today we'll master professional error handling, debugging techniques, and performance optimization strategies used by senior developers. --- ## 🔹 Comprehensive Error Handling ### 1. Error Types in JavaScript

try {
  // Potential error code
} catch (error) {
  if (error instanceof TypeError) {
    console.log("Type error occurred");
  } else if (error instanceof ReferenceError) {
    console.log("Undefined variable");
  } else if (error instanceof RangeError) {
    console.log("Value out of range");
  } else {
    console.log("Unknown error:", error.message);
  }
}

### 2. Custom Error Classes

class ApiError extends Error {
  constructor(url, status, message) {
    super(`API call to ${url} failed with ${status}: ${message}`);
    this.name = "ApiError";
    this.status = status;
    this.url = url;
  }
}

// Usage
throw new ApiError("/users", 500, "Internal Server Error");

### 3. Error Boundary Pattern (React-like)

function ErrorBoundary({ children }) {
  const [error, setError] = useState(null);

  try {
    return children;
  } catch (err) {
    setError(err);
    return <FallbackUI error={error} />;
  }
}

// Wrap components
<ErrorBoundary>
  <UnstableComponent />
</ErrorBoundary>

--- ## 🔹 Advanced Debugging Techniques ### 1. Console Methods Beyond `log()`

console.table([{id: 1, name: 'Ali'}, {id: 2, name: 'Sarah'}]);

console.group("User Details");
console.log("Name: Ali");
console.log("Age: 25");
console.groupEnd();

console.time("API Call");
await fetchData();
console.timeEnd("API Call"); // Logs execution time

### 2. Debugger Statement & Breakpoints

function complexCalculation() {
  debugger; // Pauses execution here
  // Step through with F10/F11
  const result = /* ... */;
  return result;
}

### 3. Source Maps in Production

// webpack.config.js
module.exports = {
  devtool: 'source-map', // Generates .map files
  // ...
};

--- ## 🔹 Performance Optimization ### 1. Benchmarking Tools

// Using performance.now()
const start = performance.now();
expensiveOperation();
const end = performance.now();
console.log(`Operation took ${end - start}ms`);

### 2. Memory Leak Detection Common leak patterns:

// 1. Accidental globals
function leak() {
  leakedVar = 'This is global!'; // Missing var/let/const
}

// 2. Forgotten timers
const intervalId = setInterval(() => {}, 1000);
// Remember to clearInterval(intervalId)

// 3. Detached DOM references
const elements = [];
function storeElement() {
  const el = document.createElement('div');
  elements.push(el); // Keeps reference after removal
}

### 3. Optimization Techniques

// 1. Debounce rapid events
function debounce(fn, delay) {
  let timeout;
  return (...args) => {
    clearTimeout(timeout);
    timeout = setTimeout(() => fn(...args), delay);
  };
}

// 2. Web Workers for CPU-intensive tasks
const worker = new Worker('task.js');
worker.postMessage(data);
worker.onmessage = (e) => console.log(e.data);

// 3. Virtualize long lists (react-window, etc.)

--- ## 🔹 Memory Management ### 1. Garbage Collection Basics

// Circular reference (modern engines handle this)
let obj1 = {};
let obj2 = { ref: obj1 };
obj1.ref = obj2;

// Manual cleanup
let heavyResource = loadResource();
function cleanup() {
  heavyResource = null; // Eligible for GC
}

### 2. WeakMap & WeakSet

const weakMap = new WeakMap();
let domNode = document.getElementById('node');
weakMap.set(domNode, { clicks: 0 });

// When domNode is removed, entry is automatically GC'd

--- ## 🔹 Network Optimization ### 1. Bundle Analysis

npm install -g source-map-explorer
source-map-explorer bundle.js

### 2. Code Splitting

// Dynamic imports
const module = await import('./heavyModule.js');

// React.lazy
const HeavyComponent = React.lazy(() => import('./HeavyComponent'));

## 🔹 Practical Example: Redux-like Store

function createStore(reducer, initialState) {
  let state = initialState;
  const listeners = [];

  const getState = () => state;

  const dispatch = (action) => {
    state = reducer(state, action);
    listeners.forEach(listener => listener());
  };

  const subscribe = (listener) => {
    listeners.push(listener);
    return () => {
      const index = listeners.indexOf(listener);
      listeners.splice(index, 1);
    };
  };

  return { getState, dispatch, subscribe };
}

// Reducer (pure function)
function counterReducer(state = 0, action) {
  switch(action.type) {
    case 'INCREMENT': return state + 1;
    case 'DECREMENT': return state - 1;
    default: return state;
  }
}

// Usage
const store = createStore(counterReducer);
store.subscribe(() => console.log(store.getState()));
store.dispatch({ type: 'INCREMENT' }); // Logs: 1

--- ## 🔹 Best Practices 1. Strive for purity when possible 2. Limit side effects to controlled areas 3. Use immutable data with libraries like Immer 4. Compose small functions into larger ones 5. Document function signatures clearly --- ### 📌 What's Next? In Part 9, we'll cover: ➡️ Error Handling Strategies ➡️ Debugging Techniques ➡️ Performance Optimization ➡️ Memory Management #JavaScript #FunctionalProgramming #CleanCode 🚀 Practice Exercise: 1. Convert an imperative function to pure FP style 2. Implement a pipe() function (left-to-right composition) 3. Create a memoization higher-order function

# 📚 JavaScript Tutorial - Part 8/10: Functional Programming in JavaScript #JavaScript #FunctionalProgramming #FP #PureFunctions #HigherOrderFunctions Welcome to Part 8 of our JavaScript series! Today we'll explore functional programming (FP) concepts that will transform how you write JavaScript, making your code more predictable, reusable, and maintainable. --- ## 🔹 Core Principles of Functional Programming ### 1. Pure Functions

// Pure function (same input → same output, no side effects)
function add(a, b) {
  return a + b;
}

// Impure function (side effect + depends on external state)
let taxRate = 0.1;
function calculateTax(amount) {
  return amount * taxRate; // Depends on external variable
}

### 2. Immutability

// Bad (mutates original array)
const addToCart = (cart, item) => {
  cart.push(item); // Mutation!
  return cart;
};

// Good (returns new array)
const addToCartFP = (cart, item) => [...cart, item];

### 3. Function Composition

const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

const toUpperCase = str => str.toUpperCase();
const exclaim = str => `${str}!`;
const shout = compose(exclaim, toUpperCase);

shout('hello'); // "HELLO!"

--- ## 🔹 First-Class Functions ### 1. Functions as Arguments

const numbers = [1, 2, 3];

// Passing function as argument
numbers.map(num => num * 2); // [2, 4, 6]

### 2. Returning Functions

const createMultiplier = factor => num => num * factor;
const double = createMultiplier(2);
double(5); // 10

### 3. Storing Functions

const mathOps = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b
};
mathOps.add(3, 5); // 8

--- ## 🔹 Higher-Order Functions ### 1. Array Methods

const products = [
  { id: 1, name: 'Laptop', price: 999, inStock: true },
  { id: 2, name: 'Mouse', price: 25, inStock: false }
];

// Transform data
const productNames = products.map(p => p.name);

// Filter data
const availableProducts = products.filter(p => p.inStock);

// Reduce to single value
const totalPrice = products.reduce((sum, p) => sum + p.price, 0);

### 2. Custom HOF Example

function withLogging(fn) {
  return (...args) => {
    console.log(`Calling with args: ${args}`);
    const result = fn(...args);
    console.log(`Result: ${result}`);
    return result;
  };
}

const loggedAdd = withLogging(add);
loggedAdd(3, 5);

--- ## 🔹 Closures Functions that remember their lexical scope. ### 1. Basic Closure

function createCounter() {
  let count = 0;
  return () => ++count;
}

const counter = createCounter();
counter(); // 1
counter(); // 2

### 2. Practical Use Case

function createApiClient(baseUrl) {
  return {
    get(endpoint) {
      return fetch(`${baseUrl}${endpoint}`).then(res => res.json());
    },
    post(endpoint, data) {
      return fetch(`${baseUrl}${endpoint}`, {
        method: 'POST',
        body: JSON.stringify(data)
      });
    }
  };
}

const jsonPlaceholder = createApiClient('https://jsonplaceholder.typicode.com');
jsonPlaceholder.get('/posts/1').then(console.log);

--- ## 🔹 Currying Transforming a multi-argument function into a sequence of single-argument functions.

// Regular function
const add = (a, b, c) => a + b + c;

// Curried version
const curriedAdd = a => b => c => a + b + c;
curriedAdd(1)(2)(3); // 6

// Practical example
const createUser = username => email => password => ({
  username,
  email,
  password
});

const registerUser = createUser('js_dev');
const withEmail = registerUser('js@example.com');
const finalUser = withEmail('secure123');

--- ## 🔹 Recursion ### 1. Basic Recursion

function factorial(n) {
  return n <= 1 ? 1 : n * factorial(n - 1);
}

### 2. Tail Call Optimization

function factorial(n, acc = 1) {
  return n <= 1 ? acc : factorial(n - 1, n * acc);
}

### 3. Recursive Array Processing

function deepMap(arr, fn) {
  return arr.map(item => 
    Array.isArray(item) ? deepMap(item, fn) : fn(item)
  );
}

deepMap([1, [2, [3]]], x => x * 2); // [2, [4, [6]]]

---

### 2. Getters & Setters

class Temperature {
  constructor(celsius) {
    this.celsius = celsius;
  }
  
  get fahrenheit() {
    return this.celsius * 1.8 + 32;
  }
  
  set fahrenheit(value) {
    this.celsius = (value - 32) / 1.8;
  }
}

const temp = new Temperature(25);
console.log(temp.fahrenheit); // 77
temp.fahrenheit = 100;

--- ## 🔹 Design Patterns in JavaScript ### 1. Singleton Pattern

class AppConfig {
  constructor() {
    if (AppConfig.instance) {
      return AppConfig.instance;
    }
    
    this.settings = { theme: 'dark' };
    AppConfig.instance = this;
  }
}

const config1 = new AppConfig();
const config2 = new AppConfig();
console.log(config1 === config2); // true

### 2. Factory Pattern

class UserFactory {
  static createUser(type) {
    switch(type) {
      case 'admin':
        return new Admin();
      case 'customer':
        return new Customer();
      default:
        throw new Error('Invalid user type');
    }
  }
}

### 3. Observer Pattern

class EventEmitter {
  constructor() {
    this.events = {};
  }
  
  on(event, listener) {
    (this.events[event] || (this.events[event] = [])).push(listener);
  }
  
  emit(event, ...args) {
    this.events[event]?.forEach(listener => listener(...args));
  }
}

const emitter = new EventEmitter();
emitter.on('login', user => console.log(`${user} logged in`));
emitter.emit('login', 'Ali');

### 4. Module Pattern

const CounterModule = (() => {
  let count = 0;
  
  return {
    increment() {
      count++;
    },
    getCount() {
      return count;
    }
  };
})();

--- ## 🔹 Practical Example: RPG Character System

class Character {
  constructor(name, level) {
    this.name = name;
    this.level = level;
    this.health = 100;
  }
  
  attack(target) {
    const damage = this.level * 2;
    target.takeDamage(damage);
    console.log(`${this.name} attacks ${target.name} for ${damage} damage`);
  }
  
  takeDamage(amount) {
    this.health -= amount;
    if (this.health <= 0) {
      console.log(`${this.name} has been defeated!`);
    }
  }
}

class Mage extends Character {
  constructor(name, level, mana) {
    super(name, level);
    this.mana = mana;
  }
  
  castSpell(target) {
    if (this.mana >= 10) {
      const damage = this.level * 3;
      this.mana -= 10;
      target.takeDamage(damage);
      console.log(`${this.name} casts a spell on ${target.name}!`);
    } else {
      console.log("Not enough mana!");
    }
  }
}

// Usage
const warrior = new Character('Conan', 5);
const wizard = new Mage('Gandalf', 7, 50);

warrior.attack(wizard);
wizard.castSpell(warrior);

--- ## 🔹 Performance Considerations ### 1. Prototype vs Instance Methods - Prototype methods are memory efficient (shared) - Instance methods are created per object ### 2. Object Creation Patterns | Pattern | Speed | Memory | Features | |---------|-------|--------|----------| | Constructor | Fast | Efficient | Full prototype chain | | Factory | Medium | Less efficient | No instanceof | | Class | Fast | Efficient | Clean syntax | ### 3. Property Access Optimization

// Faster (direct property access)
obj.propertyName;

// Slower (dynamic property access)
obj['property' + 'Name'];

--- ## 🔹 Best Practices 1. Use classes for complex hierarchies 2. Favor composition over deep inheritance 3. Keep prototypes lean for performance 4. Use private fields for encapsulation 5. Document your classes with JSDoc --- ### 📌 What's Next? In Part 8, we'll cover: ➡️ Functional Programming in JavaScript ➡️ Pure Functions & Immutability ➡️ Higher-Order Functions ➡️ Redux Patterns #JavaScript #OOP #DesignPatterns 🚀 Practice Exercise: 1. Implement a Vehicle → Car → ElectricCar hierarchy 2. Create a BankAccount class with private balance 3. Build an observable ShoppingCart using the Observer pattern