Advanced object oriented design and development with Pharo
Réf. 41031
This MOOC focuses on Advanced Object-Oriented Design from a programming perspective. In particular it stresses Test-Driven Design (TDD).
- Effort : 40 heures
- Rythme: Auto-rythmé
- Langues: Anglais
Ce que vous allez apprendre
À la fin de ce cours, vous saurez :
At the end of this course, you will know:
- elementary concepts around self, super, and the power of dispatching to dedicated objects.
- how to test applications and how to take advantage of test driven design.
- how to design abstractions that are extensible using hooks.
- to make the difference between data, objects and classes, based on basic principles.
- important design patterns such as composite and state.
- how to compare usage versus inheritance a way to understand the forces in presence in a design.
- the double dispatch mechanism and the visitor design pattern which is based on it.
- patterns to create and initialize objects.
- different techniques and design patterns to share objects.
- the law of demeter and different techniques to achieve Inversion of control.
- 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.
Prérequis
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.
Evaluation et 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.
Plan de cours
- 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
Équipe pédagogique
Luc Fabresse
Catégories
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
Catégories
Permanent researcher at Inria of the University of Lille, within the EVREF team.
Pablo Tesone
Catégories
Pharo consortium engineer. He holds a PhD in Computer Science from the University of Lille.
Établissements
Partenaire
Licence
Licence pour le contenu du cours
Attribution - Pas d’Utilisation Commerciale
Vous êtes autorisé à :
- Partager — copier, distribuer et communiquer le matériel par tous moyens et sous tous formats
- Adapter — remixer, transformer et créer à partir du matériel
Selon les conditions suivantes :
- Attribution — Vous devez créditer l'oeuvre, intégrer un lien vers la licence et indiquer si des modifications ont été effectuées à l'oeuvre. Vous devez indiquer ces informations par tous les moyens raisonnables, sans toutefois suggérer que l'offrant vous soutient ou soutient la façon dont vous avez utilisé son oeuvre.
- Pas d’Utilisation Commerciale — Vous n'êtes pas autorisé à faire un usage commercial de cette oeuvre, tout ou partie du matériel la composant.
Licence pour le contenu créé par les participants du cours
Attribution - Pas d’Utilisation Commerciale
Vous êtes autorisé à :
- Partager — copier, distribuer et communiquer le matériel par tous moyens et sous tous formats
- Adapter — remixer, transformer et créer à partir du matériel
Selon les conditions suivantes :
- Attribution — Vous devez créditer l'oeuvre, intégrer un lien vers la licence et indiquer si des modifications ont été effectuées à l'oeuvre. Vous devez indiquer ces informations par tous les moyens raisonnables, sans toutefois suggérer que l'offrant vous soutient ou soutient la façon dont vous avez utilisé son oeuvre.
- Pas d’Utilisation Commerciale — Vous n'êtes pas autorisé à faire un usage commercial de cette oeuvre, tout ou partie du matériel la composant.