Advanced object oriented design and development with Pharo
Ref. 41031
This MOOC focuses on Advanced Object-Oriented Design from a programming perspective. In particular it stresses Test-Driven Design (TDD).
- Effort: 40 hours
- Pace: Self paced
- Languages: English
What you will learn
At the end of this course, you will be able to:
- understand elementary concepts around self, super, and the power of dispatching to dedicated objects.
- learn how to test applications and how to take advantage of test driven design.
- understand how to design abstractions that are extensible using hooks.
- make the difference between data, objects and classes, based on basic principles.
- grasp important design patterns such as composite and state.
- discover how to compare usage versus inheritance a way to understand the forces in presence in a design.
- delve into the double dispatch mechanism and the visitor design pattern which is based on it.
- explore patterns to create and initialize objects.
- discover different techniques and design patterns to share objects.
- understand the law of demeter and different techniques to achieve Inversion of control.
- explore typing and its relation with object-oriented design.
Description
This MOOC is about Advanced 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.
Format
This MOOC is made up of 10 modules combining videos, quizzes and exercises. Module 0 is optional.
The exercises at the end of each module have been designed to train you in object-oriented design, and we have put them into a nice little book: Companion exercise book.
All the quizzes are to be taken via the fun platform.
Most exercises are based on Pharo. To launch Pharo we advice to use the Pharo Launcher.
Prerequisites
Having a first knowledge on object-oriented programming is better to fully understand the advanced topics of this MOOC.
To understand the Pharo syntax, start by taking Module 0: Warm up. If you want to learn more, you can follow the MOOC "Live Object Programming in Pharo" in speed mode.
Assessment and certification
An Open Badge for successful completion of the course will be issued on request to learners who obtain an overall score of 60% correct answers on the quizzes for modules 1 to 10.
Module 0 quizzes count as bonus points and give you an extra 5% at your final score.
Assessment is only based on quizzes.
Course plan
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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?
- 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
- 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
- 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
Course team
Luc Fabresse
Categories
Luc Fabresse is a Professor at IMT Nord Europe, leading research within the Autonomous and Resilient Systems group at the Digital Systems Center.
Guillermo Polito
Categories
Permanent researcher at Inria of the University of Lille, within the EVREF team.
Pablo Tesone
Categories
Pharo consortium engineer. He holds a PhD in Computer Science from the University of Lille.
Organizations
Partner
License
License for the course content
Attribution-NonCommercial
You are free to:
- Share — copy and redistribute the material in any medium or format
- Adapt — remix, transform, and build upon the material
Under the following terms:
- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
- NonCommercial — You may not use the material for commercial purposes.
License for the content created by course participants
Attribution-NonCommercial
You are free to:
- Share — copy and redistribute the material in any medium or format
- Adapt — remix, transform, and build upon the material
Under the following terms:
- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
- NonCommercial — You may not use the material for commercial purposes.