Quand la technique ne suffit plus

De part mes expériences en tant que développeur logiciel, les divers articles et ouvrages que je lis, les conférences auxquelles j’assiste, je me forge ma propre opinion sur l’importance de la technique en tant que développeur. Au fil de ces expériences, ouvrages, conférences, j’en suis arrivé à une conclusion toute personnelle que la technique ne suffit plus. L’article de Quentin Adam, CEO de CleverCloud, “Je n’embauche jamais de poisson pané. Alors arrêtez de vous présenter comme tel.” a fait écho dans mes réflexions ; si vous ne l’avez pas encore lu, je vous le recommande.

Cette conclusion va pourtant à l’encontre de notre époque, où les candidats se présentent comme fullstack (souvent en ne sachant pas réellement le sens de ce terme, s’il en a vraiment un), les entreprises publient des offres d’emploi où elles recherchent des ninjas du développement, des awesome developers tout en insistant sur le fait qu’elles utilisent des technologies à la pointe comme J2EE et VBScript… Sans vouloir dénigrer l’une ou l’autre partie, j’estime que cela est une perte de temps pour 1°/ le développeur tenté d’y postuler pour se rendre compte que l’esprit de l’entreprise ne lui correspond pas, 2°/ pour l’entreprise elle-même qui réalise durant un entretien avec le candidat qu’il ne correspond pas humainement à ses attentes et 3°/ car les technologies sont en constantes évolutions. Il nous suffit de constater que les outils JavaScript mutent tous les six mois, que les langages de programmation ne cessent de se multiplier et que les technologies de virtualisation varient du tout au tout.

Si en tant que développeur je souhaite être à la page, je n’aurai d’autres choix que d’être attentif aux nouveautés, à tester celles pour lesquelles je développe un intérêt plus particulier que pour d’autres, et cela de manière continuelle et assidue.

Je ne suis pas en train d’affirmer que la technique a un intérêt négligeable, simplement qu’elle n’a peut-être pas le monopole, selon moi, dans notre métier (de développeur).

La maîtrise de sa langue

Peut-être avons-nous tendance à oublier qu’un développeur ne fait pas qu’écrire du code mais il écrit de la documentation (ou du moins devrait), rédige des emails, participe à des réunions, interagis avec d’autres personnes. Malgré toutes ses interactions, je ne cesse de constater à quel point il est de plus en plus difficile de maîtriser correctement sa langue maternelle: phrases écrites en langage texto, contenant sept fautes d’orthographes pour quatre mots, composées de langage parlé, composées d’anglais et de français, etc. Bien que la langue française soit l’une des plus compliquée au monde, les correcteurs orthographiques sont de plus en plus performants et présents quasiment dans tous nos outils de communication tels que notre navigateur web, notre client email, notre traitement de texte. Alors j’ai de plus en plus de mal à accepter des phrases du genre “Nous avons constaté votre problème. Pensé-vous qu’il est possible de que cela vient de votre server ?”.

A titre personnel, cela ne me donne absolument pas confiance en mon interlocuteur. Cette mauvaise maîtrise de la langue française ne devrait pas remettre en cause les compétences de ce dernier, pourtant j’estime que cela n’est pas professionnel.

Depuis quelques années j’ai repris goût à la langue française et je m’efforce de l’utiliser au mieux :

  • j’essaie, tant que faire se peut, de ne pas employer de termes anglais au beau milieu de mes discours/documents :
    • je n’écris pas server mais serveur ;
    • je n’écris pas feature mais fonctionnalité ;
    • je ne forward pas un email, je le transfère ;
    • je ne reboot pas un serveur, je le redémarre.
  • j’essaie d’éviter les expressions orales, le parlé, à l’écrit :
    • “J’ai oublié de faire la doc” devient “J’ai oublié d’écrire la documentation”
  • j’essaie de faire des phrases grammaticalement correctes :
    • “J’ai pas envoyé le mail” devient “Je n’ai pas envoyé l’email”
  • j’essaie d’avoir un langage correct, non familier

Cela peut paraître ridicule, trop strict, mais m’apprend à mieux communiquer avec mes collègues, à éviter les quiproquos, à éviter de perdre trop de temps à tenter de me faire comprendre.

La communication

On évoque régulièrement la communication comme un art. Un art qu’il est bon de savoir maîtriser pour être sûr de transmettre convenablement nos idées, nos valeurs, nos points de vue, mais aussi afin de comprendre ce que l’on attend de nous.

J’ai l’occasion de régulièrement me rendre compte qu’il m’arrive de ne pas exposer l’ensemble d’un contexte lors d’une discussion, résultant à une incompréhension de mon interlocuteur. Cela peut également se produire lors d’un choix technique où une option parfaitement claire dans mon esprit, aboutissant au fait que je n’évoque pas pourquoi elle l’est, et à une incompréhension de la part de mon interlocuteur.

Il est aussi important de parfois savoir quand interrompre une discussion afin de se rendre compte que les deux parties n’ont pas la même définition d’un terme, d’un concept, ou qu’elles ne traitent pas du même sujet et que cela mène à un quiproquos. Nombre de fois j’ai préféré interrompre temporairement une discussion afin de m’assurer que mon interlocuteur et moi-même évoquions le même sujet, pour demander une clarification sur un terme ou un concept ou simplement pour simplifier le débat. En effet, une discussion peut rapidement se diversifier et aborder des sujets ou problématiques qui n’en étaient pas le sujet.

Enfin, il est bon de savoir être attentif à la discussion à laquelle nous prenons part afin de bien cerner l’objet de cette dernière, de s’assurer que l’on comprenne bien ce que souhaite nous transmettre notre interlocuteur. Cette écoute est aussi une preuve de respect envers notre interlocuteur et un signe de professionnalisme.

Cette maîtrise de la communication, permet bien souvent d’éviter une frustration comme une incompréhension de la part des parties y prenant part, mais aussi d’éviter une perte de temps superflue alors que ce dernier est précieux.

Le discernement

Dans notre métier de développeur, les technologies évoluent à une vitesse vertigineuse et nous sommes très souvent tenté de les adopter. Mais cette passion de notre métier doit aussi être accompagnée de discernement. La nouvelle version d’un outil est-elle vraiment indispensable à mon besoin ? Qu’apporte-t-elle ? Corrige-t-elle un dysfonctionnement que j’ai dû contourner ? Quel sera son impact dans mon projet ? Voici quelques exemples de questions que j’aime à me poser. Dans certains cas, elles m’aident à décider de ne pas utiliser cette nouvelle version pour diverses raisons : ne pas introduire de fragilités dans mon projet, m’éviter de requalifier cet outil.

Afin de réaliser une nouvelle fonctionnalité, nous pouvons être amené à choisir entre plusieurs outils : l’un très à la mode, convenant à mon besoin mais amenant des fonctionnalités inutiles à mon besoin, l’autre plus adapté à mon besoin mais moins populaire. Ni l’un ni l’autre ne peut être un mauvais choix car nous pouvons nous baser sur d’autres points pour arrêter notre choix : la communauté autour de l’un ou l’autre est plus importante et pourra nous aider à le mettre en place, en tirer pleine partie, la régularité des mises à jour (trop de mises à jour rapprochées ne témoignent-t-elles pas une instabilité de l’outil ?), la réactivité du support.

Faire preuve de discernement permet d’essayer de choisir les outils répondant au mieux à mon besoin, mon cœur de métier et de parfois éviter des écueils dû à une analyse trop brève de mon besoin et des outils disponibles.

Le courage

Lorsque l’on pense au métier de développeur, le courage n’est pas la première qualité que nous attribuerions à ce dernier. Pourtant il s’agit de l’une des qualités essentielle à mes yeux en tant que développeur. Lors de réunions de préparatifs aux développement, il nous est parfois demandé si une fonctionnalité (souvent des plus importantes) est réalisable ou non. Il m’est déjà arrivé (aux balbutiements de ma carrière) de penser que non, elle ne sera pas réalisable, et de ne pas affirmer mon opinion mais plutôt de le nuancer par un peut-être. A l’arrivée de la date butoir des développements, la fonctionnalité n’a pas pu être réalisée et terminée. Cela n’a fait qu’apporter frustration aux équipes ayant porté ce développement, et s’en est suivi une phase où une solution a dû être trouvée.

La lecture de l’ouvrage Clean Code de Robert C. Martin (que je vous recommande grandement) m’a fait prendre conscience de l’importance de savoir dire non. Il ne s’agit pas de dire non sans aucune raison valable mais d’avoir le courage de le dire tout en expliquant nos raisons : les délais impartis sont trop courts, les technologies actuelles ne le permettent pas, les compétences nécessaires à la faisabilité ne sont pas maîtrisées. Cela pourra engendrer une déception de la part de votre interlocuteur, mais ne signifie pas qu’il vous en tiendra rigueur.

Le courage doit aussi nous permettre de dire oui là où peut-être d’autres diront non. Oui parce que nous entrevoyons une solution, nous avons une idée, nous avons des compétences, nous avons des connaissances, nous arrivons à convaincre.

Des situations délicates peuvent également survenir au sein d’une équipe et d’une entreprise et il peut-être nécessaire de se saisir de courage afin d’en informer, d’en discuter avec ses collègues et sa hiérarchie. Ce courage permet d’éviter des situations de malaise, de mal-être nuisant à l’intérêt de son équipe ou de son entreprise. Cependant nous pouvons avoir des craintes à les évoquer pour diverses raisons (des représailles, des remarques inappropriées) et les surmonter peut-être difficile.

Le courage est une force démontrant notre intérêt pour le produit, pour notre équipe, pour notre entreprise. Il appuie notre investissement de contribuer à développer un produit robuste, innovant et éthique.

L’attitude

Chaque être humain a ses forces et faiblesses, son histoire, ses opinions. Le travail en équipe nécessite d’adapter son attitude à l’entreprise au sein de laquelle on évolue. Au cours de notre vie nous surmontons des épreuves, nos collègues également. Nous devrions savoir prendre sur nous et ne pas en pénaliser nos collègues par des sautes d’humeur, des remarques désobligeantes. Ce genre d’attitude ne nous permettra pas de surmonter plus aisément les épreuves de notre vie et risquera d’instaurer une ambiance délicate avec ceux avec qui nous passons la majeur partie de notre journée.

Une attitude aimable, serviable et attentionnée permet de renvoyer une image positive de nous même et participe à la bonne entente générale ainsi qu’à la cohésion de notre équipe : nos collègues n’hésitent pas à nous demander de l’aide tout en n’hésitant pas à nous recommander en cas de besoin. Elle est également source d’apprentissage pour nous même en nous offrant l’opportunité de découvrir des méthodologies, des outils. Elle permet également de faire en sorte que nous soyons et nous nous sentions un membre à part entière de l’équipe et non un développeur marginal.

Avoir une attitude et une discipline respectueuse des procédures, du traitement de l’information qui nous est fournie, permet de renvoyer une image positive de nous même, démontrant notre aptitude à nous adapter, à être concentré. Une attitude positive nous aide à trouver des solutions dans des situations semblant compromises car nous ne nous contentons pas d’être focalisés sur un problème mais au contraire de le surmonter.

Le développeur moderne

Il est important à mes yeux que le métier de développeur soit un peu moins stigmatisé : un développeur n’est pas nécessairement une personne à lunette, s’habillant avec des t-shirt amples avec des inscriptions incompréhensibles, ayant un vocabulaire limité, ne parlant qu’à une poignée de connaissances et passant ses soirées à jouer à des jeux vidéos. Il n’y a pas besoin d’être développeur pour ça.

Il est également important de se rendre compte qu’actuellement beaucoup de développeurs maîtrisent tel ou tel langage, telle ou telle technologie. Si en tant que développeur vous souhaitez être compétitif, choisi lors d’un entretien d’embauche, la différence ne se fera peut-être pas sur vos compétences techniques mais sur vos compétences humaines.

C’est cela qui m’amène à penser que la technique à elle seule ne suffit plus.

Advertisements

Why being a Rebel is hot and spicy?

I usually write technical articles about what is hot and spicy in software development, or at least what I think is hot and spicy. Well, I will make a little exception this time and write about why it is also hot and spicy being a RebelLabs author. If you’re reading this, you probably know what RebelLabs is: a house of geeky ninjas that like to write technical content about hot topics in our geeky development world. According Oliver White, head of RebelLabs:

Developers enjoy the additional “spice” of RebelLabs–we’ve managed to create a reliable content machine producing challenging, opinionated and humorous technical content for all software engineers to enjoy. Recently I saw this quote about RebelLabs by Rafael Winterhalter, in a recent Developer of the Week interview by DZone, and I think it sums things up very nicely: “I like RebelLabs a lot, especially since they manage to be both competent and humorous which is a rather rare combination.” —

Finding passion in the geeky world of development

As a geek, I’m passionate about software development, especially about Java and more recently, JavaFX. This passion leads me to go to people and say “Hey look, I discovered some pretty awesome new stuff”. But you can’t do this with your wife or your grandma, right? You won’t be understood … So frustrating …

But as passionate geek, I still need to tell somebody what I have discovered, tested and developed because I’m proud of it. Yeah you read right, proud of it. It is like being a kid having the latest trendy toy who shows everybody he has it. It is the same for me with software development. RebelLabs brings me the possibility of doing it, with a lot of fun.

I don’t need to write about old tools, APIs, languages and so on. I need to find a subject, find a way of making it attractive and interesting, and write. And when it’s published it’s like telling the world how proud you are. It is like your work being concrete and not only stored on your computer, right? Haven’t you ever felt that feeling of pride when you’ve developed the next most awesome API and nobody is using it?

The open source writer

We all know open source projects, developed by passionate ninjas to help other ninjas (or not) do their jobs better and make them easier by bringing them tools, APIs and other shiny stuff. I know a couple of those. One of them, Guillaume Scheibel (@g_scheibel and Hibernate OGM contributor) told me some time ago, that in the beginning it was not that easy to code in open source projects because you show the way you code to everyone and you have to accept remarks from others giving you advices of how doing things better. You have to accept remarks and sometimes it is not that easy. Writing is almost the same because you show the world what you’ve done and how you write. Double pressure.

I accept both because what you learn is much greater than this. Why is it? Because I work with guys that are as passionate as me and who like to teach you things about writing, tools and more. They don’t want to take you down in what you’re writing, but raising you up. And remarks are always constructive. It helps you do things better.

I also think this needs a little bit of courage. You, and I, have to be brave before publishing your first article. I needed some to accept the opinions of others, I needed some to accept the remarks and comments about my opinion, way of writing and way of thinking. I needed some to accept that other ninjas will take a look and possibly prove me wrong. But at the end the discussion will bring you a lot of point of view, a lot of ideas and you will always have the chance to be better next time.

Being visible

There is a really nice side effect of writing for RebelLabs: you are visible and you’re getting more and more known. People are reading your articles, looking at your Twitter profile, reading your blog and so on. It is a nice recognition to have people with more experience than you reading your articles, commenting on them and sometimes offering you their point of view.

You start to grow much more, and very quickly. And people can see that you are passionate, up to date, open minded and full of resources. It is a very positive image you’re giving of yourself.

You also benefit of the RebelLabs’ image, so you are more considered as experimented because if you’re not, you’re going to know it very quickly. So it is good for RebelLabs and it is good for you as well.

Hot and spicy instead of glory

To conclude, I write for fun. I write because I like to share my knowledge. I write because I’m passionate. I write because I like to write. I don’t write for any glory. I’m humble enough to admit there are plenty of ninjas out there that are thousands times better than me. But I am always looking for new challenges and I like to share them because maybe it could help other ninjas like you.

It’s a great opportunity to write for RebelLabs, and I like it very much. I can only encourage you to think about it, because being a Rebel is freakin’ awesome, and it’s hot and spicy!

Partial HTML generation from textile using eclipse Mylyn standalone

The title is pretty much explicit. For SlideshowFX, I needed to generate HTML content from textile, in order to define slide’s content. Looking for a lib, I found eclipse Mylyn that can be used in a standalone way. The library is pretty powerful but I have to look a lot at the sources in order to get the things done how I wanted to (#LukeAtTheSource power). Generally to convert a markup string into a HTML one, you create a MarkupLanguage as well as a MarkupParser and do the following:

final MarkupLanguage language = new TextileLanguage();
final MarkupParser parser = new MarkupParser(language);
parser.parseToHTML("h1. My little String");

The thing is that this code will create a whole HTML document (with html, head, body and so on tags). Me needs were to just get the HTML code corresponding to my string, e.g.

<h1>My little String</h1>

So the code should be changed to use a DocumentBuilder, like the following one:

final StringWriter writer = new StringWriter();
final DocumentBuilder builder = new HtmlDocumentBuilder(writer);
final MarkupLanguage language = new TextileLanguage();
final MarkupParser parser = new MarkupParser(language, builder);

// false indicates to not produce a whole HTML document
parser.parse("h1. My little String", false);

writer.flush();
writer.close();

String htmlContent = writer.toString();

This is almost done except that Mylyn generates IDs (which is kind of normal right?) by using the content of the markup. In short, I wanted to avoid IDs’ generation but I could’t find a right and efficient way to do it. So I decided to ensure uniqueness of IDs by always getting the current timestamp. Maybe it’s not a wonderful solution, but for the purpose of this little tutorial it will be perfect. The main idea is to change the ID generation and for doing this, you have to override some classes, because the default ID generation strategy is stored as a static and final variable, and no setters are available. The following example demonstrates how to do it:

final StringWriter writer = new StringWriter();

// The generation strategy generates IDs using the current timestamp
final IdGenerationStrategy idGenerationStrategy = new IdGenerationStrategy() {
  @Override
  public String generateId(String s) {
    return System.currentTimeMillis() + "";
  }
};

final IdGenerator idGenerator = new IdGenerator();
idGenerator.setGenerationStrategy(idGenerationStrategy);

final TextileContentState contentState = new TextileContentState() {
  @Override
  public IdGenerator getIdGenerator() {
    return idGenerator;
  }
};

// Override the language to return the created contentState used for the ID generation
final MarkupLanguage language = new TextileLanguage() {
  @Override
  protected ContentState createState() {
    return contentState;
  }
};

final DocumentBuilder builder = new HtmlDocumentBuilder(writer);

final MarkupParser parser = new MarkupParser(language, builder);

parser.parse(markupString, false);

writer.flush();
writer.close();

final String htmlContent = writer.toString();

This is it. Enjoy.

Get annotation’s field’s value easily

Hello,

Maybe have you ever been confronted to the problem of getting the value of a field of an annotation. You see what I’m talking about? No. Example:

@Foo(myField="Hello there")
public class FooClass implements Serializable {
// ...
}

Let’s imagine you want to retrieve the value of myField (ie Hello there). How could You do that? Let me propose you two ways.

First way
The easier way but absolutely not scalable is to do the following code:

// ...
String myFieldValue = "Hello there";
// ...

Well it’s working, isn’t it? But imagine you have to get this value a lot of times, in different classes and so on … Are you going to use your favorite IDE’s function “Find and replace …”? Why not. But, lets take a look to a different way.

Second way
The other solution, much more scalable, is to use reflexivity. And the great thing about that is that you will be able to use for whatever annotation and whatever field. Lets take a look at this:

public String getClassAnnotationValue(Class classType, Class annotationType, String attributeName) {
        String value = null;

        Annotation annotation = classType.getAnnotation(annotationType);
        if (annotation != null) {
            try {
                value = (String) annotation.annotationType().getMethod(attributeName).invoke(annotation);
            } catch (Exception ex) {
            }
        }

        return value;
    }

How invoke that snippet of code?

// ...
String myFieldValue = getClassAnnotationValue(FooClass.class, Foo.class, "myField");
// ...

As you can see, you can use it for whatever class annotation on a class. You can now imagine doing the same for a field Annotation. Give it a try!

This is a pretty useful when you work in JEE. Imagine a SessionBean with may implementations, or an EntityBean with the @Table annotation, or a simple field with the @Column annotation. And these two last examples, it is useful if you build your own SQL queries. Because with this snippet of code, you won’t have to look everywhere you use your EntityBean and change the table name in your query …

Well, I hope this could help you sometimes.
Enjoy.

Deal with Context-Path in Java EE

Maybe have you ever try to create an Enterprise Application in Java, containing both EJB and Web modules. And maybe have you noticed that the context-path of the web application is the same that the generated WAR file.
So let’s imagine you create an enterprise application named JustMyApp with two modules: JustMyApp-ejb and JustMyApp-war. After deploying your application, you just go to your website using an URL like this one (depending on which port your server is running): http://localhost:8080/JustMyApp-war. Well I have to admit I totally dislike to enter -war in the URL… Why not JustMyApp only?

Context-Path in Java EE is kind of strange. Indeed, if you only have a WAR (not en EAR) changing the CP for the WAR is working fine. But if you are in an EAR, things are little bit different!

So how to do that? You have to create a file called a Standard Deployment Descriptor and put it into your EAR. The name of this file must be application.xml. This file contains the name of all modules you have in the EAR, and you can specify the context-path for your Web module. Let’s see an example:

<?xml version="1.0" encoding="UTF-8"?>
<application version="6" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application_6.xsd">
  <display-name>JustMyApp</display-name>
  <module>
    <ejb>JustMyApp-ejb.jar</ejb>
  </module>
  <module>
    <web>
      <web-uri>JustMyApp-war.war</web-uri>
      <context-root>/JustMyApp</context-root>
    </web>
  </module>
</application>

The URL to enter to access your web application is just specified by the <context-root>…</context-root> markup. So put there whatever you want and just try it ! That’s how the Context-Path for EAR can be changed !

Enjoy.

Deploy Java applications on Mac

Hello,

You need to deploy Java applications on Mac? Take a look at : http://thierry.wasylczenko.free.fr/?p=108

Enjoy.

JAI : how to solve vendorName == null exception

Hello everybody,

Have You ever used JAI (Java Advanced Imaging) ? If You used the class ImageIO in order to read and save images, the answer is yes.
Most of the time, You should not have problem when You deploy Your application with an executable JAR even if You’re using JAI. But, most of the time doesn’t mean never, so that’s a problem !
Recently I had to deploy an application as a JAR, and this application was using quantity of external library. And of course it used JAI.
Well, doing a JAR is not really a problem but …

In my case, the application was developped with Eclipse, and was running fine in it. But, when it comes to run it with a JAR, that was problematic…
I got an exception when a tried to load images, especially TIFF images. This exception was thrown by JAI and told me that the vendorName was null. Interessting : but which vendor ??

The answer is quiet simple : JAI needs sometimes to know the name of the vendor who developped the application, and the implementation of it… OK, you’ll tell me “Fine. It seems it’s my application, so I’m the vendor. But how do I specify that?”. And that’s the point.

When You deploy an application as an executable JAR, You probably know that You need a manifest file. And that manifest file is the key. A complete valid manifest file could be this :

Manifest-Version: 1.0
Main-Class: fr.free.thierrywasyl.myproject.launcher.Launch

But where did I specify the author? No where. But JAI will maybe need to know that, or You’ll get an exception about the vendor. So let’s add some lines, which are good to add (take it as a good practice) which are general:

Manifest-Version: 1.0
Implementation-Vendor: Sun Microsystems, Inc
Implementation-Title: Java Runtime Environment
Implementation-Version: 1.6.0
Main-Class: fr.free.thierrywasyl.myproject.launcher.Launch

So far so good. So are You a null vendor? Of course not, You get over the exception 😉
Enjoy.