Les langages de programmation sont trop compliqués

Preview:

Citation preview

Coder

Coderj’adore ça !

Coder...mais c’est trop compliqué !

Apprenons le Java !

class MainClass {

public static void main(String[] args) {

System.out.println(“Hello, World!”);

}

}

Apprenons le Java !

class MainClass {

public static void main(String[] args) {

System.out.println(“Hello, World!”);

}

}

Apprenons le Java !

class MainClass {

public static void main(String[] args) {

System.out.println(“Hello, World!”);

}

}

? ? ??

? ?

??

? ? ? ?

Apprenons le Java !

class MainClass {

public static void main(String[] args) {

System.out.println(“Hello, World!”);

}

}

? ? ??

? ?

??

? ? ? ???!

puts “Hello World!”

print(“Hello World!”)

printStrLn “Hello World!”

print “Hello World!”

Alors comme ça c’est compliqué ?

Making Software: What Really Works and Why We Believe It

Why is it So Hard to Learn to Program?

Compliqué ?

Concevoir un algorithme est simple.

Communiquer un algorithme à un humain est simple.

Communiquer un algorithme à une machine est moins simple.

Pourquoi ?

Les langages de programmation !(?)

Plus précisément

Les langages de programmationorientés objet

java, c#, python, ruby...

Axiomes

Orienté-objet =

polymorphisme + encapsulation

Qualité=

testable / modulaire + maintenable / lisible

ranger == planquer sous le lit

Les méthodes privées

Une méthode publique trop imposante

Méthode publique

Interface

Implémentation

cp cp

Test

Des méthodes privées à la rescousse

mpubInterface

Implémentation

cp cp

Test

mpriv mpriv

Des problèmes

mpubInterface

Implémentation

cp cp

Test

mpriv mpriv

Deux styles de méthodes privées

// field equals x

updateField();

// field equals y

Parfum de variable globale

// field equals x

field = computeValue();

// field equals y

Méthode détachée de son objet

Des objets à la rescousse

mpubInterface

Implémentation

cp cp

Test

mpub mpub

Nouvelle dépendance

Nouvelle dépendance

Les méthodes privées

● Inutiles● Dangereuses

Coupling: it’s over 9000!

L’héritage de classe

Difficile à tester

Mère

Fille

TestMère

TestFille

Difficile à tester

Mère

Fille

TestMère

TestFille

super

Difficile à tester

Mère

Fille

TestMère

TestFille

Difficile à tester

Mère

Fille

TestMère

TestFille

Difficile à tester

Mère

Fille

TestMère

TestFille

Difficile à tester

Mère

Fille

TestMère

TestFille

Difficile à maintenir

public

Difficile à maintenir

public

protected

Difficile à maintenir

public

protected

Faible encapsulationCouplage fortDouble dépendance

Dépendences cycliques

Classeabstraite

Dépendences cycliques

Classeabstraite

?

Dépendences cycliques

Classeabstraite

Classe fille concrète

Dépendences cycliques

Classeabstraite

Classe fille concrète

??!

● Difficile à tester● Difficile à maintenir● Dépendances ‘cycliques’

C’est l’enfer !

● Difficile à tester● Difficile à maintenir● Dépendances ‘cycliques’● Et ça sert à...quoi exactement ?

C’est l’enfer !

● Difficile à tester● Difficile à maintenir● Dépendances ‘cycliques’● Et ça sert à...quoi exactement ?

■ L’héritage d’interfaces fournit déjà le polymorphisme

■ La composition fournit déjà de quoi réutiliser les implémentations

C’est l’enfer !

Solution : compositioninterface MembreDeLaFamille {...}

class Mère implements MembreDeLaFamille {...}

class Fille implements MembreDeLaFamille {

private final MembreDeLaFamille mère;

public Fille(MembreDeLaFamille mère) {

this.mère = mère;

}

...

}

Solution : compositionabstract class AbstractCollection<T>

implements Collection<T> {

boolean contains(Object o) {

...// appelle iterator()

}

abstract Iterator<T> iterator();

}

class CollectionDecorator<T>

implements Collection<T> {

final Iterable<T> iterable;

boolean contains(Object o) {

...// appelle iterator()

}

Iterator<T> iterator() {

return iterable.iterator();

}

}

It’s not a bug, it’s a feature!

Static dispatch

L’enfer 2.0

L’enfer 2.0

● Difficile à tester

L’enfer 2.0

● Difficile à tester● Difficile à maintenir

L’enfer 2.0

● Difficile à tester● Difficile à maintenir● Détruit tout polymorphisme

L’enfer 2.0

● Difficile à tester● Difficile à maintenir● Détruit tout polymorphisme● Rend les classes potentiellement variables…

alors qu’elles sont globales !

Pragmatisme

Débutants

Questions ?

Merci !

Hugo.Wood@sopragroup.com / @mercury_wood / elevatedabstractions.wordpress.com