Langages de programmation – quelques liens

Cette page n'a (vraiment!) pas la prétention d'être exhaustive, et liste un certain nombre de langages de programmation et de concepts leur étant associés, qu'il s'agisse de projets expérimentaux ou d'implémentations commerciales. Si vous êtes curieuses ou curieux...

Parmi les dossiers généraux, vous trouverez des liens sur :

• Les outils GNU
• L'enseignement de la programmation
• Le λ-calcul

Il existe évidemment d'autres ressources dans Internet, dont le Dictionary of Programming Languages disponible sur http://cgibin.erols.com/ziring/cgi-bin/cep/cep.pl, et l'OverAPI (une collection de Cheat Sheets pour divers langages) sur http://overapi.com/

ActionScript

Auteur : Gary Grossman

Langage de scripting de la plateforme Flash. Dialecte de ECMAScript.

• http://en.wikipedia.org/wiki/ActionScript
• Dessiner avec JavaScript ou avec ActionScript? http://www.williammalone.com/articles/flash-vs-html5-canvas-drawing/
• http://www.visionmobile.com/blog/2010/09/the-flash-vs-html5-endgame/

Ada

Auteur : Jean Ichbiah

Le langage Ada a été présenté comme le choix des militaires et comme une solution pour joindre performance et sécurité. Voir aussi le dialecte Spark.

• Un Wiki sur ce langage : http://en.wikipedia.org/wiki/Ada_%28programming_language%29
• Standard officiel : http://www.ada-auth.org/standards/
• Justification des choix faits :
  • dans le standard Ada 83 : http://archive.adaic.com/standards/83rat/html/ratl-TOC.html
  • dans le standard Ada 2012 : http://www.adacore.com/knowledge/technical-papers/ada-2012-rationale/
• Le standard 2005 du langage est ratifié : http://www.ada-europe.org/Ada_2005_Press_Release.pdf
• Interfaces abstraites en Ada : http://www.adacore.com/wp-content/files/attachments/ifaces_ae06.pdf
• Le retour d'Ada? http://gcn.com/articles/2008/04/11/the-return-of-ada.aspx
• écrire du logiciel sécuritaire : http://www.adacore.com/2008/04/08/gem-30/
• Rédaction de programmes à haute performance en Ada : http://www.ddj.com/hpc-high-performance-computing/207800151
• L'histoire et le développement de ce langage : http://www.computerworld.com.au/article/223388/-z_programming_languages_ada
• Programmation fonctionnelle en Ada : http://okasaki.blogspot.com/2008/07/functional-programming-inada.html
• En route vers Ada 2012 : http://www.ada-auth.org/standards/ada12.html
• Le compilateur Ada générant du code machine plus performant que du code écrit manuellement en langage d'assemblage? http://www.seas.gwu.edu/~adagroup/sigada-website/lawlis.html
• Ada est important, selon Robert Dewar en 2008 : http://www.mil-embedded.com/articles/id/?3277
• Programmation concurrente avec Ada, par Thomas Løcke en 2012 : http://blogs.fsfe.org/thomaslocke/2012/05/17/concurrent-ada-programming/
• Le standard ISO pour Ada 2012 est officiellement approuvé :
  • communiqué officiel : http://www.adacore.com/press/ada-2012-language-approved
  • site officiel : http://www.ada2012.org/
• L'évolution d'Ada, par Edmond Schonberg em 2013 : http://electronicdesign.com/dev-tools/whats-difference-ada-then-and-now
• Programmation par contrats avec Ada 2012, un texte de Rober Dewar en 2013 : http://www.drdobbs.com/architecture-and-design/ada-2012-ada-with-contracts/240150569
• Il semble que le code de logiciels sur avions de Boeing soit essentiellement écrit en Ada : http://archive.adaic.com/projects/atwork/boeing.html
• Site faisant la promotion d'Ada, et offrant divers ancrages pédagogiques : http://getadanow.com/
• Qui utilise Ada? Michael B. Feldman collige des cas d'utilisation en 2014 : http://www.seas.gwu.edu/~mfeldman/ada-project-summary.html
• Survol d'Ada 2012, par Benjamin M. Brosgol en 2012 : http://cotsjournalonline.com/articles/view/102810
• Gérer des objets persistantsà travers des références maison, texte de Maxim Reznik et Nicolas Setton en 2015 : http://blog.adacore.com/use-ref-types-to-persistent-object
• Ce qu'on peut apprendre d'Ada, selon Sean T. Allen en 2016 : http://www.monkeysnatchbanana.com/2016/02/22/learning-from-ada/
• Exemple de système temps réel embarqué avec Ada, par Jorge Real en 2017 : https://blog.adacore.com/writing-on-air
• Aimer Ada pour son système de types, un texte de 2017 par Riccardo Bernardini : https://dev.to/pinotattari/reasons-for-loving-ada-720
• En 2018, Courtney E. Howard rapporte qu'Ada demeure un langage prisé dans le monde de l'aérospatiale : https://www.intelligent-aerospace.com/articles/2018/05/system-complexity-safety-security-drive-continued-adoption-of-ada-spark-in-aerospace-and-defense.html
• En 2019, Steve Klabnik parle de son aventure dans l'apprentissage d'Ada : https://words.steveklabnik.com/learning-ada
• Utiliser Ada pour développer du logiciel audio, article de 2017 par Gustavo Hoffmann et Raphaël Amiard : https://www.electronicdesign.com/embedded-revolution/assessing-ada-language-audio-applications
• Un programme Ada constituant une preuve formelle d'une propriété mathématique, par Joffrey Huguet en 2019 : https://blog.adacore.com/using-spark-to-prove-255-bit-integer-arithmetic-from-curve25519
• Écrire un service REST avec Ada, par Justin Grant en 2019 : https://imagine27.com/rest-service-with-ada/

Agda

Auteur : Ulf Norel

Langage fonctionnel avec types dépendants, qui ressemble un peu à un outil de démonstration de preuves.

• http://en.wikipedia.org/wiki/Agda_%28programming_language%29
• http://wiki.portal.chalmers.se/agda/pmwiki.php
• http://www.cse.chalmers.se/~ulfn/papers/tphols09/tutorial.pdf
• http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf
• Discussion de fondements de langages de programmation exprimés à travers Agda : https://plfa.github.io/

Agenda

Auteur : Alexander Walz

Langage de script et procédural à vocation éducative.

• http://agena.sourceforge.net/index.html

قلب

Auteur : Ramsey Nasser

Un langage de programmation où les instructions s'expriment en calligraphie arabe.

• http://www.animalnewyork.com/2013/arabic-programming-language-at-eyebeam-%D9%82%D9%84%D8%A8-opens-the-world/#

Algol 58

Auteurs : plusieurs, dont John Backus, Peter Naur et John McCarthy

Langage procédural, ancêtre du très important Algol 60.

• http://en.wikipedia.org/wiki/ALGOL
• http://www.informit.com/articles/article.aspx?p=1671636

Algol 60

Auteur : plusieurs, dont John Backus, C.A.R. Hoare et Peter Naur.

Le langage Algol 60, avec son descendant direct Algol 68, est l'un des langages les plus importants de l'histoire. Sa notation inspire encore celle du pseudocode utilisé aujourd'hui.

• http://en.wikipedia.org/wiki/ALGOL
• Un compilateur pour Algol 60 : http://db.cwi.nl/rapporten/abstract.php?abstractnr=1354
• Texte de 2014 portant sur l'introduction (presque accidentelle) de la récursivité dans les langages de programmation, en particulier pour Algol 60 : http://vanemden.wordpress.com/2014/06/18/how-recursion-got-into-programming-a-comedy-of-errors-3/

Algol 68

Auteurs : Adriaan van Wijngaarden (entre autres)

Le langage Algol 68, successeur d'Algol 60, est l'un des langages ayant influencé une importante quantité de langages contemporains. Certains ne jurent encore que par lui aujourd'hui...

• http://en.wikipedia.org/wiki/ALGOL_68
• http://www.algol68.org/
• Tranche d'histoire, proposée par G D Whitaker en 2018 : https://mraths.org.uk/?page_id=2862
• Rétrospective par Daniel James en 2018, qui met en valeur l'impact de ce langage sur ceux qui ont suivi : https://accu.org/index.php/journals/2586

Alice

Auteurs : Wanda Dann et Dennis Cosgrove

Langage proposant un environnement interactif 3D et susceptible de servir à la fois à des fins éducatives et à la génération d'animations.

• http://www.alice.org/

AmbientTalk

Auteur : Tom Van Cutsem, Stijn Mostinckx, Jessie Dedecker et Wolfgang De Meuter

Langage OO axé vers la concurrence, la téléphonie mobile et les réseaux de capteurs. Met de l'avant un paradigme de programmation ambiante.

• http://en.wikipedia.org/wiki/AmbientTalk
• http://code.google.com/p/ambienttalk/
• http://soft.vub.ac.be/amop/at/introduction
• http://soft.vub.ac.be/amop/
• http://soft.vub.ac.be/amop/research/dgc

AMPL

Auteurs : Robert Fourer, David M. Gay et Brian W. Kernighan

Langage de modélisation mathématique.

• http://www.ampl.com/

ANI

Auteur : Mark Henderson?

Langage axé sur la multiprogrammation, au sens où les programmeurs ne séquencent pas explicitement leur code (le compilateur le fait). Les objets y communiquent à travers des tuyaux (Pipes), ce qui provoque un séquencement, mais outre cela, deux énoncés distincts y sont présumés exécutables en parallèle.

• http://code.google.com/p/anic/wiki/Tutorial
• http://code.google.com/p/anic/

Ante

Auteur : J. Fecher?

Langage fonctionnel qui se dit « de bas niveau ».

• https://antelang.org/

APL

Auteur : Kenneth E. Iverson.

Langage de programmation axé sur le traitement de tableaux et reposant sur une notation mathématique (on y programmait avec un clavier spécial). Ce langage est important sur le plan de l'intérêt historique. Son nom signifie littéralement A Programming Language.

• Le volume séminal, par l'auteur lui-même : http://www.jsoftware.com/papers/APL.htm
• http://en.wikipedia.org/wiki/APL_%28programming_language%29
• http://groups.engin.umd.umich.edu/CIS/course.des/cis400/apl/apl.html
• Compilateurs gratuits : http://www.thefreecountry.com/compilers/apl.shtml
• Guide de programmation (de 1978) : http://www.bitsavers.org/pdf/ibm/apl/G320-6103-0_APL_Programming_Guide_May78.pdf
• http://arcanesentiment.blogspot.com/2010/12/whats-so-cool-about-apl.html
• Une histoire d'APL, par Len Shustek en 2012 : http://www.computerhistory.org/atchm/the-apl-programming-language-source-code/
• Les qualités d'APL, mises en relief par Scott Locklin en 2013 : http://scottlocklin.wordpress.com/2013/07/28/ruins-of-forgotten-empires-apl-languages/
• Implémentation GNU d'APL : http://www.gnu.org/software/apl/
• Le compilateur APEX : http://www.snakeisland.com/apexup.htm
• Compilateur APL vers C# : http://sharparrays.com/toolkit.htm
• Le langage APL et son rôle dans l'introduction de divers symboles, un texte de John D. Cook en 2014 : http://www.johndcook.com/symbols/2014/02/apl/
• APL, c'est un peu le bonheur, selon Bernard Legrand (traduit par Sylvia Camacho) en 2006 : http://archive.vector.org.uk/art10011550
• Apprendre APL en dix minutes (!), par Yan Cui en 2015 : http://theburningmonk.com/2015/06/fear-and-loathing-with-apl/
• Le jeu de la vie en APL? Simple : https://twitter.com/seesharp/status/69537417250816409
• Ensemble d'idiomes avec APL, colligés en 1987 par Alan J. Perlis et Spencer Rugaber : http://cpsc.yale.edu/sites/default/files/files/tr87.pdf
• Ne pas avoir peur d'APL, texte de 2015 par Yan Cui : https://theburningmonk.com/2015/06/fear-and-loathing-with-apl/
• Schémas de conception avec APL, présentation d'Aaron Hsu en 2017 : https://sway.com/b1pRwmzuGjqB30On
• Débuter avec APL, un texte de 2017 par Aaron W. Shu : https://www.sacrideo.us/getting-started-with-apl/
• En 2018, Oleksandr Kaleniuk fait un plaidoyer pour une renaissance d'APL : http://wordsandbuttons.online/apl_deserves_its_renaissance_too.html
• Texte de 2020 par Aaron W. Hsu, qui se demande si APL et mort... et pense que non, mais qu'on est passé près du trépas : https://www.sacrideo.us/is-apl-dead/
• En 1982, Michael S. Montalbano donne sa vision personnelle de l'histoire du langage APL (accompagné de compléments d'information par Curtis A. Jones en 2013) : https://ed-thelen.org/comp-hist/APL-hist.html

Arc

Auteurs : Paul Graham et Robert Morris

Langage fonctionnel, dialecte de Lisp. On lui associe le Arc Challenge (voir l'encadré) que cherchent à relever des programmeurs sur différentes plateformes et avec divers outils.

• http://arclanguage.org/
• http://paulgraham.com/arc0.html
• http://paulgraham.com/core.html
• http://www.paulgraham.com/noop.html
• texte d'opinion par David Kendal en 2011 décrivant pourquoi, selon lui, ce langage n'a pas eu de réel succès : http://davidkendal.net/articles/2011/11/a-man-a-plan

Arduino

Auteur : Tom Igoe

Un langage destiné principalement aux microcontrôleurs.

• http://arduino.cc/
• http://www.computerworld.com.au/article/321749/-z_programming_languages_arduino_tom_igoe/?pp=1
• http://en.wikipedia.org/wiki/Arduino
• http://www.quicklycode.com/cheatsheets/arduino-cheat-sheet
• http://answers.oreilly.com/topic/1624-parallel-programming-arduino-and-the-good-kind-of-trouble/
• http://www.wired.com/gadgetlab/2010/07/hardware-hobbyists-arduino/
• http://www.bit-tech.net/modding/2010/09/02/arduino-projects-getting-started/1
• http://ryanwaggoner.com/2010/10/damn-you-arduino-i-have-no-free-time-for-this/
• http://blog.makezine.com/archive/2011/02/why-the-arduino-won-and-why-its-here-to-stay.html
• http://makezine.com/arduino/
• http://blog.makezine.com/archive/2011/05/why-google-choosing-arduino-matters-and-the-end-of-made-for-ipod-tm.html
• Apprendre à programmer Arduino, par Amit Saha en 2012 : http://www.linuxjournal.com/content/learning-program-arduino
• En 2012, John Graham-Cumming se dit d'avis que, bien qu'il soit possible de faire du Arduino à travers le Web, ce n'est pas une saine approche : http://blog.jgc.org/2012/10/web-scale-arduino.html
• Guide pour débutants avec Arduino, par Andrew Chalkley en 2013 : http://forefront.io/a/beginners-guide-to-arduino
• Transformer une preuve de concept Arduino en un véritable prototype, par Alexis Matelin en 2015 : http://digitaljunky.io/how-to-turn-an-arduino-based-proof-of-concept-into-a-final-prototype/
• Contrôler une serre géodésique par Arduino, article de 2017 : https://blog.arduino.cc/2017/11/01/an-arduino-controlled-geodesic-greenhouse-and-chicken-coop/
• La bibliothèque arduinojson, pour communiquer à travers JSON pour Arduino : https://arduinojson.org/
• Une application sérieuse, détecter que le café est prêt! Texte de 2018 : https://blog.arduino.cc/2018/02/23/let-an-arduino-notify-you-when-the-coffee-is-ready/

Histoire et culture du Arduino :

• À propos de la création d'Arduino : http://spectrum.ieee.org/geek-life/hands-on/the-making-of-arduino
• L'histoire du Arduino selon Hernando Barragán en 2016 : http://arduinohistory.github.io/

ArnoldC

Auteur : Lauri Hartikka

Si vous avez toujours voulu un programme dont le ton est viril...

• http://lhartikk.github.io/ArnoldC/

ASP

Auteur : plusieurs personnes.

Langage utilisé dans Internet pour la génération de pages, principalement côté serveur. On lui préfère maintenant ASP .NET.

• http://en.wikipedia.org/wiki/Active_Server_Pages
• http://www.w3schools.com/asp/default.asp
• http://www.computerworld.com.au/article/224282/a-z_programming_languages_asp/

ASP .NET

Auteur : Scott Guthrie

Langage utilisé dans Internet pour la génération de pages, principalement côté serveur. A remplacé ASP.

• http://en.wikipedia.org/wiki/ASP.NET
• http://www.asp.net/
• http://www.computerworld.com.au/article/224282/a-z_programming_languages_asp/
• http://www.codingthewheel.com/archives/asp-net-web-development-horror
• Un moteur de visualisation pour ASP .NET, nommé Razor : http://weblogs.asp.net/scottgu/archive/2010/07/02/introducing-razor.aspx
• Il faut simplifier le modèle de déploiement du langage : http://wekeroad.com/post/4373719917/asp-net-deployment-needs-to-be-fixed
• L'API pour le Web de ce langage, décrite par Kosta Hristov en 2013 : http://www.developingthefuture.net/getting-into-the-asp-net-web-api/
• Comprendre les modes de compilation d'ASP .NET, un texte d'Aman Doda en 2014 : http://www.techguidence.com/compilation-modes-in-asp-net/
• Le projet Helios, pour combiner les forces d'une prise en charge par un serveur Web tel qu'IIS avec l'agilité de solutions plus légères. Description offerte par Levi Broderick en 2014 : http://blogs.msdn.com/b/webdev/archive/2014/02/18/introducing-asp-net-project-helios.aspx
• ASP .NET vNext, présenté par Scott Hanselman en 2014 : http://www.hanselman.com/blog/IntroducingASPNETVNext.aspx
• ASP .NET 5, présenté par Scott Guthrie en 2015 : http://weblogs.asp.net/scottgu/introducing-asp-net-5
• Comme le rapporte Rick Strahl en 2016, ASP.NET v. 5 sera renommé ASP.NET 1.0 Core : http://weblog.west-wind.com/posts/2016/Jan/21/Microsoft-renames-ASPNET-5-to-ASPNET-Core-10
• Dans ce texte de 2015, Matthew Wilson trace un glossaire d'ASP.NET 1.0 Core : http://www.exceptionnotfound.net/the-asp-net-5-glossary/

Technique :

• Gestion des états avec ASP.NET :
  • en général : http://msdn.microsoft.com/en-us/library/75x4ha6s%28v=vs.100%29.aspx
  • variables de session : http://msdn.microsoft.com/en-us/library/ms178581.aspx
• Évaluer la vitesse d'exécution d'une application ASP.NET Core, par Gergely Kalapos en 2016 : https://www.dynatrace.com/blog/monitoring-asp-net-core-applications/
• Exécuter ASP.NET sur un serveur à bas prix, expérimentation par Scott Hanselman en 2018 : https://www.hanselman.com/blog/RunningASPNETCoreOnGoDaddysCheapestSharedLinuxHostingDontTryThisAtHome.aspx

Assembleur

Plus un concept qu'un langage, donc voir ici.

ATS

Auteurs : plusieurs personnes

Un langage multi-paradigme, avec une syntaxe semblable à celle des langages fonctionnels, qui met l'accent sur son système de types.

• http://www.ats-lang.org/
• http://www.bluishcoder.co.nz/2010/05/18/ats-applied-type-system-programming-language.html
• Convertir de C à ATS : http://www.bluishcoder.co.nz/2011/04/24/converting-c-programs-to-ats.html
• http://www.bluishcoder.co.nz/2011/04/25/sharing-linear-resources-in-ats.html
• Implémenter une pile à partir de preuves avec ATS, par Chris Double en 2012 : http://www.bluishcoder.co.nz/2012/10/04/implementing-a-stack-with-proofs-in-ats.html
• Utiliser des pointeurs avec ATS, texte de Chris Double en 2013 : http://www.bluishcoder.co.nz/2013/01/25/an-introduction-to-pointers-in-ats.html
• Démonstration de théorèmes dans un contexte asynchrone avec ATS, par xx Matthew Danish et Hongwei Xi en 2014 : http://cs-people.bu.edu/md/nfm2014-danish.pdf

Avail

Auteurs : l'équipe décrite sur http://www.availlang.org/about-us/team/index.html

Langage multiparadigme voué à la « programmation articulée ».

• http://www.availlang.org/
• https://www.enigmastation.com/posts/avail-a-language-for-articulate-programming-released/

AWK

Auteurs : Alfred V. Aho, Peter Weinberg, Brian W. Kernighan (le nom du langage provient des noms de ses auteurs)

Un langage orienté vers la transformation de chaînes de caractères.

• http://www.computerworld.com.au/article/216844/a-z_programming_languages_awk/
• http://en.wikipedia.org/wiki/AWK
• http://gregable.com/2010/09/why-you-should-know-just-little-awk.html
• Apprendre AWK, par Aaron Hillegass en 2013 : http://blog.bignerdranch.com/3799-a-crash-course-in-awk/
• Apprendre AWK en 20 minutes, proposition de Fred T.-H. en 2015 : http://ferd.ca/awk-in-20-minutes.html
• Explication illustrée par Julia Evans en 2018 : https://twitter.com/b0rk/status/1000604334026055681
• Guide pratique sur AWK, proposé par Liran B. H. en 2018 : https://devarea.com/understanding-awk-practical-guide/
• Utiliser AWK à titre de langage de programmation système, par Arnold Robbins en 2018 : http://www.skeeve.com/awk-sys-prog.html
• En 2020, Ben Hoyt trace un historique de AWK et décrit l'état de la situation pour ce langage : https://lwn.net/SubscriberLink/820829/5bf9bf8bb9d6f2bf/
• Texte de 2020 dans lequel Jemma Issroff explique comment elle a abordé le défi d'apprendre AWK en deux heures : https://jemma.dev/blog/awk-part-1
• Les huit niveaux d'utilisation (d'expertise?) avec AWK sur Linux, par Yang Zhou en 2022 : https://medium.com/techtofreedom/8-levels-of-using-awk-in-linux-f6a875c504d1
• Texte de 2023 par John D. Cook qui décrit AWK et explique comment il se sert de cet outil précieux : https://www.johndcook.com/blog/2023/08/26/awk/

Axum

Auteur : plusieurs personnes.

Langage compilé pour une machine virtuelle et mettant l'accent sur la multiprogrammation.

• http://msdn.microsoft.com/en-us/devlabs/dd795202.aspx
• http://blogs.msdn.com/maestroteam/archive/2009/04/17/forging-ahead.aspx
• http://www.infoq.com/news/2009/04/Axum

B

Auteur : Ken Thompson (on lui associe aussi Dennis M. Ritchie)

Le langage B est un ancêtre du très important langage C, donc de plusieurs autres langages listés sur cette page.

• Un Wiki sur ce langage : http://en.wikipedia.org/wiki/B_%28programming_language%29
• Une introduction au langage B, par Brian W. Kernighan : http://cm.bell-labs.com/cm/cs/who/dmr/btut.html ou https://web.archive.org/web/20150611114644/https://www.bell-labs.com/usr/dmr/www/btut.pdf
• https://web.archive.org/web/19980220175931/http://cm.bell-labs.com/cm/cs/who/dmr/bintro.html
• Référence en ligne : https://www.thinkage.ca/english/gcos/expl/b/manu/manu.html

Bard

Auteur : Mikel Evins

Langage qui semble s'apparenter à Clojure entre autres choses (on n'en sait que peu à son sujet pour le moment).

• http://bywicket.com/users/mikel/weblog/126a4/

Bash

Auteur : Brian Fox (mais Chet Ramey en assure l'entretien)

Langage de script et interpréteur de commandes (Shell) bien connu dans le monde Unix et Linux.

• http://www.computerworld.com.au/article/222764/a-z_programming_languages_bash_bourne-again_shell/
• http://en.wikipedia.org/wiki/Bash_%28Unix_shell%29
• En 2014, Maarten Billemont propose un guide pour bash : http://guide.bash.academy/
• http://symkat.com/90/understanding-bash-history/
• http://mywiki.wooledge.org/BashPitfalls
• http://rawsyntax.com/post/8778534130/learn-bash-remove-commands-from-your-history
• Les bases :
  • http://www.funtoo.org/wiki/Bash_by_Example,_Part_1
  • http://www.funtoo.org/wiki/Bash_by_Example,_Part_2
  • http://www.funtoo.org/wiki/Bash_by_Example,_Part_3
• Ce que tous les programmeurs bash devraient savoir, de l'avis de Robin Houston en 2012 : http://bosker.wordpress.com/2012/02/12/bash-scripters-beware-of-the-cdpath/
• Calculs numériques avec bash, selon Mark Dominus en 2012 : http://blog.plover.com/prog/spark.html
• Un Cheat Sheet pour la commande history : http://www.catonmat.net/download/bash-history-cheat-sheet.pdf
• En 2012, quelques commandes que Russell Power aurait aimé connaître plus tôt dans sa carrière : http://rjpower.org/wordpress/bash-isms-i-wish-i-knew-earlier/
• Faire en sorte que bash affiche le résultat de la plus récente commande exécutée, texte de 2013 : http://david.newgas.net/return_code/
• Quelques pièges de bash : http://bash.cumulonim.biz/BashPitfalls.html
• Améliorer son expérience avec bash, par Robert Muth en 2012 : http://robertmuth.blogspot.ca/2012/08/better-bash-scripting-in-15-minutes.html
• Programmation défensive avec bash, par Kfir Lavi en 2012 : http://www.kfirlavi.com/blog/2012/11/14/defensive-bash-programming/
• Un script qui se modifie lui-même avec bash, par Robert Copelard en 2012 : http://bobcopeland.com/blog/2012/10/goto-in-bash/
• Coup d'éclat en 2016, à partir de quand Microsoft Windows 10 intégrera bash de manière native :
  • reportage de Frederic Lardinois en 2016 : http://techcrunch.com/2016/03/30/be-very-afraid-hell-has-frozen-over-bash-is-coming-to-windows-10/
  • explications de Scott Hanselman en 2016 : http://www.hanselman.com/blog/DevelopersCanRunBashShellAndUsermodeUbuntuLinuxBinariesOnWindows10.aspx
  • texte de Peter Bright en 2016 : http://arstechnica.co.uk/information-technology/2016/03/windows-10-update-ubuntu-linux-command-line-bash/
  • même sous Windows, rm -rf est dangereux! https://www.slightfuture.com/technote/rmrf-in-wsl
• Écrire un service Web avec bash, par Henry Snopek en 2017 : https://hackernoon.com/a-web-service-written-in-pure-bash-2af847902df1
• La commande history de bash, expliquée par Kaitlyn Parkhurst en 2011 : http://www.symkat.com/understanding-bash-history
• En 2017, Julia Evans donne quelques trucs pour ne pas se mettre dans le pétrin avec bash : http://jvns.ca/blog/2017/03/26/bash-quirks/

Basic

Auteurs : John George Kemeny et Thomas Eugene Kurtz

Langage impératif qui se voulait suffisamment simple pour être appris et utilisé par des débutants. Plusieurs dialectes en ont été dérivés au fil des années, dont Small Basic : http://msdn.microsoft.com/en-us/beginner/ff384126.aspx

• http://en.wikipedia.org/wiki/BASIC
• À propos des 50 ans de BASIC :
  • texte de Harry McCracken en 2014 : http://time.com/69316/basic/
  • article de Gareth Halfacree en 2014 : http://www.bit-tech.net/news/bits/2014/05/01/basic-50/1
  • texte de 2014 : http://www.engadget.com/2014/05/01/basic-programming-language-50th-birthday/
• http://reprog.wordpress.com/2010/03/09/where-dijkstra-went-wrong-the-value-of-basic-as-a-first-programming-language/
• http://www.basic256.org/whybasic
• Manuel de BASIC, publié en 1964 : http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf
• De l'art en une seule ligne de BASIC : http://www.slate.com/articles/technology/books/2012/11/computer_programming_10_print_chr_205_5_rnd_1_goto_10_from_mit_press_reviewed.html
• Programmer en BASIC sur Atari 2600, par Hugues Johnson en 2015 : http://huguesjohnson.com/programming/atari-2600-basic/
• Apprendre BASIC, comme à l'époque, un texte de 2018 par Sinclair Target : https://twobithistory.org/2018/09/02/learning-basic.html
• En 2020, Microsoft annonce que GW-Basic est désormais à code ouvert. Texte de Rich Turner : https://devblogs.microsoft.com/commandline/microsoft-open-sources-gw-basic/
• Selon Guillaume Chereau en 2023, BASIC n'était pas qu'un simple langage de programmation : https://gcher.com/posts/2023-12-24-basic/

BCPL

Auteur : Martin Richards

Langage impératif ayant entre autrs l'insigne honneur d'être l'ancêtre direct du langage B, et donc d'être l'ancêtre indirect du langage C.

• http://en.wikipedia.org/wiki/BCPL

Beef

Auteur : BeefDev?

Langage compilé en code natif, inspiré de C#, qui vise à intégrer vitesse et saine gestion de la mémoire.

• https://www.beeflang.org/
• https://www.beeflang.org/docs/
  • En particulier : https://www.beeflang.org/docs/foreward/
• Tour d'horizon proposé par Sarah en 2020 : https://jaxenter.com/beef-programming-166540.html

Befunge

Auteur : Chris Sperrey

Langage étrange, construit de manière à être aussi difficile à compiler que possible. Version impérative de Flobnar

• https://esolangs.org/wiki/befunge

BitC

Auteurs : Jonathan Shapiro, Swaroop Sridhar et M. Scott Doerrie

Langage fonctionnel supportant la mutabilité des états, capable de programmation système, syntaxiquement semblable à Scheme et pour lequel certaines caractéristiques peuvent être formellement vérifiées.

• http://www.bitc-lang.org/
• http://www.bitc-lang.org/docs/bitc/bitc-origins.html
• Texte de 2006 par Jonatha Shapiro décrivant les raisons pour lesquelles, selon lui, des gens utilisent encore C... et ce qu'il faut faire pour « régler ce problème » : http://bitc-lang.org/docs/papers/PLOS2006-shap.html
• Il semble que Jonathan Shapiro ait abandonné ce projet. Il donne ses raisons, incluant celles d'ordre technique, dans ce texte plutôt touffu et fort intéressant de 2012 : http://www.coyotos.org/pipermail/bitc-dev/2012-March/003300.html

Blockly

Auteur : Neil Fraser

Langage avec lequel on programme en assemblant des structures de contrôle sous la forme de pièces de casse-tête.

• http://code.google.com/p/google-blockly/
• Présentation du langage, par Cade Metz en 2012 : http://www.wired.com/wiredenterprise/2012/06/google-blockly/

Bloom

Auteur : Joseph M. Hellerstein (je pense)

Langage qui met de l'avant la conjecture CALM, ou Consistency as Logicial Monotonicity.

• http://www.bloom-lang.net/
• http://www.bloom-lang.net/faq/
• http://www.bloom-lang.net/calm/

bodyfuck

Auteur : Nik Hanselmann

Langage de programmation gestuel implémentant brainfuck par une sorte de danse. Sérieusement.

• http://www.nikhanselmann.com/?/projects/bodyfuck/

Bondi

Auteur : Barry Jay

Langage mettant l'accent sur le Pattern Matching.

• http://bondi.it.uts.edu.au/

Boo

Auteur : Rodrigo B. De Oliveira

Langage OO compilé pour une machine virtuelle et mettant l'accent sur la possibilité de procéder par Duck Typing.

• http://boo.codehaus.org/
• http://boo.codehaus.org/Duck+Typing
• http://en.wikipedia.org/wiki/Boo_%28programming_language%29

Boomerang

Auteur : Benjamin C. Pierce

Un langage bidirectionnel de traitement de données textuelles ad hoc, à partir de lentilles... (voir aussi Harmony)

• http://www.seas.upenn.edu/~harmony/

Boose

Auteur : pas clair... Bjarne Stroustrup? Herb Sutter?

Un dérivé de C++... disons (portez attention à la date de publication de l'article).

• http://www.gotw.ca/publications/mill03.htm

Bosque

Auteur : Mark Marron

Langage fonctionnel, inspiré de TypeScript et de ML, qui cherche à éviter la complexité qui, selon ses auteurs, découle de reliquats de programmation impérative (p. ex. : les répétitives, les états mutables).

• https://github.com/Microsoft/BosqueLanguage/blob/master/docs/language/overview.md
• https://github.com/microsoft/BosqueLanguage/blob/master/README.md
• Article de 2019 sur ce langage, par Thomas Claburn : https://www.theregister.co.uk/2019/04/18/microsoft_bosque_programming_language/

Braid

Auteur : Josh Sharp

Langage qui ressemble syntaxiquement à Reason, mais transpile à du code Go

• https://github.com/joshsharp/braid

Brain

Auteur : Luiz Fernando Peres

Un langage ésotérique basé sur brainfuck

• https://github.com/brain-labs/brain
• https://brain-labs.github.io/brain/docs/html/index.html
• https://brain-labs.github.io/brain-visualizer/

brainfuck

Auteur : Urban Müller.

Un langage de programmation étrange, très minimaliste, qui ne comprend que huit instructions (des symboles de ponctuation).

• http://en.wikipedia.org/wiki/Brainfuck
• brainfuck serait inspiré d'un langage nommé P''. Pour des détails, voir ce texte de 2016 par Andrew Buntine : https://dev.to/buntine/p---the-original-brainfck-and-mother-of-the-turing-tarpits
• Un compilateur brainfuck rédigé... en brainfuck : http://code.google.com/p/awib/
• Le jeu de la vie, écrit en brainfuck : http://www.linusakesson.net/programming/brainfuck/
• awib, un compilateur brainfuck écrit en brainfuck... http://awibiswritteninbrainfuck.blogspot.com/2010/04/announcing-awib-02.html
• Un interpréteur brainfuck en deux lignes de code C : http://j.mearie.org/post/1181041789/brainfuck-interpreter-in-2-lines-of-c
• Un compilateur juste à temps pour brainfuck en C, expliqué en détail, par Erik Dubbelboer en 2012 : http://blog.dubbelboer.com/2012/11/18/brainfuck-jit.html
• Un interpréteur brainfuck construit à l'aide du préprocesseur du langage C, par Ferdinand Bachmann : https://github.com/Ferdi265/preprocessor_brainfuck
• Machine de Turing en brainfuck : http://work.damow.net/random/bf-turing/
• Interpréteur brainfuck écrit en brainfuck, par Mavek : https://github.com/maviek/bfbf
• S'amuser avec brainfuck en attendant l'avion : un interpréteur brainfuck en Python, texte de Iddo Friedberg en 2011 : http://bytesizebio.net/index.php/2011/11/06/brainfk-while-waiting-for-a-flight/
• De la stéganographie avec brainfuck, par Imran Nazar en 2011 : http://imrannazar.com/Steganography-with-Brainfuck
• Sémantique de module avec brainfuck, par Matías Giovanni en 2011 : http://alaska-kamtchatka.blogspot.com/2011/11/modular-semantics-for-brainfuck.html
• compilateur brainfuck pour LLVM, par Jeremy Roman en 2012 : http://www.jeremyroman.com/2012/12/11/building-a-brainfuck-compiler-with-llvm
• Un processeur microprogrammé en brainfuck, par Gergő érdi en 2013 : http://gergo.erdi.hu/blog/2013-01-19-a_brainfuck_cpu_in_fpga/
• En 2013, Kory Becker décrit un programme qui apprend à programmer, qui dont les programmes générés sont en brainfuck : http://www.primaryobjects.com/CMS/Article149.aspx
• Développer un environnement de développement pour brainfuck, texte de Stephen Malone en 2013 : http://malone.cc/posts/lhbs_1.html
• 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
• Un ordinateur implémentant brainfuck (à bas prix!), par Johan von Konow en 2013 : http://vonkonow.com/wordpress/2013/09/my-first-brainfuck-computer/
• Compiler du code brainfuck en code Java... avec un programme brainfuck (avec awib – voir plus haut), texte de Mats Linander en 2014 : http://www.hakkalabs.co/articles/compiling-brainfuck-to-java-in-brainfuck
• Les structures de contrôle en brainfuck, expliquées par Mats Linander en 2016 : http://calmerthanyouare.org/2016/01/14/control-flow-in-brainfuck.html
• Proposition d'extension de brainfuck à un nombre plus élevé de dimensions, par Dagan Martinez : https://github.com/Property404/hdbf
• Un ordinateur conçu spécifiquement pour brainfuck, par Sang-Woo Jun en 2016 : http://people.csail.mit.edu/wjun/papers/sigtbd16.pdf
• Introduction à brainfuck, proposée par Raphael Boukara en 2016 : http://blog.klipse.tech/brainfuck/2016/12/17/brainfuck.html
• Le dialecte SBrain, par Leo Tindall, augmente le vocabulaire pour le moins restreint de brainfuck, le faisant passert de huit à 32 symboles, pour faciliter l'écriture d'algorithmes génétiques : https://silverwingedseraph.net/programming/2017/04/16/sbrain-an-extension-of-brainfzck.html
• Texte de 2020 où Kirill (je ne connais pas son nom de famille) explique qu'il a en quelque sorte appris le langage d'assemblage en écrivant des compilateurs brainfuck : https://github.com/pretzelhammer/rust-blog/blob/master/posts/too-many-brainfuck-compilers.md

BrainLess

Auteur : Shakti Misra

Langage résultant d'une explication par son auteur du processus de développement d'un langage de programmation simple.

• http://www.codeproject.com/KB/recipes/BuildingBrainLess.aspx
• http://www.codeproject.com/KB/recipes/BuildingBrainLess2.aspx

BS

Auteur : Mark Rendle

Langage étrange qui a été conçu explicitement pour rendre difficile la tâche de programmer.

• http://esolangs.org/wiki/BS
• http://en.wikipedia.org/wiki/Bs_%28programming_language%29

C

Auteur : Dennis M. Ritchie (on lui associe aussi Brian W. Kernighan)

Le langage C est l'un des plus importants langages de programmation, sur le plan historique comme au quotidien. Certains prétendent que, pour prétendre savoir programmer, il faut savoir programmer en C. Simple, sans filet, fortement répandu (entre autres dû à ses liens avec Unix), c'est sans doute le Lingua Franca des langages de programmation.

J'ai localisé la plupart des liens sur ce langage dans une section à part entière :

• Considérations d'ordre général
• Standardisation
• Idées et opinions
• Technique
• Critiques
• Bibliothèques et outils
• Perles et perversions
• Ce qui touche à la fois C et C++

Caja

Auteur : Mark S. Miller

Langage permettant de sécuriser le code JavaScript.

• http://en.wikipedia.org/wiki/Caja_project

Caml

Auteur : gens de l'INRIA?

Langage multiparadigmatique. On connaît surtout OCaml.

• http://caml.inria.fr/

Carbon

Auteur : Chandler Carruth, Richard Smith et Kate Gregory (entre autres)

Langage qui se présente comme un successeur expérimental possible à C++, sur le plan technique comme sur le plan de la gouvernance.

• https://github.com/carbon-language/carbon-lang

Carnap

Auteur : à vérifier

Le lien ne répondait pas aux dernières nouvelles : http://www.carnap.info/

Carp

Auteur : Erik Svedäng

Variante syntaxique de Lisp avec gestion manuelle de la mémoire et des copies d'objets

• https://github.com/carp-lang
• https://github.com/carp-lang/carp
• http://blog.veitheller.de/Carp.html

Céu

Auteur : Francisco Sant'Anna

Langage qui vise à permettre la programmation réactive, synchrone et structurée.

• http://www.ceu-lang.org/
• http://www.ceu-lang.org/wiki/index.php?title=Main_Page

Ceylon

Auteur : Gavin King

Un langage compilé pour la JVM et qui met l'accent sur le développement par équipe.

• http://en.wikipedia.org/wiki/Ceylon_%28programming_language%29
• http://ceylon-lang.org/blog/
• http://www.javaworld.com/article/2078764/java-platform/a-first-look-at-gavin-king-s-ceylon.html
• Un survol du langage, dans cet article d'Andrew C. Oliver en 2013 : http://www.infoworld.com/d/application-development/first-look-gavin-kings-ceylon-217197
• En 2013, le langage passe à la version 1.0 : http://ceylon-lang.org/blog/2013/11/12/ceylon-1/
• Brève introduction : http://ceylon-lang.org/documentation/1.0/introduction/
• Introduction à la programmation avec Ceylon, par Renato Athaydes en 2014 :
  • http://renatoathaydes.github.io/Learn-Programming-In-Ceylon-Part-1/
  • http://renatoathaydes.github.io/Learn-Programming-In-Ceylon-Part-2/
• Texte de 2015 par Gavin King décrivant la programmation générique avec des Type Functions : http://ceylon-lang.org/blog/2015/06/03/generic-function-refs/
  • suivi sur le même sujet, aussi en 2015 : http://ceylon-lang.org/blog/2015/06/12/more-type-functions/
• Ceylon et les constructeurs, par Gavin King en 2015 : http://ceylon-lang.org/blog/2015/06/21/constructors/
• Pourquoi construire son propre système de types? Texte de Gavin King en 2015 : http://ceylon-lang.org/blog/2015/07/04/model/
• Utiliser le système de types de Ceylon pour accroître la résilience des programmes, par Renato Athaydes en 2015 : http://renatoathaydes.github.io/Using-Ceylon-Type-System-To-Write-Reliable-Extensible-Software/
• Texte de 2016 par Bastien Jansen sur l'utilisation de Ceylon dans un fureteur (en compilant vers JavaScript) : http://ceylon-lang.org/blog/2016/02/15/ceylon-browser-again/
• Ceylon serait-il un des rares langages à gérer intelligemment le concept de pointeur nul? Texte de 2016 : http://blog.jooq.org/2016/03/15/ceylon-might-just-be-the-only-language-that-got-nulls-right/
• Développement mobile avec Ceylon, par Stéphane Épardaud en 2016 : http://ceylon-lang.org/blog/2016/04/20/ceylon-on-mobile/
• En 2017, Ceylon a été pris en charge par Eclipse : https://projects.eclipse.org/proposals/eclipse-ceylon

Chapel

Auteur : Bradford L. Chamberlain (je pense)

Langage mettant l'accent sur le parallélisme

• http://chapel.cray.com/overview.html

Chicken

Auteur : Torbjörn Söderstedt

Langage de programmation étrange, où tout se programme à l'aide d'un seul mot... Le mot chicken. Sans blagues.

• http://torso.me/chicken

Church

Auteurs : Noah D. Goodman, Vikash K. Mansinghka, Daniel M. Roy, Keith Bonawitz et  Joshua B. Tenenbaum

Langage de programmation probabiliste.

• http://projects.csail.mit.edu/church/wiki/Church

Circa

Auteur : Andrew Fischer

Langage mettant l'accent sur la rétroaction immédiate dans le développement de jeux, et plus généralement sur le Live Coding..

• http://www.circa-lang.org/
• http://circa-lang.org/about/introduction.html
• http://www.gamedev.net/community/forums/topic.asp?topic_id=467939

Circle

Auteur : Sean Bax

Langage basé sur C++, mais avec un mécanisme @meta pour faire en sorte que certaines instructions soient exécutées à la compilation. Le nom du langage vient d'ailleurs du symbole @ qui y évoque... un cercle

• https://www.circle-lang.org/
• Une présentation sommaire du langage, par son auteur : https://github.com/seanbaxter/circle/blob/master/new_whitepaper/README.md

Citrine

Auteur : Gabor de Mooij

Langage OO inspiré syntaxiquement de Smalltalk, et mettant l'accent sur la lisibilité des sources, dans l'optique d'en faciliter l'entretien à moyen et à long terme.

• http://citrine-lang.org/
• http://citrine-lang.org/docs.html

Clay

Auteur : KS Sreeram

Langage mettant l'accent sur la généricité.

• http://claylabs.com/clay/
• http://tachyon.in/clay/
• https://github.com/jckarter/clay/wiki/
• http://www.drmaciver.com/2011/01/playing-with-a-new-language-clay/
• http://vocalbit.com/article/363/exploring-clay-type-inference-and-generics

Clean

Auteur : plusieurs individus.

Langage fonctionnel qu'on compare à Haskell.

• http://clean.cs.ru.nl/index.html
• http://clean.cs.ru.nl/Download/main/main.htm
• http://fpmatters.blogspot.com/2009/04/clean-programming-language-insanely.html

Clojure

Auteur : Rich Hickey.

Langage fonctionnel et dynamique, syntaxiquement inspiré de Lisp, et s'exécutant sur la JVM et sur le CLR.

Pédagogie et essentiels :

• http://clojure.org/
• http://groups.google.com/group/clojure
• http://aphyr.com/posts/301-clojure-from-the-ground-up-welcome
• Apprendre Clojure en quinze minutes... Peut-être, du moins... Par Adam Bard en 2013 : http://adambard.com/blog/clojure-in-15-minutes/
• http://clojure-doc.org/articles/tutorials/introduction.html
• Clojure pour débutant(e)s : http://www.braveclojure.com/
• Un Cheat Sheet : http://clojure.org/cheatsheet
• http://www.fogus.me/static/preso/clj1.1+/
• http://github.com/richhickey/clojure-clr
• Réécrire Clojure en Clojure : http://blog.n01se.net/?p=41
• http://clojuredocs.org/quickref/Clojure%20Core
• http://blog.fogus.me/2011/03/07/the-joy-of-the-joy-of-clojure/
• http://fronx.posterous.com/how-to-learn-clojure-effectively
• http://blog.fogus.me/2011/10/14/why-clojure-doesnt-need-invokedynamic-but-it-might-be-nice/
• http://blog.carbonfive.com/2011/10/20/up-and-running-with-clojure/
• http://tech.puredanger.com/2011/10/20/real-world-clojure/
• De l'avis de Rich Hickey lui-même, le futur de Clojure se situerait dans le développement mobile, du moins si on se fie à cette entrevue de 2012 : http://www.infoworld.com/d/application-development/clojure-inventor-hickey-now-aims-android-189105
• Un tutoriel pour Clojure, destiné aux programmeurs qui ne connaissent que peu ou pas Lisp, par Moxley Stratton en 2012 : http://moxleystratton.com/clojure/clojure-tutorial-for-the-non-lisp-programmer
• Présentation de Clojure par Andrew Jones en 2012 : http://www.andrewhjon.es/142343729
• Projet de documentation par la communauté : http://clojure-doc.org/
• En 2013, Vsevolod Dyomkin écrit sur Clojure et la complexité (entre autres sujets) : http://lisp-univ-etc.blogspot.kr/2011/11/clojure-complexity.html
• Réécriture du classique Structure and Interpretation of Computer Programs en Clojure : http://sicpinclojure.com/
• Apprendre Clojure lorsqu'on sait déjà programmer à l'aide de quelques autres langages, un texte de Michael Dippery en 2014 : http://monkey-robot.com/2014/05/clojure-a-retrospective/
• Selon Dmitri Sotnikov en 2014, la principale difficulté de la programmation avec Clojure est le besoin de trouver de nouvelles manières de résoudre des problèmes : http://yogthos.github.io/ClojureDistilled.html
• En 2015, Julian Gamble explique pourquoi, selon lui, vous devriez utiliser Clojure : http://www.informit.com/articles/article.aspx?p=2464444

Code « performant » :

• http://gnuvince.wordpress.com/2009/05/11/clojure-performance-tips/
• http://combinate.us/clojure/2010/09/27/clojure/
• Quelques micro-benchmarks, proposés par Matt Adereth en 2013 : http://adereth.github.io/blog/2013/11/22/a-few-interesting-clojure-microbenchmarks/

Critiques :

• http://briancarper.net/blog/460/five-things-that-mildly-annoy-me-in-clojure
• http://items.sjbach.com/567/critiquing-clojure
• http://www.loper-os.org/?p=42
• http://axisofeval.blogspot.com/2010/04/why-i-ignore-clojure.html
• http://mikes-tech.blogspot.com/2010/11/clojures-timeconcurrency-model-gentle.html
• http://copperthoughts.com/p/clojure-io-p1/
• http://acooke.org/cute/InitialTho0.html
• En 2012, Martin Trojer s'interroge quant aux raisons derrière la lenteur au démarrage de programmes écrits en Clojure : http://martinsprogrammingblog.blogspot.de/2012/02/why-is-clojure-so-slow.html
• Selon John P. Hackworth en 2014, la sécurité Web de Clojure laisse sérieusement à désirer : https://hackworth.be/2014/03/26/clojure-web-security-is-worse-than-you-think/
• Selon Facundo Olano en 2016, Clojure est chouette mais ne fait pas de miracles : https://facundoolano.wordpress.com/2016/03/20/first-impressions-on-clojure/
• Texte de 2016 par Ashton Kemerling qui décrit sa frustration croissante face à Clojure : http://ashtonkemerling.com/blog/2016/06/11/my-increasing-frustration-with-clojure/

Idées et opinions générales  :

• http://thecleancoder.blogspot.com/2010/08/why-clojure.html
• http://groups.google.com/group/clojure/browse_thread/thread/ffcd4bc722852b4?hl=en
• http://wiki.jvmlangsummit.com/Clojure_Keynote
• http://www.tbray.org/ongoing/When/200x/2009/12/01/Clojure-Theses
• http://tech.puredanger.com/2010/12/31/a-year-of-clojure/
• http://ericlavigne.wordpress.com/2011/01/30/a-tour-of-the-clojure-landscape/
• http://batsov.com/Clojure/Java/2011/05/12/jvm-langs-clojure.html
• Introduire Clojure dans une entreprise : http://oobaloo.co.uk/introducing-clojure-to-an-organisation
• Ajouter un système de types optionnel à Clojure :
  • http://www.indiegogo.com/projects/typed-clojure
  • article de 2013 défendant l'importance d'ajouter un tel système à Clojure : http://blog.circleci.com/supporting-typed-clojure/
• Selon Michael O. Church en 2013, Clojure serait un très bon langage de type JFDI (Just F***ing Do It) : https://docs.google.com/presentation/d/15-7qFy6URdE7Owi2LitkQI_OHBu1AFWPUwHxgBc-O4E/
• En 2014, Eric Normand indique que Clojure est plus impératif que déclaratif : http://www.lispcast.com/clojure-is-imperative
• Adam Bard, dans ce teste de 2014, se dit d'avis que programmer avec Clojure n'est pas réservé aux génies : http://adambard.com/blog/clojure-is-not-for-geniuses/
• Texte de 2015 expliquant pourquoi l'auteur privilégie Clojure, malgré un préjugé a priori défavorable envers Lisp : http://blog.venanti.us/why-clojure/
• En 2015, Steve Shogren présente six raisons « inhabituelles » pour lesquelles Clojure est un délice à ses yeux : http://deliberate-software.com/unusual-reasons-why-clojure-is-a-delight/
• Clojure est-il en mesure de tenir la route sous pression? En 2015, Marc Phillips explique que Walmart utilise Clojure et que ça se passe très bien, même lors d'un Black Friday : http://blog.cognitect.com/blog/2015/6/30/walmart-runs-clojure-at-scale
• À propos de la beauté de Clojure, texte de 2015 par Owen Rees-Hayward : http://owenrh.me.uk/blog/2015/08/24/
• Écrire du code Clojure qui soit moins rebutant, un texte sur la refactorisation patr Adam Bard en 2015 : http://adambard.com/blog/write-friendlier-clojure/
• Comment lire du code écrit en Clojure, selon Ricardo J. Méndez en 2017 : http://numergent.com/2017-01/Reading-Clojure.html
• En 2017, Nicholas Bardy explique pourquoi il fait le choix de Clojure : http://lambdafunk.com/2017-01-31-why-clojure/
• Texte de 2017 dans lequel Sean Walker présente ce qu'il décrit comme un « monolithe majestueux » en Clojure : https://medium.com/@swlkr/a-majestic-monolith-in-clojure-38097e35f03d

Technique :

• Organisation d'un projet de développement avec Clojure, par Kyle Kingsbury en 2014 : http://aphyr.com/posts/311-clojure-from-the-ground-up-logistics
• Les entrées/ sorties avec Clojure : http://nakkaya.com/2010/06/15/clojure-io-cookbook/
• Des acteurs en Clojure?
  • http://www.dalnefre.com/wp/2010/06/actors-in-clojure-why-not/
  • des agents en Clojure (inspiré des acteurs d'Erlang)? http://lethain.com/a-couple-of-clojure-agent-examples/
• http://gregslepak.posterous.com/clojures-n00b-attraction-problem
• http://programmingzen.com/2010/07/09/thoughts-on-clojure/
• Développer et déployer une petite application Web : http://mmcgrana.github.com/2010/07/develop-deploy-clojure-web-applications.html
• http://blog.jayfields.com/2010/07/clojure-destructuring.html
• Trampolines et Clojure : http://groups.google.com/group/clojure/browse_frm/thread/6257cbc4454bcb85/7d5fd827cd549080#7d5fd827cd549080
• Créer des archives JAR exécutables pour Clojure : http://asymmetrical-view.com/2009/06/22/executable-clojure-jars.html
• Les vertus de la paresse : http://debasishg.blogspot.com/2010/05/laziness-in-clojure-some-thoughts.html
• Les collections : http://www.infoq.com/articles/in-depth-look-clojure-collections
• Clojure et les états : http://clojure.org/state
• Clojure et les transitoires : http://clojure.org/transients
• Clojure et la validation, par Logan Campbell en 2013 : http://logaan.github.io/clojure/validations/vlad/2013/11/25/what-to-look-for-in-validations.html
• Clojure et les protocoles :
  • http://clojure.org/protocols
  • http://www.objectcommando.com/blog/2010/03/26/clojure-protocols-part-1/
  • http://www.objectcommando.com/blog/2010/03/29/clojure-protocols-part-2/
  • http://www.objectcommando.com/blog/2010/04/12/clojure-protocols-part-3/
  • http://debasishg.blogspot.com/2010/08/random-thoughts-on-clojure-protocols.html
• Implémenter A* en Clojure : http://clj-me.cgrand.net/2010/09/04/a-in-clojure/
• http://blog.fogus.me/2010/09/28/thrush-in-clojure-redux/
• http://cleancode.se/2010/10/17/what-is-clojure-good-at.html
• http://cemerick.com/2010/11/02/continuous-deployment-of-clojure-web-applications/
• http://www.learningclojure.com/2011/02/advice-to-newbie.html
• http://blog.jayfields.com/2011/02/clojure-truthy-and-falsey.html
• Configurer la journalisation avec Clojure : http://blog.malcolmsparks.com/?p=37
• Réduction d'arité (catamorphisme) avec Clojure : http://blog.darevay.com/2011/08/briefly-the-arity-reduce-pattern-in-clojure/
• Clojure et les macros :
  • http://learnclojure.blogspot.com/2010/09/clojure-macro-tutorial-part-i-getting.html
  • http://www.braveclojure.com/writing-macros/
  • des macros orientées objet avec Clojure : http://dosync.posterous.com/object-oriented-macros
  • anatomie d'une macro en Clojure, texte de Bryan Gilbert en 2013 : http://bryangilbert.com/code/2013/07/30/anatomy-of-a-clojure-macro/
  • introduction aux macros en Clojure :
    • http://www.braveclojure.com/writing-macros/
    • par Kyle Kingsbury en 2013 : http://aphyr.com/posts/305-clojure-from-the-ground-up-macros
• Résoudre ce qu'on nomme l'Expression Problem en Clojure, selon Stuart Sierra en 2010 : http://www.ibm.com/developerworks/java/library/j-clojure-protocols/
• En 2011, Chris McBride discute des portées dynamiques et lexicales en Clojure : http://info.rjmetrics.com/blog/bid/51652/Lexical-vs-Dynamic-Scope-in-Clojure
• Texte de 2010 listant sept règles à suivre pour programmer en Clojure : http://twoguysarguing.wordpress.com/2010/07/26/7-rules-for-writing-clojure-programs/
• Utiliser Clojure avec Swing, un texte de Stuart Sierra en 2010 : http://stuartsierra.com/2010/01/06/heating-up-clojure-swing
• Les automates sous-jacents à core.async, décrit et exploré par Huey Petersen en 2013 : http://hueypetersen.com/posts/2013/08/02/the-state-machines-of-core-async/
• Clojure et les refs, pour les cas où le programme requiert de multiples identités pour une même entité, par Scott Feeney en 2014 : https://scott.mn/2014/02/09/playing_with_refs/
• Structures de données en Clojure :
  • Hash Maps, par Timothy Pratley en 2013 : http://blog.safaribooksonline.com/2013/08/14/clojure-thinking-in-hashmaps/
  • vecteurs persistants, par Jean Niklas L'orange en 2013 : http://hypirion.com/musings/understanding-persistent-vector-pt-1
  • listes simplement chaînées, par Max Countryman en 2014 : http://macromancy.com/2014/01/16/data-structures-clojure-singly-linked-list.html
• Décompiler un programme Clojure, par Guillermo Winkler en 2014 : http://blog.guillermowinkler.com/blog/2014/04/13/decompiling-clojure-i/
• La réification avec Clojure, par Eric Normand en 2014 : http://www.lispcast.com/reification
• Transducteurs :
  • l'arrivée de transducteurs (Transducers) dans le langage, par Rich Hickey en 2014 : http://blog.cognitect.com/blog/2014/8/6/transducers-are-coming
  • comprendre les transducteurs par les types, texte de Franklin Chen en 2014 : http://conscientiousprogrammer.com/blog/2014/08/07/understanding-cloure-transducers-through-types/
• Construire des services à grande échelle avec Clojure, par Joseph Wilk en 2014 : http://blog.josephwilk.net/clojure/building-clojure-services-at-scale.html
• Programmer en Clojure avec des entités mutables, les transients, selon Jean Niklas L'orange : http://hypirion.com/musings/understanding-clojure-transients
• En 2013, Michael O. Church affirme que Clojure va outrepasser les frontières de la JVM et du « simple » langage de programmation : http://michaelochurch.wordpress.com/2013/08/07/why-clojure-will-win/
• Explication du démarrage d'un projet avec Clojure, par Carin Meier en 2015 : https://howistart.org/posts/clojure/1
• Les bons côtés / les saines pratiques avec Clojure, par Allen Rohner en 2016 : https://rasterize.io/blog/clojure-the-good-parts.html
• L'implémentation Clojerl, qui s'exécute sur la machine virtuelle d'Erlang : https://github.com/clojerl/clojerl

Parallélisme et multiprogrammation en Clojure : Multiprogrammation--Liens.html#langage_Clojure

ClojureScript

Auteur : Fogus (aussi connu sous le nom de Mike)

Pas tant un langage qu'un compilateur de Clojure et vers JavaScript, mais bon, c'est plus simple de le mettre ici pour s'y retrouver.

• http://clojure-script.org/
• https://github.com/clojure/clojurescript/wiki
• http://blog.fogus.me/2011/07/21/compiling-clojure-to-javascript-pt1/
• Introduction à ClojureScript, par David Nolen en 2014 : http://swannodette.github.io/2013/11/07/clojurescript-101/
• Programmation interactive avec ClojureScript, par Bruce Hauman en 2014 : http://rigsomelight.com/2014/05/01/interactive-programming-flappy-bird-clojurescript.html
• En 2015, Alex Eberts propose une exploration du REPL de ClojureScript : http://www.alexeberts.com/exploring-the-clojurescript-repl/
• Jon Pither, dans ce texte de 2015, s'exprime sur l'importance de ClojureScript à ses yeux : http://blog.juxt.pro/posts/why-clojurescript-matters.html
• Depuis 2015, ClojureScript exécute efficacement ClojureScript, comme l'explique David Nolen : https://swannodette.github.io/2015/07/29/clojurescript-17
• ClojureScript et les fureteurs :
  • Déboguer ClojureScript dans un fureteur, est-ce raisonnable? Texte d'Eric Normand en 2015 : http://www.lispcast.com/debugging-clojurescript
  • Évaluer ClojureScript dans un fureteur, par Dmitri Sotnikov en 2015 : http://yogthos.net/posts/2015-11-12-ClojureScript-Eval.html
• En 2016, Andrew Buntine explique à quel point ClojureScript l'a rendu productif : https://dev.to/buntine/clojurescript-saved-me-100-hours
• Selon Roman Liutikov en 2017, ClojureScript est un langage particulièrement adapté à la gestion des états du volet Front-End des applications : https://medium.com/@roman01la/clojurescript-a-frontend-language-designed-for-efficient-state-management-52f145c2fee3

Cobalt

Auteur : Mchael J. Haywoods

Langage à la fois OO et fonctionnel destiné à la JVM. Vise à couvrir les mêmes besoins que Scala, mais en accroissant la productivité des programmeuses et des programmeurs.

• https://github.com/Michael2109/cobalt

COBOL

Voir Langages/COBOL--Liens.html

Cobra

Auteur : Chuck Esterbrook

Un langage syntaxiquement semblable à Python mais qui se veut multiparadigmatique et qui donne accès à des concepts de plusieurs autres langages.

• http://cobra-language.com/
• http://cobra-language.com/docs/why/
• http://cobra-language.com/docs/python/

Coconut

Auteur : Evan Hubinger

Langage fonctionnel qui se veut un sur-ensemble de Python, et qui transpile vers Python.

• http://coconut-lang.org/

CoffeeScript

Auteur : Jeremy Ashkenas

Petit langage qui, une fois compilé, se transforme en JavaScript.

• http://jashkenas.github.com/coffee-script/
• Introduction au langage, par Aseem Kishore en 2013 : http://aseemk.com/blog/intro-to-coffeescript
• Livres en ligne :
  • par autotelicum, alias E. Hoigaard : http://autotelicum.github.com/Smooth-CoffeeScript/SmoothCoffeeScript.html
  • par Reginald Braithwaite : https://leanpub.com/coffeescript-ristretto
• http://gfxmonk.net/2010/07/04/defer-taming-asynchronous-javascript-with-coffeescript.html
• Pourquoi vous le détesterez (humour) : http://www.slideshare.net/tim.lossen.de/coffeescript-7-reasons-you-are-gonna-hate-it
• http://www.infoq.com/news/2010/08/coffeescript
• http://amix.dk/blog/post/19612
• http://buhrmi.tumblr.com/post/5371876452/how-coffeescript-makes-jquery-more-fun-than-ever
• Un compilateur JavaScript vers CoffeeScript : http://ricostacruz.com/js2coffee/
• http://issuu.com/autotelicum/docs/smooth_coffeescript
• http://robots.thoughtbot.com/post/9251081564/coffeescript-spartan-javascript
• Un dialecte de CoffeeScript nommé contracts.coffee et supportant la programmation par contrats : http://disnetdev.com/contracts.coffee/
• Combiner jQuery et CoffeeScript pour obtenir l'outil du futur pour les interfaces personne/ machine, selon Bruce Eckel en 2011 : http://www.artima.com/weblogs/viewpost.jsp?thread=335011
• Comprendre l'affectation : http://blog.carbonfive.com/2011/09/28/destructuring-assignment-in-coffeescript/
• Selon Michael Woloszynowicz en 2011, utiliser CoffeeScript signifie abandonner JavaScript : http://www.w2lessons.com/2011/11/coffeescript-means-giving-up-on.html
• Utiliser Node.js avec CoffeeScript, par Nagy Zoltán en 2011 : http://abesto.net/node-js-express-and-coffeescript
• Modèles déclaratifs en CoffeeScript, par Thomas Parslow en 2011 : http://almostobsolete.net/declarative-models-in-coffeescript.html
• Écrire du CoffeeScript efficacement, par Esa-Matti Suuronen en 2011 : http://esa-matti.suuronen.org/blog/2011/11/28/how-to-write-coffeescript-efficiently/
• Profiter des espaces blancs en CoffeeScript, par Reginald Braithwaite en 2011 : https://github.com/raganwald/homoiconic/blob/master/2011/11/sans-titre.md#readme
• Expressions régulières en CoffeeScript, par Elijah Manor en 2012 : http://www.elijahmanor.com/2012/02/regular-expressions-in-coffeescript-are.html
• Implémenter un ORM avec CoffeeScript, par Ryan Lefevree en 2013 :
  • http://meltingice.net/2013/02/21/implementing-an-orm-in-coffeescript-part-1/
• Les trampolines en CoffeeScript, le bien et le moins bien. Texte de Charles Hugues en 2014 : https://medium.com/programming-ideas-tutorial-and-experience/8eee8afb41df

Critiques :

• Selon Andrew Brehaut en 2011, les compréhensions de listes de CoffeeScript sont incorrectes : http://brehaut.net/blog/2011/coffeescript_comprehensions
• En 2011, Ryan Florence raconte pourquoi il peut être préférable de ne pas utiliser CoffeeScript, en décrivant la distance (à son avis) entre le code écrit et la lisibilité pour un programmeur, dans des cas concrets : http://ryanflorence.com/2011/2012/case-against-coffeescript/
  • toujours en 2011, Justin Etheredge répond à cette critique : http://www.codethinked.com/a-case-for-using-coffeescript
  • ensuite, toujours en 2011, Reginald Braithwaite donne son opinion : https://github.com/raganwald/homoiconic/blob/master/2011/12/jargon.md#readme
• En 2011, Armin Ronacher critique le Implicit Scoping de CoffeeScript : http://lucumr.pocoo.org/2011/12/22/implicit-scoping-in-coffeescript/
• La gestion de la portée des variables dans ce langage fait damner Jesse Donat, du moins si on se fie sur ce texte de 2013 : http://donatstudios.com/CoffeeScript-Madness
• Dans ce texte de 2012, Manuel Cerón indique qu'à son avis, CoffeeScript est un langage conçu pour simplifier l'écriture du code, mais qui en complique la lecture en contrepartie : http://ceronman.com/2012/09/17/coffeescript-less-typing-bad-readability/
• La perception, plutôt positive, qu'a Ruoyo Sun de ce langage, en 2013 : http://ruoyusun.com/2013/03/17/my-take-on-coffeescript.html
• La gestion un peu folle de la portée des variables en CoffeeScript et JavaScript, par Reginald Braithwaite en 2013 : http://raganwald.com/2013/07/27/Ive-always-been-mad.html
• En 2014, Jeff Walker est d'avis que CoffeeScript n'est pas une solution aux problèmes de JavaScript : http://www.walkercoderanger.com/blog/2014/03/coffeescript-isnt-the-answer/

Outils :

• Éviter les bogues d'indentation en CoffeeScript à l'aide de CoffeeLint, un texte de Julien Gilli en 2014 : http://www.juliengilli.com/2014/04/21/Avoid-misendented-coffeescript-callbacks-using-coffeelint/

Common Lisp

Voir Lisp.

Compute

Auteur : User:Orange?

Langage étrange qui résulte en des programmes qui dénotent une « certaine » intelligence...

• http://esolangs.org/wiki/Compute

Converge

Auteur : Laurence Tratt

Langage tirant son inspiration à plusieurs sources et se proposant comme une alternative pour les programmeuses et les programmeurs frustrés par leur langage de prédilection. En particulier, supporte la métaprogrammation statique.

• http://convergepl.org/about.html
• http://convergepl.org/documentation/2.0/ctmp/

Copper

Auteur : Marc Kerbiquet

Langage impératif avec système de types statique et généricité.

• http://tibleiz.net/copper/index.html
• http://tibleiz.net/copper/overview.html

Coq

Auteur : Benjamin Werner

À la fois langage fonctionnel et outil interactif. Vise à assister les gens dans leurs démarches de preuves formelles.

• http://coq.inria.fr/
• http://en.wikipedia.org/wiki/Coq
• http://ynot.cs.harvard.edu/papers/wwv09.pdf
• Histoire d'un projet intégrant trois langages que l'on rencontre habituellement plus dans le monde de la recherche que dans celui du code de production, soit Coq, Haskell et Ur, le tout relaté par Edward Z. Yang en 2012 : http://blog.ezyang.com/2012/05/what-happens-when-you-mix-three-research-programming-languages-together/
• Expérimentations avec Coq, relatées par Tony Young en 2012 : http://rfw.name/blog/2012/11/06/coq.html
• Est-ce que Coq serait un excellent macro assembleur? Article de Andrew Kennedy, Nick Benton, Jonas B. Jensen et Pierre-Evariste Dagand en 2015 : http://research.microsoft.com/en-us/um/people/nick/coqasm.pdf

CPC

Auteurs : Juliusz Chroboczek et Gabriel Kerneis

Langage inspiré de C et mettant l'accès sur la multiprogrammation à l'aide de threads très légers.

• http://www.pps.univ-paris-diderot.fr/~kerneis/software/cpc/

Crack

Auteur : Michael Muller

Langage de scripting qui se compile en code machine et vise ainsi une exécution plus rapide.

• http://crack-lang.org/

Cryptol

Auteurs : Jeffrey R. Lewis et Brad Martin?

Un DSL axé sur les algorithmes de chiffrement.

• http://www.galois.com/technology/communications_security/cryptol
• http://www.galois.com/blog/2008/12/24/cryptol-the-language-of-cryptography-now-available/
• http://www.galois.com/files/Cryptol/Cryptol_Whitepaper.pdf

Crystal

Auteur : Juan Wajnerman?

Langage compilé en code natif mais avec une syntaxe inspirée de celle de Ruby.

• http://crystal-lang.org/
• https://github.com/manastech/crystal/wiki/Introduction
• http://crystal-lang.org/2013/09/04/happy-birthday-crystal.html
• Texte de 2014 par Ary Borenszweig à propos de l'inférence de types globale dans ce langage : http://crystal-lang.org/2014/12/06/another-language.html
• À propos de l'inférence de types à l'aide de l'opérateur typeof sous Crystal, un texte d'Ary Borenszweig en 2015 : http://crystal-lang.org/2015/08/24/its-a-typeof-magic.html
• Introduction au langage, proposée par Serdar Doğruyol en 2016 : https://blog.codeship.com/an-introduction-to-crystal-fast-as-c-slick-as-ruby/
• Introduction au langage, par Robin Percy en 2017 : https://auth0.com/blog/an-introduction-to-crystal-lang/
• Les exceptions avec Crystal sous Microsoft Windows, par Chris Hobbs en 2018 : https://medium.com/futuredev/crystal-on-windows-a-deep-dive-on-exception-handling-97d8c3142059
• En 2019, Juan Wajnerman et Brian J. Cardiff présentent la programmation parallèle avec Crystal : https://crystal-lang.org/2019/09/06/parallelism-in-crystal.html

CSP

Auteur : C. A. R. Hoare

Langage servant surtout àdécrire la communication entre des processus séquentiels.

• http://en.wikipedia.org/wiki/Communicating_sequential_processes

Cx

Auteur : des gens de Synflow

Langage qui vise à rapprocher le design de composants matériels et les informaticien(ne)s

• http://cx-lang.org/ 

Cyclone

Auteurs : un groupe d'auteurs identifiés sur https://cyclone.thelanguage.org/wiki/People/

Langage proche du langage C, mais sous une forme beaucoup moins permissive.

• https://cyclone.thelanguage.org/

C!

Auteur : Marwan Burelle (je pense)

Langage inspiré par C et mettant l'accent sur la programmation système, mais avec extensions pour accentuer la productivité, entre autres quelques-unes se rapprochant de la POO.

• http://www.lse.epita.fr/projects/c!.html
• http://blog.lse.epita.fr/articles/12-c---system-oriented-programming.html

C#

Auteur : Anders Hejlsberg

Langage OO compilé pour en langage intermédiaire pour une machine virtuelle du modèle .NET telle que le CLR.

Pédagogie : ../Sujets/Divers--cdiese/pedagogie.html

Trucs et techniques : ../Sujets/Divers--cdiese/pedagogie.html#technique

Considérations de versions : ../Sujets/Divers--cdiese/pedagogie.html#versions

Conversions de ou vers C# :

• Convertir de Java à C# :
  • http://www.developer.com/java/other/article.php/2235411/Converting-Java-to-C.htm
  • http://www.javaworld.com/javaworld/jw-01-2003/jw-0103-migration.html
• Convertir de C# (entre autres) à Java :
  • http://www.infoworld.com/d/developer-world/inet-neatly-transforms-net-code-j2ee-320
  • http://www.infoworld.com/d/developer-world/visual-mainwin-offers-best-both-net-java-worlds-872
• Compiler de Lisp à C# :
  • http://anthonyf.wordpress.com/2009/12/31/introducing-lunula/
• Convertir de JSON à C# :
  • http://json2csharp.com/

Critiques : ../Sujets/Divers--cdiese/pedagogie.html#critiques

Cω

Auteurs : Nick Benton, Gavin Bierman, Luca Cardelli, Erik Meijer, Claudio Russo, Wolfram Schulte

Langage expérimental, axé sur la résolution de problèmes de concurrence.

• http://research.microsoft.com/en-us/um/cambridge/projects/comega/
• http://research.microsoft.com/en-us/um/cambridge/projects/comega/doc/comega_startpage.htm
• http://msdn.microsoft.com/en-us/library/ms974195.aspx

C++

Auteur : Bjarne Stroustrup

Langage compilé, orienté vers la programmation système, qui se veut multiparadigme, couvrant à la fois la programmation procédurale, la programmation orientée objet et la programmation générique. Notez que les articles techniques sur le langage C peuvent souvent (pas toujours; mieux vaut lire avec discernement!) servir aussi en C++.

La bibliothèque standard

Parce que, dans la vie, il n'y a pas que la STL...

• http://en.wikipedia.org/wiki/C_Plus_Plus_standard_library
• http://cs.stmarys.ca/~porter/csc/ref/cpp_standlib.html
• Problèmes avec la bibliothèque : http://www.comeaucomputing.com/iso/lwg-active.html
• Considérations de sécurité : http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1425.pdf
• Abstraction, bibliothèques et efficacité : http://public.research.att.com/~bs/abstraction.pdf
• http://www.cs.bsu.edu/homepages/peb/cplusplus/headers/default.htm
• Explication de 2018, portant sur ce qu'est la bibliothèque standard de C++ : https://www.internalpointers.com/post/c-c-standard-library

La STL

Généralités :

• http://en.wikipedia.org/wiki/Standard_Template_Library
• http://www.sgi.com/tech/stl/
  • http://www.sgi.com/tech/stl/stl_introduction.html
  • http://www.sgi.com/tech/stl/table_of_contents.html
  • http://www.sgi.com/tech/stl/other_resources.html
• http://en.wikibooks.org/wiki/C++_Programming/STL
• Un site mis sur pied par Jonathan Boccara et visant à servir de ressource pour se familiariser avec la STL : http://www.fluentcpp.com/stl-learning-resource
• Introduction d'Alexander Stepanov pour un livre sur la STL écrit par Dave Musser : http://www.stepanovpapers.com/MusserForeward.pdf
• Textes d'Alexander Stepanov :
  • sur le design de bibliothèques : http://www.stepanovpapers.com/Designing%20libraries.pdf
  • sur le futur de l'abstraction : http://www.stepanovpapers.com/Abstraction.pdf
• Notes de Nathan Myers sur le design de bibliothèques : http://www.cantrip.org/stdlibif.html
• Spécifications de complexité algorithmique : http://www.sgi.com/tech/stl/complexity.html
• http://www-h.eng.cam.ac.uk/help/tpl/talks/C++.html
• Étude de la solidité conceptuelle de la STL : http://gsd.web.elte.hu/contents/articles/eci06.pdf
• Le descriptif originalement soumis au comité de standardisation : http://www.hpl.hp.com/techreports/95/HPL-95-11.html
• Une version de la STL pour programmation parallèle : http://www.extreme.indiana.edu/hpc++/docs/overview/class-lib/PSTL/
• Une description UML de la STL : http://www.oonumerics.org/tmpw00/eichelberger.pdf
• La version de STL par Electronic Arts : http://msinilo.pl/blog/?p=668
• Ressources sur la STL dans MSDN : http://blogs.msdn.com/b/vcblog/archive/2014/01/21/stl-resources-on-msdn.aspx
• En quoi la STL peut remplacer du code « manuel », quelques exemples proposés par Joshua Henderson en 2014 (texte d'introduction) : http://www.digitalpeer.com/blog/c-stl-alternatives-to-non-stl-code
• Une STL pensée pour les systèmes embarqués, expliquée par John Hinke en 2014 : https://esrlabs.com/blog/estl-for-embedded-developers/

Conteneurs et itérateurs  : Caracteristiques-Cplusplus--Liens.html#conteneurs_iterateurs

Les adaptateurs tels que std::mem_fun :

• http://www.progdoc.de/papers/adapter_binder/adapter_binder/adapter_binder.html
• http://www.gotw.ca/gotw/064.htm

Critiques :

• Dans ce texte de 2013, Simon Ask indique qu'à son avis, la STL n'est pas idéale pour le développement de jeux vidéos : http://simonask.tumblr.com/post/59763277483/why-stl-isnt-great-for-game-development
• En 2013, Jon Kalb met de l'avant que la STL telle que conçue initialement montre de l'âge, au sens où elle pourrait être améliorée pour tenir compte du matériel contemporain. En particulier, le recours à des allocateurs est devenu beaucoup plus important pour qui souhaite produire du code « à haute performance » : http://www.slashslash.info/2013/10/stl-is-dated/
• En 2013, Jon Kalb préconise le recours à un flat_set (plutôt qu'à std::set) pour adapter les pratiques de programmation au matériel : http://www.slashslash.info/2013/10/ode-to-a-flat-set/

Boost

Voir ../Sujets/Divers--cplusplus/outils-compilateurs.html#boost

C+=

Auteurs : Eris Blastar, inspiré d'Ari Schlesinger

Langage féministe. Ce langage semble être proposé sur une base humoristique, mais il y a quand même eu un effort de design, de recherche et des outils de produits alors ce n'est pas sans intérêt.

• https://github.com/ErisBlastar/cplusequality

C--

Auteurs : une équipe travaillant avec Simon Peyton-Jones

Langage qui se veut une sorte d'assembleur portable pour faciliter l'écriture d'autres langages.

• http://www.cminusminus.org/

D

Auteur : Walter Bright

Langage compilé, orienté vers la programmation système, qui se veut multiparadigme, couvrant à la fois la programmation procédurale, la programmation orientée objet et la programmation générique.

• Introduction au langage D :
  • http://www.digitalmars.com/d/
  • http://tour.dlang.org/
  • introduction qui se veut pragmatique au langage D, proposée par Andreas Zwinkau : http://qznc.github.io/d-tut/
  • https://github.com/bayanr/d-tutorial
  • découvrir D, par Matthias Klumpp en 2016 : http://blog.tenstral.net/2016/05/adventures-in-d-programming.html
• En 2016, Michael Parker explique comment contribuer à l'amélioration du langage D : http://dlang.org/blog/2016/07/20/the-why-and-wherefore-of-the-new-d-improvement-proposal-process/
• Survol du langage D, par Ferdynand Górski en 2013 : http://fgda.pl/post/8/a-look-at-the-d-programming-language
• Wiki sur ce langage : http://en.wikipedia.org/wiki/D_%28programming_language%29
• Liste des caractéristiques du langage D : http://www.digitalmars.com/d/2.0/comparison.html
• Histoire de ce langage : http://www.computerworld.com.au/article/253741/-z_programming_languages_d
• Programmation fonctionnelle avec D : Paradigmes-programmation--Liens.html#programation_fonctionnelle_langage_D
• Le présent de D, selon Mike Karlesky en 2010 : http://spin.atomicobject.com/2010/06/30/d-little-language-that-could/
• La concurrence avec D, selon Andrei Alexandrescu en 2010 : http://www.informit.com/articles/printerfriendly.aspx?p=1609144
• Texte de 2011 par David Simcha sur D, la concurrence et le parallélisme : http://davesdprogramming.wordpress.com/2011/04/07/7/
• Porter D sur un Macintosh, un texte de Walter Bright en 2009 : http://drdobbs.com/tools/214502253
• Les littéraux définis par les utilisateurs en langage D, par Walter Bright en 2011  : http://drdobbs.com/blogs/tools/229401068
• D pour les programmeurs .NET : http://www.galador.net/codeblog/post/2011/05/20/D-for-NET-programmer.aspx
• Texte de Peter Alexander sur D et l'immuabilité (mais prudence, car les remarques sur C++ sont parfois basées sur une compréhension incorrecte de la syntaxe) : http://poita.org/index.php/blog/1-latest-news/67-thoughts-on-immutability-in-d
• De l'avis d'Abscissa (?) en 2011, si vous souhaitez être efficaces en D, n'utilisez pas un tableau pour implémenter une pile : https://www.semitwist.com/articles/article/view/don-t-use-arrays-as-stacks
• Qualifications de types en D, par Walter Bright en 2011  : http://drdobbs.com/blogs/cpp/231902461
• Résoudre l'énigme d'Einstein en D, par Leonardo Maffi en 2011 : http://www.fantascienza.net/leonardo/ar/einstein_riddle.html
• Les intervalles, ou Ranges, en D : http://ddili.org/ders/d.en/ranges.html
• 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
• Utiliser les fonctions évaluées à la compilation pour accélérer le calcul d'un cosinus, par Danny Arends en 2012 : http://www.dannyarends.nl/index.cgi?p=blog&viewDetailed=00029
• D et la progammation par contrats : http://dlang.org/dbc.html
• Uniformisation des conventions d'appel avec D :
  • un texte de Walter Bright en 2012 : http://drdobbs.com/blogs/cpp/232700394
  • autre texte de 2012 : http://www.gamedev.net/blog/1140/entry-2254754-uniform-function-call-syntax-in-d/
• Quelques particularités techniques intéressantes du langage D, répertoriées par Michael Larouche en 2012 : http://michaellarouche.wordpress.com/2012/05/12/cool-features-of-the-d-language/
• Les types Voldemort, qui ne peuvent être nommés :
  • une technique en D par Walter Bright en 2012 : http://www.drdobbs.com/article/print?articleId=232901591&siteSectionid=cpp
  • https://wiki.dlang.org/Voldemort_types
• Appels de fonctions :
  • évaluation paresseuse des paramètres passés aux fonctions avec D, par Walter Bright : http://dlang.org/lazy-evaluation.html
  • Syntaxes alternatives pour les fonctions en D, par Gary Willoughby en 2013 : http://nomad.so/2013/08/alternative-function-syntax-in-d/
• Utiliser l'instruction import de D pour intégrer des données à un programme dès la compilation, un texte de 2012 : http://www.gamedev.net/blog/1140/entry-2254294-compiling-data-into-a-d-executable/
• Contribuer à la bibliothèque standard de D, l'expérience de Joe Wakeling en relatée en 2012 : http://braingam.es/2012/07/sampling-d/
• Quelques exemples de programmation générique avec D, par Andrei Alexandrescu en 2011 : http://www.slideshare.net/andreialexandrescu1/generic-programming-galore-using-d
• Écrire un petit noyau en langage D : http://wiki.osdev.org/D_Bare_Bones
• Interopérabilité de D avec COM, par Lio Lunesu en 2012 : http://lunesu.com/index.php?/archives/126-Modern-COM-Programming-in-D.html
• Intégrer D et C :
  • convertir un .h en module du langage D : http://dlang.org/htomodule.html
  • série d'articles de 2012 par Mike Parker montrant comment intégrer D et C :
    • http://www.gamedev.net/blog/1140/entry-2254003-binding-d-to-c/
    • http://www.gamedev.net/blog/1140/entry-2254108-binding-d-to-c-part-two/
    • http://www.gamedev.net/blog/1140/entry-2254632-binding-d-to-c-part-three/
    • http://www.gamedev.net/blog/1140/entry-2254910-binding-d-to-c-part-four/
  • texte de Mike Parker en 2013 : http://www.gamedev.net/page/resources/_/technical/game-programming/binding-d-to-c-r3122
  • texte de Mike Parker en 2013 portant sur les exceptions en langage D et les callbacks en langage C : http://www.gamedev.net/page/resources/_/technical/general-programming/d-exceptions-and-c-callbacks-r3323
• Texte de 2012 par Walter Bright expliquant pourquoi D, par défaut, initialise les nombres à virgule flottante à NaN plutôt qu'au zéro du type visé : http://www.drdobbs.com/article/print?articleId=240005723&siteSectionid=cpp
• Programmation par composants en D, texte de Walter Bright en 2012 : http://www.drdobbs.com/architecture-and-design/component-programming-in-d/240008321
• Quelques mythes à propos de D, par Nick Sabalausky en 2012 : http://semitwist.com/articles/article/view/dispelling-common-d-myths
• En 2012, Benjamin Thaut explique comment faire une mise à jour dynamique de code D : http://3d.benjamin-thaut.de/?p=25
• Définir des formats « maison » pour les chaînes de caractères avec D : http://wiki.dlang.org/Defining_custom_print_format_specifiers
• Programmation fonctionnelle avec D, texte d'Andreas Zwinkau en 2013 : http://beza1e1.tuxen.de/articles/functional_D.html
• Des singletons en D, un texte de David Simcha en 2013 : http://davesdprogramming.wordpress.com/2013/05/06/low-lock-singletons/
• Combiner énumération et union en D de manière sécuritaire, un texte de 2013 : http://www.deadalnix.me/2013/05/10/type-safe-tagged-union-in-d-programming-language/
• Les templates avec D, un texte de Gary Willoughby en 2013 : http://nomad.so/2013/07/templates-in-d-explained/
• Programmer en D avec composants et intervalles : http://wiki.dlang.org/Component_programming_with_ranges
• Fouiller dans un graphe à l'aide d'intervalles, par Peter Alexander en 2014 : http://poita.org/2014/01/09/range-based-graph-search-in-d.html
• Traitement d'images avec D, texte de Vladimir Panteleev en 2014 : http://blog.thecybershadow.net/2014/03/21/functional-image-processing-in-d/
• Selon cet article de 2014 par Cade Metz, D serait le meilleur langage dont vous n'avez jamais entendu parler : http://www.wired.com/2014/07/d-programming-language/
• Quelques perles de la bibliothèque standard de D, répertoriées par Gary Willoughby :
  • texte de 2014 : http://nomad.so/2014/08/hidden-treasure-in-the-d-standard-library/
  • texte de 2015 : http://nomad.so/2015/08/more-hidden-treasure-in-the-d-standard-library/
• Un template qui ne fait rien, par Vladimir Panteleev en 2015 : http://blog.thecybershadow.net/2015/04/28/the-amazing-template-that-does-nothing/
• À propos de la taille des exécutables compilés avec D, par Vladimir Panteleev en 2015 : http://blog.thecybershadow.net/2015/05/05/is-d-slim-yet/
• D et les types dépendants, texte de 2015 par Dee Mon : http://www.infognition.com/blog/2015/dependent_types_in_d.html
• Métaprogrammation avec D : Paradigmes-programmation--Liens.html#metaprogrammation_langage_D
• Écrire un système de clavardage avec D, par Sönke Ludwig en 2016 : https://vibed.org/blog/posts/a-scalable-chat-room-service-in-d
• Exécuter un jeu écrit en D dans un fureteur, texte de 2016 par Sebastien Alaiwan : http://code.alaiwan.org/wp/?p=103

Cas d'espèces :

• Les raisons qui motivent Facebook à expérimenter avec D, rapportées par John Paul Titlow en 2013 : http://www.fastcolabs.com/3019948/more-about-d-language-and-why-facebook-is-experimenting-with-it
• Utiliser D pour de la programmation « scientifique », par Andrew Pascoe en 2014 : http://tech.adroll.com/blog/data/2014/11/17/d-is-for-data-science.html
• Premier contact avec D, pour une tâche de métaprogrammation dans le but de générer et de consommer du JSON, un texte de Ross Harrison en 2016 : http://rharriso.github.io/2016/01/23/jsoninflater-d-my-first-dub-d-package.html

Critiques :

• Selon Pjotr Prins en 2015 (pas sûr de la date), D est un dragon, puissant mais imprévisible : http://thebird.nl/blog/D_Dragon.html

Dao

Auteur : Limin Dalbert Fu

Langage de Scripting ayant pour objectif de simplifier certaines tâches communes de programmation tout en demeurant extensible.

• http://daovm.net/

Dart

Auteurs : Lars Bak et Gilad Bracha

Langage développé chez Google et mettant l'accent sur la programmation structurée pour le Web.

• http://www.dartlang.org/
• http://www.dartlang.org/docs/technical-overview/index.html
• Le SDK de Dart :
  • http://googledevelopers.blogspot.ca/2012/10/celebrating-darts-birthday-with-first.html
  • http://blog.chromium.org/2013/11/dart-10-stable-sdk-for-structured-web.html
• La spécification officielle de la version 0.01 du langage : http://www.dartlang.org/docs/spec/dartLangSpec.pdf
• Depuis 2014, Dart est un standard ECMA : http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf
• http://www.theregister.co.uk/2011/09/09/google_dart_web_programming_language/
• http://gotocon.com/aarhus-2011/presentation/Opening%20Keynote:%20Dart,%20a%20new%20programming%20language%20for%20structured%20web%20programming
• Le but semble être d'éventuellement remplacer JavaScript (pas une mince affaire!) :
  • http://markmail.org/message/uro3jtoitlmq6x7t
  • http://www.2ality.com/2011/09/google-dart.html
  • le futur de JavaScript et le rôle de Dart, selon un mémo interne de Google en 2011 : http://pastebin.com/NUMTTrKj
• http://www.extremetech.com/computing/99175-google-dart-unveiled-farewell-javascript
• http://googlecode.blogspot.com/2011/10/dart-language-for-structured-web.html
• http://dartinside.com/2011/dart-bashing/
• http://conway.rutgers.edu/~ccshan/wiki/blog/posts/Unsoundness/
• http://www.infoq.com/articles/google-dart
• http://journal.stuffwithstuff.com/2011/10/21/wrapping-my-head-around-optional-typing/
• Implémenter le Null-Safety pour Dart? Une proposition de Robert Nystrom en 2011 : http://journal.stuffwithstuff.com/2011/10/29/a-proposal-for-null-safety-in-dart/
• Pourquoi Dart opère sur le code source directement plutôt que sur un format intermédiaire, de l'avis de Florian Loitsch en 2011 : http://www.dartlang.org/articles/why-not-bytecode/
  • une réplique de Charles Oliver Nutter, aussi en 2011 : https://groups.google.com/a/dartlang.org/group/misc/browse_thread/thread/bbf8e4d3dd3ab188
• En 2012, Dart est encore jeune et, à l'approche d'une étape nommée Milestone 1, quelques changements importants sont prévus. Texte de Robert Nystrom : http://www.dartlang.org/articles/m1-language-changes/
  • plus particulièrement, en 2012, Dart cessera de supporter l'opérateur + sur des String. Pour une explication proposée par Seth Ladd des alternatives à cet opérateur maintenant jugé désuet, voir http://news.dartlang.org/2012/06/vm-to-remove-support-for-string.html
• Reportage de Jon Brodkin en 2012 laissant entendre que Dart serait « prêt pour le vrai monde » : http://arstechnica.com/information-technology/2012/10/googles-bid-to-fix-javascript-dart-is-ready-for-the-real-world/
• Les mixin avec Dart, texte de Gilad Bracha en 2012 : http://www.dartlang.org/articles/mixins/
• Entrevue avec Lars Bak portant sur ce langage : http://www.theregister.co.uk/2013/01/18/google_dart_interview/
• L'état de Dart en 2013, par Jonathan Edwards : http://alarmingdevelopment.org/?p=748
• Est-ce que Dart est le futur du Web? Todd Hoff donne des indications à cet effet dans ce texte de 2013 : http://highscalability.com/blog/2013/3/20/dart-is-it-the-future-of-the-web.html
• En 2013, Thomas Schranz explique pourquoi son entreprise migre vers Dart : http://www.ramen.io/post/46936028144/we-are-switching-to-dart-why
• Dart et les snapshots, pour accélérer le démarrage des applications, un texte de Siva Annamalai en 2013 : http://www.dartlang.org/articles/snapshots/
• En 2013, Dart a atteint le seuil de la version 1.0 et est devenu un standard ECMA :
  • texte de Stephen Shankland 2013 : http://news.cnet.com/8301-1023_3-57612080-93/dart-googles-controversial-web-language-turns-1.0/
  • texte de Mike James en 2013 : http://www.i-programmer.info/news/98-languages/6713-googles-dart-becomes-ecmas-dart.html
• En 2013, Dart s'engage dans un processus de standardisation ECMA : http://blog.chromium.org/2013/12/ecma-forms-tc52-for-dart-standardization.html
• Les bons côtés de Dart, un texte de Cody Casterline en 2014 : http://blog.nfnitloop.com/2014/04/27/1430/
• Dans ce texte de 2013, Nadir Muzaffar se dit d'avis que Google est sur le point de pousser Dart en tant que langage privilégié de développement sur Android : http://nadirmuzaffar.blogspot.ca/2013/08/future-of-google-dart.html
• À partir de la version 1.8, Dart supporte les enum. Texte d' Anders Thorhauge Sandholm en 2014 : http://news.dartlang.org/2014/11/dart-18-library-improvements-and.html
• Calculs numériques avec Dart, texte de 2013 par John Mccutchan : https://www.dartlang.org/articles/numeric-computation/
• Échanges sur la standardisation de Dart, par Seth Ladd en 2015 : http://www.dartosphere.org/2015/01/30/dart-language-evolution-discussed-in-ecma-tc52-.html
• En 2015, l'équipe de développement de Dart a pris la décision de compiler le code Dart en JavaScript, pour en maximiser l'utilité. À propos de ce changement de direction :
  • article de 2015 par Lars Bak et Kasper Lund : http://news.dartlang.org/2015/03/dart-for-entire-web.html
  • brève analyse de ce que signifie ce changement de cap, par Dan Rowinski en 2015 : http://arc.applause.com/2015/03/27/google-dart-virtual-machine-chrome/
• Texte de 2015 par Thomas Schranz, qui décrit les penseurs derrière Dart : https://www.blossom.co/blog/who-is-behind-dart
• Sur Android, Dart aurait pour objectif la génération de programmes sans la moindre trace de Java, et s'exécutant à 120 fps, si on en croit cet article de Rom Amadeo en 2015 : http://arstechnica.com/gadgets/2015/05/googles-dart-language-on-android-aims-for-java-free-120-fps-apps/
• Le langage de macros de Dart, selon Brian Slesinsky en 2015 : https://docs.google.com/document/d/1-We05W0xsd5hTWGsTDCY6pibf2EmmTAsm-4EhIFZoOA/preview?sle=true
• Dart expliqué à l'aide d'exemples, par John P. Ryan : http://johnpryan.github.io/dartbyexample/
• Permettre des effets de bord dans un programme Dart, texte d' Erik Meijer, Kevin Millikin et Gilad Bracha en 2015 : https://queue.acm.org/detail.cfm?id=2747873
• En 2016, Filip Hracek se joint à l'équipe de Dart et explique son choix : https://medium.com/@filiph/why-i-m-joining-the-dart-team-of-all-places-d0b9f83a3b66
• Dans ce texte de 2016, Frederic Lardinois relate le « retour » de Dart : https://techcrunch.com/2016/10/26/googles-dart-programming-language-returns-to-the-spotlight/
• Compiler des programmes Dart à l'aide de LLVM, une expérience relatée par Erik Corry en 2017 : https://medium.com/@erik_68861/dart-on-llvm-b82e83f99a70
• En 2017, Dart se donne un système de types, comme l'explique David Morgan : https://medium.com/dartlang/dart-gets-a-type-system-6bd3121772de
• Quelques outils pratiques pour manipuler des tableaux avec Dart, par Jermaine Oppong en 2018 : https://codeburst.io/top-10-array-utility-methods-you-should-know-dart-feb2648ee3a2
• En 2018, Deven Joshi présente Dart et ses particularités : https://medium.com/@dev.n/the-dart-language-and-its-peculiarities-e46c27def825
• Comme le rapport Michael Thomsen en 2020, Dart peut être compilé en code natif à partir de la version 2.6 : https://medium.com/dartlang/dart2native-a76c815e6baf
• Texte de 2020 par Robert Nystrom, qui explique le null-Safety avec Dart : https://medium.com/dartlang/why-nullable-types-7dd93c28c87a
• Mesurer la vitesse d'exécution de programmes écrits en Dart, par Vyacheslav Egorov en 2021 : https://mrale.ph/blog/2021/01/21/microbenchmarking-dart-part-1.html
• En 2022, Michael Thomson rapporte détaille la stratégie de null-Safety qui prend effet à partir de Dart version 3 : https://medium.com/dartlang/the-road-to-dart-3-afdd580fbefa

Critiques :

• http://en.wikipedia.org/wiki/Dart_%28programming_language%29#Criticism
• http://blogs.perl.org/users/rafael_garcia-suarez/2011/10/why-dart-is-not-the-language-of-the-future.html
• http://news.cnet.com/8301-30685_3-57330431-264/microsoft-shoots-down-googles-dart-language/
• Texte de Brandon Jones en 2013 à propos de la réception un peu froide qu'a réservé la communauté à ce langage : http://blog.tojicode.com/2013/06/a-tale-of-two-web-technologies.html
• En 2014, Jeff Walker est d'avis que Dart n'est pas une solution aux problèmes de JavaScript : http://www.walkercoderanger.com/blog/2014/03/dart-isnt-the-answer/

Outils :

• Flutter se veut un SDK pour le développement visuel avec Dart : https://flutter.io/

daScript

Auteur : des individus de Gaijin Entertainment

Langage de script destiné à l'automatisation de tâches côté serveur, et conçu pour le monde du jeu vidéo.

• https://dascript.org/

Deca

Auteur : Eli Z. Gottlieb

Langage de programmation système, présenté comme un assembleur de haut niveau.

• http://code.google.com/p/decac/
• http://marmoach.blogspot.com/2011/10/lambdas-for-systems-language-implicit.html
• http://decac.googlecode.com/files/Deca%20Thesis.pdf

Delphi

Auteur : Danny Thorpe (et Anders Hejlsberg)

Un dérivé syntaxique de Turbo Pascal avec environnement de développement visuel.

• http://en.wikipedia.org/wiki/Delphi_programming_language
• http://delphi.wikia.com/wiki/Delphi_Wiki
• http://www.embarcadero.com/products/delphi
• http://edn.embarcadero.com/article/32977
• En 2017, Marco Antu ne jure encore et toujours que par Delphi : http://blog.marcocantu.com/blog/2017-january-22years-delphi.html
• David Harper, dans ce texte de 2017, dit faire encore et toujours le choix de Delphi : https://csvelocity.wordpress.com/2017/07/27/why-i-choose-delphi/
• En 2019, Patrick Martin fait l'éloge de Delphi : https://accu.org/var/uploads/journals/Overload153.pdf#page=12
• En 2020, Jon Lennart Aasenden pose un regard sur le 25^e anniversaire de Delphi qu'il présente comme 25 ans d'excellence : https://community.idera.com/developer-tools/b/blog/posts/25-years-of-excellence
• En 2020, Patrick Martin se remémore les raisons qui lui ont fait utiliser Delphi : https://accu.org/var/uploads/journals/Overload153.pdf#page=12

Diacho

Auteur : aucune idée (les articles sont signés « admin »)

Langage statiquement typé qui vise la haute performance, la programmation système et la facilité d'écriture pour les programmeurs.

• http://blog.diacho.com/2011/12/diacho-programming-language/
• http://blog.diacho.com/why-should-i-use-diacho/
• http://blog.diacho.com/

Dhall

Auteur : Fabrizio Ferrai

Langage spécialisé dans la programmation de configurations, et qui n'a pas la prétention d'être généraliste.  Dans les mots de son auteur : « You can think of Dhall as: JSON + functions + types + imports »

• https://github.com/dhall-lang/dhall-lang

Dio

Auteur : (je n'en sais rien)

Langage compilé en code natif qui repose sur LLVM. Le langage se veut efficace (évitant certains cas où d'autres langages auraient recours à de l'allocation dynamique de mémoire) et sécuritaire (imposant certains tests, par exemple dans les cas où une variable pourrait être null), mais n'a pas la prétention d'être simple, annonçant le recours à plusieurs mots clés.

• https://diolang.com/
• La documentation est proposée sous forme de code : https://diolang.com/docs.dio.html

Dminor

Auteur : Microsoft Research?

Un langage de modélisation de données basé sur le langage M.

• http://research.microsoft.com/en-us/downloads/cd60cdb0-353f-48b3-81d7-177621eba1bf/default.aspx

DRAKON

Auteur : Vladimir Parondzhanov

Langage de programmation visuel et temps réel, utilisé dans le domaine de l'aérospatiale.

• https://en.wikipedia.org/wiki/DRAKON

Duck

Auteur : Greg Tourville et Hiroyuki Sano

Un langage de programmation qui veut faciliter l'adéquation entre ce qui est écrit et ce qui est fait (le Duck Typing).

• http://ducklang.org/
• http://team-duck.com/

Dylan

Auteur : pas clair (un groupe chez Apple, à l'origine)

Langage qui se veut multiparadigme, couvrant à la fois la programmation fonctionnelle et la programmation orientée objet. Ressemble un peu à Scheme et à Common Lisp.

• Un Wiki sur ce langage : http://en.wikipedia.org/wiki/Dylan_%28programming_language%29
• http://opendylan.org/index.html
• Un historique du langage : http://en.wikipedia.org/wiki/History_of_the_Dylan_programming_language
• Livre électroniques sur ce langage :
  • http://www.opendylan.org/books/dpg/
  • http://opendylan.org/news/2013/01/21/dylan-programming-guide.html
• http://www.opendylan.org/
• http://www.double.co.nz/dylan/
• Réflexions sur un nouvel écosystème pour Dylan, par Bruce Mitchener Jr. en 2013 : http://dylanfoundry.org/2013/11/12/thoughts-on-a-new-dylan-ecosystem/
• Participer à ce projet, en 2014 : http://opendylan.org/news/2014/01/28/call-for-help.html

E

Auteurs : Mark S. Miller et Dan Bornstein (entre autres).

À l'origine, un langage OO axé vers le développement de systèmes répartis sécuritaires.

• http://en.wikipedia.org/wiki/E_%28programming_language%29
• http://wiki.erights.org/wiki/Main_Page
• http://wiki.erights.org/wiki/Getting_Started
• http://wiki.erights.org/wiki/Walnut

ECMAScript

Voir JavaScript.

Eero

Auteur : Andreas Arvanitis

Dialecte d'Objective-C destiné à être exécuté sur LLVM.

• http://eerolanguage.org/

efene

Auteur : à déterminer...

Un langage qui se veut syntaxiquement proche de Java, C++ ou C#, mais qui se compile pour la machine virtuelle ERTS du langage Erlang.

• http://efene.tumblr.com/post/668063621/efene-0-7-a-language-for-the-erlang-vm-released
• http://marianoguerra.com.ar/efene/docs/releases/oseven.html

Eff

Auteur : Andrej Bauer et Matija Pretnar

Un langage fonctionnel de programmation par effets (le mot effet ici faisant référence aux changements d'états).

• http://math.andrej.com/category/eff/
• http://math.andrej.com/2010/09/27/programming-with-effects-i-theory/
• http://math.andrej.com/2010/09/27/programming-with-effects-ii-introducing-eff/
• http://math.andrej.com/2010/09/28/how-eff-handles-built-in-effects/
• http://math.andrej.com/2010/09/30/delimited-continuations-in-eff/
• http://math.andrej.com/wp-content/uploads/2012/03/eff.pdf

Eiffel

Auteur : Bertrand Meyer

Langage OO influent, porteur de plusieurs concepts importants dans l'approche OO contemporaine (en particulier la programmation par contrats).

• http://www.eiffel.com/
• http://en.wikipedia.org/wiki/Eiffel_%28programming_language%29
• http://www.drdobbs.com/184409090
• http://www.ecma-international.org/publications/standards/Ecma-367.htm

ELENA

Auteur : Alex Rakov

Langage OO dynamique, incluant des mécanismes de passage de messages entre objets.

• https://github.com/ELENA-LANG
• https://github.com/ELENA-LANG/elena-lang/wiki/Dynamic-programming-in-ELENA

Elixir

Auteur : José Valim

Langage s'exécutant sur la machine virtuelle ERTS d'Erlang. Vise à offrir un support solide à la métaprogrammation et au développement de systèmes répartis.

• http://elixir-lang.org/
• https://github.com/josevalim/elixir
• http://kukuruku.co/hub/erlang/introduction-to-elixir
• http://blog.plataformatec.com.br/2011/06/elixir-v0-3-0-released/
• Les objectifs que vise le design d'Elixir, exposés par José Valim en 2013 : http://elixir-lang.org/blog/2013/08/08/elixir-design-goals/
• Texte de Joe Armstrong en 2013, relatant son expérience avec ce langage : http://joearms.github.io/2013/05/31/a-week-with-elixir.html
• Selon Devin Torres en 2013, l'attrait d'Elixir n'est pas attribuable à sa syntaxe : http://devintorr.es/blog/2013/06/11/elixir-its-not-about-syntax/
• Texte de 2013 par Geoffrey Grosenbach à l'effet qu'Elixir est un langage vraiment pensé pour des programmeuses et des programmeurs : http://blog.pluralsight.com/elixir-is-for-programmers
• Écrire un Pattern Matcher en Elixir, par Dave Thomas en 2014 : http://pragdave.me/blog/2014/02/12/pattern-matching-and-parsing/
• Texte de 2015 où Teemu Harju explique pourquoi il a fait d'Elixir son principal langage de programmation : http://blog.teemu.im/2015/01/25/thoughts-about-elixir/
• Parallélisme avec Elixir, par Robert Sosinski en 2015 : http://www.reactive.io/tips/2015/02/03/introduction-to-parallel-computing-with-elixir/
• Programmation « orientée rails de chemin de fer » avec Elixir, une manière de visualiser le déroulement de l'exécution d'un programme, selon Zohaib Rauf en 2015 : http://zohaib.me/railway-programming-pattern-in-elixir/
• Selon Brian Cardarella en 2015, on vient à Elixir pour la syntaxe, mais on y reste pour toutes sortes d'autres raisons : http://reefpoints.dockyard.com/2015/04/08/elixir-come-for-the-syntax-stay-for-everything-else.html
• En 2015, Marius Herring décrit la conception d'un Chat Room avec Elixir : http://www.deadcoderising.com/2015-06-09-try-something-different-with-elixir/
• Du Pattern Matching de données binaires avec Elixir, article de 2015 par Zohaib Rauf : http://zohaib.me/binary-pattern-matching-in-elixir/
• Texte d'Evan Miller en 2016 sur les HTML templates d'Elixir : http://www.evanmiller.org/elixir-ram-and-the-template-of-doom.html
• Récursivité avec Elixir, par Nikola Novakovic en 2016 :
  • http://novarac.com/recursion-in-the-wild-elixir/
  • http://novarac.com/elixir-and-recursion-part-ii/
• Quelques trucs intéressants à propos d'Elixir, de l'avis de Ryan Flach en 2016 : https://dev.to/ryanflach/fun-things-in-elixir
• Le grand potentiel d'Elixir, par Adrian Philipp en 2016 : http://adrian-philipp.com/post/why-elixir-has-great-potential

Elm

Auteur : Evan Czaplicki

Langage fonctionnel axé sur la programmation pour le Web.

• http://elm-lang.org/
• http://elm-lang.org/Examples.elm
• Explication de ce que signifie la « programmation fonctionnelle réactive » dans ce langage : http://elm-lang.org/learn/What-is-FRP.elm
• Se débarrasser des rappels (des Callbacks), qualifiés par Evan Czaplicki de « goto contemporain » dans ce texte de 2012 : http://elm-lang.org/learn/Escape-from-Callback-Hell.elm
• Passer du modèle impératif au modèle fonctionnel avec Elm, par Tobias Hermann en 2013 : https://github.com/Dobiasd/articles/blob/master/switching_from_imperative_to_functional_programming_with_games_in_Elm.md
• Déboguer un programme Elm implique pouvoir faire des opérations telles que Pause, Rewind, Replay... http://debug.elm-lang.org/
• Des tableaux immuables, expliqués par Evan Czaplicki en 2014 : http://elm-lang.org/blog/announce/0.12.1.elm
• Développement Web accéléré, texte de 2014 : http://elm-lang.org/blog/Blazing-Fast-Html.elm
• Voyager dans le temps avec un programme Elm, par Michael James en 2014 qui montre comment il est possible de reculer dans le temps pour retracer l'exécution d'un programme écrit avec ce langage : http://elm-lang.org/blog/Introducing-Elm-Reactor.elm
• Le langage Elm sur la frontière de la programmation fonctionnelle, une présentation de Richard Feldman en 2014 : https://presentate.com/rtfeldman/talks/the-functional-frontier-elm
• Scott Kensell, en 2014, se présente comme un puceau de programmation fonctionnelle apprenant Elm : http://scottkensell.com/fp-virgin-learns-elm.html
• Texte d'Evan Czaplicki en 2015 et qui porte que le sujet de la production de messages d'erreurs de compilation destinés aux humains : http://elm-lang.org/blog/compiler-errors-for-humans
• Utiliser Elm pour représenter la factorisation de nombres premiers, par Ruslan Shestopalyuk en 2015 : http://blog.ruslans.com/2015/07/prime-factorization-elms.html
• Faire du compilateur son assistant, par Evan Czaplicki en 2015 : http://elm-lang.org/blog/compilers-as-assistants
• « Elm dans le vrai monde », des cas d'espèces avec ce langage relatés par Ossi Hanhinen en 2016 : http://futurice.com/blog/elm-in-the-real-world
• En 2016, Elm se sépare de la programmation réactive et passe à un autre paradigme. Texte d'Evan Czaplicki : http://elm-lang.org/blog/farewell-to-frp
• Utiliser Elm au travail, par Evan Czaplicki en 2016 : http://elm-lang.org/blog/how-to-use-elm-at-work
• En 2016, Richard Feldman présente Elm comme un langage « bâti sur la réactivité » : https://www.infoq.com/articles/language-reactivity-with-elm
• Texte de 2016 par Brad Grzesiak, qui se dit d'avis qu'Elm permet d'exprimer un schéma de conception MVC plus près de l'intention derrière cette pratique que ce que permettent la plupart des langages : http://bendyworks.com/blog/elm-frontend-right-now-updated-for-0-18
• En 2017, Ivan Pantić montre comment il a utilisé Elm pour résoudre un problème très concret (mais ne semble pas emballé) : https://pantas.net/elm_in_practice/
• Pour sa part, Christian Charukiewicz semble satisfait d'avoir utilisé Elm dans un contexte de production, comme l'indique ce texte de 2017 : https://charukiewi.cz/posts/elm/
• Apprendre à utiliser Elm pour dynamiser des pages Web, par Rajat S en 2018 : https://blog.bitsrc.io/getting-started-with-elm-language-for-web-apps-49418c6adc17
• Développer des Shaders avec Elm, par Jappie Klooster en 2018 : https://jappieklooster.nl/elm-on-fire-shaders-in-elm.html

Critiques :

• En 2016, Sandy Maguire émet une critique sévère d'Elm en tant que langage, tout en admettant que ce pourrait être une bibliothèque décente et que la documentation est de qualité : http://reasonablypolymorphic.com/blog/elm-is-wrong
• Critique d'Elm formulée par Anders Hovmöller en 2016, selon qui il manque des éléments clés à ce langage pour qu'il soit vraiment utile : https://medium.com/@boxed/a-small-dive-into-and-rejection-of-elm-8217fd5da235
• Texte émotif de Kasey Speakman en 2018, pour qui l'avènement de la version 0.19 du langage Elm fut un « brise-coeur » : https://dev.to/kspeakman/elm-019-broke-us--khn
• En 2020, Luke Plant quitte Elm et explique pourquoi : https://lukeplant.me.uk/blog/posts/why-im-leaving-elm/

Elvish

Auteur : Qi Xiao

À l'image de bash, à la fois un langage de programmation et un environnement interactif

• https://elv.sh/
• https://elv.sh/blog/

Emerald

Auteurs : Andrew P. Black, Norman C. Hutchinson, Eric B. Jul et Henry M. Levy

Un langage OO porté sur la conception de systèmes répartis.

• L'histoire de ce langage : http://www.emeraldprogramminglanguage.org/
• https://emeraldlang.github.io/emerald/
• https://en.wikipedia.org/wiki/Emerald_(programming_language)
• https://github.com/emeraldlang/emerald

Emoticon

Auteur : Michael Champanis

Un langage étrange basé sur... des émoticônes!

• http://www.teuton.org/~stranger/code/emoticon/emoticon.html

Enchilada

Auteur : Robbert van Dalen

Ce langage est un projet de recherche reposant sur la prémisse que l'information est indestructible, donc que les données sont immuables.

• http://www.enchiladacode.nl/

EnerJ

Auteur : Adrian Sampson

Un langage basé sur Java mais avec pour principal objectif de réduire la consommation énerg¸étique sur l'appareil en ex¸écutant les programmes.

• http://homes.cs.washington.edu/~asampson/blog/enerj.html
• http://spectrum.ieee.org/computing/software/enerj-the-language-of-goodenough-computing

Enterprise

Auteur : Juan Lulkin

Langage étrange, non déterministe et (selon son auteur) trop statiquement typé, destiné à avoir un effet disruptif sur les marchés

• https://github.com/joaomilho/Enterprise

Entropy

Auteur : Daniel Temkin

Langage étrange mettant l'accent sur la décrépitude des données...

• http://esolangs.org/wiki/Entropy
• http://danieltemkin.com/Entropy.aspx

EO

Auteur : Yegor Bugayenko

Langage orienté objet, qui se veut « le futur des langages orientés objets ».

• https://github.com/yegor256/eo/blob/master/README.md

Epigram

Auteurs : Connor McBride et James McKinna

Un langage fonctionnel expérimental, utilisant des types dépendants.

• http://www.e-pig.org/
• http://www.e-pig.org/epilogue/
• http://en.wikipedia.org/wiki/Epigram_%28programming_language%29

Epoch

Auteur : Mike Lewis

Langage axé sur le parallélisme pour la pleine utilisation d'ordinateurs à plusieurs processeurs ou à plusieurs coeurs.

• http://code.google.com/p/epoch-language/
• http://www.gamedev.net/blog/355/entry-2254112-the-making-of-epoch-part-1-why/
• http://www.gamedev.net/blog/355/entry-2254125-the-making-of-epoch-part-2-wtf/
• En 2013, le langage migre vers une implémentation native grâce à LLVM : https://code.google.com/p/epoch-language/wiki/GarbageCollectionScheme
• https://code.google.com/p/epoch-language/wiki/SelfHostingProject

Erasmus

Auteurs : Peter Grogono et Brian Shearing

Langage orienté vers les processus concurrents en interaction.

• http://users.encs.concordia.ca/~grogono/Erasmus/erasmus.html
• http://users.encs.concordia.ca/~grogono/Erasmus/mecref.pdf
• http://users.encs.concordia.ca/~grogono/Erasmus/E01.pdf

Eriskay

Auteurs : John Longley et Nicholas Wolverson

Un langage OO fortement typé, basé sur la sémantique des jeux.

• http://homepages.inf.ed.ac.uk/jrl/Research/eriskay-galop.pdf

Erlang

Auteurs : Joe Armstrong et Michael Williams

Langage fonctionnel axé sur la communication à partir d'un paradigme d'acteurs, et avec accent sur la résilience et sur la tolérance aux pannes.

Essentiels : ../Sujets/Divers--erlang/pedagogie.html#essentiel

Dialectes et implémentations particulières : ../Sujets/Divers--erlang/pedagogie.html#dialectes

Idées et opinions : ../Sujets/Divers--erlang/pedagogie.html#idees_opinions

Critiques : ../Sujets/Divers--erlang/pedagogie.html#critiques

Technique : ../Sujets/Divers--erlang/pedagogie.html#technique

Machine virtuelle ERTS : Machines-virtuelles--Liens.html#erts

Escher

Auteur : Petar Maymounkov

Langage qui ne prétend pas décrire une machine de Turing, préconisant plutôt la programmation par urgences et disparitions d'événements, ou « programmation par métaphores pures ».

• https://github.com/gocircuit/escher
• http://www.maymounkov.org/memex/abstract
• Programmer avec Escher : https://mapio.github.io/programming-with-escher/

Eve

Auteur : Joshua Cole

Langage de programmation « destiné aux humains ».

• http://programming.witheve.com/
• http://programming.witheve.com/deepdives/whateveis.html
• Selon Liron Shapira en 2016, Eve permet d'unifier plusieurs aspects de la programmation : https://hackernoon.com/how-eve-unifies-your-entire-programming-stack-900ca80c58a7

Ezhil

Auteur : Muthiah Annamalai

Langage de programmation impératif, qui permet de programmer à l'aide de caractères et de mots Tamil.

• https://en.wikipedia.org/wiki/Ezhil_%28programming_language%29

F

Auteur : Stevan Apter

Extension concaténative et fonctionnelle du langage False.

• http://www.nsl.com/k/f/f.htm

Factor

Auteur : Slava Pestov

Langage concaténatif, représentant les programmes comme une série de mots (de fonctions) manipulant une pile de références à des valeurs dynamiquement typées.

• http://www.factorcode.org/
• http://en.wikipedia.org/wiki/Factor_%28programming_language%29
• http://factor-language.blogspot.com/
• http://jedahu.blogspot.com/2010/08/why-i-like-factor.html
• Introduction à Factor, un tutoriel par Andrea Ferretti en 2014 : http://andreaferretti.github.io/factor-tutorial/

En particulier :

• http://factor-language.blogspot.com/2007/08/mixins.html
• http://factor-language.blogspot.com/2009/05/factor-vm-ported-to-c.html
• http://factor-language.blogspot.com/2009/05/factors-implementation-of-polymorphic.html
• http://factor-language.blogspot.com/2010/01/how-factor-implements-closures.html
• http://factor-language.blogspot.com/2010/01/replacing-gnu-assembler-with-factor.html
• http://factor-language.blogspot.com/2010/04/switching-call-stacks-on-different.html
• http://factor-language.blogspot.com/2010/07/overhauling-factors-c-library-interface.html

Articles techniques :

• http://www.bluishcoder.co.nz/2006/10/factor-parser-combinator-example.html
• http://useless-factor.blogspot.com/2009/10/bitfields-in-factor-structs-and-special.html
• http://useless-factor.blogspot.com/2010/01/type-feedback-in-factor.html
• http://re-factor.blogspot.com/2010/04/what-time-is-it-part-1.html
• La bibliothèque d'entrées/ sorties : http://factor-language.blogspot.com/2010/09/overview-of-factors-io-library.html
• http://re-factor.blogspot.com/2010/10/presentations-in-factor.html
• Transformer du texte en un document PDF : http://re-factor.blogspot.com/2010/10/text-to-pdf.html
• Implémenter du Port Knocking : http://re-factor.blogspot.com/2011/02/port-knocking.html
• Produire des graphiques de manière interactive avec Factor : http://re-factor.blogspot.com/2011/03/google-charts.html
• Grouper des éléments d'une séquence selon un critère : http://re-factor.blogspot.com/2011/04/group-by.html
• L'implémentation (intéressante) de printf en Factor : http://re-factor.blogspot.com/2011/08/printf.html
• écrire un Thesaurus en Factor : http://re-factor.blogspot.com/2011/08/thesaurus.html
• Manipuler des fichiers avec Factor : http://re-factor.blogspot.com/2011/09/manipulating-files.html
• écrire une machine à sous en mode console avec Factor, par John Benediktsson en 2011 : http://re-factor.blogspot.com/2011/12/slot-machines.html
• Trouver des mots qui peuvent être écrits à partir de noms de symboles dans le tableau périodique, par John Benediktsson en 2011 : http://re-factor.blogspot.com/2011/12/elementology.html
• Optimiser les calculs sur les gros rationnels, par John Benediktsson en 2012 : http://re-factor.blogspot.ca/2012/04/faster-big-ratios.html

Critiques :

• En 2018 (du moins, je présume), Andrew Owen jette un regard extrêmement positif sur Factor : https://www.junglecoder.com/blog/factorlang-review

Falcon

Auteur : Giancarlo Niccolai

Langage destiné à une machine virtuelle, qui se veut multiparadigme.

• Site officiel : http://falconpl.org/
• Un Wiki sur le langage : http://en.wikipedia.org/wiki/Falcon_%28programming_language%29
• Histoire du langage : http://www.computerworld.com.au/article/298655/a-z_programming_languages_falcon

False

Auteur : Wouter van Oormerssen

Langage concaténatif se voulant très simple. programmation_concatenative

• http://strlen.com/false-language
• http://strlen.com/false/false.txt

Fancy

Auteur : Christopher Bertels

Langage sémantiquement proche de Ruby et syntaxiquement proche de Smalltalk.

• http://www.fancy-lang.org/
• http://www.ohloh.net/p/fancy
• https://launchpad.net/~christopher-bertels/+archive/fancy-lang/
• http://www.adztec-independent.de/2010/03/new-project-the-fancy-programming-language/

Fantom

Auteur : Brian Frank et Andy Frank.

Langage OO destiné à être compilé pour plusieurs machines virtuelles, dont le CLR et la JVM.

• http://fantom.org/
• http://www.drdobbs.com/tools/229218754
• Évaluer Fantom, selon Stephen Colebourne en 2011 : http://blog.joda.org/2011/11/guide-to-evaluating-fantom.html

Feather

Auteur : Brian Edds (pas sûr du nom)

Langage qui n'a pas recours au tas (Heap), dans le but de permettre de réaliser des programmes pour systèmes à faibles ressources (comme par exemple des systèmes embarqués) par programmation fonctionnelle.

• http://lambda-the-ultimate.org/node/4512

Felix

Auteurs : John Skaller et Erick Tryzelaar

Langage de script « le plus rapide au monde » (selon ses auteurs).

• http://felix-lang.org/
• http://en.wikipedia.org/wiki/Felix_%28programming_language%29
• https://github.com/felix-lang/felix
• http://felix-documentation-master.readthedocs.io/en/latest/

Fexl

Auteur : Patrick Chkoreff

Langage fonctionnel, basé sur des fonctions dites pures, donc sans effets de bord.

• http://fexl.com/
• http://www.fexl.com/basics

Finch

Auteur : Robert Nystrom

Langage OO inspiré de Smalltalk, Self et JavaScript.

• http://finch.stuffwithstuff.com/
• http://journal.stuffwithstuff.com/category/finch/
• http://journal.stuffwithstuff.com/2010/07/24/killing-primitive-loops-and-conditionals/

FL

Auteurs : John Backus, John Williams et Edward Wimmers.

Langage fonctionnel (FL signifie Function Level). A inspiré le langage J.

• http://en.wikipedia.org/wiki/FL_programming_language

Flash

Auteur : des gens de Macromedia (maintenant Adobe)

Langage qui est en fait une plateforme de développement multimédia axée vers le Web. Son langage de script est ActionScript, mais on y trouve aussi Flex.

• http://en.wikipedia.org/wiki/Adobe_Flash
• http://news.cnet.com/As-Flash-turns-10,-Adobe-looks-ahead/2100-1012_3-6102973.html?tag=nefd.top
• http://blogs.adobe.com/open/2010/02/following_the_open_trail.html
• http://blogs.adobe.com/jd/2010/03/_the_fundamental_things_apply.html
• http://www.computerworld.com/s/article/9180776/Web_multimedia_6_reasons_why_Flash_isn_t_going_away
• Vingt-cinq raisons de dire non (article de 2002) : http://patrick.murris.com/articles/flash25.htm
• Utiliser Flash « sans Flash » en vue des iPhone et des iPad, malgré les restrictions d'Apple :
  • http://blogs.computerworld.com/18922/adobe_brings_flash_free_flash_to_apple_ipad_iphone
  • http://eon.businesswire.com/news/eon/20110907007466/en/Adobe/IBC/Flash-Media-Server
• Le Web est-il plus lisible sans Flash? Un texte de Pietro Polsinelli en 2011 : http://pietro.open-lab.com/2011/09/26/without-flash-the-web-is-more-readable/

Ça semble être la fin pour Flash, en 2011 (au moins pour les appareils mobiles) :

• http://www.zdnet.com/blog/perlow/exclusive-adobe-ceases-development-on-mobile-browser-flash-refocuses-efforts-on-html5-updated/19226
• http://blogs.adobe.com/conversations/2011/11/flash-focus.html
• http://www.bbc.co.uk/news/technology-15648899
• http://blog.deconcept.com/2011/11/12/flash-is-dead-long-live-the-internet/
• Un mouvement pour se débarrasser de Flash : http://occupyflash.org/
• Il faut mettre cela en perspective, selon Ben Garney en 2011 : http://blog.bengarney.com/2011/11/21/flash-player-a-declining-asset/
• La plateforme Flash serait mourante, selon Tim Anderson en 2011 : http://www.itjoblog.co.uk/2011/11/dying-platforms.html
• Et un autre, en 2013 : http://blogs.unity3d.com/2013/04/23/sunsetting-flash/
• Les voix se font encore plus insistantes en 2015, avec la désactivation d'office de Flash dans certains fureteurs, comme le rapporte Dan Rowinski : http://arc.applause.com/2015/07/14/flash-vulnerability-html5-replacement/
• Les impacts de la mort de Flash sur les fournisseurs de contenu, par Vijay Balan en 2015 : http://techcrunch.com/2015/08/23/farewell-to-flash-what-it-means-for-digital-video-publishers/
• En 2016, Dave Yin spécule que la mort maintes fois annoncée de Flash surviendra dans l'année en cours : http://www.itworldcanada.com/article/will-flash-be-dead-by-end-of-2016/383347
• Vers la fin 2016, Chrome commencera à bloquer Flash, comme l'indique cet article de Jacob Kastrenakes : http://www.theverge.com/2016/5/15/11679394/chrome-to-block-flash-later-2016 (c'est officiel, à partir de la version 53 : https://www.engadget.com/2016/08/09/google-chrome-blocking-flash/)
• Adobe ne supportera plus Flash à partir de 2020. Dans cet article de 2017, David Robinson examine la suite des choses, incluant les prochains langages susceptibles de disparaître : https://stackoverflow.blog/2017/08/01/flash-dead-technologies-might-next/
• En 2020, même le site d'Adobe cesse de supporter Flash : https://www.adobe.com/products/flashplayer/end-of-life.html#

Technique :

• Contrôler des composants Flash avec C++ (article du Code Project) : http://www.codeproject.com/KB/COM/flashcontrol.aspx

Flex

Auteur : Adobe

Langage axé sur le développement de clients riches pour le Web.

• http://flex.org/
• http://flex.org/what-is-flex
• http://en.wikipedia.org/wiki/Adobe_Flex
• http://www.artima.com/articles/bend_your_pixels.html

Critiques :

• http://yanivg.blogspot.com/2007/02/why-i-dont-get-adobe-flex.html

Flix

Auteurs : Ondřej Lhoták, Magnus Madsen et quelques autres

Langage fonctionnel et logique, qui se présente comme une sorte de « SQL sur stéroïdes »

• https://flix.dev/
• http://flix.github.io/
• http://flix.github.io/doc/

Flobnar

Auteur : Chris Sperrey

Langage étrange, construit de manière à être aussi difficile à compiler que possible. Version fonctionnelle de Befunge.

• https://github.com/catseye/Flobnar

Flow

Auteur : une équipe chez Area9.

Langage fonctionnel ayant un penchant pour la production d'interfaces Web.

• La raison d'être de Flow, de l'avis d'Asger Palm en 2019 : https://flow9.org/2019/04/26/why.html

FORMAC

Auteure : Jean E. Sammet

Langage de manipulation symbolique, inspiré de Fortran

• https://en.wikipedia.org/wiki/FORMAC_(programming_language)

Forth

Auteur : Charles H. Moore.

Un langage minimaliste axé sur le développement de mots et leur agencement. Mieux connu dans le monde des systèmes embarqués.

• http://www.computerworld.com.au/article/250530/-z_programming_languages_forth/
• http://en.wikipedia.org/wiki/Forth_%28programming_language%29
• Un manuel en ligne : http://home.iae.nl/users/mhx/sf.html
• Une livre en ligne de près de 200 pages, par Stephen Pelc : http://www.mpeforth.com/arena/ProgramForth.pdf?_
• Penser en Forth : http://thinking-forth.sourceforge.net/
• Apprendre Forth, par Nick Morgan en 2015 : http://skilldrick.github.io/easyforth/
• Automates à états finis en Forth : http://dec.bournemouth.ac.uk/forth/jfar/vol7/paper1/paper.html
• http://www.forth.org/fd/FDcover.html
• http://www.retroprogramming.com/2011/03/efficiency-in-forth.html
• http://www.forth.org/lost-at-c.html
• Un (long) essai de l'auteur du langage, datant de 1970, nommé Programming in a Problem-Oriented Language et qui donne un aperçu de sa philosophie : http://www.colorforth.com/POL.htm
• Une expérience personnelle de Forth et des machines à piles : http://www.yosefk.com/blog/my-history-with-forth-stack-machines.html
• Penser en Forth, par James Hague en 2008 : http://prog21.dadgum.com/33.html?_
• Un tout petit interpréteur pour un sous-ensemble de Forth, par John Metcalf en 2012 : http://www.retroprogramming.com/2012/09/itsy-documenting-bit-twiddling-voodoo.html
• Appliquer la méthodologie de Forth à la programmation en général, par Jeff Fox en 2001 : http://www.ultratechnology.com/method.htm
• En 2015, Phil Eaton propose une initiation à la programmation à l'aide d'une pile avec Forth : http://blog.eatonphil.com/2015/04/06/introduction-to-stack-based-languages-with-and-elementary-debugging-in-forth/
• Construire un Forth pour une architecture inhabituelle, texte de 2015 : https://moonforth.github.io/
• Quelques sujets avancés en programmation avec Forth : http://www.mosaic-industries.com/embedded-systems/sbc-single-board-computers/freescale-hcs12-9s12-c-language/instrument-control/forth-language-program-development
• Dans ce texte de 2016, Rick Carlino décrit Forth comme une expérience d'apprentissage : http://rickcarlino.com/2016/11/03/forth-as-a-learning-experience/
• En 2017, Elliot Williams décrit Forth comme le langage idéal pour les hackers : http://hackaday.com/2017/01/27/forth-the-hackers-language/
• Felix Winkelmann expose sa compréhension de la philosophie derrière Forth : http://www.call-with-current-continuation.org/articles/forth.txt

Outils :

• La plateforme 8th, pour écrire du code Forth multiplateforme : https://community.arm.com/iot/embedded/b/embedded-blog/posts/8th-a-gentle-introduction-to-a-modern-forth
• Le compilateur waforth, un compilateur Forth pour WebAssembly, présenté par Remko Tronçon en 2018 : https://el-tramo.be/blog/waforth/
• https://forth.retro-os.live/

Fortran

Voir Langages/Fortran--Liens.html

Fortress

Auteur : Guy Steele et plusieurs amis du Programming Language Research Group

Langage présenté à l'origine comme un Java pour scientifiques, avec des facilités de calcul puissantes et une syntaxe plus proche de celle rencontrée dans le monde des mathématiques. Beaucoup d'idées novatrices ici. Un projet extrêmement intéressant, mais qui est désormais clos...

• http://projectfortress.sun.com/Projects/Community
• http://projectfortress.sun.com/Projects/Community/blog
• http://projectfortress.sun.com/Projects/Community/blog/ObjectOrientedTailRecursion
• http://labs.oracle.com/minds/2005-0302/
• http://lambda-the-ultimate.org/node/673
• http://lambda-the-ultimate.org/node/574
• http://labs.oracle.com/projects/plrg/fortress.pdf (mais, par intérêt historique, vous pouvez aussi regarder http://labs.oracle.com/projects/plrg/fortress0618.pdf)
• Polymorphisme à plusieurs racines (multiméthodes) et fondements théoriques : http://www.mpi-sws.org/~skilpat/papers/multipoly-ecoop.pdf
• Le projet de recherche que fut Fortress fut fermé en 2012, bien que le tout demeure disponible en format à code ouvert pour étude, consultation et expérimentation. à cet effet, un texte de Guy Steele : https://blogs.oracle.com/projectfortress/entry/fortress_wrapping_up

FP

Auteur : John Backus.

Langage fonctionnel (FP signifie Function Programming). Ancêtre du langage FL.

• http://en.wikipedia.org/wiki/FP_programming_language

Free

Auteur : Adam McDaniel

Dans les mots (paraphrasés) de son auteur, Free est « un langage terrible qui vise la génération de code dans un langage encore pire ». En Free, il est possible d'écrire à n'importe quel endroit en mémoire, ce qui rend certains types de plantage presque impossibles.

• https://github.com/adam-mcdaniel/free

Frege

Auteur : Ingo Wechsung

Langage fonctionnel inspiré par Haskell, dont le fruit de la compilation est destiné à la JVM.

• https://github.com/Frege/frege
• http://fregepl.blogspot.ca/
• https://github.com/Frege/frege/wiki/_pages
• Présentation du langage par Ingo Wechsung en 2013 : http://files.meetup.com/4530082/Introduction%20Frege.pdf
• Écrire un serveur Web avec Frege, texte de 2016 par Michael Chavinda : http://mchav.github.io/a-simple-server-in-frege/

Frenetic

Auteurs : Walter Robert J. Harrison, Nate Foster et un groupe de travail.

Langage de programmation orienté réseau, et offrant des abstractions primitives en ce sens.

• http://www.frenetic-lang.org/
• http://ecommons.library.cornell.edu/bitstream/1813/19310/4/frenetic-tr.pdf
• http://frenetic-lang.org/papers/harrison-mse-thesis.pdf

Frink

Auteur : Alan Eliasen

Langage proposant une nouvelle métaphore de calcul et de manipulation d'unités de mesure. Ça semble très intéressant comme truc.

• http://futureboy.homeip.net/frinkdocs/
• http://en.wikipedia.org/wiki/Frink
• http://freshmeat.net/projects/frinklang/

Fun

Auteur : Marcus Westin

Langage destiné à la génération en temps réel de documents pour le Web, un peu comme l'est PHP.

• http://github.com/marcuswestin/fun
• http://marcuswest.in/read/fun-intro/

FunLOFT

Langage axé sur la concurrence.

• http://www-sop.inria.fr/mimosa/rp/FunLoft/index.html

fun4j

Auteur : Thomas Mahler

Un langage fonctionnel (une variante de Lisp) dont les programmes sont destinés à être exécutés sur la JVM et à s'intégrer harmonieusement avec les outils Java.

• http://www.fun4j.org/
• http://sourceforge.net/projects/jlambda/

Funnel

Auteur : Martin Odersky

Langage basé sur les Functional Nets, mélange de programmation fonctionnelle et de réseaux de Pétri.

• http://lampwww.epfl.ch/funnel/
• http://lampwww.epfl.ch/~odersky/papers/esop2000.html

Futhark

Auteurs : Troels Henriksen et Cosmin E. Oancea (entre autres)

Langage fonctionnel visant à générer du code destiné à une exécution parallèle sur un GPU

• http://futhark-lang.org/
• https://thelasttechie.com/2016/05/01/futhark-language-can-generate-c-andor-python-code/
• https://futhark-lang.org/blog/2018-01-28-how-futhark-manages-gpu-memory.html

F#

Auteur : Don Syme.

Langage fonctionnel visant la plateforme .NET.

• Le Wiki : http://en.wikipedia.org/wiki/F_Sharp_programming_language
• Un « Wikilivre » : http://en.wikibooks.org/wiki/F_Sharp_Programming
• Livre en ligne : https://www.gitbook.com/book/swlaschin/fsharpforfunandprofit/details
• Livre en ligne de Robert Pickering : https://www.syncfusion.com/resources/techportal/ebooks/fsharp
• http://tiny-giant-books.com/blog/f-tips/
• Une fondation pour assurer la promotion de F# : http://fsharp.org/
• Aborder la plateforme .NET d'une perspective F#, par Jacqueline Homan en 2016 : https://www.pluralsight.com/blog/software-development/tutorial-f-sharp
• Un guide pour comprendre le compilateur F# : https://fsharp.github.io/2015/09/29/fsharp-compiler-guide.html
• Les spécifications officielles de F# :
  • version  2.0 : http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec-2.0-final.pdf
  • version  3.0 : http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.pdf
• Pourquoi F#?
  • la vision de Joel Pobar, en 2009 : http://callvirt.net/blog/post/Why-F-%28TechEd-09-DEV450%29.aspx
  • la vision de Dave Fancher en 2013 : http://davefancher.com/2013/01/27/why-f/
• Rédiger un interpréteur Scheme en F# : http://blogs.msdn.com/b/ashleyf/archive/2010/01/15/fscheme-0-0-0.aspx
• http://www.simple-talk.com/opinion/geek-of-the-week/don-syme-geek-of-the-week/
• http://www.theregister.co.uk/2010/04/19/microsoft_f_sharp/
• Un blogue de trucs de programmation dans ce langage : http://fsharpcode.blogspot.com/
• Guide de survie avec F# : http://www.ctocorner.com/fsharp/book/
• Petit défi de programmation : http://richardminerich.com/2010/04/the-ted-neward-f-folding-challenge/
• Fonctions en tant que valeurs : http://msdn.microsoft.com/en-us/library/dd233158.aspx
• Formater les sources pour le Web : http://tomasp.net/articles/fswebsnippets-intro.aspx
• à propos des performances atteintes avec F# sur une XBox 360 : http://sharp-gamedev.blogspot.com/2010/12/on-performance-of-f-on-xbox-360.html
• http://bartoszmilewski.wordpress.com/2011/01/05/using-f-sequences-and-pipelines/
• Champs d'application : http://blogs.msdn.com/b/dsyme/archive/2011/01/12/f-for-energy-trading-and-energy-portfolio-optimization.aspx
• Simulations physiques en F# : http://fixplz.blourp.com/blog/=phys
• Mots clés et syntaxe de base du langage : http://lorgonblog.wordpress.com/2009/02/08/the-basic-syntax-of-f-keywords-and-constructs/
• http://tomasp.net/blog/fsharp-variations-joinads.aspx
• Définir un langage à pile à même F# : http://blogs.msdn.com/b/ashleyf/archive/2011/04/21/programming-is-pointless.aspx
• Mêler du code F# et du code C# : http://www.voyce.com/index.php/2011/05/09/mixing-it-up-when-f-meets-c/
• Remplacer des goto par des appels récursifs mutuels : http://sharp-gamedev.blogspot.com/2011/08/forgotten-control-flow-construct.html
• Programmer avec des séquences asynchrones en F# : http://tomasp.net/blog/async-sequences.aspx
• Les Tail Calls en F# : http://blogs.msdn.com/b/fsharpteam/archive/2011/07/08/tail-calls-in-fsharp.aspx
• En 2012, Francesco De Vittori relate ses expériences avec F# sur ce qu'il qualifie de « vrais projets » :
  • http://www.frenk.com/2012/01/real-world-f-my-experience-part-one/
  • http://www.frenk.com/2012/01/real-world-f-my-experience-part-two/
• En 2012, Michael Perkins présente son exploration personnelle de F# : http://graybeardprogrammer.com/?p=1
• Consommer un fichier binaire avec F#, par Luis Diego Fallas en 2012 : http://langexplr.blogspot.ca/2008/10/using-f-computation-expressions-to-read.html
• Fournisseurs de types :
  • texte d'Ivan Towlson en 2011 : http://www.mindscapehq.com/blog/index.php/2011/09/19/f-type-providers-as-if-by-magic/
  • présentation de Don Syme, en 2013 : http://blogs.msdn.com/b/dsyme/archive/2013/01/30/twelve-type-providers-in-pictures.aspx
• Programmation Stateful avec F#, un texte de Matthew Manela en 2013 : http://matthewmanela.com/blog/functional-stateful-program-in-f/
• Apprentissage automatique avec F# : http://fsharp.org/machine-learning/
• En 2013, Simon Tyler Cousins émet l'opinion que les bogues n'aiment pas F# : http://www.simontylercousins.net/journal/2013/3/7/why-bugs-dont-like-f.html
• Les monoïdes en F#, selon Scott Wlaschin en 2013 : http://fsharpforfunandprofit.com/posts/monoids-without-tears/
• Le Pattern Matching en F# :
  • texte du Code Project par Sacha Barber en 2014 : http://www.codeproject.com/Articles/764649/Fsharp-Pattern-Matching
  • texte de Steve Shogren en 2014 montrant en quoi cette mécanique permet d'alléger l'écriture des programmes : http://deliberate-software.com/function-pattern-matching/
  • texte d'Ankit Solanki en 2014, qui met l'accent sur le côté sécuritaire de cette approche : http://blog.cleartax.in/safer-programming-with-fsharp-pattern-matching/
• Utiliser F# avec Xamarin, une plateforme .NET à code ouvert : http://developer.xamarin.com/guides/cross-platform/fsharp/fsharp_support_overview/
• Explication du Currying et de l'application partielle de fonctions avec F#, par Ankit Solanki en 2014 : http://blog.cleartax.in/fsharp-functions-explained-currying-and-partial-application/
• Texte de Jef Claes en 2015 sur l'étude statistique, à l'aide de F#, des caractéristiques de temps de réponse d'un service Web : http://www.jefclaes.be/2015/01/averages-are-not-good-enough-f.html
• Quelques mauvaises habitudes que les programmeuses et les programmeurs F# n'ont pas, selon Yan Cui en 2015 : https://www.airpair.com/f%23/tips-n-tricks/seven-ineffective-coding-habits-many-fsharp-programmers-dont-have
• Utiliser le système de types de F# pour réaliser du Domain-Driven Design, présentation par Scott Wlaschin en 2015 : http://fr.slideshare.net/ScottWlaschin/domain-driven-design-with-the-f-type-system-functional-londoners-2014
• Quelques trucs chouettes à propos de F#, rapportés par Robin Ridderholt en 2015 : http://www.myeyeson.net/nifty-things-in-f/
• Tester un programme écrit en F#, par Scott Wlaschin en 2015 : http://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-3/
• Penser de manière non-linéaire pour profiter de CUDA avec F#, un texte de Boris Kogan en 2015 : http://viralfsharp.com/2015/09/08/non-linear-thinking-with-cuda/
• Ce qui s'annonce pour F# 4.1 : https://blogs.msdn.microsoft.com/dotnet/2016/07/25/a-peek-into-f-4-1/
• Texte de 2016 qui spécule que F# soit le langage idéal pour fouiller dans le Web : http://biarity.me/2016/11/23/Why-F-is-the-best-langauge-for-web-scraping/
• En 2017, Jonathan Banashek donne un exemple de ce qu'il nomme les « applications universelles » en F# : http://banashek.com/posts/20170204-a-brief-peek-at-universal-fsharp.html
• Dans ce texte de 2017, Eirik Tsarpalis décrit le style de programmation Point-Free, où les programmes sont des compositions de fonctions : https://eiriktsarpalis.wordpress.com/2017/04/02/programming-in-the-point-free-style/
• Survol de F# 4.1, par Jonathan Allen en 2017 : https://www.infoq.com/articles/FSharp-4.1
• Appliquer des techniques OO savec F#, texte de 2017 par Edgar Sánchez : https://medium.com/@edgarsanchezg/f-is-a-first-functional-language-but-being-multi-paradigm-it-can-handle-classes-objects-fd9ede7a2cc9

Critiques :

• Bien que ce ne soit pas une critique en soi, en 2012, Frederik Holmström explique qu'il retirera de la base de code d'IronJS ce qu'il reste de code F# pour ne conserver que du code C#, et décrit les raisons de ce choix : http://ironjs.wordpress.com/2012/04/19/why-not-f/
• À propos de la difficulté de faire accepter F# par une entreprise, par Daniel Tuppeny en 2014 : http://blog.dantup.com/2014/04/is-fsharp-ready-for-production/
• Ce qui manque à F# pour devenir un langage prédominant sur la plateforme .NET, selon Eric Sink en 2015 : http://ericsink.com/entries/fsharp_chasm.html
• En 2016, Chris Davies soulève la question « Pourquoi F# n'est-il pas le "roi de la plateforme .NET"? » : https://hackernoon.com/why-isnt-f-the-king-of-net-2a9a1963e087
• En 2017, Tom Prior se dit conquis par F# : http://www.prigrammer.com/?p=363

F*

Auteurs : Nikhil Swamy, Juan Chen, Cedric Fournet, Pierre-Yves Strub, Karthikeyan Bharagavan, et Jean Yang

Langage basé sur F# et inspiré de ML mais axé vers la programmation sécuritaire de systèmes répartis.

• http://research.microsoft.com/en-us/projects/fstar/
• http://research.microsoft.com/apps/mobile/showpage.aspx?page=/en-us/projects/fstar/
• https://github.com/nikswamy/FStar
• Le Typestate-Oriented Programming avec F*, un texte de 2017 par Olle Harstedt : http://olleharstedt.github.io/fstar/2017/01/12/typestate-in-fstar.html

F3

Auteur : Chris Oliver

Le nom signifie Form Follow Function. Langage axé vers le développement d'interfaces personne/ machine.

• http://blogs.sun.com/chrisoliver/entry/f3
• http://blogs.sun.com/chrisoliver/resource/f3.html
• http://blogs.sun.com/chrisoliver/entry/more_f3_demos

Gambas

Auteur : Benoît Minisini

Ce langage se présente comme presque Basic, mais sans être un clone de Basic.

• Site officiel : http://gambas.sourceforge.net/en/main.html
• Un Wiki sur ce langage : http://en.wikipedia.org/wiki/Gambas
• Documentation officielle sur le langage : http://gambasdoc.org/help/

GEC

Auteurs : Microsoft Research

Un DSL axé sur l'ingénierie de cellules vivantes.

• http://research.microsoft.com/en-us/projects/gec/

Glass

Auteur : Gregor Richards

Langage étrange conçu pour que sa syntaxe, en particulier sa notation postfixée, soit si étrange que personne n'oserait s'en servir.

• https://esolangs.org/wiki/Glass

Glitch

Auteurs : Sean McDirmid et Jonathan Edwards

Langage où le temps et pris en charge, pour donner une impresssion de simultanéité.

• http://research.microsoft.com/en-us/people/smcdirm/managedtime.aspx
• http://research.microsoft.com/apps/pubs/default.aspx?id=226574

Go

Auteurs : Robert Griesemer, Rob Pike and Ken Thompson et plusieurs autres...

Un dérivé lointain de C, fait par des gens de chez Google, avec des idées plutôt intéressantes...

Liens d'ordre général sur le langage : ../Sujets/Divers--go/index.html

Culture et pédagogie : ../Sujets/Divers--go/pedagogie.html

Critiques : ../Sujets/Divers--go/pedagogie.html#critiques

Golo

Auteur : Julien Ponge

Langage dynamique dont les programmes s'exécutent sur la JVM.

• http://golo-lang.org/
• http://golo-lang.org/documentation/next/
• http://golo-lang.org/news/2013/12/18/golo-0-preview10/

Goo

Auteur : Jonathan Bachrach

Langage OO et dynamique. Dérivé de Scheme et de Dylan.

• http://people.csail.mit.edu/jrb/goo/manual/goomanual.html
• http://people.csail.mit.edu/jrb/goo/why.htm

Gosu

Auteur : Scott McKinney

Langage OO reposant sur la JVM.

• http://gosu-lang.org/
• http://gosu-lang.org/doc/wwhelp/wwhimpl/api.htm?&context=gosu&src=intro&topic=Welcome_to_Gosu

Grain

Auteur : Oscar Spencer

Langage d'inspiration fonctionnelle, conçu pour être compilé en WebAssembly

• hhttps://grain-lang.org/
• https://github.com/grain-lang
• https://grain-lang.org/docs/

Gravity

Auteur : Marco Bambini

Langage « embarqué » qui repose sur une machine virtuelle à registres.

• https://creolabs.com/gravity
• https://marcobambini.github.io/gravity/#/

Groovy

Auteur : James Strachan

Un langage dynamique compilé pour la JVM.

• http://groovy.codehaus.org/
• http://en.wikipedia.org/wiki/Groovy_%28programming_language%29
• Créer un DSL avec Groovy : http://www.artima.com/weblogs/viewpost.jsp?thread=291467
• Du 3D avec Groovy : http://www.artima.com/weblogs/viewpost.jsp?thread=294361
• http://www.artima.com/weblogs/viewpost.jsp?thread=296081
• Trouver le bon seuil d'abstraction : http://mostmedia.com/blogs/tempus-fugit
• Bien programmer en Groovy :
  • http://canoo.com/blog/2010/06/04/slimmed-down-software-a-lean-groovy-approach-part-1-eliminate-waste/
  • http://canoo.com/blog/2010/07/05/slimmed-down-software-a-lean-groovy-approach-part-2-build-quality-in/
  • http://canoo.com/blog/2010/08/12/slimmed-down-software-a-lean-groovy-approach-part-3-create-knowledge/
• Programmer de manière productive avec Groovy, selon Sg Ganesh en 2013 : http://java.dzone.com/articles/productive-programming-groovy
• http://batsov.com/2011/05/06/jvm-langs-groovy.html
• Selon Andrew Montalenti en 2011, Groovy serait le Python de Java : http://www.pixelmonkey.org/2011/04/09/groovy-the-python-of-java
• La console de Groovy, texte de 2013 : http://forgetfulprogrammer.wordpress.com/2013/12/05/groovy-console-python-like-repl-for-java/
• Le Null Object « magique » de Groovy, par Michael Scharhag en 2013 : http://www.mscharhag.com/2013/11/groovys-magical-nullobject.html

Guile

Auteur : Neil Jerram et beaucoup d'autres.

Implémentation de Scheme, mais sans « gentil dictateur ». Le nom signifie GNU's Ubiquitous Intelligent Language for Extensions.

• http://www.gnu.org/software/guile/docs/master/guile.html/
• En 2013, Andy Wingo décrit une machine virtuelle destinée à Guile : http://wingolog.org/archives/2013/11/26/a-register-vm-for-guile
• Texte de 2014 par Andy Wingo à propos d'un style de programmation par continuations pour Guile : http://wingolog.org/archives/2014/01/12/a-continuation-passing-style-intermediate-language-for-guile
• En 2012, Rich Loveland relate son expérience dans la rédaction d'un premier script avec Guile : http://logicgrimoire.wordpress.com/2012/08/25/a-first-guile-script/

Gura

Auteur : Yutaka Saito

Langage OO où la programmation est orientée vers la manipulation d'itérateurs.

• http://www.gura-lang.org/

Guru

Auteur : Aaron Stump?

Un langage fonctionnel dont les programmes peuvent être vérifiés à la manière de preuves mathématiques.

• http://guru-lang.googlecode.com/svn/branches/1.0a/doc/book.pdf

H

Autrice : Christine Dodrill

Langage essentiellement inutile (ne fait que deux trucs, au moment d'écrire ceci, et les deux impliquent afficher la lettre 'h'), mais qui se veut un exercice de style.

• https://christine.website/blog/h-language-2019-06-30
• https://christine.website/blog/the-origin-of-h-2015-12-14
• https://christine.website/blog/formal-grammar-of-h-2019-05-19

Hack

Auteurs : Bryan O'Sullivan, Julien Verlaguet et Alok Menghrajani

Compétiteur direct de PHP, écrit en OCaml, ce langage vise à dynamiser le contenu des pages Web. S'exécute typiquement sur HHVM.

• http://hacklang.org/
• http://en.wikipedia.org/wiki/Hack_%28programming_language%29
• Présentation informelle, par Julien Verlaguet et Alok Menghrajani en 2014 : https://code.facebook.com/posts/264544830379293/hack-a-new-programming-language-for-hhvm/
• Texte de Cade Metz en 2014 : http://www.wired.com/wiredenterprise/2014/03/facebook-hack/

Halide

Auteur : Jonathan Ragan-Kelley?

Langage axé sur le traitement d'images et la photographie numérique.

• http://halide-lang.org/

Harlan

Auteur : Erik Holk

Langage déclaratif dont la syntaxe est inspirée de celle de Lisp. Axé sur la programmation pour le GPU.

• https://github.com/eholk/harlan
• http://blog.theincredibleholk.org/blog/2013/06/28/announcing-the-release-of-harlan/
• http://www.extremetech.com/computing/160367-new-programming-language-makes-turning-gpus-into-supercomputers-a-snap
• http://paritynews.com/software/item/1195-harlan-a-language-that-simplifies-gpu-programming-released

Harmony

Auteur : Benjamin C. Pierce

Un langage orienté vers les opérations bijectives et interreliées, à partir de lentilles... (voir aussi Boomerang)

• Site officiel : http://www.seas.upenn.edu/~harmony/
• Une description du problème fondamental que cherche à résoudre ce langage par son approche particulière : http://www.cis.upenn.edu/~bcpierce/papers/lenses-etapsslides.pdf

Haskell

Auteurs : Paul Hudak et Simon Peyton-Jones

Langage fonctionnel fortement typé et très en vogue. La qualité de son système de types est souvent citée en exemple, et il en va de même pour l'élégance du langage dans son ensemble.

J'ai localisé la plupart des liens sur ce langage dans une section à part entière :

• Apprendre ce langage : ../Sujets/Divers--haskell/pedagogie.html#pedagogie
• Critiques :../Sujets/Divers--haskell/pedagogie.html#critiques
• Monades :Paradigmes-programmation--Liens.html#monade

haXe

Auteurs : pas clair, mais sans doute des gens parmi http://haxe.org/com/people

Langage multiplateforme et à code ouvert.

• http://haxe.org/
• http://haxe.org/doc/intro
• http://haxe.org/doc/why
• http://haxe.org/doc
• http://lambdabrella.blogspot.com/2011/08/haxe-book-secret-weapon-under-spot.html
• haXe vu de très haut, en 2015 : http://notes.underscorediscovery.com/haxe-from-1000ft/
• haXe est-il pour vous? Texte de 2016 par Dan Korostelev : http://nadako.github.io/rants/posts/2016-07-22_is-haxe-for-you.html
• En 2018, les auteurs de FontStruct, un produit de génération de polices de caractères, relatent leur histoire d'amour avec le langage haXe : https://medium.com/@fontstruct/the-joy-of-haxe-84f933f4b859

Outils et produits :

• À propos de HxSL, le haXe Shader Language : http://ncannasse.fr/blog/announcing_hxsl
• Le moteur de jeu Heaps.io, qui repose sur haXe : https://heaps.io/

Heron2

Auteur : Christopher Diggins

Langage OO axé sur le développement à grande échelle.

• http://www.artima.com/weblogs/viewpost.jsp?thread=284558
• http://code.google.com/p/heron-language/
• http://www.artima.com/weblogs/viewpost.jsp?thread=285952
• réflexion statique : http://www.artima.com/weblogs/viewpost.jsp?thread=289749

Hilbert

Auteur : Kazuki Tanaka

Un langage orienté vers la résolution de problèmes mathématiques, et dont la syntaxe peut rappeler celle de T_EX

• http://hilbert-lang.org/

Hodor

Auteur : des gens de Hummingbird Technologies

Langage de programmation étrange, publié un 1^er avril (!), qui vise une syntaxe minimale. Suffit de voir les exemples pour le constater

• http://www.hodor-lang.org/
• http://www.hodor-lang.org/about.html

Hume

Auteurs : pas clair, mais je parierais sur Greg Michaelson et Kevin Hammond (avec une équipe, bien sûr)

Dans les mots de ses auteurs, « Hume (Higher-order Unified Meta-Environment) is a strongly typed, mostly-functional language with an integrated tool set for developing, proving and assessing concurrent, safety-critical systems ».

• http://www-fp.cs.st-andrews.ac.uk/hume/index.shtml

Humus

Auteur : Dale Schumacher

Un langage se disant purement basé acteurs.

• http://www.dalnefre.com/wp/humus/

Hy

Auteur : Paul Tagliamonte (entre autres)

Langage proche de Lisp mais vivant dans le monde de Python.

• http://docs.hylang.org/en/latest/
• http://fox.devport.no/?p=82
• https://github.com/hylang/hy
• Réflexion sur les raisons d'être de ce langage, par Colin M. Strickland en 2017 : https://beatworm.co.uk/blog/lisp/thoughts-about-hylang

HyperCard

Voir HyperTalk.

HyperTalk

Auteur : Dan Winkler

Langage de script, de type impératif, associé à la technologie HyperCard.

• http://en.wikipedia.org/wiki/HyperCard
• http://en.wikipedia.org/wiki/HyperTalk
• En 2002, Leander Kahney relate que HyperCard est disparu mais par oublié : http://www.wired.com/gadgets/mac/commentary/cultofmac/2002/08/54365
• En 2011, Stanislav (je n'ai pas trouvé son nom de famille) explique pourquoi, selon lui, HyperCard devait mourir : http://www.loper-os.org/?p=568

Idris

Auteur : Edwin Brady

Langage fonctionnel avec types dépendants.

• http://www.idris-lang.org/
• http://eb.host.cs.st-andrews.ac.uk/writings/idris-tutorial.pdf
• http://docs.idris-lang.org/en/latest/tutorial/index.html
• La version 1.0 a été publiée en 2017 : https://www.idris-lang.org/idris-1-0-released/
• Article élogieux de Paul Krill en 2017 : http://www.computerworld.com.au/article/617442/new-functional-language-champions-type-driven-development/
• Idris et les types dépendants, par Quentin Duval en 2017 : https://deque.blog/2017/09/20/data-structure-into-types/
• En 2019, Peter Caisse discute de la puissance des types en Idris : https://www.azavea.com/blog/2019/03/11/the-power-of-types-in-idris/
• En 2020, Edwin Brady aborde la question de la linéarité et de l'effacement de types en Idris : https://www.type-driven.org.uk/edwinb/linearity-and-erasure-in-idris-2.html

Imba

Auteur : Sindre Aarsaether

Se veut une jonction entre Ruby et le Framework React, compilé vers JavaScript.

• http://imba.io/

Inform

Auteur : Graham Nelson

Un langage permettant de décrire des fictions interactives à partir du langage naturel.

• Site officiel : http://inform7.com/
• L'idée derrière : http://www.inform-fiction.org/I7Downloads/Documents/WhitePaper.pdf

Insect

Auteur : David Peter

Langage de programmation offrant un soutien direct à la représentation des unités de mesure physiques.

• https://github.com/sharkdp/insect

INTERCAL

Auteur : Donald R.Woods

Un langage de programmation étrange dans lequel l'opération mathématique primitive est l'entremêlement de bits entre deux entier. On y trouve des opérations sur des trits (unités ternaires, en comparaison avec les bits, qui sont des unités binaires) et des expressions comme COMEFROM (plutôt que GOTO).

• http://www.muppetlabs.com/~breadbox/intercal-man/
• http://www.muppetlabs.com/~breadbox/intercal/
• http://www.computerworld.com.au/article/251892/-z_programming_languages_intercal/
• hum... http://www.intercaloninterstates.org/
• Introduction à la programmation dans ce langage, texte de 2007 par Clinton Forbes : http://divingintointercal.blogspot.ca/2007/03/good-programmer-constantly-strives-to.html
• Multiprogrammation avec INTERCAL (merci à Tony Van Eerd de m'avoir pointé vers ce bijou, en 2016) : http://www.cse.unsw.edu.au/~malcolmr/intercal/threaded.html
• Texte d'Adam Gordon Bell en 2021 à propos d'INTERCAL et d'autres langages horribles : https://blog.earthly.dev/intercal-yaml-and-other-horrible-programming-languages/

IntercalScript

Auteur : Robert Grosse

Un langage de script qui, sans avoir de similitude syntaxique réelle avec INTERCAL, est un langage qui semble construit pour être difficile à utiliser...

• https://github.com/Storyyeller/IntercalScript

Io

Auteur : Steve Dekorte

Langage s'apparentant à plusieurs langages bien connus (Lisp, Lua, Self, Smalltalk)

• http://www.iolanguage.com/
• http://iolanguage.org/
• Une réflexion de Nick Knowlson, en 2012, qui en a fait l'essai quelques jours : http://nickknowlson.com/blog/2012/01/16/seven-languages-week-2-day-3/

Ioke

Auteur : Ola Bini

Langage orienté prototype, inspiré de Lisp et de Ruby, mais compilant pour exécution sur la JVM. Deviendra manifestement Seph.

• http://kenai.com/projects/ioke/
• http://www.infoq.com/news/2008/11/ioke

IPLANG

Auteur : Iain Dunning

Langage ésotérique où les programmes sont exprimée sont la forme d'un problème d'optimisation binaire. Le fruit de la résolution du problème d'optimisation est traduit en brainfuck avant d'être exécuté.

• http://iaindunning.com/2014/iplang.html

Irken

Auteur : aucune idée

Dialecte simplifié de Scheme avec syntaxe inspirée de ML et typage statique.

• http://nightmare.com/rushing/irken/irken/lang.html

IRP

Auteur : Gregor Richards

Un langage de programmation étrange dans lequel les opérations sont basées sur... les interactions entre humains.

• http://esoteric.voxelperfect.net/wiki/IRP?

Isla

Auteur : Mary Rose Cook.

Langage de programmation pour enfants. Je dois vous avouer avoir souri quand j'ai constaté que syntaxiquement, ce langage est similaire à Thot, que mes étudiants et moi avons conçu entre 2005 et 2010 environ.

• http://isla.herokuapp.com/

Ivory

Auteurs : James Bielman, Thomas DuBuisson, Trevor Elliott, Pat Hickey, John Launchbury, Lee Pike et d'autres.

Langage basé sur Haskell et destiné au développemet de systèmes embarqués.

• http://smaccmpilot.org/languages/ivory-introduction.html

J

Auteurs : Kenneth Iverson et Roger Hui

Langage axé sur les calculs numériques. Inspiré par APL, mais avec une syntaxe ne reposant que sur les caractères ASCII.

• http://en.wikipedia.org/wiki/J_programming_language
• http://www.jsoftware.com/
• Un livre en ligne : http://www.jsoftware.com/help/jforc/contents.htm
• http://jsoftware.com/source.htm
• Un exemple concis de programmation en J, par James Hague en 2012 : http://prog21.dadgum.com/121.html
• Le langage J, décrit par Scott Locklin en 2012 : http://scottlocklin.wordpress.com/2012/09/18/a-look-at-the-j-language-the-fine-line-between-genius-and-insanity/
• Apprendre J par des exemples, par Oleg Kobchenko en 2005 : http://olegykj.sourceforge.net/jbyeg/jbyeg.htm
• Selon James Hague en 2009, l'environnement de développement du langage J est le meilleur qui soit : http://prog21.dadgum.com/48.html
• En 2020, Serge Zaitsev propose une ode au langage J : https://zserge.com/posts/j/
• Texte de 2020 par Hillel Wayne, qui propose de considérer la notation (compacte) de J comme un instrument pour réfléchir : https://www.hillelwayne.com/post/j-notation/

Critiques :

• La perspective de Vincent Toups sur ce langage, en 2016 : http://procyonic.org/blog/?p=171

Jai

Auteur : Jonathan Blow

Langage inspiré de C, mais avec une tournure plus moderne, et qui se veut une alternative à C++ pour le développement de jeux vidéos.

• https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md

Java

Auteur : James Gosling (entre autres)

Langage OO fort influent.

Bases, culture et pédagogie : ../Sujets/Divers--java/pedagogie.html

Outils fondamentaux et technologies périphériques : ../Sujets/Divers--java/Outils.html

À propos de Java 7 : ../Sujets/Divers--java/Evolution-Java.html#java7

À propos de Java 8 : ../Sujets/Divers--java/Evolution-Java.html#java8

À propos de Java 9 : ../Sujets/Divers--java/Evolution-Java.html#java9

Dialectes

Le dialecte FGJ_ω, qui vise à ajouter au langage des constructeurs paramétriques de types :

• http://lamp.epfl.ch/~cremet/FGJ-omega/
• http://www.jot.fm/issues/issue_2008_06/article2.pdf

Le dialecte Joe-E, orienté sécurité :

• http://www.cs.berkeley.edu/~daw/papers/joe-e-ndss10.pdf

JavaScript

Auteur : Brendan Eich

Langage fonctionnel très, très utilisé dans le monde du développement Web. Aussi connu sous le nom ECMAScript, mais le nom JavaScript demeure (de loin) la plus populaire des deux appellations (d'ailleurs, à propos des tensions entre les deux, voir le projet Harmony sur https://mail.mozilla.org/pipermail/es-discuss/2008-August/003400.html). Typiquement utilisé dans les pages Web, donc côté client des applications Web.

Général : ../Sujets/Web/JavaScript-Intro.html#liens

Histoire : ../Sujets/Web/JavaScript-Intro.html#liens_histoire

Critiques : ../Sujets/Web/JavaScript-Intro.html#liens_critiques

Apprendre et comprendre JavaScript : ../Sujets/Web/JavaScript-Intro.html#liens_pedagogie

Historique : ../Sujets/Web/JavaScript-Intro.html#liens_histoire

Futur : ../Sujets/Web/JavaScript-Intro.html#liens_futur

Le JavaScript Object Notation (JSON) : ../Sujets/Web/Developpement-Web.html#json

Le dialecte Low-Level JavaScript (LLJS), pour celles et ceux qui visent à programmer en JavaScript mais souhaitent les performances associées à du code natif : http://mbebenita.github.com/LLJS/

Le dialecte JSX, qui impose à JavaScript un système de types statique et met l'accent sur l'approche OO : http://jsx.github.com/

Jinx

Auteur : James Boer

Langage de script qui s'intègre à même du code C++.

• https://www.jinx-lang.org/

Joy

Auteur : Manfred von Thun

Un langage dit concaténatif, basé sur la mécanique d'une pile.

• http://www.kevinalbrecht.com/code/joy-mirror/joy.html
• http://www.kevinalbrecht.com/code/joy-mirror/j01tut.html
• http://en.wikipedia.org/wiki/Joy_%28programming_language%29
• En 2014, Daniel Beskin explique que pour lui, l'aventure avec Joy est terminée : http://ncreep.github.io/language_perils/blog/2014-03-24-joy-no-more.html

JSOL

Auteur : Clark DuVall

Langage de programmation dont les programmes peuvent être représentés entièrement en format JSON. Voir aussi PSOL.

• http://www.jsol.org/

Julia

Auteur : Viral Shah, Jeff Bezanson, Stefan Karpinski et Alan Edelman

Un langage dynamique construit pour générer des binaires à « haute performance » sur LLVM. Ses concepteurs se disent influencés par leur expérience avec Matlab. Ses auteurs ont gagné un chic prix en 2018 : http://news.mit.edu/2018/julia-language-co-creators-win-james-wilkinson-prize-numerical-software-1226

• http://julialang.org/
• http://julialang.org/manual/
• En 2018, Julia franchit un seuil et atteint la version 1.0 : https://julialang.org/blog/2018/08/one-point-zero
• http://julialang.org/blog/2012/02/why-we-created-julia/
• Entrevue avec Stefan Karpinski à propos de Julia, par Klint Finley en 2014 : http://www.wired.com/wiredenterprise/2014/02/julia/?cid=co18025234
• Présentation des forces de Julia, par Nic Werneck (?) en 2018 :
  • https://medium.com/@nwerneck/meeting-julia-a-great-new-alternative-for-numerical-programming-part-i-benchmarking-c03dd3289493
  • https://medium.com/@nwerneck/meeting-julia-a-great-new-alternative-for-numerical-programming-part-ii-a-high-level-perspective-170df0eee6c0
• Faire de la statistique avec Julia, par John Myles White en 2012 : http://www.johnmyleswhite.com/notebook/2012/12/02/the-state-of-statistics-in-julia/
• Des agrégats efficaces avec Julia, texte de Jeff Bezanson en 2013 : http://julialang.org/blog/2013/03/efficient-aggregates/
• Métaprogrammation avec Julia : Paradigmes-programmation--Liens.html#metaprogrammation_langage_Julia
• En 2014, Evan Miller déclare avoir la foi en Julia, qui lui permet d'abattre le mur entre l'abstraction de haut niveau et les considérations de haute vitesse auxquelles s'adressent habituellement les langages de bas niveau : http://www.evanmiller.org/why-im-betting-on-julia.html
• Utiliser Julia sur le Google Computing Engine, texte de Julia Ferraioli en 2014 : http://www.blog.juliaferraioli.com/2014/01/julia-on-google-compute-engine-working.html
• Interfacer Julia et Python, par Leah Hanson en 2014 : http://blog.leahhanson.us/julia-calling-python-calling-julia.html
• Impressions très positives de Stephen Malone en 2014 : http://eyeballtrees.com/posts/julia-impressions.html
• Métaprogrammation avec Julia, texte de Jacob Quinn en 2014 : http://quinnj.github.io/2014/06/19/data-structures-as-code-the-joys-of-meta-programming/index.html
• En 2014, John Myles White relate son expérience à JuliaCon : http://www.johnmyleswhite.com/notebook/2014/06/30/my-experience-at-juliacon/
• Calculs vectoriels avec Julia, par Arch D. Robinson en 2014 : https://software.intel.com/en-us/articles/vectorization-in-julia
• Algèbre linéaire avec Julia, selon Alex H. Woods en 2015 : http://alexhwoods.com/2015/08/22/linear-algebra-in-julia/
• Dans ce texte de 2015, John Myles White explique pourquoi, selon lui, les DataFrames de Julia sont lents : http://www.johnmyleswhite.com/notebook/2015/11/28/why-julias-dataframes-are-still-slow/
• Le modèle d'exécution usuel avec Julia est la compilation juste à temps (JIT), mais il est aussi possible de compiler un programme Julia avant de l'exécuter (Ahead-of-Time, AOT) comme l'explique Jameson Nash dans ce texte de 2016 : http://juliacomputing.com/blog/2016/02/09/static-julia.html
• Julia, présenté par Alan Edelman en 2016 : https://sinews.siam.org/DetailsPage/tabid/607/ArticleID/744/Julia-A-Fast-Language-for-Numerical-Computing.aspx
• Tirer profit de Julia pour des calculs numériques à haut volume (du Number Crunching), par JS Hysing en 2016 : https://medium.com/@jshysing/the-julia-programming-language-for-number-crunching-87faad52ce08
• Comment les gens de la finance profitent de Julia, texte de 2016 par Anthony Malakian : http://www.waterstechnology.com/waters/feature/2476518/the-infancy-of-julia-an-inside-look-at-how-traders-and-economists-are-using-the-julia-programming-language
• En 2016, Graydon Hoare décrit Julia en ses mots : https://graydon2.dreamwidth.org/189377.html
• Des indices maison pour les tableaux en Julia, par Tim Holy en 2017 : https://julialang.org/blog/2017/04/offset-arrays
• En 2017, Avik Sengupta et Simon Byrne décrivent leur expérience de transactions financières et boursières automatisées avec Julia : https://juliacomputing.com/blog/2017/08/22/algorithmic-trading.html
• Programmer pour un GPGPU avec Julia et CUDA, par Mike Innes en 2017 : http://mikeinnes.github.io/2017/08/24/cudanative.html
• Apprentissage automatique avec Julia, par Mike Innes et plusieurs autres en 2017 : https://julialang.org/blog/2017/12/ml&pl
• Les opérations Broadcast Fusion de Julia, texte de 2018 par Matt Bauman : https://julialang.org/blog/2018/05/extensible-broadcast-fusion
• La désérialisation « zéro copie » en Julia, par Jamie Brandon en 2018 : http://scattered-thoughts.net/blog/2018/08/28/zero-copy-deserialization-in-julia/
• Comparer la vitesse d'accès à un élément avec une expression map et une répétitive avec Julia, par Dean Marwick en 2019 : http://dm13450.github.io/2019/04/17/MapLoopPerformance.html
• En 2019, Aurelio Amerio présente des techniques d'optimisation avec Julia : https://techytok.com/code-optimisation-in-julia/
• Composition avec Julia, par Lyndon White en 2020 : https://white.ucc.asn.au/2020/02/09/whycompositionaljulia.html
• Texe de 2020 qui explique comment utiliser Julia comme une sorte de calculatrice haut-de-gamme à la ligne de commande : https://krasjet.com/rnd.wlk/julia/
• Les fonctions en Julia, expliquées en 2020 par Karthikeyan A K : https://data-science-with-julia.gitlab.io/2020/11/28/functions.html

Critiques :

• Opinion d'un utilisateur de Matlab, en 2012 : http://2pif.info/op/julia.html
• Opinion quelque peu joviale, par John Myles White en 2012 : http://www.r-bloggers.com/julia-i-love-you/
• En 2012, Paul Krill relate que Julia se veut le C des scientifiques : http://www.infoworld.com/d/application-development/new-julia-language-seeks-be-the-c-scientists-190818?page=0,0
• Dans ce texte de 2014, Dan Luu explique que Julia est vraiment très bien... mais pas pour lui : http://danluu.com/julialang/
• En 2016, Victor Zverovich explique pourquoi il abandonne Julia : http://zverovich.net/2016/05/13/giving-up-on-julia.html
• En 2017, Christopher Rackauckas relate son expérience plutôt positive avec Julia : http://www.stochasticlifestyle.com/like-julia-scales-productive-insights-julia-developer/
• En 2018, Chris Stokel-Walker présente Julia comme le Boucle d'Or des langages de programmation : https://increment.com/programming-languages/goldilocks-language-history-of-julia/
• En 2018, le MIT présente Julia comme un langage en croissance, selon Nick Heath : https://www.techrepublic.com/article/is-julia-the-next-big-programming-language-mit-thinks-so-as-version-1-0-lands/
• Quelques raisons d'utiliser Julia : https://ucidatascienceinitiative.github.io/IntroToJulia/Html/WhyJulia
• Présentation constructive de Julia : https://jott.live/markdown/julia
• En 2022, Yuri Vishnevsky explique pourquoi il ne se sent plus confortable de recommander Julia : https://yuri.is/not-julia/

Jumbala

Auteur : Jori Dubrovin

Un langage pour décrire des automates UML.

• http://www.tcs.hut.fi/Publications/A101.shtml

K

Auteur : Arthur Whitney

Langage de programmation système mêlant la programmation fonctionnelle et des éléments qui évoquent le langage APL, incluant la capacité de traiter efficacement des vecteurs de données.

• http://www.kuro5hin.org/story/2002/11/14/22741/791
• http://en.wikipedia.org/wiki/K_%28programming_language%29

kabas

Auteur : Christof Kaser

Langage de programmation pour débutant(e)s.

• https://kabas.online/index.html

Kal

Auteur : Robert Zimmerman

Un langage qui se veut une alternative à JavaScript, mais dont la compilation génère du code JavaScript.

• http://rzimmerman.github.io/kal/
• Texte de Robert Zimmerman en 2013 expliquant comment un compilateur Kal se compile lui-même : http://blog.rzimmerman.me/how-kal-compiles-itself/

Karmasphere DP

Auteur(s) : à déterminer...

Langage mettant l'accès sur le parallélisme des données et les structures de données aux opérations non bloquantes.

• http://labs.karmasphere.org/dp/
• http://labs.karmasphere.org/dp/javadoc/
• http://www.hadoopstudio.org/

Katana

Auteur : Belo Horizonte

Un langage se prêtant à la programmation système mais conçu pour ressembler à du JavaScript compilé en code natif.

• http://katanalang.org/
• http://katanalang.org/meta/2012/05/14/why-I-am-creating-a-language/

Kermeta

Auteur : Franck Fleurey

Ce langage se présente comme un environnement de métaprogrammation basé sur un DSL orienté objet.

• http://www.kermeta.org/

Kernel

Auteur : John N. Shutt

Dialecte de Lisp inspiré de Scheme

• http://web.cs.wpi.edu/~jshutt/kernel.html
• http://axisofeval.blogspot.com/2011/08/praising-kernel.html

Kit

Auteur : Ben Morris

Langage qui se veut approprié pour le développement de jeux, et qui vise la transpilation en code C.

• https://www.kitlang.org/

Kitten

Auteur : Jon Purdy

Langage statiquement typé, axé sur la programmation fonctionnelle et concaténative.

• http://kittenlang.org/
• https://github.com/evincarofautumn/kitten

Ko

Auteurs : Ewout Prangsma et Joseph Jacks

Langage fonctionnel sans états mutables, générique mais construit sur le run-time de Go

• https://github.com/kocircuit/kocircuit
• https://github.com/kocircuit/kocircuit/tree/master/lessons

Kodu

Auteur : Microsoft Research (Matt MacLaurin?)

Langage à visées pédagogiques, visuel et axé vers le 3D. Permet de programmer la console XBox. Repose sur la plateforme XNA.

• http://fuse.microsoft.com/projects-kodu.html
• http://en.wikipedia.org/wiki/Kodu_Game_Lab
• http://research.microsoft.com/en-us/projects/kodu/

Koka

Auteur : Dann Leijen

Langage fonctionnel séparant les fonctions pures des calculs ayant des effets de bord. Le type des fonctions y indique la présence ou non d'effets de bord, facilitant pour le compilateur le raisonnement sur les impacts de chacune d'elles.

• http://research.microsoft.com/en-us/projects/koka/
• http://research.microsoft.com/en-us/projects/koka/2012-overviewkoka.pdf
• La spécification du langage : https://koka-lang.github.io/koka/doc/kokaspec.html

Kotlin

Auteur : Andrey Breslav

Langage à système de types statique, destiné à la JVM.

• https://thestrangeloop.com/sessions/the-kotlin-programming-language
• Apprendre Kotlin en quelques minutes : https://learnxinyminutes.com/docs/kotlin/
• Tutoriel pas mal du tout : https://kotlinlang.org/docs/tutorials/koans.html
• Entrevue avec Andrey Breslav en 2013 : http://www.oracle.com/technetwork/articles/java/breslav-1932170.html
• http://www.artima.com/weblogs/viewpost.jsp?thread=335110
• En 2012, Igor Drobiazko présente quelques exemples de petits programmes en Kotlin : http://blog.tapestry5.de/index.php/2012/01/25/hello-kotlin/
• http://github.com/strangeloop/2011-slides/raw/master/Breslav-Kotlin.pdf
• http://blog.jetbrains.com/kotlin/2012/03/kotlin-m1-candidate/
• En 2012, Kotlin devient un projet à code ouvert :
  • texte d'Ann Oreshnikova : http://blog.jetbrains.com/kotlin/2012/02/kotlin-goes-open-source-2/
  • http://www.h-online.com/open/news/item/Java-alternative-Kotlin-now-available-as-open-source-1434434.html
• Selon Mike Gouline en 2014, Kotlin serait à Android ce que Swift est à iOS : http://blog.gouline.net/2014/08/31/kotlin-the-swift-of-android/
• 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/
• Écrire du code qui évolue avec le langage Kotlin, par Ilya Gorbunov en 2015 : http://blog.jetbrains.com/kotlin/2015/06/kotlin-evolves-how-to-keep-your-code-up/
• Exploration de la bibliothèque standard de Kotlin, proposée par Cédric Beust en 2015 : http://beust.com/weblog/2015/10/30/exploring-the-kotlin-standard-library/
• En 2015, Nat Pryce relate ses premières expériences avec Kotlin : http://natpryce.com/articles/000815.html
• Séance de questions / réponses avec Andrey Breslav, en 2016 : https://dzone.com/articles/a-qa-with-andrey-breslav-on-kotlin
• Nouveauté avec Kotlin 1.0+, selon Dimitry Jemerov en 2016 : http://blog.jetbrains.com/kotlin/2016/04/kotlin-post-1-0-roadmap/
• Rouler un dé avec Kotlin, par Nicolas Fränkel en 2016 : https://blog.frankel.ch/rolling-dice-kotlin
• Nombres à virgule flottante avec Kotlin, expliqués par Nicolas Fränkel en 2016 : https://blog.frankel.ch/fixing-floating-point-arithmetics-with-kotlin/
• Le « bien » et le « moins bien » avec Kotlin, de l' avis de AJ Alt en 2016 : https://medium.com/keepsafe-engineering/kotlin-the-good-the-bad-and-the-ugly-bf5f09b87e6f
• En 2016, Mark Galea montre comment écrire des arbres de décision avec Kotlin : http://cloudmark.github.io/Decision-Trees/
• Le sens du mot val en Kotlin, par Artem Zinnatullin en 2016 : https://artemzin.com/blog/kotlin-val-does-not-mean-immutable-it-just-means-readonly-yeah/
• Écrire du code idiomatique avec Kotlin, par Denis Trailin en 2016 : http://code.hootsuite.com/writing-kotlin-idiomatic-code/
• Composition de fonctions par voie d'extensions et d'opérateurs, un texte de 2016 par Daniele Conti : https://medium.com/@fourlastor/composing-functions-in-kotlin-with-extensions-and-operators-76a499f5b4b7
• En 2016, Kenneth Ford propose d'utilise Kotlin pour nettoyer le code Java : https://medium.com/@kford55/kotlin-why-i-feel-its-useful-in-a-java-only-code-base-206bdb37c79
• Les atouts de Kotlin, décrits en 2016 par Jasper Sprengers : https://blog.codecentric.de/en/2016/04/kotlins-killer-features/
• En 2017, Andrey Breslev explique comment utiliser Kotlin en mode natif, donc sans machine virtuelle : https://blog.jetbrains.com/kotlin/2017/04/kotlinnative-tech-preview-kotlin-without-a-vm/
• Inventaire de bonnes pratiques avec Kotlin, colligé par Philipp Hauer : https://blog.philipphauer.de/idiomatic-kotlin-best-practices/
• En 2017, Hadi Hariri explique comment utiliser Kotlin sur un Raspberry Pi : http://hadihariri.com/2017/04/09/kotlin-on-raspberry-pi/
• Introduction à Kotlin, série d'articles par Jussi Hallila en 2017 :
  • https://www.codementor.io/jussihallila/introduction-to-kotlin-part-1-9mt0ony0g
  • https://www.codementor.io/jussihallila/introduction-to-kotlin-part-2-9oybmr9rb

Produits dérivés :

• Le Framework de spécification Spek : http://jetbrains.github.io/spek/notes/1.0.html

Leaf

Auteur : Edaqa Mortoray

Projet personnel de son auteur, qui cherche à atteindre ce qui serait à ses yeux un « langage idéal ».

• http://mortoray.com/leaf/
• Texte de 2017 par Edaqa Mortoray, portant sur les « constructeurs nommés » : https://mortoray.com/2017/04/18/working-with-types-and-named-constructors-in-leaf/
• Réflexion sur la mutabilité ou non des paramètres passés à une fonction, à savoir quel serait le comportement préférable en pratique, par Edaqa Mortoray en 2017 : https://mortoray.com/2017/12/31/should-function-arguments-be-reassignable-or-mutable/

Legit

Auteur : Sebastian Morr

Langage étrange, basé... sur des commandes git.

• https://morr.cc/legit/

Lily

Auteur : Jesse Ray Adkins

Langage mettant l'accent sur la sécurité et l'expressivité

• http://jesserayadkins.github.io/lily/
• https://github.com/fascinatedbox/lily
• https://fascinatedbox.github.io/lily-site/

Limbo

Auteurs : Sean Dorward, Phil Winterbottom et Rob Pike

Un langage qui aurait influencé Go :

• http://www.vitanuova.com/inferno/limbo.html

Linden

Auteur : Linden Labs

Langage de script servant entre autres au développement dans le monde virtuel Second Life.

• http://wiki.secondlife.com/wiki/LSL_Portal
• http://lslwiki.net/lslwiki/wakka.php?wakka=HomePage
• http://oz.slinked.net/history/lsl2_reference.htm
• http://www.drdobbs.com/high-performance-computing/197008520

Links

Auteurs : Ezra Cooper, Sam Lindley, Philip Wadler et Jeremy Yallop

Langage axé sur la génération d'applications Web, produisant tous les tiers requis d'un seul coup.

• http://groups.inf.ed.ac.uk/links/
• http://groups.inf.ed.ac.uk/links/papers/links-fmco06.pdf

Lisaac

Auteurs : Benoit Sonntag et Xavier Oswald?

Se veut un successeur de Self.

• https://alioth.debian.org/projects/lisaac/

Liskell

Auteur : Clemens Fruhwirth

Langage fonctionnel, avec la syntaxe de Lisp et la sémantique de Haskell.

• http://www.liskell.org/
• http://clemens.endorphin.org/ILC07-Liskell-draft.pdf

Lisp

Voir Langages/Lisp--Liens.html

littleb

Auteur : Aneil Mallavarapu

Un langage niche mettant l'accès sur des modèles mathématiques complexes constitués de petits modules réutilisables. Semble être utilisé surtout par des gens qui gravitent autour de la biologie et des sciences de la vie.

• http://www.littleb.org/

Lobster

Auteur : Wouter van Oortmerssen

Langage axé sur le développement de jeu vidéo, et offrant plusieurs fonctionnalités adaptées à ce type de développement.

• http://strlen.com/lobster

Logo

Auteur : Seymour Papert

Langage à vocation pédagogique, célèbre pour ses opérations guidant la tortue, par laquelle des formes pouvaient être tracées à l'écran (ou ailleurs).

• Histoire du langage : http://el.media.mit.edu/Logo-foundation/logo/index.html et http://www.wired.com/wiredscience/2007/10/forward-40-wher/
• Qu'est-ce que Logo? http://el.media.mit.edu/Logo-foundation/logo/programming.html
• Exemple de programme : http://www.eecs.berkeley.edu/~bh/logo-sample.html
• En 2021, Auntie Myrtle propose une histoire du langage Logo : https://turtlespaces.org/2021/05/21/past-and-future-turtles-the-evolution-of-the-logo-programming-language-part-1/

LOLCODE

Auteur : Adam Lindsay

Un langage de programmation étrange dont les primitives sont basées sur les mots brefs que s'échangent les gens, typiquement par clavardage ou dans des messages textes sur téléphone cellulaire.

• Site officiel : http://lolcode.com/
• Un Wiki sur ce langage : http://en.wikipedia.org/wiki/LOLCODE
• Exemple de programme : http://lolcode.com/examples/hai-world

Loop

Auteur : Dhanji R. Prasanna.

Langage fonctionnel s'exécutant sur la JVM et profitant des processeurs à plusieurs coeurs.

• http://looplang.org/
• http://www.infoq.com/news/2012/07/loop-jvm-language

Lox

Auteur : Robert Nystrom

Langage par lequel l'auteur explique comment écrire un interpréteur dans une série d'articles à saveur pédagogique.

• En 2018, Ben Hoyt écrit un interpréteur Lox en Lox : https://benhoyt.com/writings/loxlox/

Lua

Auteurs : Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo

Langage de scripts, prisé en particulier dans le monde des jeux vidéos.

• http://www.lua.org/
• http://www.luafaq.org/
• http://en.wikipedia.org/wiki/Lua_%28programming_language%29
• Le design de Lua :
  • http://www.stanford.edu/class/ee380/Abstracts/100310-slides.pdf
  • http://queue.acm.org/detail.cfm?id=1983083
  • l'évolution de Lua, par ses auteurs en 2006 (je pense) : http://www.tecgraf.puc-rio.br/~lhf/ftp/doc/hopl.pdf
  • explications du design de Lua, par Roberto Ierusalimschy, Luiz Henrique De Figueiredo et Waldemar Celes en 2018 : https://cacm.acm.org/magazines/2018/11/232214-a-look-at-the-design-of-lua/fulltext
• Utiliser Lua avec du code C :
  • http://mdeverdelhan.developpez.com/tutoriel/lua/tutoriel1/
  • http://heavycoder.com/tutorials/lua_embed.php
  • intégrer LuaJIT en une trentaine de minutes environ, par Marek Vavruša en 2015 : http://en.blog.nic.cz/2015/08/12/embedding-luajit-in-30-minutes-or-so/
• Jill, une implémentation de Lua en Java : http://code.google.com/p/jillcode/
• http://www.troubleshooters.com/codecorn/lua/index.htm
• Distribuer un programme Lua : http://www.playwithlua.com/?p=44
• Créer un jeu très multiplateforme? Un texte de 2011 recommande Lua et explique pourquoi : http://blog.brokenfunction.com/2011/11/how-to-make-a-massively-cross-platform-game/
• Pourquoi utiliser Lua? Une opinion de Kevin T. Ryan en 2012 : http://blog.datamules.com/blog/2012/01/30/why-lua/
• Apprendre Lua en quinze minutes (ici, « apprendre » est un  peu fort), par Tyler Neylon en 2013 : http://tylerneylon.com/a/learn-lua/
• Grandeurs et frustrations avec Lua, par John Graham-Cumming en 2013 : http://fr.slideshare.net/jgrahamc/lua-the-worlds-most-infuriating-language
• Lua et les mixins, texte de 2014 : http://notmagi.me/the-power-of-lua-and-mixins/
• Utiliser Lua avec Redis, par Brian P O'Rourke en 2015 : https://www.redisgreen.net/blog/intro-to-lua-for-redis-programmers/
• Implémentation de la machine virtuelle de Lua pour le Web : http://daurnimator.github.io/lua.vm.js/lua.vm.js.html
• En 2017, Yehonathan Sharvit propose ce qu'il estime être une nouvelle manière de produire des blogues sur Lua : http://blog.klipse.tech/lua/2017/03/19/blog-lua.html
• Créer un jeu avec Lua, un pas à pas proposé par adn (?) en 2018 : https://github.com/SSYGEN/blog/issues/30
• Programmation concurrente avec Lua, texte de 2018 par Andy Wingo : https://wingolog.org/archives/2018/05/16/lightweight-concurrency-in-lua

Critiques :

• Pourquoi ne pas utiliser Lua : http://julien.danjou.info/blog/2011.html#Why_not_Lua
• En 2015, Isabella Muerte explique pourquoi elle n'utilise pas Lua : https://izzys.casa/2015/03/why-i-dont-use-lua/

Luna

Auteurs : des gens de New Byte Order?

Langage fonctionnel offrant une métaphore duale de code en tant que texte et en tant que visualisation graphique.

• http://www.luna-lang.org/
• https://www.gitbook.com/book/luxlang/the-lux-programming-language/details
• Article sur ce langage, proposé par Serdar Yegulalp en 2017 : http://www.javaworld.com/article/3155704/java/new-functional-language-for-jvm-builds-on-haskell-clojure-ml.html

Lux

Auteur : Eduardo Julian

Langage qui se veut une sorte de Lisp mais avec système de types statique, susceptible d'être exécuté sur la JVM ou transpilé en JavaScript.

• https://github.com/LuxLang/lux

M

Auteur : Microsoft Research?

Langage de modélisation de données, qui semble avoir surtout servi à titre de DSL expérimental duquel est né le langage Dminor.

• http://thecoffeedesk.com/news/index.php/2008/10/11/microsofts-new-m-programming-language/

Magpie

Auteur : Robert Nystrom

Langage OO dynamiquement typé, similaire à Python et à Ruby. L'auteur réfléchit son langage à haute voix dans ses publications, ce qui rend ses écrits plutôt intéressants.

• http://magpie-lang.org/
• http://bitbucket.org/munificent/magpie/src
• http://journal.stuffwithstuff.com/2010/09/01/a-type-checking-conundrum/
• http://journal.stuffwithstuff.com/2010/12/14/the-trouble-with-constructors/
• http://journal.stuffwithstuff.com/2010/12/31/rethinking-user-defined-operators/
• http://journal.stuffwithstuff.com/2011/01/16/pattern-matching-in-a-dynamic-oop-language/
• http://journal.stuffwithstuff.com/2011/02/13/extending-syntax-from-within-a-language/
• Magpie et les multiméthodes, un texte de 2012 : http://journal.stuffwithstuff.com/2012/06/12/multimethods-global-scope-and-monkey-patching/
• Le système de types de Magpie, par Robert Nystrom en 2010 : http://journal.stuffwithstuff.com/2010/10/29/bootstrapping-a-type-system/

Malbolge

Auteur : Ben Olmstead

Langage de programmation étrange dont la syntaxe a été conçue pour rendre presque impossible la rédaction de programmes utiles.

• http://en.wikipedia.org/wiki/Malbolge
• Entrevue avec Ben Olmstead, par Daniel Temkin en 2014 : http://esolangs.com/post/101675489813/interview-with-ben-olmstead

Mantle

Auteur : AMD

Langage mettant l'accent sur l'affichage.

• http://www.amd.com/Documents/Mantle-Programming-Guide-and-API-Reference.pdf

Marelle

Auteur : Lars Yencken

Langage axé sur la programmation déclarative et logique.

• https://github.com/larsyencken/marelle
• http://quietlyamused.org/blog/2013/11/09/marelle-for-devops/

Mathematica

Auteur : Stephen Wolfram

À la fois un logiciel de résolution de problèmes mathématiques et un langage de programmation orienté vers la résolution de tels problèmes.

• http://www.wolfram.com/mathematica/
• Une histoire d'amour avec Mathematica, par Tim Hopper en 2012 : http://www.stiglerdiet.com/2012/02/10/mathematica-a-love-story/
• Une alternative gratuite nommée Mathics : http://www.mathics.org/index.html
• Mathematica est disponible en ligne depuis 2014, selon ce texte de Stephen Wolfram : http://blog.wolfram.com/2014/09/15/launching-today-mathematica-online/

Mercury

Auteur : Zoltán Somogyi

Langage déclaratif, à la manière de Prolog, de même que fonctionnel et fortement typé, à la manière de Haskell ou de ML.

• http://en.wikipedia.org/wiki/Mercury_%28programming_language%29
• http://www.mercury.csse.unimelb.edu.au/index.html
• http://www.mercury.csse.unimelb.edu.au/information/features.html
• Manipuler des fichiers avec Mercury : http://blog.dbpatterson.com/post/10101986648

Metalua

Auteur : Fabien?

Un dialecte de Lua mettant l'accent sur la métaprogrammation statique.

• http://metalua.luaforge.net/
• http://metalua.blogspot.com/

Metamine

Auteur : ymte?

Un langage qui se veut purement déclaratif.

• https://github.com/ymte/metamine

Metaphors

Auteur : Victoria Livschitz

Pas tant un langage qu'une réflexion sur ce que les langages devraient être, du moins de l'avis de l'auteur.

• Entrevue avec l'auteur : http://java.sun.com/developer/technicalArticles/Interviews/livschitz2_qa.html

min

Auteur : Fabio Cevasco

Langage construit sur la base de Nim, qui se veut à la fois fonctionnel et concaténatif.

• https://min-lang.org/

miniKanren

Auteur : Will Byrd

Langage de type DSL destiné à la programmation logique

• http://minikanren.org/
• Tutoriel interactif : http://io.livecode.ch/learn/webyrd/webmk

Mint

Auteur : Szikszai Gusztáv

Langage de scripting visant la rédaction d'applications monopages pour le Web

• https://www.mint-lang.com/
• https://www.mint-lang.com/guide

Mirah

Auteur : Charles Oliver Nutter

Un dérivé de JRuby, dialecte de Ruby destiné à la JVM.

• http://www.mirah.org/
• http://www.mirah.org/wiki/MirahFeatures
• http://www.infoq.com/articles/mirah-interview
• http://cogitations.arbia.co.uk/post/3984477935/fun-java-with-mirah
• http://drdobbs.com/java/229400307

ML

Auteur : Robin Milner

Langage fonctionnel « impur » (car tolérant les effets de bord) facilitant l'inférence dynamique de types.

• Le Wiki : http://en.wikipedia.org/wiki/ML_%28programming_language%29
• Le Standard ML Family, un projet de développement pas la communauté : http://sml-family.org/
• Technique de transformation de types pour fins de transfert et d'interopérabilité :
  • http://research.microsoft.com/en-us/um/people/akenn/fun/picklercombinators.pdf
  • http://www.ps.uni-saarland.de/Papers/abstracts/hotPickles2007.pdf
• Mécaniser la métathéorie du langage : http://www.cs.cmu.edu/~rwh/papers/tslf/full.pdf
• Le langage Successor ML, qui prétend que le ML standard est mort : http://successor-ml.org/index.php?title=Main_Page
• HaMLet, une implémentation qui se veut fidèle au ML standard de 1997 : http://www.mpi-sws.org/~rossberg/hamlet/
• Des composants dynamiques pour ML : http://www.ps.uni-saarland.de/Papers/abstracts/missing-link.pdf
• Une critique des templates de C++, avec proposition d'amélioration en ML : http://www.kuro5hin.org/story/2003/5/26/22429/7674
• ML et les monades : http://existentialtype.wordpress.com/2011/05/01/of-course-ml-has-monads/
• Trier avec ML, un texte de Jeremy Kun en 2013 : http://jeremykun.com/2013/04/07/a-sample-of-standard-ml-and-the-treesort-algorithm/
• En 2015, Andreas Rossberg oeuvre à unifier les dialectes de ML sous un même chapiteau, nommé 1ML : http://www.mpi-sws.org/~rossberg/1ml/
• Série d'articles par Eric Lippert en 2016, portant sur ce qui, au coeur de ML, décrit les fondements des systèmes de types, en particulier ceux de l'inférence de types, de la plupart des langages fonctionnels :
  • https://ericlippert.com/2016/11/30/4498/
  • https://ericlippert.com/2016/12/05/excessive-explanation-part-two/
  • https://ericlippert.com/2016/12/08/excessive-explanation-part-three/
  • https://ericlippert.com/2016/12/12/excessive-explanation-part-four/
  • https://ericlippert.com/2016/12/15/excessive-explanation-part-five/
  • https://ericlippert.com/2016/12/19/excessive-explanation-part-six/
  • https://ericlippert.com/2016/12/22/excessive-explanation-part-seven/
  • https://ericlippert.com/2017/01/05/excessive-explanation-part-eight/
  • https://ericlippert.com/2017/01/09/excessive-explanation-part-nine/
  • https://ericlippert.com/2017/01/12/excessive-explanation-part-ten/
  • https://ericlippert.com/2017/01/17/excessive-explanation-part-eleven/
  • https://ericlippert.com/2017/01/19/excessive-explanation-part-twelve/
  • https://ericlippert.com/2017/01/26/excessive-explanation-part-thirteen/
  • https://ericlippert.com/2017/01/30/excessive-explanation-part-fourteen/
  • https://ericlippert.com/2017/02/02/excessive-explanation-part-fifteen/
  • https://ericlippert.com/2017/02/06/excessive-explanation-part-sixteen/
  • https://ericlippert.com/2017/02/09/excessive-explanation-part-seventeen/
  • https://ericlippert.com/2017/02/16/excessive-explanation-part-eighteen/
  • https://ericlippert.com/2017/02/21/excessive-explanation-part-nineteen/
  • https://ericlippert.com/2017/02/23/excessive-explanation-part-twenty/
  • https://ericlippert.com/2017/03/13/excessive-explanation-part-twenty-one/
  • https://ericlippert.com/2017/03/16/excessive-explanation-part-twenty-two/
  • https://ericlippert.com/2017/03/20/excessive-explanation-part-twenty-three/
  • https://ericlippert.com/2017/03/23/excessive-explanation-part-twenty-four/

Dialectes :

• Le langage CakeML, dont le compilateur et le runtime ont été prouvés corrects : https://cakeml.org/

Modula II

Auteur : Niklaus Wirth

Langage impératif inspiré de Pascal. Longtemps utilisé pour l'enseignement de la programmation.

• http://en.wikipedia.org/wiki/Modula-2

MoonScript

Auteur : Leaf Corcoran

Langage de scripting dont le fruit de la compilation est du code Lua.

• http://moonscript.org/

Mouse

Auteur : Peter Grogono

Petit langage reposant fortement sur une pile d'exécution.

• http://www.retroprogramming.com/2012/08/mouse-language-for-microcomputers-by.html

Mumps

Auteur : Neil Pappalardo

Langage généraliste, produit du milieu de la santé, qui facilite la représentation de tables dans des bases de données par des entités indicées primitives.

• https://en.wikipedia.org/wiki/MUMPS
• Article de Michael Byrne en 2015 : https://motherboard.vice.com/en_us/article/3dkmg3/meet-mumps-the-archaic-health-care-programming-language-that-predicted-big-data-2
• https://www.cs.uni.edu/~okane/source/MUMPS-MDH/MumpsTutorial.pdf

Mun

Auteur : un groupe de bénévoles qui se présente comme The Mun Team

Langage qui dit viser le remplacement de Lua dans le monde du jeu.

• https://mun-lang.org/
• https://docs.mun-lang.org/

Myrddin

Auteur : Ori Bernstein

Langage « jouet » de prime abord, mais qui vise à permettre de programmer tout près du matériel, tout en garantissant un Type Safety maximal.

• http://eigenstate.org/myrddin.html

Mythryl

Auteur : Cynbe?

Langage orienté plaisir (de programmer), selon son auteur principal.

• http://mythryl.org/

M#

Auteur : Joe Duffy (et son équipe)

Langage se voulant une sorte de « C# pour programmation système », et dont la structure est pensée pour faciliter l'analyse statique. Semble émerger du projet expérimental Midori. Attention : le nom M# n'est pas officiel.

• Texte présentant un survol de ce projet de recherche, par Joe Duffy en 2013 : http://joeduffyblog.com/2013/12/27/csharp-for-systems-programming/
• En 2013, Aleks Bromfield décrit certaines caractéristiques du langage, dont son approche pour ce qui est de la sécurité : https://plus.google.com/+AleksBromfield/posts/SnwtcXUdoyZ
• Article de Michael Rougeau en 2013 : http://www.techradar.com/us/news/software/operating-systems/microsoft-s-midori-os-may-have-spawned-a-new-programming-language-1211300

Nemerle

Auteurs : Kamil Skalski, Michal Moskal, Prof. Leszek Pacholski et Pawel Olszta (note : Michal et Pawel devraient se terminer par un « l » traversé d'un court trait diagonal, mais je ne trouve pas le symbole pour cette lettre pour le moment)

Langage compilé pour le CLR de .NET, combinant des facilités OO et fonctionnelles.

• http://nemerle.org/wiki/index.php?title=Main_Page
• http://en.wikipedia.org/wiki/Nemerle
• http://www.scribd.com/doc/52217916/nemerleIsNotable

nesC

Auteurs : Eric Brewer, David Culler, David Gay, Phil Levis, Rob von Behren et Matt Welsh

Langage qui est en fait une extension du langage C supportant le modèle d'exécution du système d'exploitation TinyOS, surtout utilisé sur des réseaux de petits noeuds.

• http://nescc.sourceforge.net/

NESL

Auteurs : Guy E. Blelloch

Langage voué à la programmation parallèle.

• https://www.cs.cmu.edu/~scandal/nesl.html

Newspeak

Auteur : Gilad Bracha

Langage OO, descendant direct de Smalltalk et de Self.

• Site officiel : http://bracha.org/Site/Newspeak.html
• Grammaires exécutables dans le langage : http://bracha.org/executableGrammars.pdf et http://bracha.org/newspeak-parsers.pdf
• Modules dans le langage : http://bracha.org/newspeak-modules.pdf

Newsqueak

Auteur : Rob Pike

Langage orienté vers la multiprogrammation par processus concurrents.

• http://en.wikipedia.org/wiki/Newsqueak
• http://swtch.com/~rsc/thread/newsqueak.pdf
• http://herpolhode.com/rob/lec3.pdf
• http://patricklogan.blogspot.com/2007/09/rob-pike-on-concurrency-and-message.html

Ni

Auteur : Göran Krampe

Langage intégrant des concepts de Smalltalk, Nim et REBOL entre autres sources

• https://github.com/gokr/ni
• http://goran.krampe.se/2015/09/16/ni-a-strange-little-language/
• Ajouter des objets à Ni, par Göran Krampe en 2015 : http://goran.krampe.se/2015/09/25/adding-objects-to-ni/

Nice

Auteur : Daniel Bonniot

Langage OO visant la production de programmes contenant moins de bogues...

• http://nice.sourceforge.net/
• http://nice.sourceforge.net/safety.html

Nil

Auteur : Sacha René Lieb

Langage de programmation nihiliste, tiens. Extrêmement efficace pour les tâches qu'il doit résoudre...

• http://leib.be/sascha/the-nil-programming-language/
• http://esolangs.org/wiki/Nil

Nim (autrefois Nimrod)

Auteur : Andreas Rumpf

Langage qui se veut une combinaison de la lisibilité de Python, l'expressivité de Lisp et la vitesse d'exécution de C.

• http://force7.de/nimrod/
• https://launchpad.net/nimrod
• http://joejacob.co.in/nimrod-language/
• http://www.devtopics.com/nimrod-obscure-programming-language-of-the-month/
• http://nimrod-code.org/index.html
• Selon Steve Donovan en 2013, Nimrod serait en quelque sorte le retour à l'avant-scène de Pascal (ou, plus précisément, d'ObjectPascal) : http://steved-imaginaryreal.blogspot.co.uk/2013/09/nimrod-return-of-pascal.html
• Nimrod et la métaprogrammation : Paradigmes-programmation--Liens.html#metaprogrammation_langage_Nimrod
• En 2013, Dominik Picheta décrit Nimrod : http://picheta.me/articles/2013/10/about-nimrods-features.html
• Texte de 2013 par Ivan Voras, expliquant ce que son auteur apprécie de Nimrod : http://ivoras.sharanet.org/blog/tree/2013/Oct-2013-10-05.what-i-like-about-the-nimrod-programming-language.html
• Les Type Classes de Nimrod, expliquées en 2014 : http://vocalbit.com/posts/exploring-type-classes-in-nimrod.html
• En 2014, Andreas Rumpf explique en quoi Nimrod est un langage de programmation système : http://www.drdobbs.com/open-source/nimrod-a-new-systems-programming-languag/240165321
• En 2014, Geet Dugal nous invite à envisager utiliser Nimrod : http://geetduggal.wordpress.com/2014/03/03/consider-nimrod/
• Survol de Nim, proposé par Göran Krampe en 2014 : http://goran.krampe.se/2014/10/20/i-missed-nim/
• En 2014, Maurizio Tomasi relate son expérimentation avec Nimrod : http://ziotom78.blogspot.ca/2014/01/experiments-with-nimrod.html
• Texte de 2014 par Dennis Felsing sur ce qui fait de Nim un langage spécial : http://hookrace.net/blog/what-is-special-about-nim/
• Dennis Felsing, dans cet texte de 2015, explique ce qu'il aime de Nim : http://hookrace.net/blog/what-makes-nim-practical/
• En 2015, Denis Felsing explique comment il démarre un nouveau projet avec Nim : http://howistart.org/posts/nim/1
• En 2015, Grzegorz Adam Hankiewicz souhaite au revoir à Nim et explique pourquoi : https://gradha.github.io/articles/2015/02/goodbye-nim-and-good-luck.html
• Texte de 2017 par Araq (?), qui décrit le virage de Nim vers un modèle qui ne repose plus sur la collecte d'ordures : https://nim-lang.org/araq/destructors.html
• Implémenter la commande yes, bien connue des utilisatrices et des utilisateurs de Linux, à l'aide de Nim, un texte amusant par Valts Liepiņš en 2018 : https://nim-lang.org/blog/2018/01/22/yes-command-in-nim.html
• Regard positif porté sur Nim par Steve Kellock en 2018 : https://totallywearingpants.com/posts/nim-underdog/ (avec un survol de quelques particularités-clés de ce langage sur https://totallywearingpants.com/posts/nim-language-highlights/)
• Optimiser avec Nim, selon Chris Smith en 2018 : https://chameth.com/2018/12/09/over-the-top-optimisations-in-nim/
• Texte de 2019 par Nari Miran qui décrit des mécanismes de Nim permettant de programmer dans ce langage sans avoir recours à une collecte d'ordures traçante : https://nim-lang.org/araq/ownedrefs.html
• Importer des fonctions d'un module avec Nim, par Nari Miran en 2019 : https://narimiran.github.io/2019/07/01/nim-import.html
• Exceptions basées sur des goto, par Nari Miran en 2020 : https://nim-lang.org/araq/gotobased_exceptions.html
• Du tracé de rayons avec Nim, selon Mamy Ratsimbazafy en 2020 : https://nim-lang.org/blog/2020/06/30/ray-tracing-in-nim.html

Nominine

Auteur : Thomas M. Farrelly

Langage OO se voulant très simple.

• http://nominine.org/index.html
• http://nominine.org/documentation/tutorial/idea.html
• Dépendances statiques, texte de 2013 : http://nominine.org/2013/10/06/programming_with_equations.html

none

Auteur : Leonard Ritter

Langage où les expressions imbriquées sont la manière privilégiée d'exprimer une idée, et qui a été pensé spécifiquement pour le développement de jeux.

• https://bitbucket.org/duangle/none/overview

Noop

Auteur : plusieurs personnes.

Langage OO compilé de manière à s'exécuter sur une machine virtuelle., qui cherche à encourager les bonnes pratiques et programmation et à décourager les mauvaises.

• http://code.google.com/p/noop/

Nothing

Auteur : Peter van Eerten

Langage étrange mettant l'accès sur le Bug-Free Programming. Un programme Nothing ne contient effectivement jamais de bogues. La difficulté est d'adapter ses attentes à ce qu'offre le programme

• http://www.turtle.dds.nl/nothing/
• https://esolangs.org/wiki/Nothing

NOVA

Auteurs : Alex Collins, Dominik Grewe, Vinod Grover, Sean Lee et Adriana Susnea.

Langage fonctionnel axé sur le parallélisme des données.

• https://research.nvidia.com/publication/nova-functional-language-data-parallelism-2

Oak

Auteur : Adam McDaniel

Langage qui se présente comme une « alternative plus portable » au langage C.

• https://github.com/adam-mcdaniel/oakc

Oberon

Auteur : Niklaus Wirth

Langage impératif inspiré de Modula-II.

• http://en.wikipedia.org/wiki/Oberon_programming_language
• Texte d'opinion par Lukas Mathis en 2009 : http://ignorethecode.net/blog/2009/04/22/oberon/
• Selon Michael Franz, en 2003 (du moins j'en ai l'impression), Oberon serait le joyau négligé de l'oeuvre de Niklaus Wirth : http://www.ics.uci.edu/~franz/Site/pubs-pdf/BC03.pdf
• Oberon en 2013 : http://www.inf.ethz.ch/personal/wirth/ProjectOberon/

Objective-C

Auteurs : Tom Love et Brad Cox.

Langage OO très important sur les plateformes Apple telles que le Macintosh et le iPhone.

• http://en.wikipedia.org/wiki/Objective-C
• http://developer.apple.com/Mac/library/documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html
• http://cocoadevcentral.com/d/learn_objectivec/
• http://www.macresearch.org/cocoa_for_scientists
• http://cocoasamurai.blogspot.com/2010/01/understanding-objective-c-runtime.html
• http://www.mikeash.com/pyblog/friday-qa-2009-03-13-intro-to-the-objective-c-runtime.html
• http://www.mikeash.com/pyblog/friday-qa-2009-04-24-code-generation-with-llvm-part-2-fast-objective-c-forwarding.html
• http://blog.ablepear.com/2010/04/objective-c-tuesdays-local-variables.html
• http://spin.atomicobject.com/2010/04/07/migrating-to-closures-in-objective-c
• http://www.mikeash.com/pyblog/friday-qa-2010-04-16-implementing-fast-enumeration.html
• http://cocoawithlove.com/2010/07/is-virtual-machine-for-cocoa.html
• http://cocoawithlove.com/2010/08/alternative-objective-c-object.html
• http://blog.ablepear.com/2010/09/creating-guid-or-uuid-in-objective-c.html
• http://blog.ablepear.com/2010/10/objective-c-tuesdays-replacing-in.html
• http://interfacelab.com/objective-c-memory-management-for-lazy-people/
• Objective-C après quelques mois d'utilisation, commentaires de Mario Sangiorgio en 2013 : http://blog.mariosangiorgio.com/2013/01/02/my-troubled-relationship-with-objective-c-and-ios-development/
• Techniques pour écrire moins de code : http://inessential.com/2011/08/04/less_code_less_effort
• Les blocs :
  • Un tutoriel sur le sujet, par Jim Dovey en 2011 : http://ios-blog.co.uk/iphone-development-tutorials/programming-with-blocks-an-overview/
  • Utiliser des blocs pour réduire le recours à l'héritage : http://davidhamrick.com/2011/08/07/using-blocks-for-drawing-to-avoid-subclasssing-in-objective-c.html
  • En 2012, Benjamin Coe explique comment profiter des blocs pour gérer les entrées/ sorties : http://www.benjamincoe.com/post/15891802388/objective-c-designing-with-blocks
  • Comment déclarer un bloc : http://fuckingblocksyntax.com/
• Espaces nommés et constantes en Objective-C : http://www.mikeash.com/pyblog/friday-qa-2011-08-19-namespaced-constants-and-functions.html
• Automatisation de la gestion des ressources avec Objective-C : http://www.mikeash.com/pyblog/friday-qa-2011-09-30-automatic-reference-counting.html
• Selon Daniel Jalkut, en 2011, Objective-C est le langage : http://www.red-sweater.com/blog/2256/objective-c-is-the-language
• Réflexions sur Objective-C après une dizaine d'années d'utilisation, par Matt Nunogawa en 2011 : http://www.amattn.com/2011/10/15/the_disposition_of_objective-c.html
• Utiliser Objective-C sous Windows, un texte de Paul Silisteanu en 2012 : http://solarianprogrammer.com/2012/03/21/clang-objective-c-windows/
• Littéraux avec Objective-C, texte de 2012 par Mike Ash : http://www.mikeash.com/pyblog/friday-qa-2012-06-22-objective-c-literals.html
• Quelques trucs avec Objective-C, colligés par Mattt Thompson en 2012 : http://www.nshipster.com/reader-submissions-new-years-2013/
• Sept péchés mortels des programmeuses et des programmeurs Objective-C, par Ash Furrow en 2012 : http://ashfurrow.com/blog/seven-deadly-sins-of-modern-objective-c
• Les différentes saveurs de pointeurs nuls en Objective-C, par Mattt Thompson en 2013 : http://nshipster.com/nil/
• Saines pratiques avec Objective-C : http://www.objc.io/
• En 2013, Aaron Hillegass et Mikey Ward expliquent les variables et les types avec Objective-C : http://www.informit.com/articles/article.aspx?p=2161675
• Un truc pour que les fichiers Objective-C deviennent auto-exécutables, par Nicolas Bouilleaud en 2013 : http://bou.io/HowToWriteASelfCompilingObjectiveCFile.html
• Le « Objectivist-C », une approche radicale à la programmation en Objective-C proposée par Jaymie Strecker en 2012 : http://fdiv.net/2012/04/01/objectivist-c
• Écrire du code Objective-C un peu comme un écrirait du code Smalltalk, une proposition de Soroush Khanlou en 2014 : http://khanlou.com/2014/05/smalltalky-control-structures/
• Utiliser Objective-C pour écrire des scripts, texte de 2014 : http://blog.manbolo.com/2014/06/01/shell-scripting-with-objectivec
• Programmer avec Grand Central Dispatch, série d'articles par Dave Rahardja en 2014 : http://www.humancode.us/2014/07/28/intro-to-gcd.html
• Qu'en est-il d'Objective-C en 2015? Texte de Jordan Morgan : https://medium.com/the-traveled-ios-developers-guide/objective-c-in-2015-3cb7dab3690c
• Les propriétés atomiques ou non, expliquées par Yogev Sitton en 2017 : https://medium.com/@YogevSitton/atomic-vs-non-atomic-properties-crash-course-d11c23f4366c
• Programmation impérative en OCaml, par Martina Lui en 2018 : https://thealmarty.com/2018/06/12/imperative-programming-in-ocaml/

Critiques :

• En 2013, après un an d'utilisation, Craig Gidney offre une critique du langage : http://twistedoakstudios.com/blog/Post8237_a-years-worth-of-opinions-about-objective-c
• Les 13 pires caractéristiques d'Objective-C, selon Anton Zherdev en 2013 : http://www.antonzherdev.com/post/70064588471/top-13-worst-things-about-objective-c

ObjectPascal

Auteur : Larry Tesler

Langage sous-jacent à TurboPascal, variante OO de Pascal.

• http://en.wikipedia.org/wiki/Object_Pascal
• Un historique du langage : http://wiki.freepascal.org/Object_Pascal_History
• Un tutoriel : http://wiki.freepascal.org/Object_Pascal_Tutorial
• Un livre en ligne sur l'apprentissage de la programmation avec ce langage, par Motaz Abdel Azeem en 2011 : http://www.code.sd/startprog/index.html

Oblivion

Auteur : Josh Weinstein

Langage dont la compilation génère des images SVG.

https://github.com/jweinst1/Oblivion

OCaml

Auteur : Xavier Leroy

De son vrai nom Objective Caml, langage fonctionnel mais avec un support pour l'approche OO .

• http://caml.inria.fr/index.en.html
• http://godi.camlcity.org/godi/why.html
• Démarrer avec OCaml :
  • http://thinkocaml.com/
  • http://www.ocaml-tutorial.org/
  • http://wiki.cocan.org/getting_started_with_ocaml
  • texte d' Edgar Aroutiounian en 2015 : http://hyegar.com/blog/2015/10/19/so-you' re-learning-ocaml/
  • introduction à OCaml, proposée par Daniil Baturin en 2018 : https://blog.baturin.org/introduction-to-ocaml.html
• http://caml.inria.fr/pub/docs/oreilly-book/
• Divers articles sur le design de ce langage : http://www.hxa.name/notes/note-hxa7241-20151108T1107Z.html
• http://okmij.org/ftp/Computation/caml-shift.pdf
• http://rwmj.wordpress.com/2009/08/04/ocaml-internals/
• http://ambassadortothecomputers.blogspot.com/2010/03/inside-ocaml-objects.html
• http://on-ruby.blogspot.com/2006/10/author-interview-joshua-sm_116161451874815021.html
• En 2010, Yaron Minsky propose d'utiliser OCaml comme langage de script : http://ocaml.janestreet.com/?q=node/80
• Un Cheat Sheet : http://www.ocamlpro.com/code/2011-06-03-cheatsheets.html
• Un type universel? http://ocaml.janestreet.com/?q=node/95
• L'heure d'adopter OCaml est-elle venue? Une opinion de Yaron Minsky, en 2011 : http://queue.acm.org/detail.cfm?id=2038036
• En 2012, Andrew Ruef explique pourquoi il faut, selon lui, adopter OCaml : http://www.mimisbrunnr.net/~munin/blog/why-ocaml.html
• Comment OCaml vérifie les types, un texte détaillé de 2013 : hhttp://okmij.org/ftp/ML/generalization.html
• Optimiser avec OCaml : Optimisation--Liens.html#langage_OCaml
• En 2014, Andrew Herron explique pourquoi on devrait utiliser OCaml dès maintenant : http://spyder.wordpress.com/2014/03/16/why-ocaml-why-now/
• Introduction à OCaml, par Mads Hartmann en 2014 : http://mads379.github.io/ocaml/2014/11/13/ocaml-briefly.html
• Texte de 2015 par Alain Frisch, expliquant les tableaux de nombres à virgule flottante avec OCaml : http://www.lexifi.com/blog/about-unboxed-float-arrays
• En 2014, texte mettant de l'avant pourquoi l'auteur estime qu'il est temps d'utiliser OCaml : https://spyder.wordpress.com/2014/03/16/why-ocaml-why-now/
• Programmation système sous Unix à l'aide d'OCaml, un livre en ligne par Xavier Leroy et Didier Rémy, en 2014 : https://ocaml.github.io/ocamlunix/
• OCaml expliqué aux sceptiques, par Keith Waclena : http://www2.lib.uchicago.edu/keith/ocaml-class/home.html
• Introduction à OCaml, riche en exemples, par Fredrik Dyrkell en 2015 : http://www.lexicallyscoped.com/2015/06/06/intro-to-ocaml.html
• Programmation fonctionnelle avec OCaml : Paradigmes-programmation--Liens.html#programmation_fonctionnelle_langage_OCaml
• En 2014, Jeff Meister explique pourquoi son entreprise utilise OCaml : http://tech.esper.com/2014/07/15/why-we-use-ocaml/
• Série d'articles par Eric Lippert en 2016, alors qu'il expérimente avec OCaml pour écrire sa propre version du jeu Zork, destiné à s'exécuter sur une Z-Machine (les liens sont dans la section sur la Z-Machine)
• Améliorer l'inlining avec OCaml, par Jane Street en 2016 : https://blogs.janestreet.com/flambda/
• Implémenter des Type Classes modulaires, texte de Shayne Fletcher en 2017 : https://accu.org/index.php/journals/2445
• OCaml et le Framework Rails, qu'on associe normalement à Ruby, texte de 2019 par Jasim A. Basheer : https://protoship.io/blog/rails-on-ocaml/
• Tutoriel à propos de la programmation parallèle sur mes machines multi-coeurs en OCaml : https://github.com/ocaml-multicore/parallel-programming-in-multicore-ocaml/tree/draft

Critiques :

• http://sds.podval.org/ocaml-sucks.html
• En 2016, Chris Donaher vante les mérites d'OCaml pour ce qui est de rédiger rapidement des programmes sécuritaires : https://www.endgame.com/blog/build-safer-programs-faster-ocaml
• Texte de 2020 dans lequel Paul Biggar explique ses raisons pour abandonner OCaml : https://blog.darklang.com/leaving-ocaml/

Outils et dialectes :

• Une implémentation d'OCaml pour la JVM : http://www.ocamljava.org/

Odin

Auteur : Ginger Bill

Langage qui vise à remplacer C, rien de moins.

• https://odin-lang.org/
• https://odin.handmade.network/
• https://github.com/gingerBill/Odin

OMeta

Auteur : Alessandro Warth

Langage OO pour reconnaissance de patterns.

• tinlizzie.org/ometa/

ooc

Auteur : Amos Wenger

Langage qui se dit fonctionnel et OO, sorte d'hybride syntaxique de plusieurs langages, dont la compilation produit du code C99.

• http://ooc-lang.org/

Opa

Auteur : des gens chez MLState

Langage axé vers l'infonuagique et les systèmes répartis sur le Web.

• http://opalang.org/
• http://doc.opalang.org/index.html#_introducing_opa
• http://opalang.org/see.xmlt
• http://blog.opalang.org/
• http://blog.opalang.org/2011/10/programming-in-cloud-with-opa.html

Orc

Auteur : Jayadev Misra

Langage orienté vers l'orchestration de services dans les systèmes répartis

• Site officiel : http://orc.csres.utexas.edu/
• Article sur l'orchestration avec Orc : http://www.cs.utexas.edu/users/wcook/papers/OrcJSSM05/OrcJSSM.pdf

Oz

Auteur : Gert Smolka

Langage multiparadigmatique mettant l'accent sur la multiprogrammation.

• http://en.wikipedia.org/wiki/Oz_%28programming_language%29
• http://www.mozart-oz.org/
• http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.55.4528
• http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.25.3176

P

Auteurs : Ankush Desai et Pantazis Deligiannis

Langage mettant l'accent sur la programmation événementielle et la communication asynchrone entre automates.

• https://github.com/p-org/P
• https://github.com/p-org/P/blob/master/Doc/Manual/pmanual.pdf
• https://www.microsoft.com/en-us/research/blog/p-programming-language-asynchrony/

Parasail

Auteur : Tucker Taft

Langage axé sur le développement de programmes exploitant le parallélisme. Le code est automatiquement divisé en tout petits blocs, nommés PicoThreads, et tout s'y passe en parallèle par défaut.

• http://parasail-programming-language.blogspot.com/
• http://www.technologyreview.com/computing/38149/?ref=rss&a=f
• Programmer sans pointeurs ni références, et parvenir à construire des structures de données complexes malgré tout. Texte de 2012 : http://parasail-programming-language.blogspot.ca/2012/08/a-pointer-free-path-to-object-oriented.html
• Présentation sur le design de ce langage, par Tucker Taft en 2013 : http://parasail-programming-language.blogspot.ca/2013/11/tech-talk-and-tutorial-at-splash-2013.html
• Concurrence et parallélisme dans le design de Parasail, par Tucker Taft en 2014 : http://parasail-programming-language.blogspot.ca/2013/12/concurrency-vs-parallelism.html

Pascal

Auteur : Niklaus Wirth

Langage impératif, longtemps associé de près à l'enseignement de la programmation.

• http://en.wikipedia.org/wiki/Pascal_programming_language
• http://userweb.cs.utexas.edu/users/novak/grammar.html
• http://homepages.cwi.nl/~steven/pascal/
• http://www.freepascal.org/
• http://www.osnews.com/story/10607
• http://www.osnews.com/story/18592/
• Critique de Brian W. Kernighan : http://www.lysator.liu.se/c/bwk-on-pascal.html
• Comment le premier compilateur Pascal a été écrit, selon Niklaus Wirth : https://raw.github.com/gist/1535291/da3f7f01a2c015cda3901986c6be820c9abd0175/gistfile1.txt
• En 2014, Dmitry Geurkov explique comment il est arrivé à compiler du code Pascal vieux de 30 ans : http://troydm.github.io/blog/2014/01/26/making-30-years-old-pascal-code-run-again/
• Texte de 2013 relatant qu'il est encore raisonnable de développer un jeu en Pascal plutôt qu'avec un autre langage plus « à la mode » : http://www.kamremake.com/devblog/pascal-the-best-of-both-worlds/comment-page-1/
• Un compilateur FreePascal gratuit : http://www.getlazarus.org/release/
• En 2017, Michael Fogus relate (en colligeant une série de tweets!) l'utilisation faite de Pascal chez Apple : http://blog.fogus.me/2017/07/20/pascal-at-apple/
• Depuis 2019, FreePascal peut être compilé pour WebAssembly : https://lists.freepascal.org/pipermail/fpc-pascal/2019-September/056848.html (voir principalement https://wiki.freepascal.org/WebAssembly)
• En 2021, Niklaus Wirth fait un retour sur les 50 ans du langage : https://cacm.acm.org/magazines/2021/3/250705-50-years-of-pascal/fulltext
• Site dédié au langage Pascal et à sa présence sur de « petits » ordinateurs : http://pascal.hansotten.com/

Pawn

Auteur : pas clair (des gens de ITB CompuPhase)

Langage de script, utilisé dans plusieurs jeux populaires.

• http://www.compuphase.com/pawn/pawn.htm
• http://en.wikipedia.org/wiki/Pawn_%28programming_language%29

Pepper3

Auteur : Andy Balaam

Langage multiparadigme, qui vise entre autres à faciliter la création de types et le déploiement.

• https://www.artificialworlds.net/blog/2018/01/22/questions-and-answers-about-pepper3/
• https://www.artificialworlds.net/blog/2018/01/19/examples-of-pepper3-code/

Perl

Auteur : Larry Wall

Un langage « complètement sauté », qui fait des miracles avec des riens, mais qui n'est pas le plus simple d'approche avec plus de cent opérateurs, des tas de raccourcis et un mantra selon lequel « Il y a plusieurs façons de faire chaque chose » (There's more than one way to do it, TMTOWTDI). En ce sens, Perl va à contresens de Python, qui prétend le contraire (qu'il ne devrait y avoir qu'une seule manière évidente de faire chaque chose). Perl est particulièrement puissant pour ce qui tient du traitement de chaînes de caractères, du Pattern Matching. Puisque Perl 6 sera prêt à Noël, mais reste à voir quel Noël, un calendrier de l'Avent décrit les nouvelles idées de ce langage. . à bien des points de vue, Perl est philosophiquement opposé à Python.

• Site officiel : http://www.perl.com/ (pour télécharger la version la plus récente : http://www.perl.com/download.csp)
• Perl pour débutants : http://perl-begin.org/
• Apprendre Perl par exemples, selon Matthew Might en 2014 : http://matt.might.net/articles/perl-by-example/
• Une entrevue avec Larry Wall sur Perl : http://www.computerworld.com.au/index.php?q=article/270267/-z_programming_languages_perl&fp=&fpid=
• La page Web de Larry Wall sur Perl  : http://www.wall.org/~larry/perl.html
• Perl contemporain : http://www.modernperlbooks.com/drafts/modern_perl/chapter_01.html
• L'an 2012 marque le 25^e anniversaire de Perl : http://news.perlfoundation.org/2012/12/the-first-twenty-five-years.html
• Enseigner le Perl moderne, selon Gabor Szabo en 2011 : http://szabgab.com/how-to-teach-modern-perl.html
• Qu'est-ce que le Perl contemporain? http://perlgeek.de/blog-en/perl-tips/what-is-modern-perl.html
• Pourquoi Perl?
  • Un texte de 2007 par Larry Wall : http://www.linuxjournal.com/article/2070
  • Un texte de 2011 : http://bits.shutterstock.com/?p=63
  • Texte de 2014 par Buddy Burden qui affirme que Perl est à la fois ingénierie et Art : http://blogs.perl.org/users/buddy_burden/2014/01/perl-and-me-part-6-perl-is-engineering-and-art.html
• Perl et les expressions régulières :
  • http://www.ibm.com/developerworks/linux/library/l-cpregex.html?ca=dgr-lnxw01Perl6Gram
  • http://www.perl.com/pub/a/2002/06/04/apo5.html
• Perl et les opérateurs :
  • des opérateurs « secrets » : http://www.catonmat.net/blog/secret-perl-operators/
  • tableau périodique des opérateurs du langage : http://www.ozonehouse.com/mark/periodic/
• Un vecteur multidimensionnel pleinement implémenté sans aucune répétitive : http://github.com/LastOfTheCarelessMen/Vector/blob/master/lib/Vector.pm
• Sur la manipulexité et la « Whipuptitude » (sans blagues) : http://use.perl.org/~ziggy/journal/26131
• Perl s'explique en apocalypses et en exégèses. La documentation officielle s'explique à partir de ces deux concepts : http://feather.perl6.nl/syn/
• Les (souvent délicieux) discours de Larry Wall sur le State of the Onion : http://www.perlfoundation.org/perl6/index.cgi?state_of_the_onion
• Écrire des jeux avec Perl et SDL : http://arstechnica.com/gaming/news/2006/02/games-perl.ars
• Il ne faut pas perdre la foi... http://perlmonks.org/?node_id=563050
• Perl et XML : http://www.ibm.com/developerworks/xml/library/x-xmlperl1.html?ca=dgr-lnxw01XML-Simple
• Perl et les graphiques : http://www.ibm.com/developerworks/opensource/library/os-perlgdchart/?ca=dgr-lnxw01Perl-GD-Charts
• Perl et la plateforme .NET :
  • à propos de Perl .NET (du Code Project) : http://www.codeproject.com/KB/dotnet/PerlNETQuickIntroduction.aspx
  • consommer des services .NET à partir de Perl, selon Kory Becker en 2011 : http://www.primaryobjects.com/CMS/Article128.aspx
• Perl et le Framework Rails, qu'on associe normalement à Ruby : http://www.bbc.co.uk/blogs/radiolabs/2007/11/perl_on_rails.shtml
• Pourquoi les administrateurs détestent Perl : http://www.oreillynet.com/onlamp/blog/2008/08/why_corporates_hate_perl.html
• Perl pour Windows (un Wiki) : http://win32.perl.org/wiki/index.php?title=Main_Page
• Un livre électronique sur Perl : http://hop.perl.plover.com/book/
• Cours accéléré sur Perl : http://usestrict.net/2009/05/23/perl-crash-course-pragmas-perl-modules-and-cpan/
• Implémentation de Perl en Haskell : http://www.pugscode.org/
• Une instruction amusante : le Don't, http://search.cpan.org/~dconway/Acme-Don-t-1.01/t.pm
• Plusieurs font de la poésie en Perl, mais ce poème particulier a une très vilaine réputation : http://en.wikipedia.org/wiki/Black_Perl
• Pourquoi Perl n'est pas près de disparaître : http://ostatic.com/blog/guest-post-why-perl-isnt-going-away-soon-or-ever
• http://jjnapiorkowski.vox.com/library/post/communicating-value-this-is-our-world-and-perl-is-my-choice.html
• http://curiousprogrammer.wordpress.com/2010/08/31/perl-compiler-speed-its-fast/
• http://www.modernperlbooks.com/drafts/modern_perl/chapter_01.html
• Écrire du Perl en latin... http://www.csse.monash.edu.au/~damian/papers/HTML/Perligata.html?t=1
• http://www.perl.com/pub/2007/12/06/soto-11.html
• Il ne faut apparemment pas mêler Perl et armement nucléaire : http://www.foo.be/docs/tpj/issues/vol2_1/tpj0201-0004.html
• http://f00li5h.pin21.com/blog/Examples-of-using-dispatch-tables-in-perl.html
• Ce n'est pas toujours la faute de Perl : http://blog.nu42.com/2010/12/dont-blame-perl-for-all-ugly-code.html
• http://www.onyxneon.com/books/modern_perl/index.html
• Perl, et être cool ou pas : http://blogs.perl.org/users/su-shee/2011/01/and-suddenly-youre-hip.html
• Écrire des tests pour Perl avec Test::More : http://blogs.lessthandot.com/index.php/WebDev/ServerProgramming/writing-perl-tests-with-test
• http://blogs.perl.org/users/jeffrey_kegler/2011/01/why-i-stuck-with-perl.html
• http://blog.sam-pointer.com/2011/02/07/i-keep-arriving-back-at-perl
• Obfuscation de code Perl (comme si c'était nécessaire, dirons les plus vilaines et les plus vilains parmi vous) : http://www.stunnix.com/prod/po/overview.shtml
• Une liste de One-Liners en Perl : http://www.catonmat.net/download/perl1line.txt
• Le plaisir de Perl, texte à saveur historique de Andrew Leonard en 2012 : http://www.salon.com/1998/10/13/feature_269/
• En 2009, John Graham Cumming a mis en ligne une pétition pour obtenir des excuses formelles du gouvernement britannique quant au traitement réservé à Alan Turing. Cette pétition, qui fut un succès et qui porta fruit, avait de particulier de mettre en relief que certaines célébrités l'avaient signé. En 2012, Cumming révèle le code Perl derrière cette pétition : http://blog.jgc.org/2012/07/perl-script-powered-alan-turing.html
• Utiliser Perl pour les tests, texte de 2012 : http://www.modernperlbooks.com/mt/2012/08/why-i-use-perl-testing.html
• En 2013, Dietrich Schmitz parle de Perl comme du langage que tous souhaitaient déclarer « mort » : http://www.linuxadvocates.com/2013/03/perl-language-everybody-wants-to.html
• Texte d'Allison Randall qui, en 2013, aime toujours Perl : http://allisonrandal.com/2013/03/31/mythbusters-why-i-still-love-perl/
• En 2011, Lincoln Stein explique comment Perl a sauvé, selon lui, le Human Genome Project : http://www.bioperl.org/wiki/How_Perl_saved_human_genome
• Utiliser Perl comme un meilleur [insérer ici le nom de l'outil], par John D. Cook en 2013 : http://www.johndcook.com/blog/2013/08/20/perl-as-a-better/
• Des fermetures avec Perl, texte de 2013 : http://www.manchicken.com/2013/general/gist-of-the-day-perl-closure-extravaganza.html
• Écrire du code Perl lisible et qu'il est par la suite possible d'entretenir, par A. Sinan Unur en 2013 : http://programming.oreilly.com/2013/12/can-one-write-readable-and-maintainable-perl.html
• En 2014, il devient possible d'utiliser des signatures de fonctions avec Perl. Texte à ce sujet de David Farrell : http://perltricks.com/article/72/2014/2/24/Perl-levels-up-with-native-subroutine-signatures
• La fonction split de Perl et sa polyvalence, par David Farrell en 2014 : http://perltricks.com/article/121/2014/10/24/Perl-s-versatile-split-function
• Perl présenté comme le langage de programmation ultime, par Thomas Jaspers en 2015 : https://blog.codecentric.de/en/2015/09/perl-the-ultimate-programming-language/
• Métaprogrammation avec Perl : Paradigmes-programmation--Liens.html#metaprogrammation_langage_Perl
• Les variables prédéfinies de Perl : http://perldoc.perl.org/perlvar.html

À propos de Perl 5 :

• Exécuter Perl 5 sur la JVM : http://www.nntp.perl.org/group/perl.perl5.porters/2009/08/msg150099.html
• Les principes au coeur du langage : http://blog.urth.org/2011/07/perl-5-core-principles.html
• Amusante présentation sur Perl 5, son cycle de développement et ses relations avec Perl 6 : http://www.slideshare.net/obrajesse/oscon-2011-perl-516-and-beyond
• Comment identifier du code Perl 5 déficient, un texte de 2013 : http://www.modernperlbooks.com/mt/2013/04/how-to-identify-clunky-perl-5-code.html
• Éloge de Perl 5, par Chris Travers en 2014 : http://ledgersmbdev.blogspot.ca/2014/02/in-praise-of-perl-5.html
• À propos de Perl 5.22, survol de Brian D Foy en 2015 : http://perltricks.com/article/165/2015/4/10/A-preview-of-Perl-5-22

À propos de Perl 6 :

• Qu'est-ce que Perl 6?
  • http://perl6.org/downloads/
  • http://www.perl.com/pub/a/2006/01/12/what_is_perl_6.html
  • http://dev.perl.org/perl6/
  • http://www.computerworld.com.au/article/269758/perl_6_break_compatibility_support_other_interpreters
• Introduction à Perl 6, proposée par Naoum Hankache : http://perl6intro.com/
• Différences entre Perl 5 et Perl 6 : http://design.perl6.org/Differences.html
• Le développement de Perl  6 progresse... http://www.oreillynet.com/onlamp/blog/2008/01/what_the_perl_6_and_parrot_hac.html (mais il y a des discussions serrées... http://www.perlmonks.org/?node_id=836349)
• Un tableau périodique des opérateurs de Perl 6 : http://www.ozonehouse.com/mark/blog/code/PeriodicTable.html
• Pourquoi Perl 6 est différent des autres langages : http://blogs.perl.org/users/leon_timmermans/2010/04/why-perl-6-is-different.html
• Historique de Perl 6 : http://use.perl.org/~masak/journal/40451
• http://perlgeek.de/blog-en/perl-6/perl-6-in-2009.html
• Amusant : http://www.axis-of-aevil.net/archives/img/2003_08/p6_cover.jpg
• Le processus de RFC pour Perl 6 : http://www.perl.com/lpt/a/482
• Plonger dans Perl 6 : http://perlbuzz.com/2010/08/diving-into-perl-6.html
• Perl 6 est-il encore un Perl? http://perlbuzz.com/2010/08/what-to-say-to-perl-6-isnt-perl-any-more.html
• Déboguer une grammaire Perl 6 : http://perlgeek.de/en/article/debug-a-perl-6-grammar
• http://strangelyconsistent.org/blog/extending-the-syntax-of-perl6
• Réflexions sur Haskell et Perl 6 : http://loveandhotsauce.net/nowhere/opinions/perl6haskell.html
• Perl 6 en 2010 : http://perlgeek.de/blog-en/perl-6/perl-6-in-2010.html
• Perl 6 en 2011 : http://perlgeek.de/blog-en/perl-6/perl-6-in-2011.html
• Les macros en Perl 6 : http://strangelyconsistent.org/blog/macros-what-are-they-really
• La métaprogrammation avec Perl 6, un texte de 2011 : http://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/
• En 2013, Carl Masäk met en relief que Perl 6 est maintenant aussi « vieux » que l'était Perl lorsque les travaux sur Perl 6 ont été amorcés : http://strangelyconsistent.org/blog/perl6-is-now-half-as-old-as-perl
• Réflexions sur Perl 6 et Unicode, texte de 2013 : http://rdstar.wordpress.com/2013/07/22/some-thoughts-on-unicode-in-perl-6/
• L'état de Perl 6 : http://perl6.guide/
• Apprendre à faire des One-Liners avec Perl 6 tout en s'amusant, par David Farrell en 2014 : http://perltricks.com/article/136/2014/11/20/Get-started-with-Perl-6-one-liners
• Le vieux gag veut que Perl 6 soit livré à Noël, mais qu'on ne sache pas Noël de quelle année... Mais enfin, en 2015, Larry Wall aurait annoncé Perl 6 pour Noël 2015 :
  • http://blogs.perl.org/users/shadowcat_mdk/2015/02/fosdem-2015-its-christmas.html
  • http://www.infoworld.com/article/2882300/perl/perl-creator-larry-wall-rethought-version-6-due-this-year.html
  • texte de Paul Krill en 2015 : http://www.infoworld.com/article/3017418/application-development/developers-can-unwrap-perl-6-on-christmas.html
  • à propos du lancement officiel, par Tim Toady (Camelia?) en 2015 (la veille de Noël, bien sûr) : https://perl6advent.wordpress.com/2015/12/24/an-unexpectedly-long-expected-party/ puis https://perl6advent.wordpress.com/2015/12/25/christmas-is-here/ par Coke (?), le jour de Noël, bien sûr
  • maintenant que Perl 6 a été livré, Jonathan Worthington réfléchit aux défis à venir dans ce texte de 2015 : https://6guts.wordpress.com/2015/12/26/reflecting-celebrating-and-looking-forward/
• Quelques truc chouettes à propos de Perl 6 (et, accessoirement, à propos de ... COBOL!), par Curtis Poe en 2015 : http://blogs.perl.org/users/ovid/2015/02/a-little-thing-to-love-about-perl-6-and-cobol.html
• Texte de 2015 par Moritz Lenz expliquant pourquoi il semble si ardu d'écrire un compilateur pour Perl 6 : http://perlgeek.de/blog-en/perl-6/2015-why-hard.html
• Verra-t-on Perl 6 d'ici la fin de 2015? Oui, si on en croit Larry Wall dans cette entrevue : http://www.linuxvoice.com/interview-larry-wall/
• S'amuser avec Perl 6, par Dave Rolsky en 2015 : http://blog.urth.org/2015/11/29/perl-6-is-fun/
• Présentation portant sur ce qu'il est possible de faire avec Perl 6, par Pete Evstratov en 2016 : http://tpm2016.zoffix.com/#/
• En 2016, Curtis Poe décrit Perl 6 comme le « Game of Thrones » des langages de programmation : http://techbeacon.com/why-perl-6-game-thrones-programming-languages
• Manipuler des flux à l'aide de Perl, texte de 2016 :  http://emdeha.github.io/2016/04/06/perl-streams
• Les jonctions « certifiées par Schrödinger » de Perl 6, décrites en 2016 : http://perl6.party/post/Perl-6-Schrodinger-Certified-Junctions
• En 2017, Evan Miller offre un survol de Perl 6 : http://www.evanmiller.org/a-review-of-perl-6.html
• Survol éclair des meilleurs mécanismes de Perl 6, selon Tyler Slimkemann (je spécule sur le nom de famille) en 2019 : https://aearnus.github.io/2019/04/03/a-whirlwind-tour-of-perl6-s-best-features
• Le given de Perl 6, présenté comme une sélective (switch) sur stéroïdes par Matéu (son nom de famille m'échappe) en 2019 : https://tenesianu.blogspot.com/2019/05/perl-6s-given-switch-on-steroids.html
• Article amusant de Damian Conway en 2019, qui montre que parfois, avec Perl 6, une tâche infinie peut représenter moins d'effort qu'une tâche finie, prenant exemple sur la génération de nombres premiers : http://blogs.perl.org/users/damian_conway/2019/07/infinite-work-is-less-work.html
• Faudrait-il renommer Perl 6?
  • en 2019, Elizabeth Mattijsen soulève la question : https://github.com/perl6/problem-solving/issues/81
  • texte de 2019 mettant de l'avant la position de Curtis Poe : http://blogs.perl.org/users/ovid/2019/08/is-perl-6-being-renamed.html

À propos de Perl 7 :

• La venue de Perl 7, annoncée en 2020 par Brian D Foy : https://www.perl.com/article/announcing-perl-7/
• En 2020, Leon Timmermans dit percevoir dans Perl 7 un changement de système de valeurs : http://blogs.perl.org/users/leon_timmermans/2020/08/perl7-is-a-fork-of-values.html

Critiques :

• http://perlbuzz.com/2011/04/slipping-away.html
• Les didacticiels de Perl ne sont pas tout à fait bons (je paraphrase), texte de 2011 : http://blogs.perl.org/users/mithaldu/2011/10/perl-tutorials-suck-and-cause-serious-damage.html
• Quelque chose de pas gentil : un comparatif de Perl avec « Quorom » et « Randomo », deux langages générés aléatoirement...
  • http://www.neverworkintheory.org/?p=197
  • http://www.neverworkintheory.org/?p=211
  • http://www.cs.siue.edu/~astefik/papers/StefikPlateau2011.pdf
• Texte de 2004 par Steve Yegge, qui rend hommage à ce « langage ancien » qu'est Perl : https://sites.google.com/site/steveyegge2/ancient-languages-perl
• Cette recherche de 2011 par Andreas Stefik, Susanna Siebert, Melissa Stefik et Kim Slattery laisse croire qu'apprendre la programmation avec Perl serait aussi difficile qu'apprendre la programmation avec un langage créé de manière purement aléatoire (ouille!) : http://ecs.victoria.ac.nz/foswiki/pub/Events/PLATEAU/Program/plateau2011-stefik.pdf
• Pourquoi Perl n'a pas gagné, un texte de 2014 : http://outspeaking.com/words-of-technology/why-perl-didnt-win.html
• La chute de Perl, un langage autrefois prometteur, par Conor Myhrvold en 2014 : http://www.fastcolabs.com/3026446/the-fall-of-perl-the-webs-most-promising-language
• Selon Curtis Poe en 2016, Perl n'est pas un mauvais langage, mais a une mauvaise réputation dû aux débutantes et aux débutants du Web qui s'en servaient auparavant : http://techbeacon.com/perl-not-dead-it-was-early-web-novices-gave-it-bad-name
• Est-ce une critique ou n'est-ce que de l'humour? Toujours est-il que le 1^er avril 2019 (oui, attention à la date!), Colin McMillen prétend que la plupart des taches de peinture sont en pratique des programmes Perl valides : https://famicol.in/sigbovik/
• Quelques mythes qui circulent à propos de Perl 6, selon Tyler Limkemann en 2019 : https://aearnus.github.io/2019/07/06/perl-6-is-cursed
• Texte semi-humoristique de Colin McMillen en 2019, qui met de l'avant que 93% des taches de peinture seraient aussi des programmes Perl valides : https://famicol.in/sigbovik/
• Selon The HFT Guy en 2019, Perl serait mourant et susceptible de disparaître dans quelques années : https://thehftguy.com/2019/10/07/perl-is-dying-quick-could-be-extinct-by-2023/
• Enjeu culturel important pour la communauté entourant Perl, soit le respect du code de conduite et la gestion ds comportements toxiques :
  • Article de 2021 par Jim Salter relatant les frictions dans la Perl Foundation à ce propos : https://arstechnica.com/gadgets/2021/08/the-perl-foundation-is-fragmenting-over-code-of-conduct-enforcement/

Pharo

Auteurs : une équipe faite de Marcus Denker, Stephane Ducasse, Sven Van Caekenberghe, Notbert Hartl, Guille Polito et Esteban Lorenzano