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
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
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 :
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 :
Dernière version stable : 2.1.0 (releasé en septembre 2014)
Les branches encore accessibles :
La liste des commiters participants aux développements : http://wiki.apache.org/cassandra/Committers
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/
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
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 :
- http://wiki.apache.org/cassandra/ArchitectureOverview
- http://wiki.apache.org/cassandra/ArchitectureInternals
Introduction Cassandra :
- http://planetcassandra.org/what-is-apache-cassandra/
- http://www.datastax.com/documentation/getting_started/doc/getting_started/gettingStartedCassandraIntro.html
Quelques tutoriaux :
- http://mbaron.developpez.com/tutoriels/nosql/cassandra/installation-outils-administration/
- http://www.youtube.com/watch?v=N9QllqXI1sE
- http://www.rackspace.com/blog/cassandra-by-example/
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 :
- http://perspectives.mvdirona.com/2008/07/12/FacebookReleasesCassandraAsOpenSource.aspx
- http://fr.slideshare.net/jhammerb/data-presentations-cassandra-sigmod/
- https://www.cs.cornell.edu/projects/ladis2009/papers/lakshman-ladis2009.pdf
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
lundi 25 août 2014
Rien à voir avec le dev (quoique ...)
Pour changer un peu, en dehors du monde du développement quelques artistes que j'apprécie
Littérature : Alain Damasio
http://fr.wikipedia.org/wiki/Alain_Damasio
J'ai beaucoup aimé "La zone du dehors" en anticipation sur nos sociétés, "Aucun souvenir assez solide" en recueil de nouvelles, dont une très intéressante "Les hauts parleurs" sur la privatisation et commercialisation du vocabulaire (et un langage parlé ou informatique c'est un assemblage selon une grammaire de mots). Et encore dans un autre genre "La horde du contrevent" plus fantasy, sur l'histoire d'une équipe, là où les mots, les rythmes, la ponctuation ont leur importance.
D'Alain Damasio, toujours sur nos sociétés, j'ai beaucoup aimé la nouvelle "La rage du sage" (http://crep.strasbourg.free.fr/IMG/pdf/brochure-damasio-laragedusage.pdf), petit extrait :
"Chacun ses choix. Ben ouais.Be yourself, comme tout le monde. Alpha blondit et Carla brunit. Hugo Boss. Il a bien de la chance."
Pour finir 2 artistes plus plastiques rencontrés par hasard :
Jacques Degand pour ses tableaux (http://www.artistescontemporains.net/artiste/Jacques-Degand-8), je ne sais pas pourquoi mais cela me parle, les pattern ... allez savoir ...
Marc Sparza pour ses sculptures (http://peupledepapier.blogspot.fr/2014/01/marc-sparza.html), une idée représentée de manière simple ce qui a forcément demandé du travail, simple c'est compliqué mais c'est d'autant plus fort comme en développement.
Littérature : Alain Damasio
http://fr.wikipedia.org/wiki/Alain_Damasio
J'ai beaucoup aimé "La zone du dehors" en anticipation sur nos sociétés, "Aucun souvenir assez solide" en recueil de nouvelles, dont une très intéressante "Les hauts parleurs" sur la privatisation et commercialisation du vocabulaire (et un langage parlé ou informatique c'est un assemblage selon une grammaire de mots). Et encore dans un autre genre "La horde du contrevent" plus fantasy, sur l'histoire d'une équipe, là où les mots, les rythmes, la ponctuation ont leur importance.
D'Alain Damasio, toujours sur nos sociétés, j'ai beaucoup aimé la nouvelle "La rage du sage" (http://crep.strasbourg.free.fr/IMG/pdf/brochure-damasio-laragedusage.pdf), petit extrait :
"Chacun ses choix. Ben ouais.Be yourself, comme tout le monde. Alpha blondit et Carla brunit. Hugo Boss. Il a bien de la chance."
Pour finir 2 artistes plus plastiques rencontrés par hasard :
Jacques Degand pour ses tableaux (http://www.artistescontemporains.net/artiste/Jacques-Degand-8), je ne sais pas pourquoi mais cela me parle, les pattern ... allez savoir ...
Marc Sparza pour ses sculptures (http://peupledepapier.blogspot.fr/2014/01/marc-sparza.html), une idée représentée de manière simple ce qui a forcément demandé du travail, simple c'est compliqué mais c'est d'autant plus fort comme en développement.
vendredi 15 août 2014
Le monde du développement au travers ses acteurs
Il y a différentes manières de faire sa veille technologique. On peut suivre les articles techniques, voir comment s'orientent les nouvelles versions des frameworks, assister aux conférences ou les retrouver à posteriori sur le web, pratiquer en faisant des poc ou en réalisant des projets personnels, suivre des formations, ...
Une autre manière que je trouve pertinente c'est observer, suivre, comprendre comment travail les acteurs du domaine, voir les outils que eux utilisent, les choix qu'ils ont fait et les raisons de ces choix.
Parallèlement aux aspects technologiques comprendre également les choix organisationnels d'autant plus intéressant que certains de ces acteurs de par leur nature travaillent de plus en plus avec des équipes composées de développeurs world wide, je pense, entre autres, à la fondation Eclipse et le cadre qu'elle met en place afin de permettre ceci (http://wiki.eclipse.org/Development_Resources).
Quelques articles qui dans cette ligne m'ont intéressé :
La fondation Eclipse, un peu d'histoire :
http://www.infoq.com/news/2011/11/eclipse-10
Le changement de release process chez Mozilla Firefox :
http://www.infoq.com/news/2014/07/release-process-mozilla-firefox
How Google works, l'article date un peu (2006) :
http://www.baselinemag.com/c/a/Infrastructure/How-Google-Works-1/
How GitHub works, avec un point de vue intéressant sur le travail asynchrone et la "Zone" :
Historique des SCM chez Apache OpenOffice, de CVS à Git :
Une autre manière que je trouve pertinente c'est observer, suivre, comprendre comment travail les acteurs du domaine, voir les outils que eux utilisent, les choix qu'ils ont fait et les raisons de ces choix.
Parallèlement aux aspects technologiques comprendre également les choix organisationnels d'autant plus intéressant que certains de ces acteurs de par leur nature travaillent de plus en plus avec des équipes composées de développeurs world wide, je pense, entre autres, à la fondation Eclipse et le cadre qu'elle met en place afin de permettre ceci (http://wiki.eclipse.org/Development_Resources).
Quelques articles qui dans cette ligne m'ont intéressé :
La fondation Eclipse, un peu d'histoire :
http://www.infoq.com/news/2011/11/eclipse-10
Le changement de release process chez Mozilla Firefox :
http://www.infoq.com/news/2014/07/release-process-mozilla-firefox
How Google works, l'article date un peu (2006) :
http://www.baselinemag.com/c/a/Infrastructure/How-Google-Works-1/
How GitHub works, avec un point de vue intéressant sur le travail asynchrone et la "Zone" :
- http://blog.viseo-bt.com/divers/qcon-2012-how-github-works
- http://zachholman.com/posts/how-github-works/
- http://zachholman.com/posts/how-github-works-asynchronous/
Historique des SCM chez Apache OpenOffice, de CVS à Git :
- http://www.openoffice.org/marketing/ooocon2008/programme/wednesday_1432.pdf
- http://people.apache.org/~hdu/HistOOory_Presentation.pdf
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.
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
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
Articles :
Blog de John Rose : https://blogs.oracle.com/jrose/
Charles Oliver Nutter :
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 :
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 :
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/
Petite url bonus, rien à voir (enfin si c'est de la jvm) : jvm, performance et network de Norman Maurer
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 :
- http://jaxenter.com/a-first-glimpse-at-java-9-early-access-release-of-jdk9-on-openjdk.1-50855.html
- http://dev.solita.fi/2014/08/04/what-is-coming-to-java-vm.html
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- La présentation : http://shipilev.net/talks/narnia-2555-jmm-pragmatics-en.pdf
- Site de Aleksey Shipilev : http://shipilev.net/
- Son GitHub : https://github.com/shipilev
Le lancement de Doug Lea pour les évolutions JMM 9
- Le lancement : http://mail.openjdk.java.net/pipermail/hotspot-dev/2014-January/012146.html
- La mailing dédié : http://cs.oswego.edu/mailman/listinfo/pre-jmm9
- La jep associée : http://openjdk.java.net/jeps/188
- La homepage de Doug Lea : http://g.oswego.edu/
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)- L'annonce : http://mail.openjdk.java.net/pipermail/announce/2014-June/000172.html
- Post de John Rose : https://blogs.oracle.com/jrose/entry/the_isthmus_in_the_vm
- La jep 191 pour les FFI : http://openjdk.java.net/jeps/191
- Github avec les premiers développements : https://github.com/jnr/jnr-ffi
- Présentation Java Native Runtime : http://www.oracle.com/technetwork/java/jvmls2013nutter-2013526.pdf
Articles :
- http://www.infoq.com/fr/news/2014/03/java-foreign-function-interface
- http://www.infoworld.com/t/java-programming/project-panama-builds-bridge-between-java-and-cc-244434
- http://www.developpez.com/actu/72370/Projet-Panama-une-future-alternative-a-Java-Native-Interface-fait-son-apparition-pour-offrir-un-interfacage-natif-avec-les-API-C-et-Cplusplus/
Blog de John Rose : https://blogs.oracle.com/jrose/
Charles Oliver Nutter :
- Son Blog : http://blog.headius.com/
- Son Github : https://github.com/headius
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
- Annonce : http://mail.openjdk.java.net/pipermail/discuss/2014-June/003445.html
- Ouverture de la mailing dédiée : http://mail.openjdk.java.net/pipermail/valhalla-dev/2014-July/000000.html
Articles liés :
- http://marxsoftware.blogspot.fr/2014/06/project-valhalla-proposed.html
- http://www.infoq.com/news/2014/07/Project-Valhalla
- http://jaxenter.com/brian-goetz-introduces-new-openjdk-project-valhalla-50783.html
- http://sdtimes.com/javas-generics-getting-generic/
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 :
- Jigsaw en 2012 : http://openjdk.java.net/projects/jigsaw/doc/module-class-loading.pdf
- Mark Reinhold au JFokus 2014 : http://www.jfokus.se/jfokus14/preso/Jigsaw.pdf
Article :
- http://www.developpez.com/actu/72888/Java-le-projet-Jigsaw-se-concretise-Oracle-passe-a-la-mise-en-oeuvre-de-la-modularite-dans-Java-9/
- http://michael-peeters.blogspot.fr/2013/11/devoxx-2013-modular-java-platform-and.html
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 :
- la early access : http://www.oracle.com/technetwork/java/javase/downloads/ea-jsp-142245.html
- download early access : https://jdk9.java.net/download/
- Les points d'entré :
- L'accès aux sources : http://hg.openjdk.java.net/jdk9
- Les Test results : http://download.java.net/openjdk/testresults/9/testresults.html?q=download/openjdk/testresults/9/testresults.html
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
- Sa presentation : http://normanmaurer.me/presentations/2013-jax-networking-on-jvm
- Son blog : http://normanmaurer.me/blog/
- Son github : https://github.com/normanmaurer
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 :
- Oracle's JVM Strategy (Henrik Stahl, Oracle) : https://blogs.oracle.com/henrik/entry/oracles_jvm_strategy
- Oracle press : http://www.oracle.com/us/corporate/press/173782
- Article : http://www.infoworld.com/d/developer-world/oracle-moving-merge-jrockit-hotspot-jvms-448
- Presentation du JavaOne 2011 (Marcus Hirt, Oracle) : http://parleys.com/play/514892290364bc17fc56c339/chapter0/about
- Une des premieres conséquence visible de la convergence : mission control (Jdk 7u40) : http://technology.amis.nl/2013/10/06/javaone-2013-java-mission-control-2/
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 :
- apparition nouvelle instruction bytecode (invokedynamic) avec Java7 http://www.oracle.com/technetwork/articles/javase/dyntypelang-142348.html
- disparition du permgenspace avec Java8 http://javaeesupportpatterns.blogspot.fr/2013/02/java-8-from-permgen-to-metaspace.html
- arrivé de mission controle avec Jdk7u40 dans le cadre de la convergence JRockit, Hotspot
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 :
- Yourkit (profiling jvm) : http://www.yourkit.com/java/profiler/
- JProfiler (profiling jvm) : http://www.ej-technologies.com/products/jprofiler/overview.html
- appdynamics (monitoring) : http://www.appdynamics.fr/solutions/appdynamics-java-monitoring
- newrelic (monitoring) : http://newrelic.com/java
- JRebel (suivi et déploiement à chaud de code) : http://zeroturnaround.com/software/jrebel/
- Takipi (monitoring application) : http://www.takipi.com/
- Chrononsystems (trace et chronologie de la vie de l'application) : http://chrononsystems.com/
Des projets plus développeurs :
- De Twitter pour l'anayse Garbage Collector : https://github.com/twitter/jvmgcprof
- D'Azul system jHiccup : http://www.azulsystems.com/product/jHiccup
- Analyse GC : https://github.com/chewiebug/GCViewer
- Analyse GC : https://code.google.com/a/eclipselabs.org/p/garbagecat/
- Analyse GC : https://code.google.com/p/verbosegcanalyzer/
- Tooling JVM : https://github.com/aragozin/jvm-tools
- Tooling jvm : https://code.google.com/p/jvmtop/
Queqlues produits plus spécifique :
- HPJmeter de HP : https://h20392.www2.hp.com/portal/swdepot/displayProductInfo.do?productNumber=HPJMETER
- IBM HeapAnalyzer : https://www.ibm.com/developerworks/community/groups/service/html/communityview?communityUuid=4544bafe-c7a2-455f-9d43-eb866ea60091&open&S_TACT=105AGX59&S_CMP=GRsite-jw22
- Profiler qui date un peu : http://www.oracle.com/technetwork/articles/javase/perfanal-137231.html
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>
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"
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 :
- http://commons.wikimedia.org/w/index.php?title=File%3AUnderstanding_HotSpot_Logs.pdf&page=1
- http://www.chrisnewland.com/images/jitwatch/HotSpot_Profiling_Using_JITWatch.pdf
- http://zeroturnaround.com/rebellabs/why-it-rocks-to-finally-understand-java-jit-with-jitwatch/
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>
- 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 :
- via MBean java.lang:type=Threading, l'opération dumpAllThreads qui prend en paramètre deux boolean (lockedMonitors et lockedSynchronizers, voir http://docs.oracle.com/javase/7/docs/api/)
- via jstack en ligne de commande (http://docs.oracle.com/javase/7/docs/technotes/tools/share/jstack.html), il dispose également d'un mode Force en cas de jvm qui ne répond plus (-F)
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.
- Site du projet : https://github.com/lifey/mjprof
- Article : http://blog.performize-it.com/2014/05/mjstack-mjprof.html
- Article : http://blog.performize-it.com/2014/03/mjstack-monadic-jstack-analyzer.html
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 :
- JConsole (jdk1.7.0_25\bin par exemple) http://docs.oracle.com/javase/7/docs/technotes/guides/management/jconsole.html
- VisualVM (jdk1.7.0_25\bin par exemple) qui est une version évoluée de la JConsole pouvant s'enrichir de quelques plugins. Avec VisualVM on peut commencer à faire du profiling visuel http://visualvm.java.net/
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
- vidéo et slide de la présentation : http://www.parleys.com/play/53368d45e4b0dd67cb9eda8b/chapter0/about
- slides (la session ayant du coding, ce n'est pas le plus intéressant) : http://fr.slideshare.net/bleporini/devoxx-jvm-tools
- article sur la présentation : http://www.infoq.com/fr/articles/jvm-ligne-de-commande
Documentation OpenJDK
- http://openjdk.java.net/tools/
- http://openjdk.java.net/groups/serviceability/index.html#tools
- http://openjdk.java.net/tools/svc/jconsole/
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)
- http://www.oracle.com/technetwork/articles/javase/jvmpitransition-138768.html
- http://jeremymanson.blogspot.fr/2007/05/profiling-with-jvmtijvmpi-sigprof-and.html
- http://www.jmdoudoux.fr/java/dej/chap-jvm.htm#jvm-7
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
Libellés :
classloading,
Garbage collector,
gc,
heapdump,
Java,
jhat,
jinfo,
jmap,
jps,
jstack,
jstat,
JVM,
jvm args,
MAT,
mjprof,
threaddump
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 :
- MPS (Meta Programming System) de JetBrain : http://www.jetbrains.com/mps/
- AntLr (ANother Tool for Language Recognition) : http://www.antlr.org/
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)
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
- http://blog.arungupta.me/?s=Forge
- https://community.jboss.org/en/tools/blog/2014/01/06/forge-2-in-jboss-tools-411
- http://www.stepinfo.com/2014/06/jboss-forge-2/
- http://www.youtube.com/watch?v=Dpou-FWWatI
Les sujets pour aller plus loin
- Le développement d'AddOn : http://in.relation.to/24930.lace
- Roaster pour la partie génération de code Java : https://github.com/forge/roaster
- Furnace : le runtime et core container, le moteur au coeur de Forge
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.
Inscription à :
Articles (Atom)