WHAT HAVE WE LEARNT SO FAR?

• Intro to OOP Concepts by Asyrul
  • Understanding OOP
  • Why OOP
  • 4 Pillars of OOP
    • Encapsulation
    • Inheritance
    • Polymorphism
    • Abstraction
• SOLID Principles
• 12 Factors
• Design Patterns

WHAT HAVE WE LEARNT SO FAR?

• Intro to OOP Concepts
• SOLID Principles
  • Single Responsibility Principles
  • Open Closed Principles
  • Liskov Subtitution Principles
  • Inversion of Control
  • Dependency Inversion Principles
• 12 Factors by Syafiq
• Design Patterns

WHAT HAVE WE LEARNT SO FAR?

• Intro to OOP Concepts
• SOLID Principles
• 12 Factors App by Syafiq
  • Git Repository
  • Dependency/Package Manager
  • Config in Environment Variables
  • Separate Build & Run Stages
  • Port Binding
  • Services as Attached Resources
  • Concurrency  (Ability to scale up)
  • Disposability (Ability to scale down)
  • Stateless Processes
  • Logs
  • Run Migration as one-off processes
  • Keep Dev, Staging, Prod Env as similar as possible
• Design Patterns

WHAT HAVE WE LEARNT SO FAR?

• Intro to OOP Concepts
• SOLID Principles
• 12 Factors
• Design Patterns
  • Factory by Sofwan
  • Decorator by Amirah
  • Observer by Hafiz
  • Strategy by Shirlin
  • Command by Hafiz
  • Singleton, Builder, Template,
    Composite, Adapter, Visitor etc 

We learnt too much concepts, but unable to apply it into practise..

Btw, just simply creating a subclass which inherit a superclass does not mean you're applying OOP correctly...

So let's go back to the fundamental & basic principles that we should know.

• Hide Implementation Details
• Composition over Inheritance
• Seperation of Concerns
• Encapsulate What Changes
• Delegation Principles
• Minimise Coupling
• Code For the Maintainer
• DRY
• Curly's Law

• When the implementation changes, the interface clients are using does not have to change.

• Minimize accessibility of classes and members.
• Don’t expose member data in public.
• Avoid putting private implementation details into a class’s interface.
• Decrease coupling to hide more implementation details.

• Less Coupling
• Inheritance easily make assumptions & break LSP

• Compose when there is a 'has-a'
• Inherit when 'is-a'

• Minimise required modifications when a change occurs

• Encapsulate the concept that varies behind an API
• Separate the varying concept into its own module

• No duplication of code

• Don’t do all stuff by yourself, delegate it to the respective class

• Simplify development & maintenance
• Promotes Re-usability

• Break program functionality into separate modules that overlaps as little as possible

References

• Programming Principles - Github
   
• 10 OOP Design Principle Every Programmer should know - Hackernoon