Machines virtuelles – quelques liens

Cette page est embryonnaire. Il y a beaucoup à écrire sur le sujet, et j'ai vraiment trop peu de temps...

Quelques liens d'ordre général :

• Un Wiki sur le sujet : http://en.wikipedia.org/wiki/Virtual_machine
• Le p-code, ou code pour une machine portable (typiquement, une machine à pile) : http://en.wikipedia.org/wiki/P-Code_machine
• Réflexion de Neil McAllister en 2008 sur les machines virtuelles génériques : http://www.infoworld.com/d/developer-world/virtual-machines-all-seasons-077
• En 2010, Matt Gallagher spécule sur l'inévitabilité de l'avènement d'une machine virtuelle pour Cocoa, bien connu des programmeuses et des programmeurs Objective-C : http://cocoawithlove.com/2010/07/is-virtual-machine-for-cocoa.html
• La machine virtuelle algorithmique, texte de Yosef Kreinin en 2008 : http://www.yosefk.com/blog/the-algorithmic-virtual-machine.html
• Réflexion sur les systèmes de types, les langages de programmation, les machines virtuelles et la capacité d'optimiser le code, par Charles-Oliver Nutter en 2013 : http://blog.headius.com/2013/05/on-languages-vms-optimization-and-way.html
• Comparatif de systèmes de fichiers de diverses machines virtuelles, par Mitchell Hashimoto en 2014 : http://mitchellh.com/comparing-filesystem-performance-in-virtual-machines
• Article technique de 2015 expliquant comment utiliser les « micro machines virtuelles » en tant que fondation pour le développement de langages de programmation, par Kunshan Wang et al. : http://drops.dagstuhl.de/opus/volltexte/2015/5034/pdf/24.pdf

Faire votre propre machine virtuelle :

• Développer une machine virtuelle en C# (sources incluses) : http://www.icemanind.com/
• Écrire un langage basé sur une machine virtuelle en Go : http://www.slideshare.net/feyeleanor/golightly-building-vmbased-language-runtimes-in-go
• Un exemple de petite machine virtuelle, par Alexey Lyashko en 2011 : http://syprog.blogspot.com/2011/12/simple-virtual-machine.html
• Réflexion a posteriori de Laurence Tratt qui, à quelques reprises, s'est trouvé dans une situation où il a dû écrire sa propre machine virtuelle : http://tratt.net/laurie/tech_articles/articles/fast_enough_vms_in_fast_enough_time
• Le VMKit est un ensemble d'outils basés sur LLVM pour générer des machines virtuelles :
  • http://vmkit.llvm.org/
  • http://llvm.org/pubs/2010-03-VEE-VMKit.pdf
• Une machine virtuelle métaprogrammée avec C++, texte de 2013 : http://vermeille.fr/dotclear2/index.php/post/23-Metaprogramming-a-full-Virtual-Machine
• Une machine virtuelle... en Excel? Par Brian Benchoff en 2014 : http://hackaday.com/2014/12/25/writing-a-virtual-machine-in-excel/
• Implémenter une machine virtuelle en langage C, par Felix Angell en 2015 : http://blog.felixangell.com/virtual-machine-in-c/
• Écrire une machine virtuelle CHIP-8 en Rust, par Walter Kuppens en 2016 : https://walterkuppens.com/post/writing-a-chip-8-virtual-machine-in-rust/

asm.js

La plateforme asm.js est un projet d'un grand intérêt, décrit sur ../Sujets/Web/JavaScript-Outils.html#asmjs

Alchemy

La plateforme Alchemy d'Adobe a pour objectif de supporter l'exécution de code C et C++ sur la machine virtuelle d'ActionScript..

• http://labs.adobe.com/technologies/alchemy/

CHIP-8

Une machine virtuelle qui a permis le développement de certains des premiers (et des plus célèbres!) jeux vidéos.

• https://en.wikipedia.org/wiki/CHIP-8

Le CLR de la plateforme .NET

Conçue de prime abord pour supporter plusieurs langages (mais favorisant visiblement C# depuis le début), le Common Language Runtime (CLR) de la plateforme .NET exécute des programmes compilés dans le langage intermédiaire CIL (Common Intermediate Language), autrefois nommé MSIL.

Quelques liens pertinents :

• Introduction détaillée au CLR de .NET, un document officiel maintenant que la plateforme est offerte à code ouvert, par Vance Morrison en 2007 : https://github.com/dotnet/coreclr/blob/master/Documentation/intro-to-clr.md
• La section pour programmeurs du .NET Framework Developer Center, qui regroupe plusieurs des textes clés décrivant la plateforme .NET : http://msdn.microsoft.com/en-US/netframework/aa496165.aspx
• De manière plus spécifique, la section portant sur le CLR en tant que tel : http://msdn.microsoft.com/en-us/netframework/aa663296
• Un Wiki sur la plateforme .NET : http://en.wikipedia.org/wiki/.NET_Framework
• Un Wiki sur le CLR : http://en.wikipedia.org/wiki/Common_Language_Runtime
• Quelques textes de Sandro Magi :
  • critique de la plateforme .NET, texte de 2007 : http://higherlogics.blogspot.ca/2007/05/whats-wrong-with-net.html
  • réflexion sur certaines asymétries du CIL, texte de 2010 : http://higherlogics.blogspot.ca/2010/05/asymmetries-in-cil_17.html
  • vérification du code et sécurité avec le CIL, texte de 2010 : http://higherlogics.blogspot.ca/2010/05/cil-verification-and-safety.html
• À propos du sens de readonly et de la confusion derrière IsReadOnly, par Craig Gidney en 2012 : http://twistedoakstudios.com/blog/?p=1473
• En 2013, Andrea Magnorsky avoue que, bien qu'elle aime beaucoup C#, elle est d'avis que la plateforme .NET est mourante : http://roundcrisis.com/2013/05/15/the-dying-platform-net/
• Un compilateur de JavaScript à CIL : http://jsil.org/
• Depuis 2014, il est possible de compiler du code MSIL en format natif pour diverses architectures :
  • texte de Subramanian Ramaswamy et Andrew Pardoe en 2014 : http://blogs.msdn.com/b/dotnet/archive/2014/04/02/announcing-net-native-preview.aspx
  • description des optimisations que permet ce modèle, par Xy Ziemba et Andrew Pardoe en 2014 : http://blogs.msdn.com/b/dotnet/archive/2014/04/24/dotnetnative-performance.aspx
  • en 2014, Anders Hejlsberg explique cette nouvelle direction pour la plateforme : http://www.itwriting.com/blog/8361-microsofts-new-open-source-direction-for-c-and-net-and-native-compilation-too-anders-hejslberg-explains.html
  • description des outils du .NET natif, par Xy Ziemba en 2014 : http://blogs.msdn.com/b/dotnet/archive/2014/05/09/the-net-native-tool-chain.aspx
  • caractéristiques dynamiques du code statique, texte de Morgan Brown en 2014 : http://blogs.msdn.com/b/dotnet/archive/2014/05/20/net-native-deep-dive-dynamic-features-in-static-code.aspx
  • que faire lorsqu'une exception de type MissingMetadataException est levée? Texte de Morgan Brown en 2014 : http://blogs.msdn.com/b/dotnet/archive/2014/05/21/net-native-deep-dive-help-i-hit-a-missingmetadataexception.aspx
  • l'impact de .NET natif sur les développeurs pour plateforme Windows universelle, texte de Daniel Jacobson en 2015 : http://blogs.windows.com/buildingapps/2015/08/20/net-native-what-it-means-for-universal-windows-platform-uwp-developers/
  • exploration de .NET natif et des ses éléments constitutifs, par Mark Rendle en 2016 : https://blog.rendle.io/what-ive-learned-about-dotnet-native/
• À propos de la difficulté de générer des projets .NET :
  • opinion de Maarten Balliauw en 2014 : http://blog.maartenballiauw.be/post/2014/04/11/Building-NET-projects-is-a-world-of-pain-and-heres-how-we-should-solve-it.aspx
• Après un passage à vide, Christian Nagel fait état, dans ce texte de 2014, d'un regain de popularité de la plateforme .NET : http://weblogs.thinktecture.com/cnagel/2014/04/dotnet.html
• IL2CPP, un compilateur AOT (Ahead of Time) pour le code scripté d'Unity, décrit par Ralph Hauwert en 2014 : http://blogs.unity3d.com/2014/05/20/the-future-of-scripting-in-unity/
• Migrer du code vers la version 4.5.2 du Framework, texte de 2014 : http://blogs.msdn.com/b/dotnet/archive/2014/08/07/moving-to-the-net-framework-4-5-2.aspx
• Gros coup en 2014 : la plateforme .NET est à code ouvert et pleinement disponible pour plusieurs plateformes, incluant iOS et Linux :
  • http://blogs.msdn.com/b/dotnet/archive/2014/04/03/the-next-generation-of-net.aspx
  • texte d'Andrew Binstock en 2014 : http://www.drdobbs.com/windows/c-and-nets-sudden-ubiquity/240169282
  • texte de Miguel de Icaza en 2014 : http://tirania.org/blog/archive/2014/Nov-12.html
  • le .NET Core, expliqué par Immo Landwerth en 2014 : http://blogs.msdn.com/b/dotnet/archive/2014/12/04/introducing-net-core.aspx
  • le .NET Core, mythes et réalités, selon Christoph Nahr en 2014 : http://news.kynosarges.org/2014/11/15/net-core-hype-vs-reality/
  • en 2014, Frank Bouma fait remarquer que s'il se peut que .NET Core soit le futur, il reste à voir le futur... de quoi : http://weblogs.asp.net/fbouma/%E2%80%9C-net-core-is-the-future%E2%80%9D-but-who%E2%80%99s-future-is-that
  • Sergio Simone pose un premier regard sur le .NET Core avec ce texte de 2014 : http://www.infoq.com/news/2014/12/dotnet-core-first-look
  • article de Paul Krill en 2015 : http://www.infoworld.com/article/2879438/microsoft-net/microsofts-net-execution-engine-goes-open-source.html
  • http://blogs.msdn.com/b/dotnet/archive/2015/02/03/coreclr-is-now-open-source.aspx
  • comprendre ce qu'est devenue la plateforme .NET suite à ce mouvement, par Beth Massi en 2015 : http://blogs.msdn.com/b/bethmassi/archive/2015/02/25/understanding-net-2015.aspx
  • l'état de la situation, expliqué par Rich Lander en 2015 : http://blogs.msdn.com/b/dotnet/archive/2015/02/26/net-core-open-source-update-february-26-2015.aspx
  • un an plus tard, qu'en est-il? L'opinion de Matthew Warren en 2015 : http://mattwarren.org/2015/12/08/open-source-net-1-year-later/
  • quelques composants de .NET Core qui sont discontinués, par Jonathan Allen en 2016 : http://www.infoq.com/news/2016/02/Core-Discontinued
  • vérifier si votre code peut être porté vers .NET Core : https://icanhasdot.net/
• To .NET or not to .NET, telle est la question posée par ce texte d'Ofer Zelig en 2014 : http://fullstack.info/to-dotnet-or-not-to-dotnet-that-is-the-question/
• À propos de l'importance de comprendre la disposition en mémoire des objets .NET (même si le réflexe serait de ne pas s'en préoccuper), texte de 2014 par Matt Warren : http://mattwarren.org/2014/07/04/know-thy-net-object-memory-layout/
• L'évolution dans le proche futur pour la plateforme .NET, telle que relatée par Darryl K. Taft en 2015 : http://www.eweek.com/developer/microsoft-counting-on-developers-to-follow-.net-to-the-cloud.html
• Utiliser la plateforme .NET comme outil de scripting, par Dave Glick en 2015 : http://www.daveaglick.com/posts/compiler-platform-scripting
• Un effort est en cours en 2016 pour accroître la portabilité du code écrit pour la plateforme .NET : https://github.com/dotnet/corefx/blob/master/Documentation/architecture/net-platform-standard.md
• En 2017, WordPress a migré vers la plateforme .NET : http://www.peachpie.io/2017/02/wordpress-announcement.html

Comparatifs :

• Comparatif de vitesse d'exécution entre le CLR et la JVM, par Jeff Cogswell en 2013 : http://slashdot.org/topic/cloud/java-vs-c-which-performs-better-in-the-real-world/
• Comparatif de richesse d'API entre le CLR et la JVM, par Jeff Cogswell en 2013 : http://slashdot.org/topic/bi/java-api-and-microsofts-net-api-a-comparison/
• La JVM expliquée aux programmeurs .NET, un guide de survie préparé par Hadi Hariri en 2013 : http://hadihariri.com/2013/12/29/jvm-minimal-survival-guide-for-the-dotnet-developer/
• Les changements que vit la plateforme .NET, expliqués aux gens familiers avec la JVM par Steve Perkins en 2015 : http://steveperkins.com/understanding-the-new-cross-platform-net/
• En 2015, Omar Khudeira explique pourquoi son entreprise fait le choix de la plateforme .NET : http://engineering.gopangea.com/2015/12/10/why-dot-net.html

Critiques :

• En 2015, Justin Angel se dit d'avis que l'écosystème .NET est en train de s'écrouler : https://onedrive.live.com/view.aspx?resid=1E5AA35A965D3234!26479&ithint=file%2cdocx&app=Word&authkey=!AHbAQ1i_GgwNxJY

La CVM

Le projet Coherent Virtual Machine, ou CVM, est de développer une machine virtuelle à mémoire distribuée sur plusieurs ordinateurs.

• http://www.cs.umd.edu/projects/cvm

Le DGEE de la plateforme DotGNU

Projet GNU d'une machine virtuelle pour la plateforme .NET. Maintenant défunt, si on se fie au site officiel.

• http://www.dotgnu.org/dgee.html

Le DLR de la plateforme .NET

On trouve une strate dynamique par-dessus le CLR pour la plateforme .NET. Cette strate se nomme le Dynamic Language Runtime, ou DLR, et permet de supporter des langages dynamiques qui ne sont pas desservis efficacement de prime abord par le CLR.

Pour en savoir plus :

• un Wiki sur le sujet : http://en.wikipedia.org/wiki/Dynamic_Language_Runtime
• texte de Jim Hugunin en 2007 : http://blogs.msdn.com/b/hugunin/archive/2007/04/30/a-dynamic-language-runtime-dlr.aspx

ERTS

La machine virtuelle ERTS, pour Erlang Runtime System, est celle qui sous-tend l'exécution d'Erlang mais aussi de quelques autres langages de programmation, le plus connu de ces langages alternatifs étant Elixir.

• Comparatif de la JVM et d'ERTS, par Tõnis Pool en 2015 : http://ds.cs.ut.ee/courses/course-files/To303nis%20Pool%20.pdf

HHVM

La Hip Hop Virtual Machine, utilisée en particulier chez Facebook pour les langages Hack et PHP.

• http://en.wikipedia.org/wiki/HipHop_for_PHP
• http://hhvm.com/
• En 2014, Wikipédia a migré vers HHVM : https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2014-10-08/Technology_report

IBNIZ

Projet expérimental de machine virtuelle audiovisuelle.

Texte de Ville-Matias Heikkilä en 2011 : http://countercomplex.blogspot.ca/2011/12/ibniz-hardcore-audiovisual-virtual.html?m=1

La JVM de la plateforme Java

Machine virtuelle traitant du bytecode, un langage intermédiaire. À l'origine conçue pour supporter le langage Java, cette plateforme sert maintenant à titre de « machine » hôte pour un grand nombre de langages. Il s'agit d'une plateforme d'une grande maturité, qui a fait école et a constitué une sorte de preuve qu'il était possible d'écrire des programmes destinés à une machine virtuelle et offrant des caractéristiques de performance acceptables.

Quelques liens pertinents :

• Un Wiki sur le sujet : http://en.wikipedia.org/wiki/Java_virtual_machine
• La JVM de Java 7 : https://docs.oracle.com/javase/specs/jvms/se7/jvms7.pdf
• La JVM de Java 8 : https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf
• Un tour guidé de la JVM, par Alexey Zhebel : https://anturis.com/blog/java-virtual-machine-the-essential-guide/
• Une liste d'implémentations existantes : http://en.wikipedia.org/wiki/List_of_Java_virtual_machines
• http://java.sun.com/docs/books/jvms/
• http://java.sun.com/products/hotspot/docs/whitepaper/Java_HotSpot_WP_Final_4_30_01.pdf
• http://www.theregister.co.uk/2010/11/06/oracle_dueling_jvms/
• Un ensemble de raffinements offerts par la JVM HotSpot pour Java SE 7 :
  • http://docs.oracle.com/javase/7/docs/technotes/guides/vm/performance-enhancements-7.html
  • en 2009, Ed Ort parle de l'ajout de support pour les langages dynamiquement typés dans la JVM depuis Java 7 : http://java.sun.com/developer/technicalArticles/DynTypeLang/index.html
• Présentation de 2011 par Brian Goetz portant sur la co-évolution du langage Java, de sa bibliothèque standard et de la JVM elle-même pour Java 8 : https://blogs.oracle.com/briangoetz/resource/devoxx-lang-lib-vm-co-evol.pdf
• De la documentation destinée aux développeurs de JVM ou sur la JVM :
  • suggestions de Pekka Enberg en 2010 : http://penberg.blogspot.ca/2010/01/java-virtual-machine-developer.html
  • suggestions de Thomas Lockney en 2011 : http://prehensiletail.com/blog/2011/11/25/a-jvm-based-developers-reading-list/
  • la mise au point d'une JVM expliquée aux « pauvres mortels », un texte de Michael Keller en 2013 (en gros, selon lui, une telle mise au point est une forme d'optimisation prématurée) : http://labs.sixdimensions.com/blog/michael-kelleher/2013-08-01/jvm-tuning-mere-mortals
• Texte de Brian Goetz en 2005 sur ce qu'il qualifie de « légendes urbaines » quant aux performances d'une JVM : http://www.ibm.com/developerworks/java/library/j-jtp09275/index.html
• Un rapport informel du sommet sur la JVM de 2008, alors qu'il commençait à y avoir plusieurs nouveaux langages destinés à cette plateforme, le tout par Tim Bray (avec quelques photos) : http://www.tbray.org/ongoing/When/200x/2008/09/25/JVM-Summit
• Discussion du rapport coûts/ bénéfices de la JVM, texte de 2009 : http://newartisans.com/2009/03/the-jvm-and-costs-vs-benefits/
• Comparatifs :
  • un comparatif entre plusieurs implémentations de la JVM, à partir de plusieurs bancs d'essais : http://z.cs.utexas.edu/users/habals/jvmcmp/
  • comparatif de JVM sur ARM/ Linux, par Jim Connors en 2012 : https://blogs.oracle.com/jtc/entry/comparing_jvms_on_arm_linux
• L'outil VisualVM, pour mieux interagir avec la JVM en période de développement : http://geeknizer.com/java-visualvm/
• Certains ont essayé de porter Perl 5 sur la JVM, mais ont abandonné. Une discussion des raisons derrière cette décision est offerte ici : http://www.nntp.perl.org/group/perl.perl5.porters/2009/08/msg150099.html
• Présentation fort intéressante de Cliff Click, en 2011, sur ce que fait, concrètement, une JVM : http://www.azulsystems.com/blog/wp-content/uploads/2011/03/2011_WhatDoesJVMDo.pdf
• Dans ce texte de 2011, Alexander J. Turner argumente qu'il peut être pertinent de migrer des langages plus anciens vers un environnement pris en charge comme la JVM : http://nerds-central.blogspot.ca/2011/08/tackling-legacy-languages-with-jvm.html
• Une JVM en JavaScript capable d'exécuter des programmes Java :
  • survol par Mike James en 2011 : http://www.i-programmer.info/news/167-javascript/3360-javascript-jvm-runs-java.html
  • texte plus poussé par Vyacheslav Egorov en 2012 : http://blog.mrale.ph/post/24351748336/explaining-js-vm-in-js
  • le produit Doppio, qui combine JVM, compilateur et désassembleur : http://badassjs.com/post/32812527381/doppio-a-java-virtual-machine-compiler-and
• Texte d'Eric Bruno en 2012 sur les langages implémentés pour la JVM : http://www.drdobbs.com/jvm/a-long-look-at-jvm-languages/240007765
• Détails internes d'une JVM, texte de Se Hoon Park en 2012 : http://www.cubrid.org/blog/dev-platform/understanding-jvm-internals
• La JVM que Google déploie sur Android, Dalvik, décrite par Jim Huang en 2012 : http://fr.slideshare.net/jserv/understanding-the-dalvik-virtual-machine
• Présentation  de Christian Wimmer et Chris Seaton en 2013, selon qui la JVM est « la machine virtuelle pour les gouverner toutes » : http://lafo.ssw.uni-linz.ac.at/papers/2013_JVMLanguageSummit_OneVMToRuleThemAll.pdf
• S'amuser avec le bytecode, un texte de Cory Li en 2014 : http://cory.li/bytecode-hacking/
• Une JVM pour l'infonuagique, décrite par Graeme Johnson et Michael Dawson en 2013 : http://www.ibm.com/developerworks/java/library/j-multitenant-java/index.html?ca=drs-
• La PyJVM, une JVM en Python : http://pyjvm.org/
• Les types valeurs dans la JVM, par John Rose en 2012 : https://blogs.oracle.com/jrose/entry/value_types_in_the_vm
• À propos de Nashorn, une machine virtuelle JavaScript intégrée à Java 8 qui supporte les invocations dynamiques :
  • texte de 2014 : https://seniorjava.wordpress.com/2014/03/29/introduction-to-nashorn/
  • un tutoriel, par Daniel Winterberg en 2014 : http://winterbe.com/posts/2014/04/05/java8-nashorn-tutorial/
• Résautique « haute performance » pour la JVM, présentation de Norman Maurer en 2014 : http://normanmaurer.me/presentations/2013-jax-networking-on-jvm/#/
• Faire évoluer la JVM, présentation de John Rose et Brian Goetz en 2014 : http://cr.openjdk.java.net/~jrose/pres/201407-JVMEvolution.pdf
• Une JVM qui s'auto-guérit, par Nikita Salnikov-Tarnovski en 2014 : https://plumbr.eu/blog/self-healing-jvm
• Compiler la JVM, texte de 2014 : https://neomatrix369.wordpress.com/2014/12/20/how-is-java-jvm-built-adopt-openjdk-is-your-answer/
• Comment la JVM supporte d'autres langages que Java : https://docs.oracle.com/javase/8/docs/technotes/guides/vm/multiple-language-support.html
• Exécuter du code C de manière Type-Safe sur une JVM, article de Matthias Grimmer et al en 2015 : http://chrisseaton.com/plas15/safec.pdf

Comparatifs :

• Comparatif de complexité dans les implémentations (en termes de lignes de code et de nombre de modules impliqués) de divers langages construits sur une même machine virtuelle, dans ce cas la JVM, par Gary Trakhman en 2012 : http://gtrak.wordpress.com/2012/01/14/dynamic-jvm-language-complexity/
• Comparatif de vitesse d'exécution entre le CLR et la JVM, par Jeff Cogswell en 2013 : http://slashdot.org/topic/cloud/java-vs-c-which-performs-better-in-the-real-world/
• Comparatif de richesse d'API entre le CLR et la JVM, par Jeff Cogswell en 2013 : http://slashdot.org/topic/bi/java-api-and-microsofts-net-api-a-comparison/
• La JVM expliquée aux programmeurs .NET, un guide de survie préparé par Hadi Hariri en 2013 : http://hadihariri.com/2013/12/29/jvm-minimal-survival-guide-for-the-dotnet-developer/
• Les changements que vit la plateforme .NET, expliqués aux gens familiers avec la JVM par Steve Perkins en 2015 : http://steveperkins.com/understanding-the-new-cross-platform-net/
• Comparatif de la JVM et d'ERTS, par Tõnis Pool en 2015 : http://ds.cs.ut.ee/courses/course-files/To303nis%20Pool%20.pdf

LuaJIT

La machine virtuelle LuaJIT se veut une machine virtuelle à haute performance pour le langage Lua.

• Un regard sous la couverture, proposé par Sanjoy Das en 2012 : http://playingwithpointers.com/archives/1010

Metascala

Projet de machine virtuelle métacirculaire en Scala, avec les sources.

• https://github.com/lihaoyi/Metascala

Parrot

La machine virtuelle Parrot est une machine virtuelle à registres ayant entre autres la vocation de prendre en charge des programmes écrits dans des langages dynamiques (bien qu'elle supporte plusieurs autres types de langages). En particulier, elle est a été pensée pour exécuter les programmes Perl 6. Quelques liens :

• Un Wiki à son sujet : http://en.wikipedia.org/wiki/Parrot_virtual_machine
• Le site officiel : http://www.parrot.org/
• Texte d'opinion d'Allison Randal qui affirme, en 2009, que Parrot est quelque chose d'important : http://www.linux-mag.com/id/7373/
• En 2013, un important contributeur au projet Parrot en a essentiellement déclaré la mort : http://www.modernperlbooks.com/mt/2013/02/goodnight-parrot.html
• Que faire avec Parrot? Christoph Otto, en 2013, suggère des pistes : http://reparrot.blogspot.de/2013/02/its-been-quiet_15.html

Sol

Une toute petite machine virtuelle, à code ouvert.

• Descriptif de Rasmus Andersson en 2012 : http://rsms.me/2012/10/14/sol-a-sunny-little-virtual-machine.html

Zend

La machine virtuelle supportant PHP 7.

• Survol du fonctionnement de cette machine virtuelle, par Nikita Popov en 2017 : http://nikic.github.io/2017/04/14/PHP-7-Virtual-machine.html

Z-Machine

La machine virtuelle sur laquelle s'exécutait (entre autres) le jeu Zork.

• https://en.wikipedia.org/wiki/Z-machine
• http://inform-fiction.org/zmachine/standards/index.html

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 :

• Mise en situation : http://ericlippert.com/2016/02/01/west-of-house/
• Introduction au langage : http://ericlippert.com/2016/02/03/north-of-house/
• Encapsuler adéquatement dans ce langage : http://ericlippert.com/2016/02/05/forest_path/
• Conversions et tests : http://ericlippert.com/2016/02/09/up-a-tree/
• Gestion de la mémoire, mutabilité et immuabilité : http://ericlippert.com/2016/02/10/behind-house/
• Entrées / sorties sur disque : http://ericlippert.com/2016/02/12/kitchen/
• Compression de zstring : http://ericlippert.com/2016/02/15/living-room/
• Décompression de zstring : http://ericlippert.com/2016/02/17/attic/
• Types optionnels et Pattern Matching : http://ericlippert.com/2016/02/19/cellar/
• Le Pattern Matching en plus de détails : http://ericlippert.com/2016/02/22/troll-room/
• http://ericlippert.com/2016/02/24/round-room/
• Concaténation de chaînes de caractères : http://ericlippert.com/2016/02/26/dome-room/
• Implémenter une forêt d'objets : http://ericlippert.com/2016/02/29/temple/
• http://ericlippert.com/2016/03/02/egyptian-room/
• Présenter un arbre de manière lisible : http://ericlippert.com/2016/03/04/altar/
• Décoder le format de la Z-Machine : http://ericlippert.com/2016/03/09/canyon-view/ puis http://ericlippert.com/2016/03/11/end-of-rainbow/
• Représenter une variable : http://ericlippert.com/2016/03/14/aragain-falls/
• Décoder le format de la Z-Machine, en portant une attention plus spéficique à une partie des opérations (la partie Store) : http://ericlippert.com/2016/03/16/sandy-cave/
• Décoder une instruction conditionnelle : http://ericlippert.com/2016/03/18/studio/
• Décoder la longueur d'une chaîne de caractères : http://ericlippert.com/2016/03/21/reservoir-south/
• Imprimer une instruction : http://ericlippert.com/2016/03/23/dam/
• Déterminer des relations entre des objets : http://ericlippert.com/2016/03/25/maintenance-room/
• Construction d'un automate : http://ericlippert.com/2016/03/28/reservoir/
• Générer la fermeture transitive d'une instruction : http://ericlippert.com/2016/03/30/reservoir-north/
• Quelques correctifs : http://ericlippert.com/2016/04/01/dam-base/
• Les instructions de la Z-Machine semblent parfois étranges : http://ericlippert.com/2016/04/04/frigid-river-in-the-magic-boat/
• Premier pas vers la conception d'un interpréteur pour la Z-Machine : http://ericlippert.com/2016/04/06/white-cliffs-beach/
• Implémenter le lieu d'entreposage des variables locales : http://ericlippert.com/2016/04/08/windy-cave/
• Une Evaluation Stack : https://ericlippert.com/2016/04/11/entrance-to-hades/
• Un cadre de pile : https://ericlippert.com/2016/04/13/hades/
• Appels de fonctions, incluant celles qui sont variadiques : https://ericlippert.com/2016/04/15/mirror-room/
• Conception d'un type interpréteur : https://ericlippert.com/2016/04/18/twisting-passage/
• Ajouter ou retirer des cadres d'exécution : https://ericlippert.com/2016/04/20/drafty-cave/
• Implémenter le return : https://ericlippert.com/2016/04/22/winding-passage/
• Ajouter le support d'autres types d'instructions à l'interpréteur : https://ericlippert.com/2016/04/25/slide-room/
• Décoder un OpCode : https://ericlippert.com/2016/04/27/mine-entrance/
• Représenter les indirections : https://ericlippert.com/2016/04/29/bat-room/
• Implémenter quelques opérations de base : https://ericlippert.com/2016/05/02/shaft-room/
• Branchements : https://ericlippert.com/2016/05/04/gas-room/
• Affichage : https://ericlippert.com/2016/05/06/coal-mine/
• Gestion de pile d'exécution : https://ericlippert.com/2016/05/16/ladder-room/
• Encoder / décoder les propriétés : https://ericlippert.com/2016/05/19/shaft-room-again/

Émulateurs

Une thématique connexe à celle des machines virtuelles est celle des émulateurs, des programmes qui simulent un matériel existant et offre une forme de virtualisation pour, par exemple, permettre l'exécution de logiciels plus anciens sur du matériel plus contemporain.

Quelques liens sur ce sujet :

• http://emulator101.com/
• Relations entre l'émulation, la simulation et l'histoire de l'informatique à partir du projet SIMH. Texte de Tim Jones en 2011 : http://www.ibm.com/developerworks/opensource/library/os-emulatehistory/index.html

• À propos de MAME :
  • le bien connu projet MAME, ou Multiple Arcade Machine Emulator : http://mamedev.org/
  • histoire de ce projet : http://www.mame.net/history.html
  • MAME a eu 20 ans en 2017 : http://www.mame.net/?p=439
  • une équipe a porté MAME sur Chrome à l'aide du Native Client (NaCL) : https://developers.google.com/native-client/community/porting/MAME
  • depuis 2016, MAME est un projet à code ouvert : http://mamedev.org/?p=422
  • en 2017, Marcus Estrada rapporte qu'un fan du jeu Primal Rage est parvenu, grâce à MAME, à donner vie au jeu Primal Rage 2, qui n'avait jamais été publié concrètement : https://www.hardcoregamer.com/2017/02/15/fan-makes-unreleased-primal-rage-2-playable/246848/
• L'outil FCEUX, un émulateur de plusieurs plateformes (dont la NES) : http://www.fceux.com/web/home.html
• Le produit n64js, un émulateur de Nintendo 64 en JavaScript :
  • http://hulkholden.github.com/n64js/
  • http://n64js.blogspot.co.uk/
• Produire un émulateur de NES en code natif à partir de Go et de LLVM, texte d'Andrew Kelley en 2013 : http://andrewkelley.me/post/jamulator.html
• Émulateur de Nintendo 64 s'exécutant sur asm.js : http://jquesnelle.github.io/mupen64plus-ui-console/
• Émulateur d'Oberon en JavaScript : http://schierlm.github.io/OberonEmulator/
• Émulateur de Commodore 64 écrit en C#, par Mladen Janković en 2014 : http://kataklinger.com/index.php/commodore-64-emulator/
• Émuler un processeur avec... T_EX, par Christian Dietrich en 2014 : https://gitlab.brokenpipe.de/stettberger/avremu/tree/master#README
• Écrire un processeur virtuel en C++, texte de 2014 : http://megalomaniacbore.blogspot.co.uk/2014/04/virtual-cpu-in-c-4001-cpu.html
• Un émulateur de NES écrit en Go, par Michael Fogleman : https://github.com/fogleman/nes
  • en 2015, d'ailleurs, Michael Fogleman explique ce qu'il a appris sur la NES en écrivant son émulateur : https://medium.com/@fogleman/i-made-an-nes-emulator-here-s-what-i-learned-about-the-original-nintendo-2e078c9b28fe
• Émuler un Linux MIPS aec Perl, par Marc A. Lehmann en 2015 :
  • http://schplog.schmorp.de/2015-06-08-emulating-linux-mips-in-perl-1.html
  • http://schplog.schmorp.de/2015-06-13-emulating-linux-mips-in-perl-2.html
  • http://schplog.schmorp.de/2015-07-01-emulating-linux-mips-in-perl-3.html
  • http://schplog.schmorp.de/2015-07-04-emulating-linux-mips-in-perl-4.html
• Texte de 2015 qui explique la source de la latence dans un émulateur : http://byuu.org/articles/latency/
• En 2016, Jeff Atwood explique comment le Raspbery Pi a révolutionné le monde de l'émulation : https://blog.codinghorror.com/the-raspberry-pi-has-revolutionized-emulation/
• Texte de 2017 relatant l'expérience de Andre Weissflog en rédigeant un émulateur : http://floooh.github.io/2017/02/04/yack-counters.html
• À propos de Dolphin, un émulateur de consoles de jeu Nintendo : https://fr.dolphin-emu.org/. À ce sujet :
  • est-il plus difficile d'émuler une Wii qu'un GameCube? Article de 2018 : https://fr.dolphin-emu.org/blog/2018/07/21/myth-debugging-wii-more-demanding-emulate-gamecube/?cr=fr

Certaines entreprises n'apprécient pas que l'on écrive des émulateurs pour leurs vieux binaires. À ce sujet :

• Ce que fait Nintendo pour nuire aux émulateurs, un texte de 2014 par Jeffrey Pfau : https://endrift.com/mgba/2014/12/28/classic-nes/
• Critique de cette pratique par Jamie Zawinski, en 2014 : http://www.jwz.org/blog/2014/12/classic-nes-series-anti-emulation-measures/

Une pratique connexe à l'émulation est ce qu'on nomme en anglais le Rehosting. Cette pratique va comme suit : à partir d'un binaire, étudier les entrées et les sorties et comprendre le binaire comme une boîte noire qu'il est possible d'intégrer à un système plus complexe. Texte de 2003 par Peter Phillips et George Phillips décrivant le Rehosting : http://queue.acm.org/detail.cfm?id=945155