Passer au contenu principal
FUN MOOC
  • Actualités
  • Cours
  • FormaPro
  • Établissements
  • À propos
  • FAQ
  • Vous êtes ici:
  • Accueil
  • Cours
  • Advanced object oriented design and development with Pharo

Advanced object oriented design and development with Pharo

Réf. 41031
CatégorieInformatique et programmationCatégorieNumérique et technologie
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

Stéphane Ducasse

Catégories

Research director at Inria. He leads the EVREF team.

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

Inria

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.
FacebookTwitterLinkedin

En savoir plus

  • Aide et Contact
  • A propos de FUN
  • Foire aux questions
  • Boutique en ligne
  • Mentions légales
  • Politique de confidentialité
  • Infolettres
  • Conditions générales d'utilisation
  • Conditions générales de vente
  • Charte utilisateurs
  • Accessibilité : partiellement conforme
  • Plan de site
  • Gestion des cookies
Logo FUN Mooc propulsé par Richie