Systèmes client/ serveur – quelques liens pertinents

Vous trouverez ici quelques liens portant sur les systèmes client/ serveur (SCS) et les technologies associées à ce thème. Si vous découvrez d'autres liens dignes d'intérêt, faites-m'en part!

• Livre en ligne sur la programmation réseau : http://beej.us/guide/bgnet/
• Pourquoi localhost est quelque chose d'important : http://sheddingbikes.com/posts/1282093058.html
• Une définition succincte de ce qu'est un SCS est disponible sur http://www.pcai.com/pcai/New_Home_Page/ai_info/client_server.html.
• Vers une Foire Aux Questions (FAQ) sur les SCS.
• Pour les amatrices et les amateurs de développement de jeux vidéo:
  • une description de l'infrastructure sous Unreal – si vous suivez mes cours, vous devriez vous reconnaître dans ce genre de démarche;
  • une description de l'infrastructure sous Quake 3, très intéressante. Une maxime y frappe en particulier, d'office : « In a fast paced environment any information that is not received on first transmission is not worth sending again because it will be too old anyway ».
• Dans le même ordre d'idées: une description des choix technologiques faits par une entreprise dont le produit est un SCS massivement réparti de jeu (un MMOPRG). En plus d'être intéressant, ce texte décrit certains choix surprenants (comme celui d'utiliser un moteur maison pour la strate métier – le Middleware ou intergiciel – plutôt qu'un moteur commercial comme COM, CORBA ou EJB).
• Lien trouvé par Philippe Calvé menant vers un site discutant de différences et de ressemblances entre DCOM/CORBA/RMI et comment faire des « ponts » entre ces technologies
• Le Great Internet Mersenne Prime Search, une proposition de Marc Dagenais : http://www.mersenne.org/

Quelques organismes de standardisation importants :

• Le site Web du Object Management Group, OMG, qui est responsable entre autres de la standardisation de la technologie CORBA, est http://www.omg.org/.
• Le site Web du International Standards Organization, ISO, qui examine entre autres C++ et .NET, est http://www.iso.org/.
• Le site Web du European Computer Manufacturers Association, ECMA, mandaté de la standardisation de .NET, est http://www.ecma-international.org/.

Interopérabilité

L'interopérabilité entre diverses plateformes est un problème à la fois complexe et de la plus haute importance. Si les cours offerts dans les institutions d'enseignement supérieur couvrent les stratégies et problématiques générales d'interopérabilité, de même que certains cas particuliers, il est inévitable que des problèmes pointus surviennent en cherchant à intégrer deux technologies spécifiques entre elles.

Modalités générales

À propos des interactions synchrones (sens faible) et asynchrones pour des rappels (Callbacks) : http://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/

Étude relativement détaillée des difficultés inhérentes à l'interopérabilité entre les langages, par David Chisnall en 2013 : http://queue.acm.org/detail.cfm?id=2543971

Réaliser le réordonnancement des bytes dans un entier, selon Rob Pike en 2012 : http://commandcenter.blogspot.it/2012/04/byte-order-fallacy.html?m=1

Intégrer .NET avec COM ou Win32

Même entre deux technologies provenant d'une même entreprise, les problèmes d'interopérabilité potentiels sont nombreux et sont susceptibles d'être épineux.

• Lien officiel : http://msdn.microsoft.com/en-us/library/z6tx9dw3.aspx
• Article généraliste sur le sujet : http://www.blong.com/Conferences/BorConUK2002/Interop1/Win32AndDotNetInterop.htm
• Série de liens sur le sujet (orienté VB.NET) : http://www.vbdotnetheaven.com/Articles/ArticleListing.aspx?SectionID=2&SubSectionID=98
• Article intitulé Wrapping .NET in COM+ : http://www.itworld.com/nl/windows_sec/02182002/
• Foire aux questions à propos des composants .NET exploitant des services COM : http://www.sabbasoft.com/serviced_components.htm
• Introduction à C++/ CLI, le dialecte .NET de C++, pour les intéressé(e)s : http://www.ddj.com/cpp/184403870
• Articles sur l'interopérabilité entre COM et .NET (partie 1, partie 2)
• Interopérabilité entre COM et .NET avec C# : http://www.codeguru.com/Csharp/Csharp/cs_misc/com/article.php/c9065__2/
• Article sur le marshalling des tableaux entre COM et .NET (un gros bug pas gentil) : http://msdn2.microsoft.com/fr-fr/library/z6cfh6e6.aspx
• Accéder à un serveur COM sur 64 bits à partir d'un client .NET, par Marius Bancila en 2011 : http://mariusbancila.ro/blog/2011/10/19/accessing-64-bit-native-com-server-from-a-managed-client/
• Textes de Raymond Chen :
  • est-ce que .NET appelle CoInitializeEx() quoiqu'il arrive lors d'un appel de type p/invoke? Texte de 2015 qui répond à la question et montre comment trouver soi-même la réponse : http://blogs.msdn.com/b/oldnewthing/archive/2015/03/16/10600388.aspx
  • texte de 2015 sur les transtypages permettant à un programme C# d'appeler une fonction Win32 en tenant correctement compte de l'alignement : http://blogs.msdn.com/b/oldnewthing/archive/2015/08/20/10636350.aspx

Articles du Code Project sur l'interopérabilité entre .NET et COM (comme tout ce qui vient de ce site, la qualité varie beaucoup) :

• http://www.codeproject.com/KB/COM/cominterop.aspx
• http://www.codeproject.com/KB/COM/simpleclrhost.aspx
• http://www.codeproject.com/KB/COM/COM_DOTNET_INTEROP.aspx
• http://www.codeproject.com/KB/dotnet/BuildCOMServersInDotNet.aspx
• http://www.codeproject.com/KB/cs/unmanagedtomanaged.aspx
• http://www.codeproject.com/KB/dotnet/BuildCOMServersInDotNet.aspx
• http://www.codeproject.com/KB/cpp/threadingframework.aspx
• http://www.codeproject.com/KB/vb-interop/Net_COM__Interop.aspx
• http://www.codeproject.com/KB/dotnet/DllExporter.aspx

Intégrer .NET avec CORBA

Bien que CORBA ait développé une mauvaise réputation dans certains cercles (plusieurs disent cette mécanique lente et complexe, mais – comme c'est souvent le cas – une partie de la critique tient du produit et une autre partie relève de l'usage qui en est fait), cet intergiciel demeure très présent dans certains cercles et savoir interfacer avec lui peut être précieux.

Pour un produit à code ouvert pour intégrer CORBA dans une relation de Remoting avec un homologue .NET, voir http://sourceforge.net/projects/remoting-corba/ ou encore http://www.dotnetguru.org/articles/articlets/iiopchannel/iiopremoting.htm pour un article sur cette technologie.

Intégrer Java avec du code natif

Parfois, il faut sortir du carré de sable défini par Java et interagir avec le monde extérieur d'une manière que les conceptrices et les concepteurs de cette plateforme n'ont pas prévu.

Pour un article du Code Project expliquant une manière pour un programme Java d'exploiter un composant C++ sous Win32, voir http://www.codeproject.com/KB/DLL/JNITest.aspx

À propos de JNI, le Java Native Interface :

• documentation officielle : hhttp://java.sun.com/developer/onlineTraining/Programming/JDCBook/jni.html
• pour un plug-in utilisant JNI, voir http://java.sun.com/products//plugin/1.2/docs/jni.html
• entreposer un pointeur natif dans du code Java, une proposition de Clebert Suconic en 2010 : http://planet.jboss.org/post/pointers_in_jni_c

Déboguer du code C++ à partir d'une application Java, un texte du Code Project par Gregory Shpitalnik en 2009 : http://www.codeproject.com/KB/debug/java_cpp_debugging.aspx

Intégrer Java avec .NET

• Deux moteurs de prise en charge du code ne sont pas nécessairement faciles à intégrer dans un tout cohérent. Pour deux articles du Code Project; donnant des indications susceptibles de vous rendre service, voir http://www.codeproject.com/KB/dotnet/JavaDOTNETIntegrate.aspx et http://www.codeproject.com/KB/dotnet/Espresso.aspx
• Un texte du Code Project;, par Duc Huy Nguyen en 2012, montrant comment enrober une bibliothèque C# de manière à faciliter son utilisation dans un code Java : http://www.codeproject.com/Articles/378826/How-to-wrap-a-Csharp-library-for-use-in-Java
• Pour passer de Java à C#, si c'est votre souhait, Microsoft offre un assistant à l'adresse http://msdn2.microsoft.com/fr-fr/vstudio/aa718346(en-us).aspx et, pour passer de JSP à ASP.NET, un guide est disponible sur http://msdn2.microsoft.com/en-us/asp.net/aa336627.aspx (un article donnant les grandes lignes de ces stratégies se trouve sur http://www.developer.com/java/other/article.php/2235411).
• Une autre option pour migrer de Java au monde .NET est offerte par l'article disponible sur http://www.javaworld.com/javaworld/jw-01-2003/jw-0103-migration.html et qui offre plusieurs liens permettant d'en savoir plus.
• À l'inverse, l'article http://www.infoworld.com/article/04/10/15/42TCinet_1.html discute d'un produit facilitant la migration d'un programme .NET au monde J2EE.
• Autre stratégie : rédiger un programme de manière à pouvoir le compiler à la fois pour Java et pour .NET. Voir http://www.infoworld.com/article/04/06/11/24TCmainwin_1.html
• Encore une autre approche : IKVM, qui permet d'exécuter du code Java sur la plateforme .NET à code ouvert qu'est Mono.
• Texte de Mike Grim en 2014 sur les avantages d'IKVM : http://mikegrim.wordpress.com/2014/11/04/an-easy-way-to-combine-the-power-of-net-and-java/
• Un article décrivant l'interopérabilité entre .NET et J2EE pour des développeurs .NET.
• En 2003, Manish Verma explique comment réaliser une communication asynchrone entre Java et .NET : http://developers.sun.com/appserver/reference/techart/async_paper.html

Intégrer C++ avec CORBA

Exemple pas à pas du Code Project, par Carlos Jiménez de Parga en 2009 : http://www.codeproject.com/KB/IP/corba.aspx

Explication du RMI de CORBA pour C++, article du Code Project par Jarl Lindrud en 2009 : http://www.codeproject.com/KB/threads/RMI_For_Cpp.aspx

Intégrer C++ avec le monde pris en charge

• Petit article pour vous aider à intégrer C++ et le monde .NET dans des programmes qui ne souffrent pas trop des problèmes de performance du code pris en charge (à prendre avec un grain de sel puisque cela vient du Code Project) : http://www.codeproject.com/KB/mcpp/ManagedCPPInterop.aspx
• Autre article discutant généralement de l'interaction de C++ avec les langages dynamique du Web : http://www.codeproject.com/KB/cross-platform/SCS.aspx
• Accéder aux types .NET à partir de code C++, article du Code Project par Vivek Rathod en 2015 : http://www.codeproject.com/Articles/868230/Cplusplus-CLI-Accessing-a-managed-type-from-unmana
• Interfacer C++ et la plateforme .NET sans passer par COM, selon Rodney Viana en 2015 : https://blogs.msdn.microsoft.com/rodneyviana/2015/08/24/pure-native-c-consuming-net-classes-without-com-registration/

Intégrer des langages de programmation et des outils Microsoft Office

Pour un lien montrant comment contrôler une feuille Excel à partir d'un programme C++, vous pouvez examiner http://www.codeproject.com/KB/wtl/WTLExcel.aspx ou http://www.codeproject.com/KB/COM/VOLE_word.aspx

Deux liens pris chez Microsoft pour faciliter l'interaction entre C++ et Excel (pas du très beau code, cela dit, alors ne vous gênez pas pour nettoyer le tout) : http://support.microsoft.com/kb/196776 et http://support.microsoft.com/kb/216686

Interopérabilité entre Office et C# :

• Si vous comptez interfacer Office et C#, soyez prudent(e)s avec les indices de vos tableaux, car les pratiques sont très variables et il en va de même pour les indices valides ou non. En particulier, l'indice 0, comme le rapporte Jake Binstein en 2012 : http://madebyknight.com/why-cant-microsoft-count-to-0/
• Un guide pour l'interopérabilité « sans douleur » entre ces deux technologies, proposé par Claudio Bernasconi en 2014 : http://www.claudiobernasconi.ch/2014/02/13/painless-office-interop-using-visual-c-sharp/

Dans ce texte de 2013, Ric da Paz suggère d'utiliser Ruby plutôt que Visual Basic .NET pour réaliser ce type d'interopérabilité : http://www.dapaz.net/blog/blog/2013/01/21/ms-office-and-ruby/

Automatiser Microsoft Office avec Python, texte de 2013 : http://nbviewer.ipython.org/urls/raw.github.com/sanand0/ipython-notebooks/master/Office.ipynb

À propos des contrôles OLE et ActiveX

Si l'idée vous prend de développer des contrôles OLE ou ActiveX, je vous invite à prendre connaissance des règles et recommandations à ce sujet : http://msdn.microsoft.com/en-us/library/ms974303.aspx

Autres

Comparatif des approches SOAP et ICE, d'un point de vue favorable à ICE : http://www.zeroc.com/iceVsSoap.html

Comment profiter au maximum de SWIG, le Simple Wrapper and Interface Generator, texte de 2015 : https://www.softwariness.com/articles/api-design-for-swig/

Nommage

Dans le monde des services répartis, on trouve plusieurs approches au nommage unique des ressources (des objets, des entités, des services, etc.). Certaines sont universelles, d'autres sont associées de plus près au monde du Web, comme par exemples les URI (URL, URN).

Texte de Zack Bloom en 2014 à propos de la longueur minimale d'un identifiant se voulant unique au monde : https://eager.io/blog/how-long-does-an-id-need-to-be/?r

À propos des UUID, ou Universally Unique Identifier, aussi nommés GUID à l'occasion (pour Globally Unique Identifiers) :

• Une description du concept et du format : http://www.famkruithof.net/guid-uuid-info.html
• Un générateur de UUID en ligne : http://www.famkruithof.net/uuid/uuidgen
• Description de ce format dans son acception DCE, qui est celui implémenté pour COM en fonction de Microsoft Windows : http://pubs.opengroup.org/onlinepubs/9629399/apdxa.htm
• Utiliser des UUID « maison » à titre de clé primaire dans une base de données, un texte de Michael Lambert en 2012 : http://www.digitilapia.com/custom_uuid_as_primary_key
• Série de textes expliquant ce que sont les GUID, par Eric Lippert en 2012 :
  • http://blogs.msdn.com/b/ericlippert/archive/2012/04/24/guid-guide-part-one.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2012/04/30/guid-guide-part-two.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2012/05/07/guid-guide-part-three.aspx
• Textes de Raymond Chen :
  • il est possible d'adapter l'algorithme de génération de GUID pour qu'une partie en soit reconnaissable, dans le respect de certaines contraintes du moins, comme l'explique ce texte de 2011 : http://blogs.msdn.com/b/oldnewthing/archive/2011/03/24/10145093.aspx
  • le rôle d'un GUID est d'être unique au monde, pas d'être aléatoire, comme le rappelle ce texte de 2012 : http://blogs.msdn.com/b/oldnewthing/archive/2012/05/23/10309199.aspx
  • peut-on générer des GUID qui se lisent, au sens où ils ne sont composés que de « caractères ASCII »? C'est pas si simple, comme l'indique ce texte de 2015 : http://blogs.msdn.com/b/oldnewthing/archive/2015/04/10/10606561.aspx
  • est-ce une bonne idée d'utiliser des UUID en tant que mots de passe? En gros : non, puisque l'objectif d'un UUID est d'être unique, pas d'être sécuritaireé Texte de 2015 : http://blogs.msdn.com/b/oldnewthing/archive/2015/07/01/10624287.aspx
  • les probabilités que deux UUID soient conflictuelles sont extrêmement faibles, mais encore faut-il voir l'algorithme utilisé pour les générer. Texte de 2016 : https://blogs.msdn.microsoft.com/oldnewthing/20160114-00/?p=92851
• Un outil pour transformer un UUID en une série de mots : http://bloomha.sh/
• En 2017, Rick Branson propose un historique des UUID : https://segment.com/blog/a-brief-history-of-the-uuid/
• Une bibliothèque pour manipuler des UUID, proposée par Marius Bancila : http://mariusbancila.ro/blog/2018/02/27/stduuid-a-cpp-library-for-universally-unique-identifiers/

Modèle RPC

Le modèle RPC préconise de représenter les messages transitant entre deux homologues par des appels de fonctions. Typiquement, l'appelant de la fonction sera le consommateur du service (le client, dans la majorité des cas) et l'appelé sera le fournisseur du service (le serveur, habituellement).

Pour isoler les deux homologues dans cette relation des détails du réseau qui les lie, on appliquera souvent le schéma de conception Intermédiaire (Proxy) par lequel un objet côté client exposera l'interface du serveur en se faisant passer pour ce dernier, et un objet côté serveur se comporte comme le client. Ces deux entités tierces (les intermédiaires) implémenteront le service par un échange de messages, à l'insu des homologues « réels ».

Il existe plusieurs implémentations de ce modèle, mais il est tombé quelque peu en défaveur dans les années 2000 avec l'avènement du modèle REST.

• Le RFC général de l'approche RPC est disponible sur : http://www.faqs.org/rfcs/rfc1050.html
• Un pas à pas proposé par Dave Marshall en 1999 : http://www.cs.cf.ac.uk/Dave/C/node33.html
• Le modèle DCE, pour Distributed Computing Environment, sous-jacent entre autres à COM, est disponible en format à code ouvert : http://www.opengroup.org/dce/
• À propos des problèmes inhérents à ce modèle, par Steve Vinoski en 2009 : http://qconlondon.com/dl/qcon-london-2009/slides/SteveVinoski_RPCAndItsOffspringConvenientYetFundamentallyFlawed.pdf
• Selon Rüdiger Möller en 2015, il faudrait reconsidérer la vague REST et revenir à une approche RPC quand des considérations d'efficacité et de vitesse sont importantes : http://java-is-the-new-c.blogspot.de/2015/06/dont-rest-revisiting-rpc-performance.html
• Explication du modèle RPC sur Microsoft Technet, texte de 2003 : https://technet.microsoft.com/en-us/library/cc738291%28v=ws.10%29.aspx
• Implémentation gRPC, proposée par Google : http://www.grpc.io/docs/

Protocoles

Quelques considérations générales :

• en 2012, John Graham-Cumming fait l'éloge des protocoles texte. Dans l'un de mes premiers emplois à titre d'informaticien, au début des années '90 à IREQ, on m'avait servi le même discours (avec raison, dans bien des cas... La vie n'est pas monolithique) : http://blog.jgc.org/2012/04/in-praise-of-text-files-and-protocols.html

Quelques protocoles RPC bien connus suivent.

DCE/RPC

Protocole sous-jacent entre autres au modèle DCOM. Pour plus de détails, voir http://en.wikipedia.org/wiki/DCE/RPC

Java RMI

Pour quelques détails, voir http://en.wikipedia.org/wiki/Java_RMI

Un guide en ligne pour apprivoiser cette technologie : http://docs.oracle.com/javase/tutorial/rmi/

Site officiel de la technologie : http://www.oracle.com/technetwork/java/javase/tech/index-jsp-136424.html

Un exemple simple, par Takashi Yamanoue : http://yama-linux.cc.kagoshima-u.ac.jp/~yamanoue/researches/java/rmi-ex2/

Pour réaliser Java RMI à travers une couche de transport IIOP :

• http://java.sun.com/products/rmi-iiop/
• http://docs.oracle.com/javase/1.3/docs/guide/rmi-iiop/

IIOP

Voir http://en.wikipedia.org/wiki/General_Inter-ORB_Protocol pour débuter vos lectures. Aussi, voir :

• http://www.omg.org/library/iiop4.html
• http://www.omg.org/spec/CCM/

NFS

Voir http://en.wikipedia.org/wiki/NFS_protocol pour des détails.

RPC/XDR

Le format XDR est décrit sur http://en.wikipedia.org/wiki/External_Data_Representation

Architectures orientées services (AOS, en anglais Service-Oriented Architectures, ou SOA)

Le Wiki sur les SOA est disponible sur http://en.wikipedia.org/wiki/Service-Oriented_Architecture (pour une brève – et moins complète – définition, voir http://www.service-architecture.com/web-services/articles/service-oriented_architecture_soa_definition.html). Un petit article associant SOA et faible couplage est disponible sur http://webservices.xml.com/pub/a/ws/2003/09/30/soa.html. Vous trouverez aussi plusieurs liens sur la SOA à travers http://wiki.java.net/bin/view/Javapedia/ServiceOrientedArchitecture

Le SOA Consortium, http://www.soa-consortium.org/, vise entre autres à identifier ce qui fait que des projets SOA ont ou non du succès, de manière à faciliter le succès de nouvelles entreprises en ce sens.

Articles divers sur le sujet :

• Qu'est-ce que SOA? Texte de 2012 : http://www.soa-probe.com/2012/10/what-is-soa.html
• Blogue qui soulève la question : est-ce que les SOA sont ce qu'il vous faut? http://blogs.ittoolbox.com/emergingtech/soa/archives/soa-is-it-right-for-you-part-i-5834
• Les SOA et la réutilisation des composants existants : http://www-128.ibm.com/developerworks/webservices/library/ws-reuse-soa.html?ca=dgr-lnxwReuseSOA
• Une proposition de processus de design pour les SOA : http://www-128.ibm.com/developerworks/webservices/library/ws-soad1/
• Le petit coin enchanté des SOA, selon Chris Swan en 2011 : http://blog.thestateofme.com/2011/09/18/amqp-the-enchanted-corner-of-soa/
• En 2010, Josh Long réfléchit sur cinq ans de SOA : http://www.artima.com/weblogs/viewpost.jsp?thread=290352
• Recommandations pour des SOA en infonuagique (Cloud Computing), par Adam Riglian en 2012 : http://searchsoa.techtarget.com/news/2240114036/Service-oriented-cloud-computing-infrastructure-guidelines-released
• Les effets secondaires positif d'une AOS, par Randall Degges en 2012 : http://rdegges.com/service-oriented-side-effects
• En contrepartie, les côtés moins heureux d'une AOS, par Randall Degges en 2012 : http://rdegges.com/service-oriented-problems
• Mieux vaut concevoir l'approche SOA comme un modèle de pensée orienté vers la gestion des dépendances, selon Ganesh Prasad en 2015 : http://www.infoq.com/articles/dependency-oriented-thinking-1

Technologies dans le secteur intergiciel (Middleware)

Il existe plusieurs technologies dans le secteur intergiciel, en anglais Middleware. Voici quelques-unes des principales dans le lot.

CORBA

• http://www.omg.org/
• http://www.sei.cmu.edu/str/descriptions/corba.html
• L'implémentation Java du protocole RMI-IIOP : http://docs.oracle.com/javase/1.3/docs/guide/rmi-iiop/
• Apprendre des erreurs de CORBA, un texte de Michi Henning en 2006 : http://queue.acm.org/detail.cfm?id=1142044
• La montée, puis la chute de CORBA, une réflexion de Michi Henning en 2015 : http://queue.acm.org/detail.cfm?id=1142044
• CORBA sera déprécié en Java à partir de la version 9 du langage : http://hg.openjdk.java.net/jigsaw/jake/corba/rev/37bfe73e7cc3
• Une mise en correspondance entre IDL de CORBA et code C++ 11 : http://www.omg.org/spec/CPP11/

COM

Pédagogie :

• Site officiel : http://www.microsoft.com/com/default.mspx
• Comprendre l'agrégation sous COM, un article du Code Project; en 2007 : http://www.codeproject.com/KB/COM/AggregationSample.aspx
• Clients et serveurs dans le modèle COM : http://msdn.microsoft.com/en-us/library/ms683835
• Qu'est-ce que COM exactement? Un texte de Larry Osterman en 2004 : http://blogs.msdn.com/b/larryosterman/archive/2004/10/15/242989.aspx

Technique :

• Isoler une DLL dans un exécutable substitut (en anglais : Surrogate), autre que celui du client : http://msdn.microsoft.com/en-us/library/ms695225
• Comment utiliser COM avec du C « vanille », une série d'articles du Code Project par Jeff Glatt :
  • http://www.codeproject.com/KB/COM/com_in_c1.aspx
  • http://www.codeproject.com/KB/COM/com_in_c2.aspx
  • http://www.codeproject.com/KB/COM/com_in_c3.aspx
  • http://www.codeproject.com/KB/COM/com_in__c4.aspx
  • http://www.codeproject.com/KB/COM/com_in_c5.aspx
  • http://www.codeproject.com/KB/COM/com_in_c6.aspx
  • http://www.codeproject.com/KB/COM/com_in_c7.aspx
  • http://www.codeproject.com/KB/COM/com_in_c8.aspx
• Interopérabilité avec COM, de la manière difficile, un article du Code Project par Kees Pieters en 2007 : http://www.codeproject.com/KB/COM/ComHard.aspx
• Émuler CoCreateInstance(), article du Code Project par Elias Bachaalany en 2007 : http://www.codeproject.com/KB/COM/Emul_CoCreateInstance.aspx
• Interopérer avec Microsoft Word, article du Code Project par Dmitry Khudorozhkov en 2007 : http://www.codeproject.com/KB/COM/twowords.aspx
• Interopérer avec Microsoft Excel à partir de Python, texte de 2009 : http://www.dev-explorer.com/articles/excel-spreadsheets-and-python
• Un COM-Callable Wrapper qui peut être appelié par JavaScript, article du Code Project en 2010 : http://www.codeproject.com/KB/COM/Universal_CCW.aspx
• Communiquer avec DCOM autrement que par le port traditionnel, article du Code Project un texte de 2009 : http://www.codeproject.com/KB/COM/ComBridge.aspx
• En lien avec XPCOM, la variante de COM pour Mozilla :
  • un didacticiel du Code Project, par Mazharul Islam Khan en 2010 : http://www.codeproject.com/KB/miscctrl/XPCOM_Creation.aspx
  • passer de COM à XPCOM, article du Code Project, par Mazharul Islam Khan en 2010 : http://www.codeproject.com/KB/cross-platform/MsCOM_to_XPCOM.aspx
• Les clés de registre pertinentes pour COM : http://msdn.microsoft.com/en-us/library/ms680055
• Considérations de sécurité :
  • en général : http://msdn.microsoft.com/en-us/library/ms693319
  • constantes utilisées pour fins d'authentification : http://msdn.microsoft.com/en-us/library/ms678435
  • prudence en appelant des fonctions de COM dans DllMain(), un article de Raymond Chen en 2014 : http://blogs.msdn.com/b/oldnewthing/archive/2014/08/21/10551659.aspx
• Considérations d'inscription à la base de registres, textes de Larry Osterman en 2006 :
  • quelles sont les entrées requises dans la base de registre pour une inscription correcte? http://blogs.msdn.com/b/larryosterman/archive/2006/01/11/511647.aspx
  • quel est le minimum requis pour que la mécanique fonctionne? http://blogs.msdn.com/b/larryosterman/archive/2006/01/05/509731.aspx
  • quand doit-on inscrire un APPID? http://blogs.msdn.com/b/larryosterman/archive/2006/01/04/509436.aspx
  • inscription d'un PROGID : http://blogs.msdn.com/b/larryosterman/archive/2006/01/10/511279.aspx
  • inscriptions pour accès inter-processus : http://blogs.msdn.com/b/larryosterman/archive/2006/01/06/510168.aspx
  • inscriptions dépendant d'une bibliothèque de types : http://blogs.msdn.com/b/larryosterman/archive/2006/01/09/510856.aspx
• En 2014, Raymond Chen rappelle que COM ne peut régler vos problèmes pour vous s'il n'intervient pas : http://blogs.msdn.com/b/oldnewthing/archive/2014/09/26/10560553.aspx
• Dans quelles circonstances AddRef() est-elle susceptible de retourner zéro? Explication de Raymond Chen en 2015 : http://blogs.msdn.com/b/oldnewthing/archive/2015/03/12/10599631.aspx
• Une méthode COM peut-elle être variadique? La réponse courte est « non », et Raymond Chen explique pourquoi dans ce texte de 2015 : http://blogs.msdn.com/b/oldnewthing/archive/2015/04/24/10609576.aspx

Résurgence :

• L'arrivée de Windows 8 suggère un retour en force de cette technologie, selon un article de Tim Anderson en 2011 : http://www.theregister.co.uk/2011/09/19/programming_for_windows_8/
• Court texte de John D. Cook, en 2012, sur la « disparition » et le retour de COM : http://www.johndcook.com/blog/2012/11/12/remembering-com/
• Utiliser C++ et COM avec WinRT, par Christophe Pichaud en 2014 : http://www.drdobbs.com/windows/using-c-and-com-with-winrt/240168150?_mc=sm_drd
• COM et mort... Longue vie à COM, un texte de 2014 : http://www.codergears.com/Blog/?p=950
• Les nouveaux pointeurs intelligents pour interagir avec COM, décrits par Kenny Kerr en 2015 : https://msdn.microsoft.com/fr-fr/magazine/dn904668%28en-us%29.aspx

EJB

ICE

OSGi

Infos à venir.

• Comprendre la résolution des Bundles d'OSGi, un texte de Christian Posta en 2012 : http://www.christianposta.com/blog/?p=241
• Le projet Jigsaw, prévu initialement pour Java 8 et apparemment remis pour Java 9, semble être un compétiteur direct de OSGi. À cet effet, un texte de Neil Bartlett en 2012 : http://njbartlett.name/2012/07/19/jigsaw-postponed.html

.NET

• http://www.microsoft.com/net/
• Pourquoi ce nom? C'est pas tout à fait clair, mais voici quelques pistes : http://www.dodgycoder.net/2012/05/why-was-net-called-net.html
• http://go-mono.com/tutorial/html/en/mono/dotnet.html

Théorème CAP

En 2000, Eric Allen Brewer, dans une présentation nommée Towards Robust Distributed Systems, a mis de l'avant que, pour un système réparti où des données sont partagées, on ne peut avoir que deux des trois propriétés suivantes :

• Cohérence (Consistency), au sens où les écritures et les changements aux états partagés sont atomiques pour le système entier
• Disponibilité (Availability), au sens où le système demeure disponible et opérationnel en tout temps
• Tolérance aux partitions (Partition Tolerance), au sens où rien d'autre qu'une panne du système entier ne peut empêcher ce système de répondre correctement aux requêtes

Cette conjecture, que l'on nomme maintenant théorème CAP dû aux lettres qui débutent chacun des mots clés qu'il met de l'avant, semble tenir la route en pratique. Il a été prouvé par Seth Gilbert et Nancy Lynch (voir ci-dessous) et a entre autres influencé le développement d'approches telles que la mouvance NoSQL, qui tendent vers ce qu'elles qualifient de « cohérence éventuelle » sans exiger que le système soit en tout temps cohérent.

Quelques pistes pour apprivoiser le théorème CAP :

• http://en.wikipedia.org/wiki/CAP_theorem
• Une foire aux questions sur le sujet : https://github.com/henryr/cap-faq
• Article de Seth Gilbert et Nancy A. Lynch, qui ont démontré formellement le théorème CAP en 2002 et ont discuté de ses implications : http://webpages.cs.luc.edu/~pld/353/gilbert_lynch_brewer_proof.pdf
• Une présentation d'Eric Allen Brewer lui-même, en 2004 : http://www.cs.berkeley.edu/~brewer/cs262b-2004/PODC-keynote.pdf
• Texte de Werner Vogels en 2008 décrivant ce que signifie être « éventuellement cohérent » : http://www.allthingsdistributed.com/2008/12/eventually_consistent.html
• Vaincre le théorème CAP, texte de Nathan Marz en 2011 : http://nathanmarz.com/blog/how-to-beat-the-cap-theorem.html
• Réflexion d'Eric Allen Brewer sur le théorème CAP, douze ans après que celui-ci ait été énoncé : http://www.infoq.com/articles/cap-twelve-years-later-how-the-rules-have-changed
• En 2012, Seth Gilbert et Nancy A. Lynch proposent une nouvelle perspective sur le théorème CAP, qu'ils reformulent comme « the impossibility of guaranteeing both safety and liveness in an unreliable distributed system » : http://groups.csail.mit.edu/tds/papers/Gilbert/Brewer2.pdf
• En 2013, Lior Messinger propose ce qu'il estime être une meilleure explication du théorème CAP : http://architects.dzone.com/articles/better-explaining-cap-theorem
• Explication illustrée de Robert Greiner en 2014 : http://robertgreiner.com/2014/08/cap-theorem-revisited/
• En 2015, Nicolas Liochon critique le choix terminologique du théòrème CAP : http://thislongrun.blogspot.ca/2015/03/the-confusing-cap-and-acid-wording.html
• Texte de 2014 qui exprime l'opinion qu'être conséquent est plus important qu'être correct : http://blog.iterate.no/2014/09/15/consistency-over-correctness/
• Réflexion de 2014 par Jef Claes à propos de la cohérence éventuelle : http://www.jefclaes.be/2014/05/eventual-consistency-in-wild-west.html
• Réflexion de Mark Burgess en 2012 sur le théorème CAP et ses conséquences :
  • http://markburgess.org/blog_cap.html
  • http://markburgess.org/blog_cap2.html
• En 2015, Spiros Eliopoulos propose une interpétation du théorème CAP sur le plan de la logique des propositions : http://computationallyendowed.com/blog/2015/07/09/cap-theorem-logic.html
• Texte de 2023 par Kaushik Sathupadi qui vise à expliquer le théorème CAP en des termes simples : http://ksat.me/a-plain-english-introduction-to-cap-theorem

Cohérence répartie :

• http://blog.mongodb.org/post/475279604/on-distributed-consistency-part-1
• http://blog.mongodb.org/post/498145601/on-distributed-consistency-part-2-some-eventual
• http://blog.mongodb.org/post/505822180/on-distributed-consistency-part-3-network
• http://blog.mongodb.org/post/516567520/on-distributed-consistency-part-4-multi-data-center
• http://blog.mongodb.org/post/520888030/on-distributed-consistency-part-5-many-writer
• http://blog.mongodb.org/post/523516007/on-distributed-consistency-part-6-consistency-chart
• En 2017, Robert Yokoda recommande de ne pas se limiter à la cohérence éventuelle, en mettant de l'avant en quoi un système qui n'offre que A et P ne suffit pas à ses yeux : https://yokota.blog/2017/02/17/dont-settle-for-eventual-consistency/

Approche NoSQL

Quelques pistes pour apprivoiser l'approche NoSQL, plusieurs ayant un lien avec le théorème CAP :

• Définir le terme NoSQL, un texte de Martin Fowler en 2012 : http://martinfowler.com/bliki/NosqlDefinition.html
• Description de la mouvance NoSQL, en 2010 : http://blogs.computerworlduk.com/app-dev-and-programme-management/2010/02/the-nosql-movement-is-growing-but-what-is-it/index.htm
• Un lien général vers diverses technologies dans ce créneau, lien qui m'a été proposé par Mounir Boussafsaf en 2012 : http://nosql-database.org/
• Selon Robert Treat, en 2012, il ne faut pas confondre NoSQL avec NoDBA : http://omniti.com/seeds/why-nosql-does-not-mean-nodba
• Les textes qu'il faut lire pour comprendre NoSQL, du moins selon Kas Thomas en 2009 : http://asserttrue.blogspot.com/2009/12/nosql-required-reading.html
• Quitter MySQL pour prendre un virage NoSQL, un cas d'espèce relaté en 2010 : http://www.unixmen.com/news-today/875-digg-says-yes-to-nosql-and-bye-to-mysql
• En 2009, un texte de Dare Obasanjo qui discute de NoSQL, de dénormalisation des données : http://www.25hoursaday.com/weblog/2009/09/10/BuildingScalableDatabasesDenormalizationTheNoSQLMovementAndDigg.aspx
• Selon Stephan Schmidt en 2010, NoSQL ne mourra pas de sitôt : http://codemonkeyism.com/nosql-die/
• Visualiser la mouvance NoSQL et le théorème CAP, par Nathan Hurst en 2010 : http://blog.nahurst.com/visual-guide-to-nosql-systems
• Texte de Jonathan Ellis en 2009 décrivant l'écosysème NoSQL à l'époque : http://www.rackspacecloud.com/blog/2009/11/09/nosql-ecosystem/
• Texte expliquant comment Aleksander Kmetec voyait le futur de la mouvance NoSQL en 2009 : http://lexandera.com/2009/11/predictions-on-the-future-of-nosql/
• Entrevue avec un penseur du domaine, par Gavin Clarke en 2010 : http://www.theregister.co.uk/2010/09/13/mic    hael_stonebraker_interview/
• Utiliser MySQL avec une approche NoSQL, par Yoshinori Matsunobu en 2010 : http://yoshinorimatsunobu.blogspot.com/2010/10/using-mysql-as-nosql-story-for.html
• L'approche NoSQL serait l'enfant conceptuel de Google, Amazon et... Lotus Notes, selon cet article de Klint Finley en 2012 : http://www.wired.com/wiredenterprise/2012/12/couchdb/
• En 2010, Daniel Lemire se questionne à savoir si NoSQL ne devrait pas plutôt se nommer NoJoin : http://lemire.me/blog/archives/2010/06/28/nosql-or-nojoin/
• Texte de 2012 par Ilya Katsov sur des techniques de modélisation de données appropriées pour NoSQL : http://highlyscalable.wordpress.com/2012/03/01/nosql-data-modeling-techniques/
• Approche pragmatique à la mouvance NoSQL, par Benjamin Black en 2010 : http://gigaom.com/cloud/nosql-is-for-the-birds/
• Comment l'approche NoSQL est appliquée chez Netflix, texte de 2011 : http://techblog.netflix.com/2011/01/nosql-at-netflix.html
• En 2011, Erik Meijer et Gavin Bierman dissertent sur le fait que SQL et NoSQL sont en faits deux facettes d'une même entité : http://queue.acm.org/detail.cfm?id=1961297
• Choisir NoSQL pour les bonnes raisons, un texte de Markus Winand en 2011 : http://blog.fatalmind.com/2011/05/13/choosing-nosql-for-the-right-reason/
• Les quatre catégories de bases de données NoSQL, décrites par Timan Rebel en 2012 : http://rebelic.nl/engineering/the-four-categories-of-nosql-databases/
• Utiliser NoSQL? Mieux vaut se demander tout d'abord si on a besoin d'une base de données, de l'avis de Martin Fowler en 2011 : http://martinfowler.com/bliki/MemoryImage.html
• Apprendre NoSQL, un texte de Karl Seguin en 2011 : http://openmymind.net/2011/8/15/How-You-Should-Go-About-Learning-NoSQL/
• Utiliser une Cache répartie comme s'il s'agissait d'une base de données NoSQL, texte de 2011 par Srini Penchikala : http://www.infoq.com/news/2011/11/distributed-cache-nosql-data-sto
• À propos de l'impact de Google sur le mouvement NoSQL, texte de William Edwards en 2012 : http://williamedwardscoder.tumblr.com/post/16399069781/google-moresql-is-real
• Des algorithmes répartis appropriés pour des technologies NoSQL, par Ilya Katsov en 2012 : http://highlyscalable.wordpress.com/2012/09/18/distributed-algorithms-in-nosql-databases/
• En 2012, John D. Cook parle de la chute de popularité de la troisième forme normale : http://www.johndcook.com/blog/2012/11/21/rise-and-fall-of-the-third-normal-form/
• Comprendre NoSQL en trois étapes, par Maun PK en 2014 : http://www.javacodegeeks.com/2013/03/a-3-step-guide-to-getting-started-with-nosql.html
• Entrevue avec Michael Franklin sur l'importance à la fois de NoSQL et de SQL, relatée par Derrick Harris en 2015 : https://medium.com/s-c-a-l-e/database-guru-on-why-nosql-matters-and-sql-still-matters-c64239fe84fd

Une particularité de plusieurs types de bases de données NoSQL est de ne pas garantir une cohérence (le « C » du théorème CAP) des données en tout temps – dans le monde NoSQL, on parle plutôt de cohérence éventuelle, au sens où même s'il y a réplication des données, il est possible que certains noeuds d'une telle base de données aient une version d'une donnée pendant que d'autres noeuds ont une autre version de la même donnée. Accepter cette réalité est un a priori du choix d'une approche NoSQL. À ce sujet :

• Texte de 2011 par Victor Nicollet, proposant des tactiques pour compenser la réalité des bases de données dont les données ne sont pas cohérentes : http://www.nicollet.net/2011/08/coping-with-inconsistent-databases/
• Texte de 2012 par Peter Bailis mettant de l'avant qu'il n'est selon lui pas sécuritaire de reposer sur une cohérence éventuelle : http://www.bailis.org/blog/safety-and-liveness-eventual-consistency-is-not-safe/

Plus près des produits eux-mêmes (liste non-exhaustive) :

• D'intérêt historique, le produit BerkeleyDB : http://highscalability.com/blog/2012/2/20/berkeley-db-architecture-nosql-before-nosql-was-cool.html
• Le produit Apache Cassandra : http://cassandra.apache.org/
  • voir aussi http://spyced.blogspot.com/2010/04/cassandra-fact-vs-fiction.html par Jonathan Ellis en 2010
• Le produit Couchbase (autrefois Membase) : http://www.couchbase.com/wiki/display/couchbase/Home
• Le produit Hadoop, d'Apache : http://readwrite.com/2013/05/23/hadoop-what-it-is-and-how-it-works
• Le produit Moneta, pour interfacer avec les entrepôts de type clé/ valeur : https://github.com/wycats/moneta#readme
• Le projet Voldemort, un entrepôt de type clé/ valeur : http://www.project-voldemort.com/voldemort/
• Le produit CouchDB : http://couchdb.apache.org/
• Le produit MongoDB : http://www.mongodb.org/display/DOCS/Home
  • migrer de SQL Server vers MongoDB, un texte de 2011 : http://www.wireclub.com/development/TqnkQwQ8CxUYTVT90/read
  • ce n'est pas pour tout le monde, évidemment. À cet effet :
  • un texte de 2012 : http://www.zopyx.de/blog/goodbye-mongodb
  • autre texte de 2012 : http://blog.postmarkapp.com/post/37338222496/bye-mongodb-hello-cloudant
• Le produit Neo4j : http://neo4j.org/
• Un produit NoSQL par Oracle, texte de 2011 par Peter Wayner : http://www.infoworld.com/d/data-explosion/first-look-oracle-nosql-database-179107
• Une base de données clé/ valeur méconnue, Postgresql : http://blog.creapptives.com/post/14062057061/the-key-value-store-everyone-ignored-postgresql
• Le produit Hyperdex : http://hyperdex.org/
• Bien utiliser un outil NoSQL, par Jim Webber en 2011 : http://jim.webber.name/2011/04/square-pegs-and-round-holes-in-the-nosql-world/
• http://code.google.com/p/redis/
• http://1978th.net/tokyocabinet/
• Appliquer l'approche NoSQL en Ruby, par James Golick en 2009 : http://jamesgolick.com/2009/12/16/introducing-friendly-nosql-with-mysql-in-ruby.html
• Je ne sais pas où classer ceci, mais Zed A. Shaw a construit sa propre base de données NoSQL dans laquelle JSON est le format dominant : http://sheddingbikes.com/posts/1273859940.html
• Le langage UnQL, qui se veut un « sur-ensemble » de SQL, décrit par Joab Jackson en 2011 : http://www.arnnet.com.au/article/395469/couchbase_sqlite_launch_unified_nosql_query_language/

Évidemment, c'est un mouvement contesté :

• Le « côté obscur » de la mouvance NoSQL, par Stephan Schmidt en 2009 : http://codemonkeyism.com/dark-side-nosql/
• http://www.yafla.com/dforbes/Getting_Real_about_NoSQL_and_the_SQL_Isnt_Scalable_Lie/
• En 2009, BJ Clark nous rappelle en quelque sorte que « passer à NoSQL » ne signifie pas automatiquement gagner en échelonnabilité : http://bjclark.me/2009/08/nosql-if-only-it-was-that-easy/
• En 2009, Michael Stonebraker rappelle que la mouvance NoSQL n'a, malgré les apparences, rien à voir avec SQL : http://cacm.acm.org/blogs/blog-cacm/50678-the-nosql-discussion-has-nothing-to-do-with-sql/fulltext
• http://www.yafla.com/dforbes/The_Impact_of_SSDs_on_Database_Performance_and_the_Performance_Paradox_of_Data_Explodification/
• Régler certains problèmes associés aux bases de données relationnelles sans faire le saut vers un modèle NoSQL, texte de Daniel Abadi en 2010 : http://dbmsmusings.blogspot.com/2010/08/problems-with-acid-and-how-to-fix-them.html
• Texte de 2011 par Bob Warfied et selon lequel NoSQL entre dans la catégorie des « optimisations prématurées » : http://smoothspan.wordpress.com/2011/07/22/nosql-is-a-premature-optimization/
  • en réponse à ce texte, voir ce texte de Jeremy Zawodny en 2011 : http://blog.zawodny.com/2011/07/23/nosql-is-what/
• Est-ce que NoSQL est une avancée ou un recul en comparaison avec la vision originale d'Edgar Codd? Vision de Doug Turnbull en 2013 : http://www.opensourceconnections.com/2013/12/11/codds-relational-vision-has-nosql-come-full-circle/
• En 2014, Doug Turnbull explique qu'il estime que l'on devrait cesser d'utiliser le nom NoSQL : http://opensourceconnections.com/blog/2014/09/27/lets-stop-saying-nosql/
• Texte de 2017 par Ajai Kulkarni, selon qui SQL fait un retour face à NoSQL : https://blog.timescale.com/why-sql-beating-nosql-what-this-means-for-future-of-data-time-series-database-348b777b847a

Un livre pas mal sur le sujet.