Créativité, contraintes et paradigmes

(ça tape non ?)

Raphaël Bellec

Quel rapport avec l’informatique ?

Péréc, Queneau, Racine

Question :

Qu’est-ce que c’est ?

Amie de la créativité ?

La page blancheL’espace vide à remplir

A l’inverse...

Developpe publiquement des trésors de créativité...

La contrainte ?

• Fixer un élément de la forme

• Un bras figé

• Des alexandrins

• Laisser le fond se construire l’idée venant.

Livre : Element du monoïde libre composé sur l’alphabet et contraint par la

langue et les choix d’écriture

Contrainte : limitation de l’espace des solutions, intrisequement continu et

infini, lui donnant des points d’entrées

retournons vers le code

Une autre forme de poésie...

parfois completementfor my $passion (@to_terminate){ map {my $body} ($through and $through); shift @me,'oh'..'so close to you!';}listen 'closer',$_ foreach $breath;kill $me,'with that little death';"What's the meaning of this rhyme"?'You will come to learn in' : time;if (our $little_code) {'is_run'};'Then the two'. $will_be.'as',1;

Un programme

• La représentation d’un monde...

• Progressant à l’image de notre pensée...

• Influencée par le langage et surtout...

• Son paradigme

Les paradigmes• Objet : Héritage,

hiérarchie

• Fonctionnel : opérations unitaires, structure

• // : op simultannées, communication, synchronisation

• Systemes Experts : regles, ontologie, faits

• Typé algebriquement : types, nature des habitants du monde

• Logique : relation entre les éléments, faits, règles.

• Lazy - pure : monde pur, monde exterieur impur, structures infinies

• Par contraintes

• Brainfuck : > + .

qsort [] = []qsort (x:xs) = qsort ys ++ x : qsort zs where (ys, zs) = partition (< x) xs

GENERIC INTERFACE ArraySort(Elem); PROCEDURE Sort(VAR a: ARRAY OF Elem.T; cmp := Elem.Compare); END ArraySort.GENERIC MODULE ArraySort (Elem); PROCEDURE Sort (VAR a: ARRAY OF Elem.T; cmp := Elem.Compare) = BEGIN QuickSort (a, 0, NUMBER (a), cmp); InsertionSort (a, 0, NUMBER (a), cmp); END Sort; PROCEDURE QuickSort (VAR a: ARRAY OF Elem.T; lo, hi: INTEGER; cmp := Elem.Compare) = CONST CutOff = 9; VAR i, j: INTEGER; key, tmp: Elem.T; BEGIN WHILE (hi - lo > CutOff) DO (* sort a[lo..hi) *)  (* use median-of-3 to select a key *) i := (hi + lo) DIV 2; IF cmp (a[lo], a[i]) < 0 THEN IF cmp (a[i], a[hi-1]) < 0 THEN key := a[i]; ELSIF cmp (a[lo], a[hi-1]) < 0 THEN key := a[hi-1]; a[hi-1] := a[i]; a[i] := key; ELSE key := a[lo]; a[lo] := a[hi-1]; a[hi-1] := a[i]; a[i] := key; END; ELSE (* a[lo] >= a[i] *) IF cmp (a[hi-1], a[i]) < 0 THEN key := a[i]; tmp := a[hi-1]; a[hi-1] := a[lo]; a[lo] := tmp; ELSIF cmp (a[lo], a[hi-1]) < 0 THEN key := a[lo]; a[lo] := a[i]; a[i] := key; ELSE key := a[hi-1]; a[hi-1] := a[lo]; a[lo] := a[i]; a[i] := key; END; END;  (* partition the array *) i := lo+1; j := hi-2;  (* find the first hole *) WHILE cmp (a[j], key) > 0 DO DEC (j) END; tmp := a[j]; DEC (j);  LOOP IF (i > j) THEN EXIT END;  WHILE i < hi AND cmp (a[i], key) < 0 DO INC (i) END; IF (i > j) THEN EXIT END; a[j+1] := a[i]; INC (i);  WHILE j > lo AND cmp (a[j], key) > 0 DO DEC (j) END; IF (i > j) THEN IF (j = i-1) THEN DEC (j) END; EXIT END; a[i-1] := a[j]; DEC (j); END;  (* fill in the last hole *) a[j+1] := tmp; i := j+2;  (* then, recursively sort the smaller subfile *) IF (i - lo < hi - i) THEN QuickSort (a, lo, i-1, cmp); lo := i; ELSE QuickSort (a, i, hi, cmp); hi := i-1; END;  END; (* WHILE (hi-lo > CutOff) *) END QuickSort; PROCEDURE InsertionSort (VAR a: ARRAY OF Elem.T; lo, hi: INTEGER; cmp := Elem.Compare) = VAR j: INTEGER; key: Elem.T; BEGIN FOR i := lo+1 TO hi-1 DO key := a[i]; j := i-1; WHILE (j >= lo) AND cmp (key, a[j]) < 0 DO a[j+1] := a[j]; DEC (j); END; a[j+1] := key; END; END InsertionSort; BEGINEND ArraySort.

qsort( [], [] ).qsort( [H|U], S ) :- splitBy(H, U, L, R), qsort(L, SL), qsort(R, SR), append(SL, [H|SR], S). % splitBy( H, U, LS, RS )% True if LS = { L in U | L <= H }; RS = { R in U | R > H }splitBy( _, [], [], []).splitBy( H, [U|T], [U|LS], RS ) :- U =< H, splitBy(H, T, LS, RS).splitBy( H, [U|T], LS, [U|RS] ) :- U > H, splitBy(H, T, LS, RS).

L’interêt

• Pas dans le langage ! Ni les Frameworks

• Comprendre une nouvelle façon de penser

• Difficile et prend (un peu de temps)

Ma liste...• C

• Ruby (faillotage)

• XSLT

• SQL

• CAML

• Scheme

• Prolog

• Erlang

• Un S.E.

• Contraintes (Oz, Prolog, minion, Gecode...)

• Plus tard : Haskell

• Pour comprendre vraiment (ou pas !) : Coq

Références

• Pour les livres, j’ai laissé la couverture complète.

• Poeme l’oeuf, voir : http://www.digitalcraft.org/iloveyou/poetry.htm

• Feuille d’impot : Formulaire cerfa, auteur inconnu et souhaitant probablement rester anonyme.

• Je n’arrive pas à remettre la main sur les références du poème informatique «Paradigm». Toute aide est la bienvenue !

• Poème en PERL : http://www.perlmonks.org/?node_id=963133

• Codes sources : voir rosetta code.

Notes importantes

• J’ai placé des langages pour exemple. Le plus important est le paradigme et il n’est pas toujours lié au langage.

• Plusieurs personnes m’ont dit detester XSLT lors de la conf. Je ne préconise pas de l’utiliser non plus... juste de l’avoir vu et surtout vu Xpath et XQuery.