Affichage des articles dont le libellé est Java. Afficher tous les articles
Affichage des articles dont le libellé est Java. Afficher tous les articles

mardi 26 septembre 2017

Outils Java, jvm pratique

Long time without post but not dead blog. Du coup juste un passage rapide avant de reprendre une activité plus dense ici (bientôt j'espère) pour lister quelques outils opensource disponibles sous Github.

Analyser les optimisation JIT de la JVM
https://github.com/AdoptOpenJDK/jitwatch

Analyse des temps de réponse en percentile
https://github.com/giltene/jHiccup

Outil pour insérer de la fragmentation dans le heap afin de tester son application
https://github.com/giltene/HeapFragger

Mesure de la latence
https://github.com/LatencyUtils/LatencyUtils

Mesure des temps de réponse de socket
https://github.com/LatencyUtils/jRT

Ensemble d'outil pour l'analyse du comportement de la jvm
https://github.com/aragozin/jvm-tools

Manipulation des output de jstack pour faciliter l'analyse
https://github.com/lifey/mjprof

PlugIn pour MAT et requeter la Heap
https://github.com/vlsi/mat-calcite-plugin
Publié par à Aucun commentaire:
Libellés : , , , , , , , ,

dimanche 15 mars 2015

Quelques mots sur Cassandra

Ayant récemment un peu creusé la technologie et sans faire redite avec un post précédent quelques points concernant Cassandra.

Cassandra


     Dans la mouvance NoSQL (lire dans le texte NotOnlySQL), structure de stockage de données développée en Java entrant dans la catégorie hybride clé/valeur clé/colonne. Cassandra prend place dans le triangle du CAP théorème (autrement nommé théorème de Brewer) proposant à l'utilisateur de régler le niveau de réplication et le niveau de cohérence via paramètres et ce fonction de ses besoins.

Le home du projet : http://cassandra.apache.org/

     Vous les trouverez régulièrement pas très loin : Datastax. Société qui propose une surcouche à Cassandra, orienté "entreprise". Ils possèdent une forte expertise sur Cassandra, comptant dans leur rang un certain nombre de committers Cassandra. Leur surcouche permet (entre autres) de faire le lien entre le storage Cassandra et de l'analytics comme Spark ou encore recherche/indexation avec Solr. Ils viennent récemment de s'attaquer aux graph db en faisant l'acquisition de Aurelius (TitanDb).

Les communiqués de presse :
Côté Datastax : http://www.datastax.com/2015/02/datastax-acquires-aurelius-the-experts-behind-titandb
Côté Aurelius : http://thinkaurelius.com/2015/02/03/aurelius-acquired-by-datastax/
Home de TitanDB : http://thinkaurelius.github.io/titan/

Le home de Datastax : http://www.datastax.com/what-we-offer/products-services/datastax-enterprise

Les outils pour travailler avec Cassandra


     Les outils qui vont bien (très orienté DataStax, il doit exister d'autres) :

CCM (Cassandra Cluster Manager), outil de développement réalisé par Sylvain Lebresne (DataStax). Non recommandé en production, il permet en local de gérer un cluster avec plusieurs noeuds Cassandra. Très bien pour se faire la main et commencer à jouer avec la technologie.

Home CCM : https://github.com/pcmanus/ccm
How to CCM : http://planetcassandra.org/getting-started-with-ccm-cassandra-cluster-manager/
Article : http://www.datastax.com/dev/blog/ccm-a-development-tool-for-creating-local-cassandra-clusters

DevCenter, outil de Datastax qui permet de bénéficier d'une GUI pour s'interfacer avec un Cassandra déployé. Permet de requêter, voir les traces d'exécution, visualiser les tables de vos namespaces et les tables systèmes.
DevCenter : http://www.datastax.com/what-we-offer/products-services/devcenter

OpsCenter, outils de DataStax également qui nous fait entrer plus du côté administrateur pour visualiser nos clusters, noeuds Cassandra.
OpsCenter : http://www.datastax.com/what-we-offer/products-services/datastax-opscenter

     Enfin pour coder son client Java qui vient requêter le datastore Cassandra au travers un noeud qui devient coordinateur : le Java driver Datastax
Home Java Driver (avec la dependency Maven qui va bien) : https://github.com/datastax/java-driver

     Cassandra étant en Java bien entendu toutes les JConsole, VisualVM & co sont les bienvenues pour suivre ce qu'il se passe.

Un peu d'histoire


     Cassandra trouve à sa source deux projets le précédent BigTable de Google (2006) auquel Cassandra empruntera le modèle de données structuré ColumnFamily. Et Dynamo d'Amazon (2007) auquel Cassandra reprend le partitionning et le système de réplication.

Ces deux projets ont fait l'objet de publication technique :

     Cassandra est développé au sein de Facebook par Avinash Lakshman (un des créateur de Dynamo d'Amazon) et Prashant Malik (ingénieur Facebook). Il sera open sourcé par Facebook en 2008.

A propos du key value store vs column family : http://www.edwardcapriolo.com/roller/edwardcapriolo/entry/on_key_value_vs_column

Quelques mots clé (pour approfondir via google & co)


     Généralités sur l'architecture : http://wiki.apache.org/cassandra/ArchitectureOverview

     OnHeap, offHeap : Cassandra (en java donc dans une jvm) utilise du off heap pour stocker un certain nombre d'information : http://noflex.org/cassandra-component-on-heap-or-off-heap/

     Composants techniques au cœur de Cassandra : MemTable et SSTable

     A connaitre pour bien comprendre le fonctionnement : Read Path et Write Path
http://fr.slideshare.net/joshmckenzie/cassandra-21-read-write-path

     Requête sur une base Cassandra :
CQL : https://cassandra.apache.org/doc/cql3/CQL.html
Avant le CQL, le shell (qui viendrait à disparaitre) : http://wiki.apache.org/cassandra/CassandraCli
Enfin quelques drivers permettant d'attaquer Cassandra dans différents langages : http://planetcassandra.org/client-drivers-tools/

Quelques Algo derrière cette belle machine


     Au coeur du principe distribué de Cassandra et ce qui en fait un système sans SPOF (Single Point Of Failure) : le Gossip protocole

     Filtre de Bloom

     Merkle tree, pour vérifier la consistance et permettre la remonté rapide de nœud :

     Paxos pour les transactions dites légère

Dans la vie réelle


     Pour finir quelques utilisateurs de Cassandra en production sans gâcher la surprise quelques noms connus : CERN, eBay, GitHub, Instagram, Intuit, Netflix, Reddit, The Weather Channel, ...

Pour plus de détails :
Utilisateurs de Cassandra : http://planetcassandra.org/companies/
L'exemple de Netflix (presentation 2012) : http://fr.slideshare.net/acunu/cassandra-eu-2012-netflixs-cassandra-architecture-and-open-source-efforts
Blog technique netflix : http://techblog.netflix.com/search/label/Cassandra

Conclusion


     En guise de conclusion, trois points qui me semblent importants à réfléchir pour passer un projet sur Cassandra :
  • J'ai mon storage de donnée mais comment je mets en place mon moteur d'agrégation (Datastax avec sa surcouche propose quelques solutions).
  • Le schéma de mon stockage dans Cassandra est très fortement impacté par comment je vais requêter, il faut avoir une idée de ce que l'on veut avant de partir (contrairement à des datastorage plus souple comme MongoDB, orienté document).
  • Une fois dedans, quelles portes de sorties. Par exemple comment je back up sur un autre support mes données qui sont dans les noeuds Cassandra ... un réponse peut être pas besoin, la solution comme cela me va mais à ce moment attention aux migrations.

     Quelques éléments de réflexion chez les géants du web :
Publié par à Aucun commentaire:
Libellés : , , , , , , , , ,

dimanche 5 octobre 2014

Revue de press du développeur Java


     Quelques news déjà plus si nouvelles que cela (et oui notre monde va vite) mais assez intéressantes pour être notée

Les slides et vidéos du JVM Language Summit 2014 qui s'est déroulé du 28 au 30 juillet dernier
http://www.oracle.com/technetwork/java/javase/community/jlssessions-2255337.html

En lien avec la JVM : Graal
http://www.javaworld.com/article/2691233/scripting-jvm-languages/oracles-graal-project-empowers-language-creation-on-the-jvm.html

Java 9 et open JDK
http://www.javaworld.com/article/2689365/java-platform/openjdk-project-opens-up-java-9-to-collaboration-experimentation.html
http://www.infoworld.com/article/2608801/java/why-developers-should-get-excited-about-java-9.html

Les élections 2014 au JCP (Java Community Process) pour les EC (Executive Committee) :
https://jcp.org/ja/whatsnew/elections

Parce que l'IT ce sont des modèles aussi qui se cherchent il y a aussi des projets qui s'arrêtent :

EOL (EndOfLife) pour LiveRebel
http://zeroturnaround.com/blog/goodbye-liverebel/
http://zeroturnaround.com/rebellabs/the-5-inconvenient-truths-indicating-the-market-still-isnt-ready-for-release-automation/

CloudBees arrête le Paas et se recentre sur Jenkins
http://www.lemondeinformatique.fr/actualites/lire-cloudbees-ferme-son-paas-et-s-allie-avec-pivotal-58603.html
http://www.infoq.com/news/2014/09/CloudbeesExitPAASResignEC
Publié par à Aucun commentaire:
Libellés : , , , ,

Un jour, un storage : Cassandra

     L'objet de ces billets "un jour, un storage" est de parcourir les différentes structures de stockage de données qui fleurissent ces derniers temps (NoSQL ou pas).

     La plus part ne sont pas forcément jeunes et ont des ancêtres qui remontent à bien plus longtemps encore mais les besoins de technologies face aux flux de données actuels, les tendances buzz ("big data") aidant ont les croise de plus en plus régulièrement.

     Je ne vais pas détailler leurs architectures, fonctionnement, utilisation ... mais plutot donner quelques points d'entré qui permettront d'avoir un aperçu et pour ceux qui le souhaitent creuser plus en avant la technologie.

     Première structure de cette série : Cassandra

Cassandra c'est quoi


     C'est un système de stockage de donnée distribué open source. Il adresse les problématiques de scalabilité, destiné à gérer des volumes important de donnés en gardant de bonnes performances et en étant tolérant aux pannes.

     Cassandra est développé en java, considéré comme hybride dans les familles NoSQL : entre clé/valeur et orienté colonnes.

Architecture interne :

Introduction Cassandra :

Quelques tutoriaux :

L'historique


     Comme on le disait tout à l'heure même si ces projets semblent récent, ils ont démarré il y a quelques temps déjà. Quelques dates concernant Cassandra.

     A l'origine Cassandra est un projet réalisé sur un modèle open source par deux développeurs de FaceBook (Avinash Lakshman et Prashant Malik), mis à disposition en juillet 2008 sous google code.

Quelques présentations aux débuts de Cassandra :

     En Mars 2009 Cassandra rejoint Apache Incubator

     Puis Mars 2010 il devient Apache Top Level Project

     Depuis les développements continuent sous l'aile de la fondation Apache :
  • octobre 2011 la version 1.0
  • Septembre 2013 la version 2.0

     Dernière version stable : 2.1.0 (releasé en septembre 2014)

     Les branches encore accessibles :
  • 2.0.10 (aout 2014)
  • 1.2.19 (septembre 2014)

La liste des commiters participants aux développements : http://wiki.apache.org/cassandra/Committers

Les URLS


Le projet : http://cassandra.apache.org/
Download : http://cassandra.apache.org/download/
Wiki du projet : http://wiki.apache.org/cassandra/
Wikipedia : http://en.wikipedia.org/wiki/Apache_Cassandra

DataStax Société commerciale avec expertise Cassandra : http://www.datastax.com/
Communauté Cassandra/Datastax : http://planetcassandra.org/

Un meetup Cassandra sur Paris : http://www.meetup.com/Cassandra-Paris-Meetup/

Participer aux développements


Comment contribuer : http://wiki.apache.org/cassandra/HowToContribute

Les mailing :
User : user-subscribe@cassandra.apache.org
Developer : dev-subscribe@cassandra.apache.org
Notifications de Commits : commits-subscribe@cassandra.apache.org
API cliente : client-dev-subscribe@cassandra.apache.org

Le JIRA Cassandra
https://issues.apache.org/jira/browse/CASSANDRA/?selectedTab=com.atlassian.jira.jira-projects-plugin:summary-panel

Repo Git : https://git-wip-us.apache.org/repos/asf?p=cassandra.git
Règle de coding : http://wiki.apache.org/cassandra/CodeStyle
Publié par à Aucun commentaire:
Libellés : , ,

lundi 11 août 2014

Work is in progress : Java 9

     Les travaux ont commencé pour la next release : Java 9. Les core développeurs se mettent en ordre de bataille et commencent à lancer les discussions sur les mailings, les premiers développements ont été commit (une early est dès à présent disponible).

     Dans les grandes lignes des changements en profondeur (JMM, typage, modularisation ne sont pas une mince affaire) tout en gardant en tête la compatibilité avec les précédentes versions.

     Jettons un oeil dans l'atelier pour voir ce qu'il se prépare.

En introduction


     Les préparations des nouvelles versions de jdk passent maintenant par openjdk et les JEP (JDK Enhancement-Proposal). Les jep permettent d'avancer les développements dans un cadre moins formalisé que les JSR, facilitant ainsi le début des travaux.

La jep 0 liste l'ensemble des jep (et les target release) : http://openjdk.java.net/jeps/0
La jep 1 détail le processus qui ne remplace pas celui des jsr (restant les spécifications officielles) mais vient plutôt en amont : http://openjdk.java.net/jeps/1

Un article de Stephen Colebourne concernant les jep : http://blog.joda.org/2011/11/future-is-in-jeps.html
La mailing dédiée aux jep : http://mail.openjdk.java.net/mailman/listinfo/jep-changes

Quelques généralités

Articles sur le sujet :

     Une présentation qui s'est déroulée au jvm language summit de juillet 2014. Présentation lors de laquelle John Rose et Brian Goetz donne les grandes lignes des orientations concernant l'évolution de la JVM, une runtime qui ne se destine pas uniquement à Java :
http://cr.openjdk.java.net/~jrose/pres/201407-JVMEvolution.pdf

Evolution du Java Memory Model (JMM)

Une présentation de Aleksey Shipilev (spécialiste de Java Performance chez Oracle) sur le JMM

     Le lancement de Doug Lea pour les évolutions JMM 9

     Dans la continuité, forcément des impacts sur les aspects concurrence : http://cs.oswego.edu/pipermail/concurrency-interest/2014-January/012169.html

Projet Panama

     Annoncé par John Rose, le projet Panama dont l'objectif est une meilleur connectivité entre la JVM et les API non java. Ce projet vise à mettre en place les FFI (Foreign Function Interface) en tant qu'alternative aux JNI (Java Native Interface), JNA (Java Native Access). FFi devrait être basé sur Java Native Runtime (JNR)


Articles :

Blog de John Rose : https://blogs.oracle.com/jrose/

Charles Oliver Nutter :

Projet Valhalla


     Initié par Brian Goetz, ce projet vise à faire évoluer le langage et son typage. Quelques exemples pouvant entrer dans ce domaine les value type, Spécialisation des generics et ici ou encore amélioration des volatiles


Articles liés :

Projet Jigsaw


     Initialement prévue en Java8 mais finalement retardé, il est annoncé pour Java 9 par par Mark Reinhold. Jigsaw vise à amliorer la modularité de Java afin de faciliter la scalabilité, améliorer la sécurité, améliorer les performances et faciliter les développements et la maintenance des librairies.

Retard de Jigsaw pour Java 8 :

L'annonce de la phase 2 : http://mreinhold.org/blog/jigsaw-phase-two
Jigsaw : http://openjdk.java.net/projects/jigsaw/goals-reqs/03
Présentation générale : http://cr.openjdk.java.net/~mr/jigsaw/notes/jigsaw-big-picture-01

Les JEP liées à Jigsaw :
jep 161 : http://openjdk.java.net/jeps/161
jep 162 : http://openjdk.java.net/jeps/162




Quelques présentations sur le sujet :

Article :

Les ressources Java 9


     Après avoir parcouru les grandes lignes si vous voulez entrer dans le détail et voir par vous même :

En early access on en est déjà au build 25, les changes de ce dernier build.:
http://download.java.net/jdk9/changes/jdk9-b25.html

Et si vous souhaitez contribuer, ce que vous pouvez faire et comment le faire :
http://openjdk.java.net/contribute/



Pour finir



Petite url bonus, rien à voir (enfin si c'est de la jvm) : jvm, performance et network de Norman Maurer

Publié par à Aucun commentaire:
Libellés : , , , , , , , , , , , ,

dimanche 27 juillet 2014

Investigation au niveau de la JVM

Introduction


     La JVM est un système complexe (JIT, GC, ...), pouvant être optimisé dans son utilisation. Il faut cependant faire attention à ne pas optimiser trop tôt car ce faisant on spécialise son utilisation et si cela répond bien aux use cases d'aujourd'hui, rien ne garantie que cela ne dégradera pas les performances pour les use cases de demain. Quoi qu'il en soit l'optimisation passe par de l'observation et des tests pour étudier les impacts. Et bien souvent les settings de base suffisent.

     A savoir la JVM via JIT est un système intelligent qui s'optimise (et se désoptimise) lui même à la volée (paramétrable également par jvm argument). Conclusion on peut observer un comportement localement qui ne sera pas le comportement une fois en production si l'on a pas pris les bonnes précautions.

     De même faire attention à l'implémentation de la JVM utilisée, les trois principalement rencontrées sont :
  • Hotspot d'Oracle (anciennement Sun)
  • JRockit d'Oracle (anciennement BEA), on la trouve sur serveurs applicatifs Weblogic
  • J9 d'IBM, on la trouve sur serveur applicatifs Websphere

     Ces 3 JVM peuvent avoir des comportements différents, des paramètres (jvm args) différents comme pour l'activation de la compression des références d'objets pour les jvm 64bit, voir OOPS. Suite aux différents rachats Oracle possède maintenant deux de ces JVM et met en place un projet de convergence, voir les liens suivant sur le sujet :

     Une dernière JVM apparait régulièrement, beaucoup plus spécifique c'est la Zing d'Azul System (http://www.azulsystems.com/products/zing/whatisit), je ne développerais pas ici.

     Dernier point les JVM, jdk sont des choses dynamiques, terrain encore en évolutions sur lesquels une communauté active et les éditeurs travaillent. Il est toujours bien de savoir sur quelle version on est, les différences qu'elles apportent, ... Quelques exemples d'évolutions récentes qui ont un impact :

     Il existe un certain nombre de produits sur le marché (software, services) facilitant l'étude du comportement d'une JVM :
  • en se basant sur les api, services de la jvm qui permettent de collecter des métriques et propose une interface pour les exploiter. La collecte des métriques est souvent réalisée par des agents développés et attachés à la jvm que l'on veut suivre, voir cet article.
  • en fournissant des services interprétant les logs de GC et donnant un rendu plus visuel
  • en instrumentant le code par différentes techniques (aop, introspection, ....)

     Dans ce billet je ne parlerais pas de ces solutions mais il est toujours bon de savoir que cela existe, ce qu'elles permettent de faire et comment elle le font. Quelques un de ceux ci :

Les plus connu :

Des projets plus développeurs :

Queqlues produits plus spécifique :

     Pour finir cette introduction, une url présentant une vision assez complète des JVM arguments que l'on peut utiliser : JVM Arguments card

Observation de la JVM


     Dans la partie qui va suivre on va discuter d'un certain nombre de JVM arguments (flags activant certaine options, comportement, traces). Pour au démarrage de votre process java avoir connaissance des jvm args, il existe un jvm arg : -XX:+PrintFlagsFinal qui permettra d'avoir une sortie console du type
[Global flags]
...        
    uintx AdaptiveSizeThroughPutPolicy              = 0               {product}          
    uintx AdaptiveTimeWeight                        = 25              {product}          
     bool AdjustConcurrency                         = false           {product}          
     bool AggressiveOpts                            = false           {product}          
     intx AliasLevel                                = 3               {product}          
     intx AllocateInstancePrefetchLines             = 1               {product} 
...
   

Observation via les logs


     La jvm effectue un certain nombre de tâches techniques depuis son démarrage jusqu'à son arrêt. Il peut être utile pour comprendre son comportement d'avoir une visibilité concernant ces opérations. Pour ce faire il est possible d'activer des logs techniques.

Les Logs GC (Garbage Collector)


     Il est recommandé de les activer systématiquement en environnement de développement, voir même en production (l'overhead reste léger, juste faire attention au volume de log généré sur le filesystem) car les informations fournies peuvent être précieuses et un évènement survenu ne sera pas toujours reproductible.

  • Activation des logs Garbage collector : -XX:+PrintGC 
  • Activation logs détaillé : -XX:+PrintGCDetails (recommandé)
  • Activation du timestamp pour savoir quand l'évènement a eu lieu : -XX:+PrintGCTimeStamps (nombre de seconde depuis le démarrage de la jvm) ou -XX:+PrintGCDateStamps (format date)
  • Spécifier les fichiers de log destination : -Xloggc:<file> 

A partir des jdk 1.6_34 et 1.7_2, possibilité de spécifier un roll sur les fichiers de configuration :
  • Activation : -XX:+UseGCLogFileRotation 
  • Obligatoire en cas d'activation de la rotation, nombre de fichier à garder : -XX:NumberOfGCLogFiles=<number of files>  
  • Obligatoire en cas d'activation de la rotation, taille de chaque fichier (possibilité d'utiliser la notation K (Kilo), m (mega)) : -XX:GCLogFileSize=<size>
Trois autres flags pouvant être utiles : -XX:+PrintTenuringDistribution -XX:+PrintGCApplicationStoppedTime -XX:+PrintGCApplicationConcurrentTime

     De plus -XX:+PrintGC et -XX:+PrintGCDetails sont dit "Manageable", c'est à dire qu'ils peuvent être activés runtime. Pour se faire deux manière
  • via le MBean com.sun.management:type=HotSpotDiagnostic, l'operation setVMOption (les parametres sont nom et valeur, voir javadoc pour plus de détail)
  • via le command line tool jinfo (fourni avec le jdk) "-flag <name>=<value> to set the named VM flag to the given value"
     Les jvm argument "manageable" sont indiqués dans la liste fournie par Oracle : http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html

     Ces logs permettent de savoir quand tourne le Garbage Collector, combien de temps cela dure, ce qu'il fait. Le format de logs étant standard, un certain nombre d'outils permettent d'en avoir une visualisation graphique.

Logs Classloading


     Plus que pour de l'optimisation, ces logs permettent surtout de savoir quelle classe a été chargée depuis quelle librairie. Très pratique quand par dépendance transitive on tire plusieurs versions d'une même librairie (les parsers XML par exemple).

     Le jvm arg est "-verbose:class" à ajouter au lancement. Il permettra d'avoir tout le class loading (classe technique, jdk, librairies utilisées) sous la forme :
...
[Loaded java.util.HashMap from shared objects file]
[Loaded sun.misc.Hashing from D:\jdk1.7.0_25\jre\lib\rt.jar]
....
[Loaded org.junit.internal.runners.model.ReflectiveCallable from file:/C:/Users/Toto/.m2/repository/junit/junit/4.11/junit-4.11.jar]
....

    C'est une sortie console, on ne peut pas spécifier de fichier de sortie contrairement aux logs GC.

Logs JIT


     Un autre aspect dynamique de la jvm, que l'on aborde moins souvent au quotidien et qui je pense nécessite d'être outillé pour analyser : les logs du JIT (JustInTime) qui pratique les optimisations et désoptimisation du code à la volée.

Un outil : JITWatch (https://github.com/AdoptOpenJDK/jitwatch)
Article à son sujet :
     Pour se faire une idée de ces optimisations pratiquées runtime JIT est l'une des raison pour lesquels en Java un benchmark n'est pas toujours fiable 100%.

Observation via les dumps


     Un dump est une photo à moment donné de l'état de notre JVM. Il existe principalement deux types de dump. Le heap dump qui donne le contenu de la mémoire et le thread dump qui liste les thread en vie, leur état et leur stack d'appel afin de savoir ce qu'elles sont en train de faire au moment du dump.

HeapDump


     Il est possible de générer un heapdump à la demande mais également de le générer systématiquement sur un OutOfMemory. Il faut bien avoir conscience que la taille du fichier dump sera au moins égale à la taille du heap.

Jvm args pour avoir un heap dump sur les OOM :
  • -XX:+HeapDumpOnOutOfMemoryError  
  • -XX:HeapDumpPath=<path to dump file>
HeapDump à la demande (fonction des jdk et versions) :
  • depuis Java 6, via l'appel d'un MBean : com.sun.management:type=HotSpotDiagnostic, l'operation dumpHeap (parametre sont outputfile et onlyLiveObject, voir javadoc)
  • via l'outil ligne de commande jmap : jmap -dump:file=D:\mon\filepath\dump.bin javaProcessPid

     Pour récupérer le pid d'un process java, le command line tool jps les liste, sous windows on peut également les retrouver via le task manager et sous linux "ps -eaf | grep java" permet généralement de s'en sortir.

     Si l'on veut faire une génération en programmatique il est facile d'effectuer le code suivant :

            //get my process pid
            String name = ManagementFactory.getRuntimeMXBean().getName();
            String pid = name.substring(0, name.indexOf("@"));
           
            //prepare launch
            String[] cmd = { "jmap", "-dump:file=D:\\dump.bin", pid };
            try {
                //exec jmap process
                Process p = Runtime.getRuntime().exec(cmd);
            } catch (IOException e) {
                System.out.println("InterruptedException " + e);
            }

     Une fois le dump généré, il y a la deuxième partie, sa lecture. Pour ce faire (en dehors des outils du marché, on ne les a pas toujours à disposition) :
  • MAT : Memory Analyzer d'Eclipse (http://www.eclipse.org/mat/)
  • jhat en command line tool fourni avec le jdk. "jhat dump.bin", il ouvre un petit serveur http présentant les résultat, accessible via http://localhost:7000/

     Ce dernier donne un résultat peu enrichie mais il facilement accessible étant dans le jdk. A noter aussi que jhat peut faire une comparaison basé sur un baseline dump et ainsi marquer les nouveaux objets (http://docs.oracle.com/javase/6/docs/technotes/tools/share/jhat.html).

     Jmap (http://docs.oracle.com/javase/7/docs/technotes/tools/share/jmap.html) présente également quelques options intéressantes qui sans aller jusqu'au dump complet fournissent des informations utiles (toujours en command line tool donc facilement accessible) :
  • "jmap -histo:live javaPid" : sort l'histogramme du heap (liste des classes et nombre d'instances)
  • "jmap -permstat javaPid" : donne les indication concernant le permgen space
  • "jmap -heap javaPid" : permet d'avoir la composition du heap

     A savoir pour -histo et -dump, jmap dispose d'un mode forcé (-F) qui même lorsque la jvm ne répond permet d'avoir une sortie d'information. Il m'ai déjà arriver avant que ma jvm ne tombe de ne plus pouvoir accéder via JConsole, ... et de quand même pouvoir sortir un minimum d'information grâce à ce mode Force.

ThreadDump


     La encore un thread dump peut être généré runtime de différentes manière :

     L'analyse des stacks, lock et monitor permet de comprendre ce que l'application était en train de faire au moment de la génération du dump. Pour comprendre la composition d'un threaddump voir l'article

     Un outil intéressant pour faciliter l'analyse des threaddump mjprof. Il s'utilise conjointement avec jstack et permet de filtrer, trier, manipuler les stacks.

Observation Runtime


     Tout les éléments précédemment abordés permettent de collecter des données figées (logs, dump, ....) mais il est aussi intéressant de suivre en temps réel l'évolution. Ce peut être fait en rapprochant les photos (dump) et comparant leurs valeurs. Mais il existe d'autres alternatives.

     Entre deux modes, un outil jstat (http://docs.oracle.com/javase/1.5.0/docs/tooldocs/share/jstat.html) qui permet de produire quelques métriques avec un affichage continu rafraîchi sur une périodicité donnée.

     Sinon pour suivre en temps réel ce qui se passe deux outils très bien, fourni de base avec le jdk :

     A noter également, qui se rapproche plus des Yourkit et JProfiler, Java Mission Control disponible à partir des jdk7u40. A tester et voir ce que cela va donner avec le temps (http://www.oracle.com/technetwork/java/javaseproducts/mission-control/java-mission-control-1998576.html)






En résumé


     Sans outillage complexe, pour avoir de l'information sur une JVM qui tourne :
  • Bilan des flags (jvm args) activés, positionnés, les settings de heap initiales, la GCPolicy en place
  • Des logs à activer (GC, classloading, JIT)
  • Dans le suivi runtime, deux aspects importants : la mémoire et les threads (consommation CPU)
  • On peut les dumper ou interroger la jvm pour avoir des informations (command line tools sont nombreux et documentés) ou encore les suivre via des consoles (JConsole, VisualVM)
  • Un mode force (-F) pour jstack et jmap, pratique quand une jvm ne répond plus

Quelques Références


Une présentation concernant les outils ligne de commande "Tout ce que vous avez toujours voulu savoir de la JVM sans jamais oser lui demander en ligne de commande" de Brice Leporini

Documentation OpenJDK

Tuto Oracle sur les command line tools : http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/JavaJCMD/index.html

Pour compléter un point que je n'ai pas abordé, la JVM ouvre des points d'API permettant de l'interroger directement (souvent utiliser par les outils de monitoring)

Et après avoir investigué, observé ...


     Fort de toutes ces métriques récoltées il est maintenant possible de passer à l'optimisation (et regarder leur impact) mais cela fera l'objet d'un autre billet.

     La première "optimisation" si ce n'est pas fait est de bien sizer ses variables initiales :
  • Taille du heap au démarrage et taille maximale : -Xms, -Xmx (il existe un débat concernant ce point, moi j'aime bien fixer à la même valeur pour éviter de resizer en cours d'utilisation)
  • Taille max du permgen space : -XX:MaxPermSize qui vient en addition du Xmx et dont la valeur par défaut est 64 Mb

     Un "jmap -heap" permettra de faire un bilan concernant les valeurs actuelles et la garbage policy utilisée.

     Aller pour finir une dernière url concernant les optimisations : http://fr.slideshare.net/leonjchen/java-optimization-twjug

Publié par à Aucun commentaire:
Libellés : , , , , , , , , , , , , , , ,

lundi 21 juillet 2014

Survol de la fonderie à application : Forge2 de JBoss

Pourquoi Forge2


     Pour la petite histoire je ne suis pas un grand fan du code généré. Les théories et outils autour des DSL (Domain Specific Language), DDD (Domain Driven Design) bien qu'intéressant ont peu croisés ma route de manière directe lors de mes projets. Par contre j'ai bien croisé quelques outils UML liés à du code généré mais je m'en suis très rapidement écarté (trop lourd à faire tourner, peu maintenable, difficulté à faire évoluer sur des problématiques orthogonales).

J'en garde tout de même deux en tête  :
     Donc sans grande conviction j'ai assisté à une présentation du produit Forge2 de JBoss. Au final après la présentation, je suis passé de "sans conviction" à "A tester, pourrait bien répondre à quelques use cases".

Pourquoi à tester ? 


  • Forge2 reste un outil et ne se veut pas la solution à tous les problèmes : il génère du code et des structures projets
  • Forge2 est ouvert et extensible par addOn. Il peut donc ainsi bénéficier des apports d'une communauté de développeurs et c'est bien souvent éléments clé.
  • Forge2 est scriptable (fichier .fsh) et il ouvre une API permettant d'interagir avec le moteur via du code Java.
  • Forge2 reste basé sur les standards JEE, Maven (pas de configuration propriétaire, pas de systèmes runtime en surcouche, ...)

Pour quelles utilisations


     Java est au delà un langage orienté objet un langage orienté Framework, comme le notait Neal Ford dans son article :
"in the Java world that I've started saying that we should stop referring to Java programming as an object-oriented language and should call it a framework-oriented language".

     L'écosystème Java foisonne de Frameworks pour divers besoins, dont certains finissent par être intégrés dans les specs (JSR) et deviennent des standards. Bien que rendant l'écosystème très riche (voir le nombre de frameworks forkés dans d'autre langages) il reste que le ticket d'entré pour se ballader au sein de cette galaxie d'API, normes, ... est parfois un peu chère.

     Un exemple concret de cette difficulté : commencer un projet Web from scratch avec du JPA, du REST, ... peut s'avérer compliqué si l'on ne maîtrise pas bien toutes ces spécifications (où si l'on ne s'est pas mis à jour récemment).

     Ainsi un use case que l'on rencontre régulièrement : initialiser un projet

Quelques manières de faire :
  • Tâtonner en jonglant avec plusieurs tutoriaux (pas toujours à jour). Ceci peut être long.
  • Reprendre une ossature de projet faisant sensiblement la même choses pour avoir les charnières qui vont bien. On trouve pas toujours le pattern idéal.
  • Utiliser les wizards à disposition. Pas toujours la solution la plus heureuse en raison de l'interprétation/implémentation du context assez spécifique au wizard.
  • Enfin une de mes préférées : utiliser un maven archetype (http://maven.apache.org/guides/introduction/introduction-to-archetypes.html)
Forge2 peut être vue comme une alternative aux solutions précédemment citées.

     Rapidement d'autre use cases pouvant être rempli en utilisant Forge2 :
  • Réalisation d'un poc
  • Toute application CRUD simple
  • Reprise d'une base de données existante pour voir ce qu'elle a dans le ventre
  • Définir des templates de projet via les scripts fsh permettant d'encore accélérer le démarrage d'un projet et d'avoir des structures un peu normées.

Premiers pas avec Forge2


Récupérer un Eclipse Luna (4.4)
https://www.eclipse.org/downloads/

Récupérer un jdk8 (8u5 last release)
http://www.oracle.com/technetwork/java/javase/downloads/index.html?ssSourceSiteId=otnjp

Installer les plugin Eclipse (update site) qui vont bien
JBoss Tools Usage Reporting plugin : http://download.jboss.org/jbosstools/updates/development/luna/
La dernière version de Forge2 (pour aller avec Luna et jdk8) : http://download.jboss.org/jbosstools/builds/staging/jbosstools-forge_master/all/repo/

Si l'on ne souhaite pas rester dans Eclipse, on peut aussi récupérer le Zip Forge2 et l'utiliser en dehors de tout EDI.

Premier projet avec Forge2 et Eclipse


  • Ouvrir la view console Forge (disponible grâce au plugin)
  •  Start de la console
  • A partir de là on peut utiliser les lignes de commande (TAB pour avoir les commandes disponibles et arguments nécessaires). 
  • Un premier projet commencera par exemple par "[LunaWorkspace]$ project-new --named ForgeDemo --topLevelPackage org.test.forge.demo --type war"

Quelques liens de référence


La présentation à laquelle j'ai assisté (présenté par Antonio Goncalves)
"30 minutes pour développer une appli Java EE ?"
http://www.parleys.com/play/535e1643e4b03397a8eee8ce/chapter0/about

Le site Forge : http://forge.jboss.org/
Le gitHub : https://github.com/forge

posts et tutos sur le sujet

Les sujets pour aller plus loin



Ma conclusion


     Assez intéressé pour avancer sur le sujet au travers les use cases décrit plus haut si ils se présentent mais quand même un peu de pratique nécessaire pour bien connaitre les lignes de commandes et les possibilités de l'outil.

     Encore un petit manque de documentation sur le web et pas toujours facile de voir si le tuto concerne Forge ou Forge2. J'ai essayé d'approfondir sur Furnace, mais je pense qu'il va falloir mettre les mains dans le code pour bien comprendre le container, les API et le fonctionnement des addOn.

     Pas pour toute les utilisations, je ne me vois pas définir tous mes attributs un à un avec l'outil pour tout le code de mon projet (en même temps c'est là que le scripting intervient).

     Pas l'impression que je puisse adresser du refactoring ou prendre facilement la main sur un projet existant, l'expérience me le dira.
Publié par à Aucun commentaire:
Libellés : , ,

lundi 16 juin 2014

R&D java et jvm : Graal, Maxine, Truffle

     Derrière ces noms étranges que l'on rencontre peu, avancent des projets de recherche dans les couches basses du langage Java et ses jvm. Pour celles et ceux qui veulent se faire plaisir les sources et outils sont accessible via les sites des projets.

Les projets


Graal & Truffle

"Graal is an extensible, dynamic compiler using Java"
"Truffle a language abstract syntax tree interpreter" (allow to implements languages on top of graal)


Maxine VM

"Java Virtual Machines written entirely in Java in a meta-circular style"


Quelques présentations sur le sujet


"Graal - A Bytecode Agnostic Compiler for the JVM"
http://medianetwork.oracle.com/video/player/1113230360001

"Graal: A quest for the JVM to leverage its own J"
http://wiki.jvmlangsummit.com/images/c/c4/Simon_Graal_Presentation.pdf

"Maxine: A JVM Written in Java", slide 45 donne un aperçu intéressant
http://www.jugsaxony.org/wp-content/uploads/2012/05/Maxine-A_JVM_in_Java.pdf

"Graal and Truffle : one VM to rule them all"
http://fr.slideshare.net/ThomasWuerthinger/graal-truffle-ethdec2013
https://www.cs.purdue.edu/homes/gkrichar/papers/onward2013-wuerthinger-truffle.pdf

"Maxine: A Virtual Machine For, and In, Java" (Jun 15, 2012)
https://wikis.oracle.com/download/attachments/41846038/ECOOPSummerSchool2012.pdf?version=1&modificationDate=1340845232000

Status sur Graal (juillet 2013) et travail sur le GPU d'AMD
http://www.oracle.com/technetwork/java/jvmls2913wuerth-2013918.pdf

Quelques ressources (slide et vidéo) sur Graal et d'autre sujet R&D : les ressources du JVM Language Summit 2013
http://www.oracle.com/technetwork/java/javase/community/jvmls2013-2013900.html
Publié par à Aucun commentaire:
Libellés : , , , ,

dimanche 15 juin 2014

Docker en urls

A l'occasion de la sortie 1.0 de Docker (Prod ready), une série d'articles et liens sur le sujet

Docker, les urls officielles



La sortie de la 1.0



Around Docker



Technical docker




Mais en fait docker c'est quoi



Docker et quelques applications



Publié par à Aucun commentaire:
Libellés : ,

mercredi 19 mars 2014

Java 8 tout chaud sorti du four

     Je ne pouvais pas ne pas mettre un petit mot, ca y est Java 8 GA (General Availability) est sortie. Un certain nombre de développeurs se sont déjà fait la main (et on blogués) sur les milestone mais cette fois c'est la version officielle.

Le mot de Mark Reinhold : http://mreinhold.org/blog/jdk8-ga
Download depuis chez Oracle : http://www.oracle.com/technetwork/java/javase/downloads/index.html


Quelques réactions à la sortie :

Les outils suivent et supportent Java 8

     Et du coup des comparaisons qui peuvent être amusantes, les deux étant du bytecode quelles sont les différences entre scala et lambda Java 8.

     Alors pour le meilleur et pour le pire (je suis sûr qu'il existe des manières très tordues d'utiliser les lambda, default method, ...) avançons, essayons, testons, hackons et regardons ce que cela va donner.
Publié par à Aucun commentaire:
Libellés : ,

dimanche 16 mars 2014

Maven en quelques urls

     Ce billet pour donner quelques urls utiles quand on utilise Maven. Je ne détaillerais pas tout ce que permet de faire cet outil car c'est vaste et les nombreux posts, livres à ce sujet le font déjà très bien.

     Pour commencer forcément : http://maven.apache.org/

La dernière version est actuellement Maven 3.2.1
L'historique des versions est disponible sous http://maven.apache.org/docs/history.html

Maven c'est quoi


Maven dans les grandes lignes c'est (http://maven.apache.org/what-is-maven.html) :
  • un outil pour "builder" les projets Java avec un cylcle de vie  bien défini.
  • un outil qui permet de gérer les dépendances aux librairies externes.
  • un outil qui peut distribuer/versionner les librairies Java via les systèmes de repository (local, intranet, internet).
 Un peu d'histoire sur Maven et sa philosophie.

Les solutions alternatives


     Les premières alternatives plus rudimentaires sont le scripting (sh, bat, ...) ou le make. En dehors de ces dernières il existe principalement trois autres solutions plus évoluées

Ant : http://ant.apache.org/
L'un des premiers à avoir permis de scripter des builds de projets Java en standardisant des tasks.

Ant et Ivy : https://ant.apache.org/ivy/
Ivy pour une gestion de dépendances dite agile qui est devenu officiellement un sous projet de Ant en 2007 (Mail de passage à l'incubator) permettant ainsi une complémentarité de ces deux projets.

Gradle : http://www.gradle.org/
Solution open source dont la communauté est drivé par GradleWare. Le code est disponible sous GitHub.

Gradle, Ivy et Maven via des plugins peuvent s'intégrer dans les différentes EDI (Eclipse, NetBeans, IntelliJ)

Maven c'est aussi un outil en ligne de commande


     Maven un outil en ligne de commande qui s'étend par système de plugin. Il en existe de très nombreux maintenus par Apache Maven ou d'autre organisations.

     Ces plugins permettent d'apporter de nouvelles fonctionnalités (déploiement sur des serveurs applicatifs, visualisation de dépendances, couverture de code par les tests unitaires, ...) ou peuvent faciliter l'intégration dans d'autres outils comme les serveurs d'intégration continu tel Jenkins.

Quelques plugins : http://maven.apache.org/plugins/index.html

En plus des plugins existant chacun peut développer les siens, adaptés à ses besoins

Maven : un repository et un outil de gestion de dépendances

 

     Les repository Maven sont les emplacements où sont distribuées/récupérées les librairies nécessaires aux builds de vos projets. On a un repository local sur le poste sur lequel on travail mais (fonction de la configuration utilisée) on peut être en interaction avec un repository Maven central, un repository d'entreprise, un repository d'éditeur (par exemple JBoss).

Les principaux repository Maven officiels : http://maven.apache.org/repository/index.html

Les outils permettant de faciliter la gestion des repository :
Une matrice de comparaison de leurs features : http://docs.codehaus.org/display/MAVENUSER/Maven+Repository+Manager+Feature+Matrix

 Rechercher une librairie sur un repository Maven central :
http://repo.maven.apache.org/maven2/
http://search.maven.org/#browse

Comment faire lorsque l'on est développeur et que l'on souhaite voir son framework publié sur un repo centrale Maven : http://lkrnac.net/blog/2014/03/06/deploy-to-maven-central/

Quelques ressources sur Maven 



Publié par à Aucun commentaire:
Libellés : ,

dimanche 2 mars 2014

Un nouveau français Java Champion

     Un nouveau français viens de rejoindre le cercle assez fermé des Java Champion : David Gageot (http://blog.javabien.net/2014/02/24/look-ma-im-a-java-champion/)

     Pourquoi un rapide post sur ce sujet ? Parce que je trouve que c'est une bonne chose. Ce sont ces personnes qui amènent une émulsion positive dans notre monde de développeurs, qui peuvent donner envie d'avancer et qui par leur travail nous apportent à tous.

   Les java champions c'est quoi


En résumé : groupe comprenant des passionnés, des développeurs qui œuvrent pour la communauté Java au travers différentes contributions (auteurs de livre, speakers en conférence, ...)

La définition à la source : https://java-champions.java.net/

C'est différent des Java RockStar (http://www.oracle.com/javaone/rock-stars/2013/index.html), programme visant plutôt à reconnaitre la qualité de speaker.

Tous les Java champions et leur bio : https://java.net/website/java-champions/bios.html

    Les frenchies Java Champions


     Quelques autres Java Champions à suivre


     Je ne vais pas tous les citer mais quelques uns de ceux que j'essaye de suivre régulièrement au travers leurs présentations, publications :


mais aussi Gavin King, Bruce Eckel, Jonas Boner, Joshua Bloch, Ben Evans, Neal Gafter, Brian Goetz, Kirk Pepperdine et bien d'autres encore.
Publié par à Aucun commentaire:
Libellés : ,

dimanche 16 février 2014

La veille technologique et les Blogs

     On a changé de monde, l'information brut qu'il fallait chercher, dénicher voir payer est maintenant abondante, à porté de main et gratuite. Par contre l'information utile, pertinente pour un besoin particulier peut rester compliquée à trouver. Elle se trouve noyée dans cette masse d'informations accessibles.
     2e temps après l'arrivé du web et la possibilité de partager cette information, les entreprises ont commencées à développer leur expertise, maturer ces changements. Elles se sont appropriées les technologies, les médias de communication et ont irriguées le web de leurs communications, informations (à dessein commercial, marketing, ...) C'est normal toute entité s'adapte à son environnement afin de s'y développer (individus comme entreprises).
     3e temps : le temps réel, l'information de plus en plus vite, au plus près de l'individu via les supports mobiles et toutes les portes ouvertes permettant d'attirer et mobiliser leur attention.

     La veille technologique est un domaine qui vit pleinement ces changements mais avant de poursuivre deux éclaircissements :

La veille technologique pour moi c'est quoi
Principalement une démarche personelle qui me permet de me tenir à niveau rapport aux changements touchant mon domaine professionel : l'informatique, le développement.

La veille technologique à quoi cela me sert
  • savoir où on l'on peut trouver l'information qui nous intéresse, l'information nécessaire le jour où j'en aurais besoin.
  • sentir les tendances. Plus on croise des flux d'informations nombreux et variés, plus on peut discerner ce qui intéresse, les technologies, pattern qui se renforcent et ceux qui au contraire s'affaiblissent et disparaissent.
  • voir les nouveautés avant qu'elles ne s'imposent et croissent dans le monde de l'entreprise.
  • renforcer ma culture générale autour de mes centres d'intérêts.
  • se promener autour de sujets technologiques de fonds ou du moment, c'est comme cela que peuvent surgir des idées, des rapprochements incongrus qui génèrent une idée qui se traduira par un développement, voir un projet.

     Pour pratiquer cette veille technologique, un type de média (parmi d'autres) m'intéressant particulièrement sont les blogs. Il en existe d'autres tels les mailings listes, les archives de mails de projets open source, les forums techniques ou généralistes, les revues, les conférences, les conversations café, ... mais pour ce billet je garderais le focus sur les blogs.

     Les blogs peuvent être de différentes natures (blog personnel, blog d'entreprise, blog communautaire, agrégateur de blogs, ...). C'est un support d'information vivant, souvent proche de l'individu pour les blogs personnels donc moins standardisés bien que chacun puisse avoir ses méthodes et centres d'intérêts particulier. Donc c'est de l'ensemble et leur diversité que l'on peut faire une veille technologique intéressante.

     Afin de pouvoir suivre cet ensemble, des outils adaptés peuvent faciliter la veille (voir juste la rendre possible).

     Outils pour suivre les blogs


     Delicious, Google Reader ont à ma connaissance été précurseurs pour cet outillage. En tout cas ce sont ceux vers lesquels, à l'époque je me suis tourné.

     Depuis Delicious a perdu de son charme pour finir par être racheté et devenir à dimension plus social que pratique (pour un développeur) et Google Reader a fermé ses portes. Du coup je me suis lancé à la recherche d'une alternative.


Les fonctionnalités en vrac que j’attends de tels outils :
  • Non payant, pas l'intention sur ce type de service de dépenser un budget pour l'instant.
  • centraliser en un endroit mes lectures au lieu de parcourir tous les sites.
  • recherche dans les articles (recherche au milieu d'un sous ensemble du web).
  • face à une masse importante d'information un bon moyen d'avancer plutôt que tout voir, c'est voir ce qui bouge : donc isoler et faciliter la lecture de ces mouvements.
  • statistiques ... c'est toujours intéressant.
  • ouvert, pour que ce que j'y ai mis soit exportable dans un format compréhensible (ceci pour le respect du temps que j'ai passé à y saisir des informations ou faciliter ma migration vers un autre outils).
  • consultable même derrière des firewall d'entreprise (pas de système login pour consulter, pas de tag word social, ...).
  • le top du top, avoir une api qui permet d'interagir de manière programmatique.
Les outils recensés

     Parmi ces possibilités : il y a des solutions payantes, des solutions plus orientés support mobile, ... Au milieu de tout cela mon choix a été oldReader pour un résultat mitigé pour l'instant :
  • Rachat peu de temps après (ils se sont fait débordés par les migrations depuis Google Reader vers chez eux). Ce n'est pas forcément une mauvaise chose en soi mais à voir le changement de positionnement et stratégie suite à cela.
  • Conservation et search dans les posts des blogs pas du niveau de Google Reader
  • Limitation du nombre flux à 100 dans la version non premium. Premium qui montre peut être la nouvelle stratégie (http://blog.theoldreader.com/post/76417559063/the-old-reader-premium)  
     Bref, ils font des choses bien mais qui ne me conviennent pas forcément pour l'utilisation que je cherche à en faire donc il est très probable que je regarde inoreader de plus prêt sous peu.

Quelques blogs pour cette fameuse veille


Disclaimer : attention cette partie du billet va ressembler à un catalogue d'url.


Donc un outil oui mais pour suivre quoi ? Regardons cela de plus prêt.

 Pourquoi je les liste ici :
  • les retrouver facilement, non encapsulés dans un autre outil comme ceux cités précédemment.
  • les partager avec celles et ceux intéressés.
  • cela a été l'occasion d'écrire ce post donc ce serait dommage de ne pas les citer.

Les blogs corporates d'Oracle

Les blogs perso/oracle


Blogs de sociétés et fondations dont le coeur de métier est l'IT


Blogs de quelques autres sociétés informatiques


Des blogs plutôt communautaires

Des Aggregateurs de flux et concentrateurs d'articles (très verbose)


Quelques blog d'IT people


D'autres blogs perso IT

Pour finir, pas des blogs mais des sites tournés vers les Communautés développeurs et projet open sources

Publié par à Aucun commentaire:
Libellés : , ,
Inscription à : Articles (Atom)