Yevhen Kalinichenko, Senior JavaScript Developer “Object oriented concepts in real projects” - Abstraction. What is it and what abstraction gives us - Inheritance. Why do we need inheritance? Composition over inheritance. - Encapsulation. Why it’s so important to hide implementation. Breaking of encapsulation leads us to maintenance hell - Polymorphism. Working with interface but not with concrete implementation - Single responsibility. Why “classes” must adhere single responsibility - Open/Closed principle - Related topics – cohesion, coupling, interfaces, separation of responsibilities for each team member.

1. Kalinichenko Yevhen
Basic principles of Object Oriented Programming
Object Oriented Concepts

2. Statistic
50 Interviews
20 Interviews
47 Interviews
70 Interviews
60 Interviews
247 Interviews
80% don’t knowwhat OOP is

3. Common OOP in Javascriptexamples
Prototypal Inheritance

4. We work in teams

5. A set of principles
Polymorphism

6. Abstraction
Polymorphism
Single responsibility
Encapsulation
Open/Closed
Principles for today
JavaScript

7. Abstraction

8. Abstraction
The concept of describing something in simpler terms.
Abstracting away the details, in order to focus on what is important.
Abstraction helps us to reduce complexity and increase efficiency.

9. Real Case
Task
Visual Features Team
Core Features Team
Interface
Interface

10. Abstract Classes
Core Features Team
DataStore
Real Case

11. Inheritance

12. Inheritance

13. Life case
Widget

14. New requirements

15. New requirements

16. Responsibilities and Roles
Widget
Container View
Data
Data Visualization
Configuration
Architecture solution
Customer
BE Dev
FE Dev
FE Dev
Tech Lead
FE Dev

17. Single Responsibility Principle
A class should have only one reason to change.
Class should have a cohesive set of behaviors, together comprising a single responsibility.

18. Inverse dependencies
Data VisualizationComponent
Data
Widget
Container
Configuration

19. Polymorphism

20. Different behavior of method based on arguments length/arguments type.
Method overloading

21. Duck typing
We work with objects of different types identically if these objects adhere the same contract.
“When I see a bird that walks like a duck
and swims like a duck and quacks like a duck,
I call that bird a duck.” (c)

22. Polymorphism
Core Features Team
DataStore

23. Compose components
Container
Configuration
Data Visualization

24. Encapsulation

25. Encapsulation
Encapsulation hides the implementation details.
Expose public interface.

26. Breaking of encapsulation
We can’t change inner implementation of our class without breaking of the client’s code.
Maintenance hell.

27. Ops…
Let’s break it

28. Everything is ok now.
Always use clear defined interface

29. Open/Closed principle

30. Open/Closed principle
Widget
Closed for modification
New data visual
Open for extension

31. Open/Closed examples
JQuery plugins.
Strategypattern.

32. Conclusion
“Continuous refactoring”.
Principles in mind.

33. Related materials
SOLID JavaScript -http://freshbrewedcode.com/derekgreer/2011/12/08/solid- javascript-single-responsibility-principle/
Pro JavaScript design Patterns -http://www.amazon.com/Pro-JavaScript-Design- Patterns-Object-Oriented/dp/159059908X
Head First Object-Oriented Analysis and Design - http://shop.oreilly.com/product/9780596008673.do
Head First Design Patterns -http://shop.oreilly.com/product/9780596007126.do
Code Complete -http://www.amazon.com/Code-Complete-Practical- Handbook-Construction/dp/0735619670

34. Q&A