Les langages de programmation sont trop compliqués
-
Upload
mercurywood -
Category
Technology
-
view
178 -
download
1
Transcript of Les langages de programmation sont trop compliqués
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