Paradigmes de programmation – quelques liens pertinents

Quelques grandes familles de langages de programmation, ou même de paradigmes de programmation, (le terme étant pris au sens large) sont décrites ci-dessous. Pour une liste plus exhaustive voir http://en.wikipedia.org/wiki/Programming_paradigm

• Si vous êtes curieuse ou curieux de savoir ce qu'il est possible de faire d'étrange avec un langage de programmation, voici quelques exemples.
• Voici aussi quelques trucs particuliers que permettent de faire divers langages.
• Un texte sur les langages Perlis, au sens du célèbre informaticien Alan Perlis, soit (selon l'auteur) des langages qui modifient la manière de penser de ceux qui les utilisent : http://blog.fogus.me/2011/08/14/perlis-languages/
• Un réflexion sur les types génériques covariants, par Chung-Chieh Shan en 2011 : http://conway.rutgers.edu/~ccshan/wiki/blog/posts/Unsoundness/ (aussi, par Rob Simmons en 2011, voir http://requestforlogic.blogspot.com/2011/10/incomplete-by-design-thought-on-dart.html)
• Un design visuel « live » décrivant des types de langages de programmation, par Arthur Ventura en 2011 : http://www.surf-the-edge.com/2011/11/16/live-sketching/
• Les principaux paradigmes de programmation, regroupés dans un schéma : http://www.info.ucl.ac.be/~pvr/paradigmsDIAGRAMeng.pdf
• Catégoriser les langages en fonction d'un paradigme ou de l'autre, une tâche difficile selon Laurence Tratt en 2013 : http://tratt.net/laurie/blog/entries/relative_and_absolute_levels
• En 2013, Greg Jorgensen propose ce qu'il nomme la « programmation orientée abject » (Abject-Oriented Programming), une satire sur les pratiques de programmation malsaines : http://typicalprogrammer.com/abject-oriented/
• Survol des quatre principaux paradigmes de programmation (selon l'auteur du texte en question), soit la programmation impérative, la programmation fonctionnelle, la programmation logique et la programmation orientée objet

Métaprogrammation

À venir...

Métaprogrammation avec C++ :

• Implémenter brainfuck par métaprogrammation avec des templates de C++, par Michael Speer en 2013 : https://github.com/knome/metabrainfuck/blob/master/bf.cpp
• Texte de votre humble serviteur (avec inspirations diverses, indiquées à même le texte) à propos de la métaprogrammation en C++ : ../Sujets/Divers--cplusplus/Metaprogrammation.html

Métaprogrammation avec D :

• Un texte pour débutant(e)s par Maik Klein en 2015 : https://maikklein.github.io/2015/08/11/Metaprogramming-D/
• Métaprogrammation à l'aide d'objets de type Type, par Maik Klein en 2016 : https://maikklein.github.io/2016/03/01/metaprogramming-typeobject/

Métaprogrammation avec Julia :

• http://docs.julialang.org/en/latest/manual/metaprogramming/
• http://julia.readthedocs.org/en/latest/manual/metaprogramming/
• Texte de Jacob Quinn en 2014 : http://quinnj.github.io/2014/06/19/data-structures-as-code-the-joys-of-meta-programming/index.html

Nim (autrefois Nimrod) et la métaprogrammation :

• Texte d'Andreas Rumpf en 2013 : http://nimrod-lang.org/talk01/slides.html#%281%29
• La métaprogrammation avec Nim, selon Dennis Felsing en 2016 : https://hookrace.net/blog/introduction-to-metaprogramming-in-nim/

Métaprogrammation avec Perl :

• Métaprogrammation avec Perl 6, un texte de 2011 : http://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/

Métaprogrammation avec Python :

• Métaclasses avec Python : http://www.ibm.com/developerworks/linux/library/l-pymeta.html
• Utiliser la métaprogrammation avec Python pour traiter de grosses quantités de données, présentation de 2013 : http://tuulos.github.io/sf-python-meetup-sep-2013/#/
• Comparer des types à l'aide de Python, par Eli Bendersky en 2016 : http://eli.thegreenplace.net/2016/comparing-types-in-python-3/

Métaprogrammation avec Ruby :

• http://ola-bini.blogspot.com/2006/09/ruby-metaprogramming-techniques.html
• http://ducktypo.blogspot.com/2010/08/metaprogramming-spell-book.
• Programmer en Ruby avec... rien, ou à peu près, un texte de 2011 : http://experthuman.com/programming-with-nothing

Métaprogrammation statique en Scala : http://scalamacros.org/

Comparatifs :

• Les Type Classes du langage Haskell, comparées (avec biais pro-Haskell, mais ça reste instructif) aux templates de C++ et aux generics de divers langages : http://www.haskell.org/haskellwiki/OOP_vs_type_classes

Multiprogrammation et systèmes répartis

À venir...

Programmation concaténative

À venir...

http://concatenative.org/wiki/view/Front%20Page

À propos de l'importance de la programmation concaténative, texte de Jon Purdy en 2012 : http://evincarofautumn.blogspot.mx/2012/02/why-concatenative-programming-matters.html

La concaténation serait une composition : http://concatenative.org/wiki/view/Concatenative%20language/Concatenation%20is%20composition

Programmation déclarative

À venir...

Introduction à la programmation déclarative, par Michael R. Bernstein en 2013 : http://michaelrbernste.in/2013/06/20/what-is-declarative-programming.html

Les risques de certaines caractéristiques impures de Prolog : http://okmij.org/ftp/Prolog/index.html#impure

Huit faussetés à propos de la programmation déclarative, énoncées par Erik Meijer et rapportées par John D. Cook en 2012 : http://www.johndcook.com/blog/2012/11/30/eight-fallacies-of-declarative-computing/

Ce qu'est la programmation déclarative (un terme confus), de l'avis de Robert Harper en 2013 : http://existentialtype.wordpress.com/2013/07/18/what-if-anything-is-a-declarative-language/

Programmation dynamique

Bien qu'il existe une stratégie d'optimisation du même nom, connue surtout dans le monde des mathématiques, les informaticiennes et les informaticiens utilisent typiquement le terme programmation dynamique en informatique en lien avec des langages dynamiques, qui demandent aux programmeuses et aux programmeurs d'expliquer moins de choses à leur outil de développement, cherchant à deviner des choses telles que les types de données impliqués dans les expressions. La frontière entre langages dynamiques et langages de scripts est mince.

• http://arcanesentiment.blogspot.com/2010/04/why-dynamic-programming.html?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+ArcaneSentiment+%28Arcane+Sentiment%29
• http://blog.labnotes.org/2006/03/11/james-gosling-explains-whats-wrong-with-java/
• http://www.infoworld.com/d/developer-world/dynamic-programming-futures-839
• http://www.infoworld.com/d/developer-world/application-builders-in-sky-477
• http://www.johndcook.com/blog/2010/06/09/dynamic-typing-and-risk-homeostasis/
• Chez Microsoft, l'investissement dans le développement en vue du support de langages dynamiques sur plateforme .NET semble se tarir, si on se fie aux incidents en lien avec IronRuby
• Une réflexion sur ce que signifie vraiment le mot « dynamique » dans ce contexte : http://gnuu.org/2010/12/13/too-lazy-to-type/
• Une critique fort pertinente des langages dynamiques (l'argumentaire est subtil) : http://existentialtype.wordpress.com/2011/03/19/dynamic-languages-are-static-languages/
• En 2012, William Edwards explique pourquoi, selon lui, les langages dynamiques mènent à du code lent : http://williamedwardscoder.tumblr.com/post/19538827844/why-dynamic-programming-languages-are-slow
• Selon Swizec Teller en 2013, les langages dynamiques ne sont plus aussi pertinents si on les compare aux langages contemporains munis de systèmes de types statiques : http://swizec.com/blog/dynamic-languages-have-jumped-the-shark/swizec/6204
• Texte de Jamie Wong en 2013 sur les difficultés d'entretien associés aux noms de fonctions dynamiques dans de tels langages : http://jamie-wong.com/2013/07/12/grep-test/

Programmation évolutive

On entend par programmation évolutive une approche par laquelle un programme évolue au cours de son existence de quelque chose de simple à quelque chose de plus riche. Ceci peut impliquer une évolution de son système de types, de sa robustesse, de l'applicabilité de ses interfaces, de la réflexivité, etc. On peut faire des liens entre la programmation évolutive et plusieurs autres types de programmation (programmation génétique, programmation par Scripting, programmation orientée objet, métaprogrammation, etc.).

Un descriptif général du concept, par J. Heitkötter et D. Beasley, qui donne même une perspective Darwinienne à cette approche : http://www.aip.de/~ast/EvolCompFAQ/Q1_2.htm

Programmation évolutive avec JavaScript, un texte de Lars T. Hansen en 2007 : http://www.ecmascript.org/es4/spec/evolutionary-programming-tutorial.pdf

Programmation fonctionnelle

Comme le nom l'indique, cette approche se concentre sur le concept de fonction. On y trouve fréquemment des fonctions qui reçoivent en paramètre des fonctions ou qui retournent des fonctions. La plupart font ce qu'on nomme des évaluations paresseuses des expressions, ne procédant à une évaluation qu'au moment où cela s'avère nécessaire (ce qui permet par exemple de représenter des concepts abstraits comme l'infini potentiel).

L'approche fonctionnelle pure est telle que les fonctions n'ont pas d'effets secondaires : elles ne modifient pas d'états globaux (en fait, ses objets sont typiquement immuables), et ne conservent pas d'états internes d'une invocation à l'autre, ce qui les rend réentrantes et place l'approche fonctionnelle en excellente position pour attaquer de front les problèmes nouveaux du parallélisme. L'absence d'effets secondaires complique en retour certaines tâches de la vie courante, comme les entrées/ sorties (pour lesquelles on trouve tout de même des solutions, telles que les monades en Haskell, concept qu'on aime ou qu'on déteste).

Parmi les langages fonctionnels les plus connus, on trouve Lisp, Scheme, Haskell et JavaScript.

Certains langages impératifs comme C (voir http://conal.net/blog/posts/the-c-language-is-purely-functional/) ou C++ permettent en partie d'appliquer une approche fonctionnelle; la métaprogrammation à l'aide de templates, en particulier, est en fait une approche fonctionnelle pure.

• http://www.haskell.org/haskellwiki/Functional_programming
• Comprendre ce qui distingue l'approche fonctionnelle de l'approche impérative : http://stackoverflow.com/questions/5226055/truly-understanding-the-difference-between-procedural-and-functional/5280719#5280719
• Penser de manière fonctionnelle avec Haskell, par Paul; Callaghan en 2012 : http://pragprog.com/magazines/2012-09/thinking-functionally-with-haskell
• principes de programmation fonctionnelle avec Scala, par Heather Miller et Martin Odersky en 2012 : http://docs.scala-lang.org/news/functional-programming-principles-in-scala-impressions-and-statistics.html
• Une cartographie de l'influence de divers langages de programmation sur l'approche fonctionnelle, tracée par Michael Fogus en 2012 : http://blog.fogus.me/2012/05/02/a-functional-programming-influence-graph/
• Que signifie « programmation fonctionnelle »?
  • une réflexion de Tony Harris en 2010 : http://dl.dropbox.com/u/7810909/docs/what-does-fp-mean/what-does-fp-mean/html/index.html
  • une opinion de Victor Nicollet en 2011 : http://www.nicollet.net/2011/10/functional-programming/
  • perspective de Kris Jenkins en 2015 : http://blog.jenkster.com/2015/12/what-is-functional-programming.html
• C'est le temps de se remettre à la programmation fonctionnelle : http://www.drdobbs.com/tools/212201710
• Pourquoi la programmation fonctionnelle est quelque chose d'important : http://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf
• Cela dit, il est clair que ce n'est pas tout le monde qui s'y connaît : http://research.microsoft.com/apps/pubs/default.aspx?id=141506
• Programmation fonctionnelle pour débutant(e)s :
  • http://www.defmacro.org/ramblings/fp.html
  • http://jdfrens.blogspot.com/2010/06/functional-programming-for-dummies.html
  • introduction à la programmation fonctionnelle proposée par Slava Akhmechet en 2012 : http://www.defmacro.org/ramblings/fp.html
  • les bases de la programmation fonctionnelle, expliquées par Robert C. Martin en 2013 : http://pragprog.com/magazines/2013-01/functional-programming-basics
    • une critique de ce texte par Cédric Beust en 2013 : http://beust.com/weblog/2013/01/02/no-silver-bullet-reloaded/
  • apprendre la programmation fonctonnelle en cinq minutes (en fait, une brève présentation sur le Currying), un diaporama électronique de Gias Kay Lee en 2013 : http://slid.es/gsklee/functional-programming-in-5-minutes
  • introduction aux avantages de la programmation fonctionnelle, par Greg Hale en 2013 : https://www.fpcomplete.com/user/imalsogreg/functional-programming-elevator-pitch
  • les étapes clés pour apprendre la programmation fonctionnelle, de l'avis d'Amit Dev en 2014 : http://amitdev.github.io/coding/2014/06/29/Learning-Functional-Programming/
  • introduction à la programmation fonctionnelle, par Mary Rose Cook en 2014 : https://codewords.hackerschool.com/issues/one/an-introduction-to-functional-programming
  • la migration de la pensée vers la programmation fonctionnelle, texte de Neal Ford en 2014 : https://www.voxxed.com/blog/2014/11/neal-ford-on-shifting-to-functional-thinking/
  • une approche qui se veut plus simple pour apprendre l'approche fonctionnelle, par Ricky Stewart en 2016 : https://rickystewart.wordpress.com/2016/01/02/a-simpler-approach-to-functional-programming/
  • introduction proposée par Mary Rose Cook en 2016 : http://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming
  • introduction proposée par Marko Pavlovic en 2016 : http://markonis.github.io/functional/programming/2016/04/16/intro-to-functional-programming.html
• Quelques perles de programmation fonctionnelle : http://www.haskell.org/haskellwiki/Research_papers/Functional_pearls
• Quand un programme fonctionnel n'en est pas un : http://citeseer.ist.psu.edu/cache/papers/cs/11680/ftp:zSzzSzftp.dcs.ed.ac.ukzSzpubzSzjrlzSzwhenfun.pdf/longley99when.pdf
• Programmation fonctionnelle réactive : http://conal.net/papers/push-pull-frp/
• Historique de la programmation objet-fonctionnelle, portant surtout sur Scala : http://www.artima.com/weblogs/viewpost.jsp?thread=275983
• Explication concise de l'immuabilité et de l'approche fonctionnelle : http://itmmetelko.com/blog/2008/02/23/functional-programming-immutable-objects-explained-irc-style/
• Sémantique des programmes et programmation fonctionnelle : http://homepages.cwi.nl/~jve/cs/
• Refactoriser ou réécrire? http://blog.objectmentor.com/articles/2009/08/05/functional-refactoring-and-you-cant-get-there-from-here
• Représenter des valeurs par des types en Haskell : http://www.cs.rutgers.edu/~ccshan/prepose/prepose.pdf
• Libérer la programmation fonctionnelle du paradigme des machines de type VonNeumann : http://conal.net/blog/posts/can-functional-programming-be-liberated-from-the-von-neumann-paradigm/
• Programmation fonctionnelle dans un langage orienté-objet : http://www.harukizaemon.com/2010/03/functional-programming-in-object-oriented-languages.html
• Un outil pour transformer des programmes fonctionnels, semblables à ceux écrits en Haskell, en métaprogrammes C++ : http://gergo.erdi.hu/projects/metafun/
• Espèces d'entités dans un programme fonctionnel : http://www.cis.upenn.edu/~byorgey/papers/species-pearl.pdf
• La réputation des langages fonctionnels est surfaite? http://www.benrady.com/2010/06/a-bit-of-heresy-functional-languages-are-overrated.html
• Étudier les langages fonctionnels pour ne pas être ignorant(e)? http://benhutchison.wordpress.com/2009/06/02/study-functional-programming-or-be-ignorant/
• Archéologie des langages fonctionnels : http://prog21.dadgum.com/14.html
• Expliquer la programmation fonctionnelle à un enfant : http://prog21.dadgum.com/73.html
• Adapter un Framework OO pour utilisation par un langage fonctionnel réactif : http://www.cs.brown.edu/~sk/Publications/Papers/Published/ick-adapt-oo-fwk-frp/paper.pdf
• Une série très mathématisée sur la programmation fonctionnelle en C++ : http://cpp-next.com/archive/2010/07/algebraic-data-types/
• à propos de la thèse de Church et de la programmation fonctionnelle :http://www.cs.kent.ac.uk/people/staff/dat/miranda/ctfp.pdf
• Au sujet des structures de données Topless, ou sans fin mais dans une seule direction : http://conal.net/blog/posts/topless-data/
• Vérifier la pureté fonctionnelle en Java : http://www.cs.berkeley.edu/~daw/papers/pure-ccs08.pdf
• Programmer de manière fonctionnelle en Java, par Cyrille Martaire en 2011 : http://cyrille.martraire.com/2011/03/thinking-functional-programming-with-map-and-fold-in-your-everyday-java/
• Texte à saveur pédagogogique : http://devlicio.us/blogs/christopher_bennage/archive/2010/09/06/what-is-functional-programming.aspx (et les suites, car il y en a plusieurs)
• La programmation fonctionnelle serait à la mode : http://prog21.dadgum.com/31.html
• Programmation fonctionnelle, de Java à Scala : http://www.artima.com/weblogs/viewpost.jsp?thread=306337
• Programmation fonctionnelle en Scala pour le commun des mortels, un texte de 2011 : http://www.tikalk.com/incubator/blog/functional-programming-scala-rest-us
• Programmation fonctionnelle et design matériel : http://www.jucs.org/doi?doi=10.3217/jucs-011-07-1135
• Réflexivité (au sens OO) et programmation fonctionnelle : http://gbracha.blogspot.com/2010/12/reflecting-on-functional-programming.html
• Passer du modèle OO au modèle fonctionnel : http://squirrel.pl/blog/2011/03/14/two-worlds-learning-functional-thinking-after-oo/
• Certaines approches fonctionnelles, pour être naturelles, exigent (aux yeux de certains, du moins) l'immuabilité : http://algorithm.com.au/blog/files/immutability-blocks-lambdas-closures.php#unique-entry-id-613
• Enseigner la programmation fonctionnelle : http://existentialtype.wordpress.com/2011/04/17/some-advice-on-teaching-fp/
• La programmation fonctionnelle est difficile... et tant mieux, selon Dave Fayram en 2011 : http://dave.fayr.am/posts/2011-08-19-lets-go-shopping.html
• La paresse :
  • http://existentialtype.wordpress.com/2011/04/24/the-real-point-of-laziness/
  • http://augustss.blogspot.com/2011/05/more-points-for-lazy-evaluation-in.html
• Blogue sur les schémas de conception en programmation fonctionnelle : http://patternsinfp.wordpress.com/
• Penser fonctionnel :
  • http://www.ibm.com/developerworks/java/library/j-ft1/index.html
• Comparer la programmation impérative et la programmation fonctionnelle :
  • http://apocalisp.wordpress.com/2011/05/30/imperative-vs-functional-programming/
• La « programmation fonctionnelle totale », pour rapprocher la programmation fonctionnelle des mathématiques :
  • http://www.eis.mdx.ac.uk/staffpages/dat/sblp1.pdf
• Types de données algébriques, ou ADT :
  • une description par Etienne Millon, en 2011 : http://blog.emillon.org/posts/2011-12-14-what-s-in-an-adt.html
• À propos des compréhensions de listes, un texte de Jeremy Gibbons en 2012 : http://patternsinfp.wordpress.com/2012/01/19/comprehensions/
• Distinguer les applications partielles comme on en voit en C# du Currying :
  • un texte de Jon Skeet en 2012 : http://msmvps.com/blogs/jon_skeet/archive/2012/01/30/currying-vs-partial-function-application.aspx
  • texte de Reginald Braithwaite en 2013 : http://raganwald.com/2013/03/07/currying-and-partial-application.html
  • texte d'Alec Benzer en 2013 : http://alecbenzer.com/blog/currying-partial-application/
• Schémas de conception en programmation fonctionnelle, un texte de Neal Ford en 2012 : http://www.ibm.com/developerworks/java/library/j-ft10/index.html?ca=drs-
• Intégrer les approches OO et fonctionnelle, un texte de Michael Feathers en 2012 : http://michaelfeathers.typepad.com/michael_feathers_blog/2012/03/tell-above-and-ask-below-hybridizing-oo-and-functional-design.html
• En 2012, Bartosz Milewski explique qu'à son avis, la multiprogrammation a sonné le glas de la programmation impérative, et que la programmation fonctionnelle est maintenant le chemin à emprunter : http://fpcomplete.com/the-downfall-of-imperative-programming/
• Selon Jessica Kerr, en 2012, la programmation fonctionnelle clarifie notre pensée : http://blog.jessitron.com/2012/06/why-functional-matters-your-white-board.html
• La pensée fonctionnelle avec Haskell, par Paul Callaghan en 2012 : http://pragprog.com/magazines/2012-08/thinking-functionally-with-haskell
• Correspondance fonctionnelle entre les évaluateurs et les machines abstraites, par Mads Sid Ager, Dariusz Biernacki, Olivier Danvy et Jan Midtgaard en 2003 : http://www.brics.dk/RS/03/13/BRICS-RS-03-13.pdf
• Une technique fonctionnelle pour optimiser certaines tâches, par Andy Gill et Graham Sutton en 2009 : http://www.cs.nott.ac.uk/~gmh/wrapper.pdf
• Implémenter des générateurs, par Oleg Kiselyov en 2011 : http://okmij.org/ftp/continuations/generators.html
• L'opérateur amb de Lisp, proposé par John McCarthy et qui permet (si une implémentation l'implémente, ce qui – à ce que je sache – n'est jamais arrivé) de réaliser un choix non-déterministe entre plusieurs expressions : http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-16.html#node_chap_14
• Mise en garde de David J. Pearce, auteur du langage Whiley, proposée en 2012 et destinée à ceux qui confondent programmation fonctionnelle et style fonctionnel : http://whiley.org/2012/09/06/a-misconception-of-functional-programming/
• Dans ce texte de 2012, Michael O. Church nous invite à programmer de manière impérative lorsque c'est nécessaire, tout en préférant une approche fonctionnelle en général : http://michaelochurch.wordpress.com/2012/12/06/functional-programs-rarely-rot/
• Réaliser un Church Encoding en JavaScript, par Matt Might en 2013 : http://matt.might.net/articles/js-church/
• Le code écrit selon une approche fonctionnelle tend à être plus court que son équivalent selon d'autres approches... Mais pourquoi? L'opinion de Paul Chiusano en 2013 : http://pchiusano.blogspot.ca/2013/02/why-functional-code-is-shorter.html
• En 2013, James Hague explique comment la programmation fonctionnelle peut même servir de métaphore à l'apprentissage de Photoshop : http://prog21.dadgum.com/180.html
• La programmation fonctionnelle « totale », texte de D. A. Turner en 2004 : http://www.jucs.org/jucs_10_7/total_functional_programming/jucs_10_07_0751_0768_turner.pdf
• Propriétés « universelles » des opérations Map, Fold et Filter, texte de Jeremy Kun en 2013 : http://jeremykun.com/2013/09/30/the-universal-properties-of-map-fold-and-filter/
• Style de programmation par composition de « flèches », un texte de John Hughes (qui semble avoir été publié en 2004 si je me fie sur les références) : http://www.cse.chalmers.se/~rjmh/afp-arrows.pdf
• Texte de 2014 par Tony DaSilva, qui décrit ce que son auteur considère un « changement de régime », au sens où selon lui, la programmation fonctionnelle prend graduellement le dessus sur l'approche dominante (l'approche OO) au moment où le texte a été écrit : http://bulldozer00.com/2014/11/12/regime-change/
• En 2015, réflexion de Dennis McWherter sur le « lent glissement » de plusieurs langages vers le paradigme fonctionnel : http://deathbytape.com/post/122385153704/slow-shift-to-functional
• Les fonctions d'ordre supérieur (High Order), par Mark Galea en 2016 : http://cloudmark.github.io/Higher-Order-Functions/

Les lentilles (lenses) :

• Discussion d'un aspect de cette approche, par Bartosz Milewski en 2013 : http://bartoszmilewski.com/2013/10/08/lenses-stores-and-yoneda/
• Texte de 2015 par Bartosz Milewski à propos de llentilles et de Yoneda Embedding : http://bartoszmilewski.com/2015/07/13/from-lenses-to-yoneda-embedding/

Comparatifs :

• L'influence de la pensée fonctionnelle sur la saine pensée OO, par Simon Harris en 2010 : http://www.harukizaemon.com/blog/2010/03/01/functional-programming-in-object-oriented-languages/
• La migration d'une pensée OO à une pensée fonctionnelle, texte de Hadi Hariri en 2013 : http://hadihariri.com/2013/11/24/refactoring-to-functionalwhy-class/
• Selon John D. Cook en 2010, la POO et la programmation fonctionnelle aident toutes deux, chacune à sa façon, à la compréhension du code : http://www.johndcook.com/blog/2010/11/03/object-oriented-vs-functional-programming/
• Dans ce texte de 2014, Erik Meijer explique qu'à son avis, la programmation « presque fonctionnelle », comme le mettent de l'avant des langages comme C# ou C++, est un cul de sac : http://queue.acm.org/detail.cfm?ref=rss&id=2611829
• Selon Erkki Lindpere en 2013, le débat entre les tenants de la pensée fonctionnelle et ceux de la pensée OO en est un qui porte surtout sur la composition : http://zeroturnaround.com/rebellabs/why-the-debate-on-object-oriented-vs-functional-programming-is-all-about-composition/
• Texte de Robert C. Martin en 2012 expliquant la programmation fonctionnelle aux programmeuses et aux programmeurs OO : http://blog.8thlight.com/uncle-bob/2012/08/24/functional-programming-for-the-object-oriented-programmer.html
• Le glissement de l'approche OO vers l'approche fonctionnelle passe en particulier par l'immuabilité, selon ce texte de 2014 : http://valve.github.io/blog/2014/07/04/from-object-to-functional-immutability/
• Traverser le pont entre l'approche OO et l'approche fonctionnelle, par Dave Thomas en 2009 : http://www.jot.fm/issues/issue_2009_07/column4/
• En 2014, Robert C. Martin compare la programmation fonctionnelle à la programmation OO : http://blog.cleancoder.com/uncle-bob/2014/11/24/FPvsOO.html
• Dans ce texte de 2015, Yevgeniy Brikman explique sa perception à l'effet de laquelle les paradigmes contemporains dominants lui semblent tendre vers le typage statique et la programmation fonctionnelle : http://brikis98.blogspot.ca/2015/02/are-static-typing-and-functional.html

Critiques :

• Est-ce raisonnable de se limiter au modèle fonctionnel? Texte de James Hague en 2009 : http://prog21.dadgum.com/54.html
• Dans le même ordre d'idées, la pureté mise de l'avant par le modèle fonctionnel mène-t-elle nécessairement à des implémentations efficaces? Texte de James Hague en 2009 : http://prog21.dadgum.com/41.html?0
• En 2012, Larry O'Brien laisse entendre que le problème avec la programmation fonctionnelle est qu'elle sous-tend un discours prétentieux, ou plutôt suffisant : http://www.sdtimes.com/content/article.aspx?ArticleID=36534
• Dans ce texte de 2012, Judah Johns émet l'opinion que la programmation fonctionnelle, si pertinente soit-elle, est un ghetto : http://blog.jelastic.com/2012/07/24/functional-programming-is-a-ghetto/
• Qu'est-ce qui nous fait penser que la programmation fonctionnelle mène à des programmes fondamentalement lents (en comparaison avec des équivalents écrits en C, par exemple)? Une réflexion de John Harrop en 2012 : http://flyingfrogblog.blogspot.co.uk/2012/06/are-functional-languages-inherently.html
• Dans ce texte de 2013, Elliotte Rusty Arnold prétend que la programmation fonctionnelle avec Java ¸(ou, sur la base de son argumentaire, avec tout langage n'offrant pas le support propre aux idiomes de la programmation fonctionnelle, par exemple la récursivité – au moins par Tail Call Optimization – au même prix que l'itération, et l'évaluation paresseuse des valeurs) est dangereuse : http://cafe.elharo.com/programming/java-programming/why-functional-programming-in-java-is-dangerous/
• Parfois, permettre quelques effets de bord peut être avantageux, de l'avis de Yin Wang en 2013 : https://yinwang0.wordpress.com/2013/11/09/oop-fp/
• En 2014, James Hague met en relief que, selon lui, la simulation est un « pire cas » pour la programmation fonctionnelle : http://prog21.dadgum.com/189.html
• Définir un type « mutable » dans un langage où les données sont typiquement immuables, un texte de 2014 par Joseph Abrahamson :
  • http://tel.github.io/2014/07/12/mutable_algorithms_in_immutable_languges_part_1/
  • http://tel.github.io/2014/07/13/mutable_algorithms_in_immutable_languages_part_2/

Programmation fonctionnelle par langage

Programmation fonctionnelle en Ada :

• http://okasaki.blogspot.com/2008/07/functional-programming-inada.html

Programmation fonctionnelle avec C :

• Texte de 2009 par Conal Elliott, qui met en relief que C, lorsque pris dans une acception particulière (et mettant en valeur le préprocesseur), est essentiellement un langage purement fonctionnel : http://conal.net/blog/posts/the-c-language-is-purely-functional
• Implémenter le Tail Call Recursion efficacement (sans faire exploser la pile du programme), un texte de Danny Gratzer en 2014 : http://jozefg.bitbucket.org/posts/2014-05-05-i-used-c-correctly.html
• http://conal.net/blog/posts/the-c-language-is-purely-functional/
• En 2012, Job Vranish en donne une démonstration, programmant en C un peu comme on le ferait en Lisp (mais avec quelques restrictions)  : http://spin.atomicobject.com/2012/11/01/hey-c-is-a-functional-language-too/
• Dans ce texte de 2013, Charles Cary met de l'avant qu'appliquer des techniques de programmation fonctionnelle en C peut rapporter, et montre comment il est possible d'y représenter certaines des choses auxquelles les programmeuses et les programmeurs fonctionnels tiennent : http://blog.charlescary.com/?p=95

Programmation fonctionnelle avec C# :

• Rendre C# plus fonctionnel, selon Chris Eargle en 2011 : http://www.kodefuguru.com/post/2011/09/02/Making-It-More-Functional.aspx
• Mieux vaut ne pas écrire du code C# qui dépende du support du Tail Recursion, comme le montre ce texte de 2014 : http://blog.cellfish.se/2014/03/tail-recursion-and-c.html
• Série sur la programmation fonctionnelle avec C#, par Vladimir Khorikov en 2015 :
  • l'immuabilité : http://enterprisecraftsmanship.com/2015/03/02/functional-c-immutability/
  • l'obsession des primitifs : http://enterprisecraftsmanship.com/2015/03/07/functional-c-primitive-obsession/
  • les types non-nullables : http://enterprisecraftsmanship.com/2015/03/13/functional-c-non-nullable-reference-types/
  • la gestion des erreurs : http://enterprisecraftsmanship.com/2015/03/20/functional-c-handling-failures-input-errors/

Programmation fonctionnelle avec C++ :

• Une série très mathématisée sur la programmation fonctionnelle en C++ : http://cpp-next.com/archive/2010/07/algebraic-data-types/
• Programmation fonctionnelle avec C++, un texte de John Carmack en 2012 : http://www.altdevblogaday.com/2012/04/26/functional-programming-in-c/
• Un texte de John Carmack en 2012 : http://www.altdevblogaday.com/2012/04/26/functional-programming-in-c/
• Texte d'Alfons Haffmans en 2013 : http://pragprog.com/magazines/2013-07/living-with-lambdas
• Analyse d'Eric Niebler en complément d'une proposition de Bartosz Milewski, en 2013 : http://ericniebler.com/2013/07/16/f-algebras-and-c/
• Définir des types-classes comme avec Haskell, par exemple des monoïdes, un texte de 2013 : http://functionalcpp.wordpress.com/2013/08/16/type-classes/
• Présentation d'Andrew Weiss en 2013 : http://de.slideshare.net/andreweissflog3/quovadis2013-cpp-ontheweb
• Quelques textes de Bartosz Milewski :
  • listes immuables texte de 2013 : http://bartoszmilewski.com/2013/11/13/functional-data-structures-in-c-lists/
  • arbres immuables, texte de 2013 : http://bartoszmilewski.com/2013/11/25/functional-data-structures-in-c-trees/
  • structures de données immuables et concurrence, texte de 2013 : http://bartoszmilewski.com/2013/12/10/functional-data-structures-and-concurrency-in-c/
  • voir un foncteur (au sens mathématique du terme) comme un conteneur, texte de 2014 : hhttp://bartoszmilewski.com/2014/01/14/functors-are-containers/
  • arbres immuables penchés (à gauche), texte de 2014 : http://bartoszmilewski.com/2014/01/21/functional-data-structures-in-c-leftist-heaps/
  • des monades avec C++ 17? Texte de 2014 : http://bartoszmilewski.com/2014/02/26/c17-i-see-a-monad-in-your-future/
  • le virage fonctionnel, texte de 2014 : http://bartoszmilewski.com/2014/06/09/the-functional-revolution-in-c/
• Le Monadic Lifting en C++, par Joaquín M López Muñoz en 2014 : http://bannalia.blogspot.ca/2014/03/monadic-lifting-in-c.html
• Selon Christoph Kohlhepp en 2014, l'évolution de C++ depuis C++ 11, et à plus forte partie depuis C++ 14, le rapproche conceptuellement de langages fonctionnels tels que Lisp :
  • http://chriskohlhepp.wordpress.com/convergance-of-modern-cplusplus-and-lisp/
  • http://chriskohlhepp.wordpress.com/lambda-over-lambda-in-cplusplus14/
• En 2014, Bartosz Milewski propose des techniques d'évaluation paresseuse en C++ pour gérer les séquences infinies : http://bartoszmilewski.com/2014/04/21/getting-lazy-with-c/
• Présentation de la programmation fonctionnelle avec C++, par David Sankel en 2014 : https://github.com/boostcon/cppnow_presentations_2014/raw/master/files/intro-to-functional-programming-in-cpp.pdf
• Structures de données fonctionnelles avec C++, par Bartosz Milewski en 2014 : https://github.com/boostcon/cppnow_presentations_2014/raw/master/files/functional-data-structures.pdf
• La programmation fonctionnelle pour résoudre des problèmes de télémétrie, par Bartosz Milewski en 2014 : http://bartoszmilewski.com/2014/11/12/formula-1-go-functional/
• Série d'articles sur la théorie des catégories expliquée aux programmeurs, par par Bartosz Milewski :
  • texte de 2014 introduisant le tout : http://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/
  • texte de 2014 sur la question de la composition : http://bartoszmilewski.com/2014/11/04/category-the-essence-of-composition/
  • texte de 2014 sur les types et les fonctions : http://bartoszmilewski.com/2014/11/24/types-and-functions/
  • texte de 2014 sur les catégories, petites et grandes : http://bartoszmilewski.com/2014/12/05/categories-great-and-small/
  • texte de 2014 sur les catégories de Kleisli : http://bartoszmilewski.com/2014/12/23/kleisli-categories/
  • texte de 2015 sur les produits et les coproduits : http://bartoszmilewski.com/2015/01/07/products-and-coproducts/
  • texte de 2015 sur les foncteurs au sens de la théorie des catégories (pas au sens de Lisp ou de C++) : http://bartoszmilewski.com/2015/01/20/functors/
  • texte de 2015 sur la composition de foncteurs simples pour en arriver à un foncteur plus riche : http://bartoszmilewski.com/2015/02/03/functoriality/
  • texte de 2015 sur les types fonctions : http://bartoszmilewski.com/2015/03/13/function-types/
  • texte de 2015 sur les transformations naturelles : http://bartoszmilewski.com/2015/04/07/natural-transformations/
  • texte de 2015 qui se veut une introduction à la deuxième partie de cette série d'articles, et portant sur la programmation déclarative : http://bartoszmilewski.com/2015/04/15/category-theory-and-declarative-programming/
  • texte de 2015 qui parle de résolution de contraintes, plus précisément de la monade List : http://bartoszmilewski.com/2015/05/11/using-monads-in-c-to-solve-constraints-1-the-list-monad/
  • texte de 2015 qui parle de résolution de contraintes, plus précisément de la monade State : http://bartoszmilewski.com/2015/05/14/using-monads-in-c-to-solve-constraints-2-the-state-monad/
  • texte de 2015 qui parle de résolution de contraintes par une « fable des deux monades » : http://bartoszmilewski.com/2015/05/18/using-monads-in-c-to-solve-constraints-3-the-tale-of-two-monads/
  • texte de 2015 qui parle de résolution de contraintes et de refactorisationr : http://bartoszmilewski.com/2015/05/25/using-monads-in-c-to-solve-constraints-4-refactoring/
  • texte de 2015 qui parle de limites et de colimites : http://bartoszmilewski.com/2015/04/15/limits-and-colimits/
  • texte de 2015 qui parle de monoïdes libres : http://bartoszmilewski.com/2015/07/21/free-monoids/
  • texte de 2015 qui parle de foncteurs représentables : http://bartoszmilewski.com/2015/07/29/representable-functors/
• Texte de Victor Laskin en 2015 sur la programmation par pipeline d'opérations, une approche très fonctionnelle : http://vitiy.info/functional-pipeline-in-c11/
• Les projections, analogues à une forme de Currying, par Scott Prager en 2015 : http://yapb-soc.blogspot.ca/2015/02/common-algorithm-patterns.html

Programmation fonctionnelle avec D :

• Texte d'Andreas Zwinkau en 2013 : http://beza1e1.tuxen.de/articles/functional_D.html
• D et la pureté fonctionnelle :
  • implémentation de l'immuabilité et de la pureté fonctionnelle en D, par Andrei Alexandrescu : http://www.digitalmars.com/d/2.0/accu-functional.pdf
  • la pureté en D, par David Nadlinger en 2012 : http://klickverbot.at/blog/2012/05/purity-in-d/
  • la pureté fonctionnelle en D : http://leonardo-m.livejournal.com/99194.html
  • comment D assure le respect de la pureté, par Walter Bright en 2014 : http://www.drdobbs.com/architecture-and-design/function-purity-and-immutable-data-struc/240169087

Programmation fonctionnelle avec Java :

• Vérifier la pureté fonctionnelle en Java : http://www.cs.berkeley.edu/~daw/papers/pure-ccs08.pdf
• Les expressions λ et le type Optional<T> sont de grands pas en avant pour faire avancer ce paradigme de programmation pour Java :
  • ../Sujets/Divers--java/Evolution-Java.html#lambda
  • ../Sujets/Divers--java/Evolution-Java.html#optional

Programmation fonctionnelle avec Kotlin :

• Présentation par Mike Hearn en 2015 : https://medium.com/@octskyward/kotlin-fp-3bf63a17d64a

Programmation fonctionnelle avec OCaml :

• Introduction proposée en 2015 : http://afoote.me/2015/09/20/functional-and-fold/

Programmation fonctionnelle en Python :

• http://www.artima.com/weblogs/viewpost.jsp?thread=248953
• Présentation d'Alexey Kachayev en 2012 : http://kachayev.github.io/talks/uapycon2012/index.html#/
• En 2016, Sachin Joglekar propose une introduction à la programmation fonctionnelle pour programmeuses et programeurs Python : https://codesachin.wordpress.com/2016/04/03/a-practical-introduction-to-functional-programming-for-python-coders/

Programmation fonctionnelle avec Ruby :

• Texte de 2005 selon lequel Ruby serait un Lisp acceptable : http://www.randomhacks.net/articles/2005/12/03/why-ruby-is-an-acceptable-lisp
• Profiter à plein des possibilités de programmation fonctionnelle avec Ruby, par Alex Shestakov en 2015 : http://www.programmableweb.com/news/how-to-leverage-rubys-functional-programming-capability/how-to/2015/09/24

Programmation fonctionnelle avec Rust :

• Le polymorphisme de haut niveau avec Rust, par Daniel Fagnan en 2014 : http://www.hydrocodedesign.com/2014/04/02/higher-kinded-types/

Programmation fonctionnelle avec Scala :

• Scala est-il fonctionnel ou non?
  • http://www.scala-lang.org/node/4960
  • http://enfranchisedmind.com/blog/posts/scala-not-functional/
  • http://www.codecommit.com/blog/scala/is-scala-not-functional-enough
• Programmation fonctionnelle en Scala pour le commun des mortels, un texte de 2011 : http://www.tikalk.com/incubator/blog/functional-programming-scala-rest-us

Programmation fonctionnelle avec Swift :

• Texte de Giovanni Lodi en 2015 qui montre comment traduire certains concepts et certaines pratiques de Haskell en termes de Swift : http://www.mokacoding.com/blog/functor-applicative-monads-in-pictures/

Monades

Les monades sont une particularité importante des langages fonctionnels contemporains, particularité qui fait son chemin vers plusieurs autres paradigmes de programmation. Techniquement, une monade représente formellement une étape dans une séquence de calculs, et constitue un jalon dans plusieurs efforts de composition de calculs. Pour y arriver, les monades transigent non pas des valeurs mais bien la possibilité d'une valeur (optional<T> en C++, Maybe en Haskell).

Certains diront que les monades s'expriment par un triplet d'opérations fondamentales :

• La projection d'une opération dans le contexte d'une monade, ou map
• La transformation de la valeur retournée en valeur potentielle, ou return
• La transformation d'une possibilité de possibilité en possibilité plus simple (d'un optional<optional<T>> en optional<T>, à titre d'exemple), ou join

D'autres se limiteront à un couple d'opérations :

• Le bind, qui correspond à une fonction prenant deux paramètres, soit un optional<Src> et une fonction transformant un optional<Src> en optional<Dest>, et
• Le return, qui s'apparente au constructeur d'un optional<T> résultant du calcul réalisé par une fonction

Quelques textes sur le sujet :

• http://en.wikipedia.org/wiki/Monad_%28functional_programming%29
• Définition compacte mais pour gens avec un solide bagage mathématique, commentée par John D. Cook : https://plus.google.com/u/0/+JohnCook/posts/chbNpyhve1d
• Introduction aux monades, par Philip Wadler en 2006 : http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/baastad.pdf
• Introduction aux monades sous Haskell : http://www.haskell.org/tutorial/monads.html
• Lois des monades avec Haskell : http://www.haskell.org/haskellwiki/Monad_laws
• Présentation pour comprendre les monades : http://marakana.com/static/courseware/scala/presentation/comprehending-monads.html#slide-0
• Les monades expliquées avec Haskell par Stephen Diehl : http://www.stephendiehl.com/posts/monads.html
• Monades pour débutants, texte de Stephan Boyer en 2014 : http://www.stephanboyer.com/post/83/monads-for-dummies
• Programmation par contraintes à l'aide de monades : http://homepages.inf.ed.ac.uk/wadler/topics/monads.html
• Les monades ne sont pas des métaphores : http://www.codecommit.com/blog/ruby/monads-are-not-metaphors
• La monade d'entrée/ sortie a eu 45 ans en 2010 : http://www.haskell.org/pipermail/haskell-cafe/2010-December/087788.html
• Une description des monades « pour programmeurs curieux » :
  • http://bartoszmilewski.wordpress.com/2011/01/09/monads-for-the-curious-programmer-part-1/
  • http://bartoszmilewski.wordpress.com/2011/03/14/monads-for-the-curious-programmer-part-2/
  • http://bartoszmilewski.wordpress.com/2011/03/17/monads-for-the-curious-programmer-part-3/
  • http://bartoszmilewski.wordpress.com/2011/07/11/monads-in-c/
• Comprendre les monades avec JavaScript : http://igstan.ro/posts/2011-05-02-understanding-monads-with-javascript.html
• ML et les monades : http://existentialtype.wordpress.com/2011/05/01/of-course-ml-has-monads/
• Explications relativement claires du concept de monade en programmation fonctionnelle, par Stephan Boyer :
  • http://www.stephanboyer.com/2011/08/kicked-in-monads.html
  • http://www.stephanboyer.com/2011/09/uniqueness-types-and-godel.html
  • http://www.stephanboyer.com/2011/10/monads.html
  • http://www.stephanboyer.com/2011/10/monads-part-2.html
• Les monades avec Scheme : http://okmij.org/ftp/Scheme/monad-in-Scheme.html
• Quelques monades connues :
  • la monade State avec Haskell, une explication de Brandon Simmons en 2012 : http://brandon.si/code/the-state-monad-a-tutorial-for-the-confused/
  • la monade Continuation avec Haskell, une explication de Gabriel Gonzales en 2012 : http://www.haskellforall.com/2012/12/the-continuation-monad.html
• En 2012, Paul Callaghan nous rappelle qu'il y eut un temps avant les monades : http://www.free-variable.org/2012/08/i-remember-the-time-before-monads/
• Texte de 2012 expliquant les monades, pas à pas : http://tailcalled.wordpress.com/2012/12/31/on-types-functional-programming-and-monads/
• Les monades avec C# :
  • texte explicatif de Wes Dyer en 2008, qui positionne les monades comme un triplet fait d'un type, d'une fonction Unit et d'une fonction Bind, triplet devant satisfaire trois lois (deux d'identité et une d'associativité), et qui met en valeur que la force de la monade est qu'elle facilite la composition, donc la réutilisation du code : http://blogs.msdn.com/b/wesdyer/archive/2008/01/11/the-marvels-of-monads.aspx
  • série de textes par Eric Lippert en 2013 :
    • une introduction au concept, qui propose de voir la monade comme un schéma de conception : http://ericlippert.com/2013/02/21/monads-part-one/
    • la monade vue comme un type générique qui amplifie l'expressivité d'un autre type : http://ericlippert.com/2013/02/25/monads-part-two/
    • pour un type monadique M<T>, il doit être possible d'écrire une fonction génératrice d'un M<T> à partir d'une instance de T, et l'objet résultant doit être tel que sa structure encode la séquence d'opérations qui résultera de son utilisation (un type proche d'un foncteur ou d'une fonction, en quelque sorte) : http://ericlippert.com/2013/02/28/monads-part-three/
    • utiliser la monade pour transformer une fonction applicable aux types d'origine en une fonction applicables aux types résultant de l'amplification monadique, donc transformer une opération de signature R(A) en une opération de signature M<R>(M<A>) : http://ericlippert.com/2013/03/04/monads-part-four/
    • une monade peut « aplatir » un M<T> en T, ce qui permet d'appliquer une monade à un M<T> sans récupérer un M<M<T>> en retour : http://ericlippert.com/2013/03/07/monads-part-five/
    • la fonction génératrice d'une monade et la fonction « aplatissante » correspondantes doivent toutes deux préserver la valeur de la donnée et du type sous-jacents : http://ericlippert.com/2013/03/11/monads-part-six/
    • monades et composition de fonctions : http://ericlippert.com/2013/03/14/monads-part-seven/
    • la nomenclature « standard » de certaines monades, soit unit et bind : http://ericlippert.com/2013/03/18/monads-part-eight/
    • les monades pour coupler des valeurs avec des états : http://ericlippert.com/2013/03/21/monads-part-nine/
    • comment on peut exprimer LINQ avec des monades : http://ericlippert.com/2013/03/25/monads-part-ten/
    • monades et expressions sur des séquences : http://ericlippert.com/2013/03/28/monads-part-eleven/
    • il aurait été possible de construire LINQ strictement à partir de monades : http://ericlippert.com/2013/04/02/monads-part-twelve/
  • complément proposé par Stephen Toub en 2013, portant sur les monades représentant des tâches : http://blogs.msdn.com/b/pfxteam/archive/2013/04/03/tasks-monads-and-linq.aspx
• Les monades avec C++ :
  • explication par Tres Walsh en 2014 : http://treswalsh.com/posts/an-attempt-to-explain-monads-in-cxx.html
• Les monades avec Haskell :
  • http://www.engr.mun.ca/~theo/Misc/haskell_and_monads.htm
  • http://fpmatters.blogspot.com/2009/04/beware-monads.html
  • http://strongtyped.blogspot.com/2010/01/monad-non-tutorial.html
  • Programmation par contraintes à l'aide de monades : http://homepages.inf.ed.ac.uk/wadler/topics/monads.html
  • http://learnyouahaskell.com/monads
  • Applications des monades dans Haskell, texte de Paul Callaghan en 2012 : http://pragprog.com/magazines/2012-11/thinking-functionally-with-haskell
• Les monades avec Java 8 :
  • explication d'Oleg Shelajev en 2014 : http://zeroturnaround.com/rebellabs/monadic-futures-in-java8/
  • implémenter des monades, un texte de Pierre-Yves Saumont en 2014 : http://java.dzone.com/articles/do-it-in-java-8-state-monad
• Les monades avec Rust :
  • la monade Option, par Andrew Hobden en 2014 : http://www.hoverbear.org/2014/08/12/Option-Monads-in-Rust/
• Les monades avec Swift :
  • explication de Javier Soto, en 2015 : http://www.javiersoto.me/post/106875422394
• Les monades illustrées, par vouditya Bhargava en 2013 : http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html
• En 2006, Dan Piponi explique que vous avez peut-être déjà inventé les monades vous-mêmes, sans vous en apercevoir : http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html
• Monoïdes libres et constructions universelles, texte de Bartosz Milewski en 2013 : http://bartoszmilewski.com/2013/12/21/understanding-free-monoids-and-universal-constructions/
• Une critique des tutoriels portant sur les monades, par Brent Yorgey en 2009 : http://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/
• La monade « liste », selon Bartosz Milewski en 2014 : https://www.fpcomplete.com/user/bartosz/basics-of-haskell/13-the-list-monad
• Les monades en tant que schéma de conception, par Amit Dev en 2014 : http://amitdev.github.io/coding/2014/07/28/A-Functional-Design-Pattern/

Programmation graphique

À venir...

Réflexion de Philip C. Monk en 2013 : http://pcmonk.wordpress.com/2013/10/14/graphical-programming-i-really-hope-this-is-the-future/

Variante proposée par Sean McDirmid en 2013 et nommée Usable Live Programming : http://research.microsoft.com/en-us/people/smcdirm/liveprogramming.aspx

Programmation générative

La programmation générative se veut une approche par laquelle certaines tâches de programmation manuelle sont automatisées, incluant la production et l'assemblage de composants logiciels. Les idées derrière cette façon de faire sont véhiculées en partie par Krzysztof Czarnecki dans sa dissertation de 1998 et depuis celle-ci.

Quelques définitions de cette approche sont proposées sur http://www.program-transformation.org/Transform/GenerativeProgramming et, de manière générale, le Wiki http://www.program-transformation.org/Transform/GenerativeProgrammingWiki s'y consacre.

Une présentation de la programmation générative et de ses applications, exprimées par la voie de la métaprogrammation, peut être consultée sur http://www.slideshare.net/ysb33r/generative-programming-in-the-large-applied-c-metaprogramming

Texte de Chris Sells en 2001 exprimant la programmation générative à partir d'exemples concrets : http://msdn.microsoft.com/en-us/magazine/cc301675.aspx

Site sur la programmation générative et ses vertus, par Anders Hoff : http://inconvergent.net/

Programmation générique

Dans les mots d'Alexander Stepanov lui-même, tels que rapportés par son interviewer du moment, John Lakos, dans une entrevue de 2015, la programmation générique est la recherche d'algorithmes tels que « an algorithm in one domain can be applied in another similar domain ».

Texte explicatif à venir.

Liens et différences entre généricité et héritage, par Bertrand Meyer en 1986 : http://se.ethz.ch/~meyer/publications/acm/geninh.pdf

Texte expliquant ce qu'est la programmation générique, prise au sens large mais avec un accent sur les templates de C++, par Gabriel Dos Reis et Jaakko Järvi en 2005 : http://lcsd05.cs.tamu.edu/papers/dos_reis_et_al.pdf

Quelques textes de votre humble serviteur (avec inspirations diverses, indiquées à même le texte) à propos de la programmation générique en C++ :

• Introduction aux templates : ../Sujets/Divers--cplusplus/templates.html
• Programmation générique appliquée : ../Sujets/Divers--cplusplus/Programmation-generique-appliquee.html
• Les concepts : ../Sujets/Divers--cplusplus/Concept-de-concept.html
• Introduction à la métaprogrammation : ../Sujets/Divers--cplusplus/Metaprogrammation.html
• ... et beaucoup plus, que vous trouverez à partir de ../Sujets/Divers--cplusplus/index.html

Programmation générique avec Haskell : http://people.cs.uu.nl/johanj/publications/ComparingGP.pdf

Un livre en ligne sur les templates de D, par Philippe Sigaud en 2012 : https://docs.google.com/viewer?url=https://github.com/PhilippeSigaud/D-templates-tutorial/blob/master/dtemplates.pdf?raw%3Dtrue&pli=1

Comparatif (malheureusement, superficiel et un peu mince) des mécanismes de généricité en C#, Java et C++, par Kosta Hristov en 2013 : http://www.developingthefuture.net/difference-between-generics-in-c-java-and-c/

Programmation générique avec Swift, une explication de ce qui s'annonce, par Douglas Gregor en 2016 : http://article.gmane.org/gmane.comp.lang.swift.evolution/8484

Programmation génétique

À venir...

Série d'articles sur le sujet, proposée par Alan Zucconi en 2016 :

• http://www.alanzucconi.com/2016/04/06/evolutionary-coputation-1/
• http://www.alanzucconi.com/2016/04/13/evolutionary-computation-2/
• http://www.alanzucconi.com/2016/04/20/evolutionary-computation-3/
• http://www.alanzucconi.com/2016/04/27/evolutionary-computation-4/

Programmation impérative (procédurale)

À venir...

Comparer la programmation impérative et la programmation fonctionnelle :

• http://apocalisp.wordpress.com/2011/05/30/imperative-vs-functional-programming/
• En 2012, Bartosz Milewski explique qu'à son avis, la multiprogrammation a sonné le glas de la programmation impérative, et que la programmation fonctionnelle est maintenant le chemin à emprunter : http://fpcomplete.com/the-downfall-of-imperative-programming/
• Texte de Mark Dominus en 2009, qui se dit d'avis qu'Edsger W. Dijkstra n'était pas fou quand il s'insurgeait contre les opérations de bris de répétitive telles que break et continue : http://blog.plover.com/2009/07/
• Qu'est-ce que la « programmation structurée »? Texte de Robert C. Martin en 2015 : http://blog.8thlight.com/uncle-bob/2015/09/23/a-little-structure.html

Programmation intentionnelle

Par programmation intentionnelle, on entend un modèle de programmation cherchant à faire en sorte que le code source rejoigne précisément l'intention de la programmeuse ou du programmeur. L'idée d'origine vient, à ma connaissance, des travaux de Charles Simonyi et Gregor Kiczales.

Le Wiki décrivant l'idée derrière cette approche est http://en.wikipedia.org/wiki/Intentional_programming

Pour un texte de Martin Fowler sur le sujet, voir http://martinfowler.com/bliki/IntentionalSoftware.html

Programmation logique

À venir...

Programmation orientée aspect (POA)

À venir...

Comparer l'injection de dépendance et la POA :

• Pourquoi préférer la POA? Texte de Gael Fraiteur en 2010 : http://www.postsharp.net/blog/post/Aspect-Oriented-Programming-vs-Dependency-Injection.aspx
• Dans ce texte de 2013, Kenneth Truyers recommande de préférer l'injection de dépendance à la POA : http://www.kenneth-truyers.net/2013/05/16/why-choose-di-interception-over-aspect-oriented-programming/

Selon les langages

La POA avec C++ :

• Explication appuyée par des exemples, proposée par Victor Laskin en 2015. Remarquez les liens avec la programmation fonctionnelle : http://vitiy.info/c11-functional-decomposition-easy-way-to-do-aop/

Programmation orientée caractéristiques (Feature-Oriented Programming, FOP)

À venir...

• formalisme pour la composition uniforme de caractéristiques, par Sven Apel et DeLesley Hutchins en 2010 : http://www.infosun.fim.uni-passau.de/cl/publications/docs/TOPLAS10.pdf

Programmation orientée objet (POO)

Au sujet du Unified Modeling Language (UML) :

• Site décrivant la norme UML;
• Petit dictionnaire UML (notez que les définitions données conviennent à la norme UML, mais peuvent ne pas être acceptées de manière universelle dans le monde orienté objet).

Aussi :

• Programmation fonctionnelle dans un langage OO :
  • http://www.harukizaemon.com/2010/03/functional-programming-in-object-oriented-languages.html
  • selon l'auteur, les langages OO bénéficieraient nettement de ce qu'on nomme le Tail-Call Optimization : http://www.harukizaemon.com/2009/12/why-object-oriented-language-need-tail-calls.html
• Adapter un Framework OO pour utilisation par un langage fonctionnel réactif : http://www.cs.brown.edu/~sk/Publications/Papers/Published/ick-adapt-oo-fwk-frp/paper.pdf
• Intégrer les approches OO et fonctionnelle, un texte de Michael Feathers en 2012 : http://michaelfeathers.typepad.com/michael_feathers_blog/2012/03/tell-above-and-ask-below-hybridizing-oo-and-functional-design.html
• Design OO avec Go, par Nathan Youngman en 2013 : http://nathany.com/good/
• Une variante, la programmation par modèle d'instance : http://slkpg.byethost7.com/instance.html

Comparatifs :

• L'influence de la pensée fonctionnelle sur la saine pensée OO, par Simon Harris en 2010 : http://www.harukizaemon.com/blog/2010/03/01/functional-programming-in-object-oriented-languages/
• La migration d'une pensée OO à une pensée fonctionnelle, texte de Hadi Hariri en 2013 : http://hadihariri.com/2013/11/24/refactoring-to-functionalwhy-class/
• Selon John D. Cook en 2010, la POO et la programmation fonctionnelle aident toutes deux, chacune à sa façon, à la compréhension du code : http://www.johndcook.com/blog/2010/11/03/object-oriented-vs-functional-programming/
• Selon Erkki Lindpere en 2013, le débat entre les tenants de la pensée fonctionnelle et ceux de la pensée OO en est un qui porte surtout sur la composition : http://zeroturnaround.com/rebellabs/why-the-debate-on-object-oriented-vs-functional-programming-is-all-about-composition/
• Le glissement de l'approche OO vers l'approche fonctionnelle passe en particulier par l'immuabilité, selon ce texte de 2014 : http://valve.github.io/blog/2014/07/04/from-object-to-functional-immutability/
• Traverser le pont entre l'approche OO et l'approche fonctionnelle, par Dave Thomas en 2009 : http://www.jot.fm/issues/issue_2009_07/column4/
• En 2014, Robert C. Martin compare la programmation fonctionnelle à la programmation OO : http://blog.cleancoder.com/uncle-bob/2014/11/24/FPvsOO.html

Programmation orientée objets par langage

Programmation orientée objet avec C :

• http://arxiv.org/abs/1003.2547
• http://nithinbekal.com/2011/writing-object-oriented-code-in-ansi-c/
• http://www.cs.rit.edu/~ats/books/ooc.pdf (livre en ligne)
• Encapsulation et C, texte de Stephen Friedrichs en 2013 : http://www.embeddedrelated.com/showarticle/166.php
• Comment Brent Cook s'y prend, texte de 2013 : http://boundary.com/blog/2013/09/27/welcome-to-meter-2-design/
• Simuler des méthodes virtuelles en C, par Antonio Maiorano en 2014 : http://vgcoding.blogspot.ca/2014/03/virtual-functions-in-c.html
• Démarche proposée par Christopher Wellon en 2014 : http://nullprogram.com/blog/2014/10/21/
• Techniques proposées par Dmitry Frank en 2015 : http://dmitryfrank.com/articles/oop_in_c

Programmation orientée objet avec Go :

• Perspective OO sur Go, par John Bauer : https://github.com/luciotato/golang-notes/blob/master/OOP.md

Programmation par passage de messages

Détails à venir.

• Textes de 2013 par Steve Bate, présentant la programmation par passage de messages comme un modèle de programmation à part entière et l'opposant à la programmation orientée objet :
  • http://eventuallyconsistent.net/2013/08/12/messaging-as-a-programming-model-part-1/
  • http://eventuallyconsistent.net/2013/08/14/messaging-as-a-programming-model-part-2/

Programmation probabiliste

Détails à venir.

• Explication de ce que signifie ce terme, texte de 2013 par Beau Cronin : http://radar.oreilly.com/2013/04/probabilistic-programming.html
• Quelques projets dans ce créneau :
  • le projet BUGS : http://www.mrc-bsu.cam.ac.uk/bugs/
  • le langage Church
  • la bibliothèque Factorie : http://factorie.cs.umass.edu/
  • le Framework Infer.net : http://research.microsoft.com/en-us/um/cambridge/projects/infernet/

Programmation réactive

Détails à venir

• Une introduction proposée par Andre Staltz en 2014 : https://gist.github.com/staltz/868e7e9bc2a7b8c1f754
• En 2010, Paul Stovell explique ce qu'est la programmation réactive : http://paulstovell.com/blog/reactive-programming

Utiliser Kotlin sur Android dans une optique de programmation réactive, textes de Cédric Beust en 2015 :

• http://beust.com/weblog/2015/03/23/android-rx-and-kotlin-a-case-study/
• http://beust.com/weblog/2015/04/05/android-rx-and-kotlin-part-2/

Programmation relativiste

Détails à venir.

Explication sommaire du paradigme :http://wiki.cs.pdx.edu/rp/

Programmation par Scripting

Il existe plusieurs guerres de clochers d'un point de vue philosophique comme d'un point de vue technique entre des tenants dogmatiques de diverses approches de programmation :

• les aficionados des langages portables sur le plan des sources (par exemple C++) et ceux des langages portables au niveau des binaires (langages de scripts, Java, C#)
• les aficionados des langages surtout fonctionnels (Haskell, Lisp, JavaScript, etc.) et les amants des langages surtout OO (C++, Java, C#)
• les aficionados des langages surtout dynamiques (Ruby, Python, plusieurs langages fonctionnels) et ceux qui privilégient les langages statiques (C, C++, Java, C#)
• les aficionados de dialectes (langages à accolades, langages à parenthèses, langages semblables à ceux de Niklaus Wirth)
• les aficionados des langages OO à héritage simple seulement (Java, C#), ceux qui préfèrent l'option de l'héritage multiple (C++, Eiffel) et ceux qui expriment l'héritage comme un idiome de programmation (JavaScript, Lisp)
• les aficionados de langages à collecte automatique d'ordures et ceux qui privilégient les comportements plus déterministes
• les aficionados de langages riches et mots clés et en objets déjà faits (C#, Java, et en général les langages qui viennent avec un Framework) et ceux des langages qui privilégient moins de mots clés, plus d'expressivité et les bibliothèques (C et C++); etc.

Pourtant, le monde de l'informatique a besoin de plusieurs outils parce que ses défis sont nombreux et diversifiés. En effet :

• quand le problème exige vitesse et clarté ou quand il sort des sentiers battus, nous sommes heureux d'avoir accès à C++ et à la métaprogrammation;
• quand le problème demande une solution réalisée rapidement et s'exécutant à une vitesse raisonnable, ou quand il ressemble à des problèmes types, les langages à Framework comme Java et C# permettent de relever le défi à pied levé;
• quand un problème demande principalement de la souplesse et du dynamisme, les langages dynamiques et les langages de scripts sont fréquemment la solution la plus pertinente.

Même dans une situation où le souci de performance est omniprésent (simulation, réalité virtuelle, jeu vidéo, systèmes en temps réel), on voudra souvent combiner plus d'une approche pour arriver à nos fins. La trame narrative d'un jeu s'exprime bien avec un langage de scripts alors que le moteur se prête à de la programmation C++ très serrée. Un service Web construit en VB.NET se développe sans peine et peut cacher à la fois un composant C++ pour les calculs les plus exigeants et un relais vers une application Java interfaçant avec des technologies pour lesquelles VB.NET est moins utile (tout ce qui sort du monde Windows).

N'adhérons donc pas aux dogmes et aux chicanes de basse-cour et explorons brièvement les langages de scripts qui permettent de dynamiser (principalement) la partie cliente (souvent dans un fureteur) des applications Web.

Les langages de scripts sont nombreux. Parmi les plus populaires, on trouve PHP, Perl, Python, Ruby, JavaScript, Tcl/Tk et bien d'autres (Adobe Flash, dans une certaine mesure, avec ActionScript). Chacun a sa raison d'être et ses adhérent(e)s.

On associe souvent la programmation par Scripting à la programmation dynamique. Typiquement, les langages de scripts sont axés sur la souplesse et la facilité d'exprimer les idées plutôt que sur la performance à l'exécution : avec des scripts, le programmeur est plus rapide, même si les programmes sont typiquement plus lents. Les langages de scripts servent fréquemment à produire des extensions à des moteurs existants, par exemple pour les fureteurs ou dans le monde du jeu vidéo (pour le développement d'intelligences artificielles simples).

• http://en.wikipedia.org/wiki/Scripting_language
• http://www.cse.wustl.edu/~loui/praiseieee.html
• http://www.cio.com/article/446829/PHP_JavaScript_Ruby_Perl_Python_and_Tcl_Today_The_State_of_the_Scripting_Universe?contentId=446829&slug=&
• http://www.robvanderwoude.com/index.php
• Opinion de Brian W. Kernighan : http://www.eecs.harvard.edu/cs152/lectures/CS152-Lecture_14-Kernighan.pdf
• Les langages de script évoluent : http://blog.technologyofcontent.com/2011/05/scripting-languages-grow-up/
• Gérer les erreurs et les trappes dans des Shell Scripts : http://www.ibm.com/developerworks/aix/library/au-usingtraps/index.html
• Utiliser C++ comme langage de script dans un jeu, texte de Stefan Reinalter en 2014 : http://molecularmusings.wordpress.com/2014/05/10/using-runtime-compiled-c-code-as-a-scripting-language-under-the-hood/
• Utiliser la plateforme .NET comme outil de scripting, par Dave Glick en 2015 : http://www.daveaglick.com/posts/compiler-platform-scripting

Comparatifs :

• Comparatif (qui remonte à 2002, alors lire avec prudence) entre Perl, Python et Ruby : http://mjtsai.com/blog/2002/11/25/perl_vs_python_vs_ruby/
• Comparatif de multiples langages en lien avec des tâches normalement associées à des langages de scripts : http://rigaux.org/language-study/scripting-language/

Programmation transformative

Programmer en connectant les sorties de certains modules aux entrées de certains modules, créant par le fait-même des flots transformatifs de données.

• Réflexion de Simon St. Laurent, en 2013 : http://programming.oreilly.com/2013/10/transformative-programming.html

Typestate-Oriented Programming

Détails à venir

Texte de 2009 par Jonathan Aldrich, Joshua Sunshine, Darpan Saini et Zachary Sparks : http://www.cs.cmu.edu/~aldrich/papers/onward2009-state.pdf