Advanced object oriented design and development with Pharo

Description

This MOOC is aboutAdvanced Object-Oriented Design. You will get to know and understand the key mechanisms and the essence of OOD. Either you are a beginner or an expert in object-oriented programming, this MOOC immerses you in advanced object-oriented design. We are sure that you will not develop the same way after following this unique lecture. It is built on more than 60 years of expert teaching object-oriented design.This MOOC invites you to a journey around 10 modules (with over 60 videos) covering the following topics:

• Understanding messages
• Test-Driven Design
• Hooks: support for evolution
• Objects: state and behavior
• Elementary design patterns
• Double dispatch
• Object creation
• Sharing objects
• Inversion of control
• About types

The MOOC proposes several design exercises ranging from little interpreters to games and quizzes.

Plan de cours

• Module 0: Little Warm up with Pharo
  • 0.1 Pharo Object Model in a Nutshell
    0.2 Pharo Syntax in a Nutshell
    0.3 Class and Method Definitions
    0.4 Understanding Messages
    0.5 Messages for Java Programmers
    0.6 Messages: Composition and Precedence
    0.7 Understanding Messages: Sequence and Cascade
    0.8 Introduction to Blocks
• Module 1: Understanding messages
  • 1.1 Essence of Dispatch: Taking Pharo Booleans as Example
    1.2 Essence of Dispatch: Let the receiver decide
    1.3 Inheritance Basics
    1.4 Inheritance and Lookup: Self - Understand lookup once for all
    1.5 About super
    1.6 Reification and delegation - A case study: Microdown in Pillar
• Module 2: Test-Driven Design
  • 2.1 Test 101: The minimum you should know
    2.2 Tests: Why testing is Important?
    2.3 Test-Driven Development
    2.4 Xtreme Test Driven Development: Getting a productivity boost
    2.5 Parametrized Tests: Getting more tests out of test cases
• Module 3: Hooks: support for evolution
  • 3.1 An introduction to design patterns
    3.2 Message Sends are Plans for Reuse
    3.3 Hooks and Template: One of the cornerstones of OOP
    3.4 Using well asString and printString: A Pharo code idiom
    3.5 Global to parameter
• Module 4: Objects: state and behavior
  • 4.1 Methods: the elementary unit of reuse
    4.2 Objects vs. Data - An API perspective studying the class Point
    4.3 About global variables
    4.4 Fat classes are bad - A large class vs. a class hierarchy
    4.5 Singleton: a Highly Misunderstood Pattern
    4.6 Decorator Design Pattern
• Module 5: Elementary design patterns
  • 5.1 Composite: a Nice and Common Design Pattern
    5.2 About State Design Pattern
    5.3.1 Command Design Pattern: Actions as objects
    5.3.2 Application of Command Design Pattern
    5.4 Delegation vs. Inheritance
    5.5 Turning Procedures to Objects
    5.6 Blocks vs. Objects: Rethinking common abstractions
    5.7 Avoid Null Checks
    5.8 About Fluid API
• Module 6: About double dispatch
  • 6.1 A double dispatch starter: Stone Paper Scissors
    6.2 Double dispatch: Does not have to be symmetrical
    6.3 a Die + a DieHandle: Practicing dispatch more
    6.4 Visitor: Modular and extensible first class actions
    6.5 Some discussions on Visitor
    6.6 Stone Paper Scissors: The case of results
    6.7 Double Dispatch: Adding numbers as a Kata
• Module 7: Object creation
  • 7.1 About Null Check: The case of lazy initialization
    7.2 Customization degree of hooks: Class vs. instance hooks
    7.3 DieHandle new vs. self class new: When classes are first class citizen
    7.4 Delegation of actions and accumulator: Form validation as an example
    7.5 Behavior delegation at work: The case of the class printer
    7.6 Builder Design Pattern: Encapsulating object creation
    7.7 Builder API variations
    7.8 Did You Really Understand Super?
• Module 8: Sharing objects
  • 8.1 Shared variables: A Pharo code idiom
    8.2 Sharing with instance specific possibilities
    8.3 Shared Pools: Static sharing between hierarchies
    8.4 About magic literals
    8.5 Flyweight
    8.6 TypeObject
    8.7 A variation on sharing
• Module 9: About Inversion of control / Registration
  • 9.1 About coupling and encapsulation
    9.2 Class Methods At Work
    9.3 About Registration: When class method-based registration is too much
    9.4 Application settings: From a monolithic to a modular architecture
    9.5 Learning from a Sokoban implementation
    9.6 Class vs. Object-Oriented Programming
• Module 10: About Types
  • 10.1 The two interfaces: In presence of delta programming
    10.2 Subclassing vs. Subtyping
    10.3 About type and method lookup
    10.4 Polymorphic objects: Support for software evolution
    10.5 About defensive programming