Auteur/autrice : Benoit

Quand l’oubli des fondamentaux du code finit par coûter cher

J’utilise MongoDB comme base de données principale et j’en suis globalement satisfait. Mais j’ai l’impression que depuis un certain temps la tendance consiste à le dénigrer. Souhaitant comprendre ce qu’on lui reproche réellement, je suis à l’affût de retours d’expériences. C’est ainsi que j’ai récemment lu cet article publié le 21 novembre 2017 : Why We Moved From NoSQL MongoDB to PostgreSQL.

Je n’ai malheureusement pas appris grand chose sur MongoDB en le lisant, mais je trouve que cet article est un cas d’école qui nous montre ce qu’il se passe quand on s’assoie sur les bonnes pratiques de développement. Je vous propose donc dans cet article d’étudier ça plus en profondeur. Continuer la lecture de Quand l’oubli des fondamentaux du code finit par coûter cher

Spring Boot, le couteau suisse du développeur Java

Ralenti et frustré par les problèmes de build rencontrés en utilisant Play Framework (que j’avais détaillés ici), j’ai finalement décidé de migrer vers Spring Boot.

Après quelques mois (ou années pour certains morceaux) de développement et d’exploitation d’applications Spring Boot en production, je pense avoir pu prendre le recul nécessaire pour me livrer à l’exercice du retour d’expérience. Continuer la lecture de Spring Boot, le couteau suisse du développeur Java

Ansible, l’outil coup de cœur pour gérer son infrastructure

En start-up il y a souvent tout à faire. Des choses qu’on aime faire, d’autres qu’on aime moins. Des choses qu’on sait faire, d’autres qu’on maîtrise moins. Mon métier, c’est le développement, et je suis beaucoup moins à l’aise quand il s’agit de gérer une production et donc une infrastructure.

J’ai récemment revu en profondeur l’infrastructure que je gère pour mettre en place de la redondance. Je ne me voyais pas configurer les serveurs à l’identique manuellement, d’abord parce que ça prend du temps et puis parce qu’ils n’auraient justement pas été identiques…

Je me suis donc tourné vers les outils d’automatisation de gestion de machines et mon choix s’est rapidement porté vers Ansible. Et je dois bien avouer que c’est un véritable coup de cœur. Continuer la lecture de Ansible, l’outil coup de cœur pour gérer son infrastructure

AssertJ pour des assertions plus expressives

Écrire des tests, c’est bien, écrire des bons tests c’est encore mieux. La technique given when then est une des bonnes pratiques pour écrire des tests (unitaires ou pas d’ailleurs). Les 3 concepts sont en effet nécessaires, y-compris le dernier qui correspond aux assertions. En effet, un test n’apporte vraiment de la valeur que si il procède à des vérifications sur le résultat de son exécution. Ça parait évident mais je suis tombé à plusieurs reprises sur des tests qui exécutaient du code sans rien vérifier…

En Java, les outils de base les plus populaires pour écrire des tests (JUnit et TestNG) sont assez pauvres pour écrire les assertions. Heureusement, il existe des outils permettant de gagner à la fois en puissance et en expressivité pour exprimer les assertions. Continuer la lecture de AssertJ pour des assertions plus expressives

Fin de crise d’ado en vue pour Play Framework

play_full_color J’avais écrit un retour d’expérience à propos de Play Framework il y a un peu plus d’un an. J’y exprimais ma frustration quant au fait qu’il ne manquait pas grand chose à Play Framework pour être un super outil de développement.

J’étais assez peu optimiste sur le fait que ces points puissent s’estomper rapidement parce que c’étaient ceux que Typesafe mettait en avant pour se différencier des autres. Il semblerait cependant que le vent a tourné récemment et il souffle maintenant de mon point de vue dans la bonne direction ! Continuer la lecture de Fin de crise d’ado en vue pour Play Framework

Passage en HTTPS grâce à Let’s Encrypt

Le blog utilise depuis quelques jours HTTPS. J’ai pu mettre en place HTTPS gratuitement grâce à Let’s Encrypt, une initiative supportée par différents acteurs du web visant à sécuriser le web à grande échelle.

Let’s Encrypt

letsencryptLet’s Encrypt résout les deux plus gros freins à l’adoption de HTTPS :

  • Il propose des certificats gratuits reconnus par une autorité de certification et donc considérés comme étant de confiance par la très grande majorité des navigateurs.
  • Il propose également un outil open-source qui prend en charge de manière automatique la configuration du serveur web. Il était jusqu’alors difficile de configurer correctement un serveur web en HTTPS quand on ne connaît pas grand chose au fonctionnement du protocole. L’outil met en place la configuration nécessaire pour le certificat, mais aussi la configuration optimale pour avoir le maximum de sécurité tout en excluant le minimum de clients.

Continuer la lecture de Passage en HTTPS grâce à Let’s Encrypt

Mock ou pas mock ?

C’est quoi un mock ?

Avant de rentrer dans le vif du sujet, il me semble important de faire une mise au point sur les concepts dont je vais parler dans cet article.

Dans le jargon du développeur, le mot mock a tendance à être utilisé à toutes les sauces. Martin Fowler, dans l’article Mocks Aren’t Stubs, parle de différents concepts :

  • Test double : objet factice qui prétend être l’objet attendu mais dont le comportement est adapté spécifiquement aux besoins du test. Le mot double fait allusion à la doublure au cinéma. Le mot mock est souvent utilisé dans ce sens-là.
  • Dummy : objet demandé par l’API qu’on teste mais qui n’est pas utilisé lors de l’exécution du code.
  • Fake : objet qui remplit le contrat (interface) mais dont l’implémentation peut faire abstraction de certaines contraintes, ce qui fait qu’il n’est pas adapté à la production (les bases de données en mémoire en sont un bon exemple).
  • Stub : objet au comportement éventuellement configurable qui peut ne répondre que très partiellement au contrat qu’il est censé remplir. Souvent écrit spécifiquement pour un ou ensemble de tests, il peut parfois enregistrer les interactions qu’on a avec lui dans l’objectif de les vérifier par la suite.
  • Mock : objet magique au comportement pré-câblé très spécifique. Dans la plupart des langages il est nécessaire d’utiliser un outil pour générer ce genre d’objets, cet outil permettant souvent de configurer au moment de l’exécution le comportement de l’objet sous la forme : «quand on te demande ça tu fais ça».

Continuer la lecture de Mock ou pas mock ?

Puis-je avoir confiance en mes tests ?

Il existe un certain nombre d’outils permettant de fournir des métriques qui visent à mesurer la qualité d’un logiciel, notamment à travers l’analyse statique dont j’avais eu déjà l’occasion de parler. Ces métriques sont plus ou moins représentatives de la qualité du code. Mais nous permettent-elles de savoir si nous pouvons avoir confiance en notre code ?

Jusqu’à nouvel ordre, pour s’assurer que du code remplit correctement les besoins, nous n’avons pas vraiment d’autre solution que de le tester, et nous le faisons de manière aussi automatique que possible pour augmenter notre productivité. Mais nos tests sont-ils fiables ? Puis-je sortir une nouvelle version de mon produit en toute confiance ou dois-je croiser les doigts à chaque mise à jour ?

Il existe un certain nombre de façons permettant de savoir si nous pouvons avoir confiance en nos tests. Continuer la lecture de Puis-je avoir confiance en mes tests ?

Architecture multi-tenant, une fausse bonne idée ?

Les concepts de Software as a Service ou de Cloud Computing sont de plus en plus répandus dans l’informatique d’aujourd’hui. Cela a pour conséquence que les éditeurs de logiciel ne vendent plus directement un logiciel mais le service que rend leur logiciel. Cette nouvelle façon de déployer du logiciel a changé la donne dans la façon dont sont conçus ces mêmes logiciels.

Vers un déploiement simplifié

Les architectures multi-tenant (multi-entités ou multi-locataires en français) ont vocation à faire en sorte qu’un logiciel soit capable de gérer un certain nombre de clients en une seule installation. Au lieu d’installer le logiciel une fois pour chaque client, ce dernier est capable de créer des environnement virtuels distincts pour chaque client de sorte à ce que de l’extérieur les autres environnements ne soient pas du tout visibles. En fin de compte, le logiciel répond lui-même aux problématiques de déploiement.

Dans le contexte d’un prestataire de service qui souhaite vendre son service à différents clients, l’architecture multi-tenant semble être la réponse évidente. Il suffit de déployer le logiciel une fois et de créer autant d’environnements que nécessaire, et le tour est joué. L’administration d’un tel système est, du coup, relativement simple. Continuer la lecture de Architecture multi-tenant, une fausse bonne idée ?

Générer les structures de données avec AutoValue

En Java comme dans d’autres langages, nous écrivons souvent des classes qui représentent des structures de données (appelées parfois objets métier, DTO, value objects, ou encore value types). Nous appliquons très souvent le principe d’encapsulation en exposant les valeurs à travers des getters et des setters quand la structure de données est mutable.

Mais implémentez-vous systématiquement la méthode equals de votre classe ? Et la méthode hashcode ? Si c’est le cas, equals et hashcode sont-elles cohérentes ? Et quand vous ajoutez un champ, pensez-vous à mettre à jour ces deux méthodes ? Il est pourtant important que ces méthodes soient correctement implémentées, faute de quoi on peut avoir des surprises en les insérant dans une HashMap ou un HashSet par exemple. Continuer la lecture de Générer les structures de données avec AutoValue