Rizki Sasri Dwitama
Programming

TypeScript: Syllabus

Ah, Object-Oriented Programming. The magical art of convincing yourself that your code is organized—while secretly creating an over-engineered mess. Welcome to this quick book, where we slap some structure onto your chaos and teach you the dark rituals of OOP in TypeScript (because JavaScript wasn’t confusing enough).

This book is 90% hands-on (because nobody ever became a coding ninja by reading theory alone). You’ll dive into OOP principles, advanced design patterns, and real-world TypeScript applications—basically, everything you need to write code that doesn’t collapse like a Jenga tower when requirements change.

By the end, you’ll have mastered TypeScript OOP, built multiple hands-on projects, and hopefully written software that won’t send your teammates into therapy. Buckle up—your code is about to get dangerously maintainable.

Module 1: Introduction to Object-Oriented Programming (OOP)

  • Why OOP? Understanding the need for object-oriented design
  • Principles of OOP (Encapsulation, Inheritance, Polymorphism, Abstraction)
  • Setting up the Python and TypeScript environment for OOP development

Module 2: Classes and Objects in Python & TypeScript

  • Defining classes and creating objects
  • The self (Python) and this (TypeScript) keyword
  • Understanding constructors and destructors
  • Class vs. instance attributes

Module 3: Encapsulation and Data Hiding

  • Public, protected, and private attributes/modifiers
  • Getters, setters, and property decorators
  • Implementing encapsulation in real-world applications

Module 4: Inheritance and Code Reusability

  • Types of inheritance (single, multiple, multilevel, hierarchical, hybrid)
  • The super() method in Python and super in TypeScript
  • Method overriding and extending functionality

Module 5: Polymorphism and Method Overloading

  • Function overloading and method overriding in Python & TypeScript
  • Duck typing and dynamic method resolution
  • Operator overloading in Python (__add__, __str__, __eq__)

Module 6: Abstract Classes and Interfaces

  • Understanding abstraction and why it matters
  • Implementing abstract classes (ABC module in Python, abstract keyword in TypeScript)
  • Enforcing method implementation with interfaces

Module 7: Static and Readonly Properties

  • Difference between instance, static, and readonly properties
  • Using @classmethod and @staticmethod in Python
  • Implementing static and readonly properties in TypeScript

Module 8: Composition and Aggregation

  • Difference between inheritance and composition
  • Implementing has-a relationships in Python & TypeScript
  • Designing modular applications with composition

Module 9: Software Design Principles in OOP

  • SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion)
  • DRY, KISS, and YAGNI principles
  • Applying these principles in large-scale software

Module 10: Design Patterns in Python & TypeScript

  • Introduction to software design patterns
  • Creational patterns: Singleton, Factory, Builder
  • Structural patterns: Adapter, Decorator, Proxy
  • Behavioral patterns: Observer, Strategy, Command

Module 11: Exception Handling and Debugging in OOP

  • Handling exceptions in an object-oriented way
  • Custom error classes and raising exceptions
  • Debugging OOP-based applications in Python & TypeScript

Module 12: Unit Testing and Test-Driven Development (TDD)

  • Writing unit tests for classes and methods
  • Using unittest and pytest for Python, Jest/Mocha for TypeScript
  • Implementing TDD in object-oriented software design

Module 13: File Handling and Persistence

  • Reading and writing files with OOP principles
  • Working with JSON, CSV, and databases (SQLAlchemy for Python, TypeORM for TypeScript)

Module 14: Building Scalable OOP Applications

  • Structuring large-scale object-oriented applications
  • Implementing modular architecture
  • Managing dependencies and organizing packages

Module 15: Capstone Project and Real-World Applications

  • Applying OOP and design patterns to build a complete software application
  • Code review and best practices for maintainable object-oriented code
  • Documenting and deploying the final project

Hands-On Projects

Project 1: Employee Management System

  • Implement encapsulation and inheritance for employee roles
  • Use static methods for salary calculations
  • Store and retrieve data using JSON (Python) & LocalStorage (TypeScript)

Project 2: E-Commerce Order Processing System

  • Implement product catalogs and order management with OOP
  • Use design patterns like Factory and Observer
  • Store customer transactions in a database (SQLAlchemy/TypeORM)

Project 3: AI Chatbot with Object-Oriented Architecture

  • Build a chatbot using object-oriented principles
  • Implement polymorphism for multiple response strategies
  • Optimize chatbot behavior using design patterns

Project 4: Bank Account Management System

  • Use OOP principles to model bank accounts and transactions
  • Implement security measures with encapsulation
  • Store transaction history using file handling

Project 5: Social Media Feed Aggregator

  • Implement API-based data fetching using OOP
  • Use decorators and adapters to format and process feeds
  • Apply TDD and write unit tests for the application

References

Prev
Python: Syllabus