Commentaires pour Today's tip

Commentaires sur Quand 1+1=3, on dit merci au cache de Java par thierryler

thierryler — Fri, 04 Sep 2015 20:23:02 +0000

Oui je sais. C’est d’autant plus vicieux hein

Imagine ces lignes de code mélangées au milieu d’un gros algo : bonne chance pour comprendre ce qui se passe…

Commentaires sur Quand 1+1=3, on dit merci au cache de Java par adiGuba

adiGuba — Thu, 03 Sep 2015 13:34:13 +0000

Le plus drôle c’est que System.out.println() n’affiche pas la même chose :

1 2	System.out.println(res); // affiche 2 System.out.printf("%d", res); // affiche 3

a++

Commentaires sur Buzz : le puzzle d’entrainement du concours du meilleur dév de France 2014 par Mister Tie

Mister Tie — Sat, 17 May 2014 16:40:56 +0000

Je suis d’accord avec Thierry sur le côté très verbeux de la solution proposée avec Java 8.
Cependant, la programmation fonctionnelle peut tout de même nous aider.
Voyez ci-après ma tentative en Scala:

1
2
3
4

def resolveBuzz(input: String) = {
val buzzIndices = input.split(" ").zipWithIndex.filter(_._1.equals("Buzz")).map(_._2 + 1)
(buzzIndices.head, buzzIndices.tail.find(_ % buzzIndices.head != 0).get)
}

La méthode zipWithIndex permet de construire un tuple à partir de chaque élément et son index dans le tableau.
Ex: (« 1″, 0), (« Buzz », 1).

On filtre ensuite ces tuples pour ne garder que ceux ayant comme premier élément « Buzz ». Enfin, on ne conserve que les indexes de ces derniers que l’on incrémente de 1.

Le premier de ces indexes est forcément n; donc la tête du tableau.
Il suffit ensuite de prendre le premier élément qui n’est pas multiple du premier.

Commentaires sur Buzz : le puzzle d’entrainement du concours du meilleur dév de France 2014 par thierryler

thierryler — Fri, 16 May 2014 12:49:42 +0000

Je ne suis pas encore passé à Java 8 donc je ne peux pas vérifier si ça fonctionne. En tous cas, ça a l’air vachement plus complexe (et tordu aussi) que ma version… Comme quoi, la programmation fonctionnelle n’est pas forcément gage de lisibilité.

Commentaires sur Buzz : le puzzle d’entrainement du concours du meilleur dév de France 2014 par ybonnel

ybonnel — Fri, 16 May 2014 12:43:57 +0000

Juste pour le plaisir, j’ai essayé d’écrire la méthode « solve » en utilisant les nouvelles API Java 8 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public static String solve(final String line) {
AtomicInteger compteur = new AtomicInteger(0);
return Arrays.stream(line.split(" "))
.map(word -> new Pair(compteur.incrementAndGet(), word))
.filter(wordWithIndex -> wordWithIndex.getValue().equalsIgnoreCase("buzz"))
.map(Pair::getKey)
.collect(
ArrayList::new,
(list, index) -> {
if (list.isEmpty()) {
list.add(index);
} else if (list.size() < 2) {
if (index % list.get(0) != 0) {
list.add(index);
}
}
},
ArrayList::addAll
).stream()
.map(Object::toString).collect(
Collectors.joining(" ")
);
}

Si quelqu'un a plus simple, je suis preneur

Commentaires sur Renverser une String en Java : une question d’entretien technique par icexplorer

icexplorer — Tue, 06 May 2014 20:45:16 +0000

Sinon voici une version qui « fonctionne tant bien que mal » sans prise en compte des caractères spéciaux (ça peut servir au candidat fainéant :p)

1
2
3
4
5
6
7

final String chaine = "abc";
final char[] chaineArray = chaine.toCharArray();
final StringBuilder s = new StringBuilder();
for (final char c : chaineArray) {
s.insert(0, c);
}
System.out.println(s.toString());

Commentaires sur Le Multirator par thierryler

thierryler — Wed, 16 Apr 2014 19:24:01 +0000

C’était pour un tri par insertion monotone mais ça marche pareil pour un tri fusion : bien vu.

Pour être franc, je n’ai jamais utilisé de ma vie la méthode remove() des Iterators. Du coup je ne me suis pas encore attaqué à la question.

Commentaires sur Le Multirator par thierryler

thierryler — Wed, 16 Apr 2014 19:16:49 +0000

C’est surtout que je voudrais que ce soit dynamique et qu’on puisse modifier les itérators pendant l’utilisation.

Commentaires sur Le Multirator par Nemek

Nemek — Wed, 16 Apr 2014 12:06:43 +0000

pas mal l’exercice faudrait le proposer à tes élèves ;).
Si je comprends le but est de réaliser le travail de reconstruction du merge sort ?
J’aurais préféré un exercice autour de l’appareillage d’itérateur, une idée pour un prochain billet/exercice ?

Juste une petite remarque, la méthode remove() doit supprimer le dernier élément renvoyé par next() ! Il suffit de conserver l’itérateur qui a servi à renvoyer le dernier élément.

Commentaires sur Le Multirator par thierryler

thierryler — Tue, 15 Apr 2014 09:06:55 +0000

J’ai ajouté une version utilisant un PeekingIterator

Commentaires sur Le Multirator par issamm

issamm — Mon, 14 Apr 2014 15:09:51 +0000

En utilisant des ListIterator, il ne devrait pas y avoir de ConcurrentModificationException.
A tester

Commentaires sur Le Multirator par thierryler

thierryler — Mon, 14 Apr 2014 14:35:03 +0000

Et que se passe-t-il si le contenu des iterator est changé durant l’execution ?

Commentaires sur Le Multirator par issamm

issamm — Mon, 14 Apr 2014 13:30:35 +0000

En gros :

1
2
3
4
5
6
7
8
9
10
11
12

public class IntegerBox implements Comparable {

private final Integer value;

private final Iterator iterator;

public IntegerBox(Integer value, Iterator iterator) {
this.value = value;
this.iterator = iterator;
}
// Getter & setter
// hashcode + equals

L’itérateur :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public class MultiIterator {

private final TreeSet valuesToCompare;

private final Comparator comparator;

public MultiIterator() {
comparator = new MyComparator();
valuesToCompare = new TreeSet(comparator);
}

public void addList(List list){
if(list == null || list.size() < 1){
return;
}
Iterator iterator = list.iterator();
IntegerBox integerBox = new IntegerBox(iterator.next(), iterator);
valuesToCompare.add(integerBox);
}

public void run(){
while(valuesToCompare.size() > 0){
IntegerBox integerBoxToDisplay = valuesToCompare.first();
Iterator iterator = integerBoxToDisplay.getIterator();

System.out.println(integerBoxToDisplay);
valuesToCompare.remove(integerBoxToDisplay);

if(iterator.hasNext()){
IntegerBox integerBoxToAdd = new IntegerBox(iterator.next(), iterator);
valuesToCompare.add(integerBoxToAdd);
}
}
}

private class MyComparator implements Comparator{

@Override
public int compare(IntegerBox object1, IntegerBox object2) {
return object1.getValue().compareTo(object2.getValue());
}
}
}

Enfin, le main d’exemple :

1
2
3
4
5
6
7
8
9
10

public static void main(String[] args) {
// Arrange
final List listA = Arrays.asList(4, 3, 1);
final List listB = Arrays.asList(5, 4, 2);

MultiIterator multiIterator = new MultiIterator();
multiIterator.addList(listA);
multiIterator.addList(listB);
multiIterator.run();
}

Commentaires sur Le Multirator par thierryler

thierryler — Mon, 14 Apr 2014 12:38:40 +0000

Bonjour,

Merci pour cette proposition. J’avoue toutefois n’avoir pas très bien compris Un peu de code aiderait…

J’ai aussi pensé à une version encore mieux utilisant le PeekingIterator de Guava et que je vous montrerai la semaine prochaine.

Commentaires sur Le Multirator par issamm

issamm — Mon, 14 Apr 2014 10:03:29 +0000

Précisions : Cela nécessite de créer un Comparator, comparant sur les champs IntegerBox.value.

Commentaires sur Le Multirator par issamm

issamm — Mon, 14 Apr 2014 09:58:30 +0000

Bonjour Thierry,

J’aurais certainement procéder de la sorte, avec l’instanciation d’un TreeSet, afin d’avoir un Set trié sur les valeurs à comparer.

1 – Création d’une classe encapsulant un Integer, ainsi qu’une référence vers la liste d’Integer d’origine (vous allez comprendre pourquoi) : IntegerBox (nom choisi en moins d’une seconde).
class IntegerBox { private final Integer value; private final List list; }

2 – Lors de la génération des valeurs en sortie :
a) Création des IntegerBox pour chaque valeur de chaque liste, avec initialisation de la référence sur la liste.
a) Création du TreeSet et initialisation avec les 1ères valeurs de chaque liste
b) lors du parcours, prendre la valeur la + petite du TreeSet (méthode first() ), et la retirer du TreeSet
c) placer dans le TreeSet, la valeur de next(), sur la liste contenue dans l’IntegerBox.

3 – Et voilà

Cordialement,
Issam El Hachimi

Commentaires sur Puzzle sur le final++ par thierryler

thierryler — Wed, 26 Feb 2014 10:54:30 +0000

L’idée n’est pas de tester pour copier-coller la réponse. L’idée c’est de l’expliquer sans le tester.

Commentaires sur Puzzle sur le final++ par kolodz

kolodz — Thu, 20 Feb 2014 13:49:44 +0000

1) Cela ne compile pas !

Exception in thread « main » java.lang.Error: Unresolved compilation problems:
The final local variable i cannot be assigned. It must be blank and not using a compound assignment

Commentaires sur Le non early return par thierryler

thierryler — Sat, 02 Nov 2013 11:53:01 +0000

Évidement que ça dégrade les performances. C’est mécanique.

Commentaires sur Le non early return par floppy22

floppy22 — Thu, 31 Oct 2013 23:15:21 +0000

Je m’accorde à Lunatix sur la règle de l’unicité du mot clef return dans toutes fonctions / méthodes mais sans condition de nombre de lignes.
Bien que développeur Java et partiellement .Net, je reste adepte du développement C/C++ dans sa rigueur.
Un unique return final ne dégrade aucunement les performances (Les tests conditionnels étant correctement réalisés en amont et n’influençant pas le code assembleur sous-adjacent) mais peut au contraire les améliorer de par le traitement de toutes les opérations préalablement réalisées et la libération des ressources intermédiaires « oubliées » et laissées à charge du GC (Java ou .Net).
Je suis convaincu de la mauvaise habitude des développeurs quant à la déclaration des variables / variables membres / attributs (natifs, objets) au fil de l’eau et des retours au gré des envies.
Je reste convaincu de la déclaration des varibales / variables membres / attributs (natifs, objets) en tête de fonction(s) / méthode(s) et de l’utilisation du mot clef return toujours en fin de fonction / méthode.
Seule et unique réponse à la lisibilité / maintenabilité.
L’early return est maintenu même dans votre exemple …

Commentaires sur Utilisez map.entrySet par Aldian

Aldian — Thu, 31 Oct 2013 17:14:49 +0000

Sans davantage de précisions j’avais compris que tu faisais varier le nombre d’éléments dans une map, mais pas que tu exécutais le test plusieurs fois avant de mesurer le temps d’exécution. Cette impression est renforcée par le fait que tu donnes très peu de chiffres significatifs dans tes mesures. A partir du moment où tu fais un nombre de boucles suffisant pour te permettre une bonne précision de mesure, je pense que tu peux te permettre de mettre au moins trois chiffres significatifs

Commentaires sur Utilisez map.entrySet par thierryler

thierryler — Mon, 28 Oct 2013 10:04:14 +0000

Sérieusement, tu te doutes bien que c’est déjà ce que je fais !

Commentaires sur Utilisez map.entrySet par Aldian

Aldian — Sun, 27 Oct 2013 10:11:34 +0000

Pour finir, je fais varier le nombre d’éléments dans les maps (…). Le résultat n’est pas forcément évident mais on comprend bien le problème…

Avec d’aussi petits temps mesurés tu aurais très bien pu avoir des temps de réponse non ordonnés en cas de petit lag système. Je te suggèrerai de faire une boucle pour effectuer 10.000 fois chaque test et de comparer les temps totaux.

C’est le même principe que pour mesurer l’épaisseur d’une feuille de papier avec un double décimètre, ce n’est pas évident, mais si par contre tu mesures un bloc de 1000 pages et que tu divises par 1000, tout de suite le résultat devient beaucoup plus significatif

Commentaires sur Le non early return par thierryler

thierryler — Mon, 21 Oct 2013 18:43:27 +0000

On pourrait aussi dire que c’est plus ou moins différent ?

Commentaires sur Le non early return par lunatix

lunatix — Sat, 19 Oct 2013 16:46:19 +0000

perso : si la methode fait plus de quelques lignes (on va dire une petite dizaine) : UN SEUL return est autorisé.

ca revient plus ou moins au meme

Commentaires sur Utilisez map.entrySet par thierryler

thierryler — Wed, 16 Oct 2013 11:21:21 +0000

On fait du Java 1.4 chez nous. Là on est en train de changer tous les bloc booléens :

1 2	boolean value = ... Boolean result = new Boolean(value);

par

1	Boolean result = Boolean.valueOf(value);

Le second bloc renvoie une valeur statique alors que le premier passe par un constructeur. C’est pas bien méchant mais on en a beaucoup. Et je ne parle même pas de quand on veut directement les constantes…

Avec l’autoboxing, c’est masqué. Donc c’est le drame… D’ailleurs, il ne faut pas oublier qu’un Boolean a trois états : true, false et null. Dans l’autoboxing, ça joue ! J’avais écris un petit billet là-dessus.

Commentaires sur Utilisez map.entrySet par Nemek

Nemek — Wed, 16 Oct 2013 10:29:52 +0000

Ca fait plaisir de lire qu’on est pas seul ! T’as pas le même soucis avec l’auto(un)boxing à gogo ou la concaténation de chaînes ?

Je pense qu’il doit y avoir un paquet d’autres exemples, de prochains billets ?

Commentaires sur Utilisez map.entrySet par thierryler

thierryler — Thu, 03 Oct 2013 11:58:54 +0000

Effectivement. Je crois me souvenir que la précision de Java 1.4 est de l’ordre de 10ms. Ca doit être sensiblement la même chose pour Java 7…

L’idée, ici, c’est surtout la « propreté sémantique » du code. L’exemple, avec mesure des performances, est surtout un prétexte pour proposer un cas concret.

Commentaires sur Utilisez map.entrySet par adiGuba

adiGuba — Thu, 03 Oct 2013 11:53:46 +0000

Salut,

Même si je suis plutôt d’accord concernant le fond du billet, il faut faire attention aux tests qui ont un résultat de moins de 30ms…
En effet currentTimeMillis() n’a pas forcément une bonne précision et peut amener des erreurs…

Sinon vivement Java 8 qu’on puisse utiliser la méthode forEach() :
Map map = …

map.forEach((key,value) -> {
// Traitement key-value
System.out.println(« key: » + key + » value: » + value);
});

Commentaires sur Le Croissant Master Agile par thierryler

thierryler — Mon, 23 Sep 2013 18:42:48 +0000

Bonjour et merci pour ce commentaire.

Une précision s’impose. Pour l’instant, j’ai introduit le rôle de Croissant Master avec l’espoir que ça donne des résultats, mais aussi en tant qu’expérience. Je suis prêt à admettre que ça ne fonctionne pas… Et je dois avouer que ça ne fonctionne pas, jusqu’à présent, aussi bien que je l’avais espéré.

Autre précision, sur laquelle je n’ai pas assez insisté, c’est que nous ne sommes pas dans une optique agile, même si nous reprenons deux ou trois éléments classiques comme le stand-up. Pour autant, je n’ai pas l’impression qu’il y ait du paternalisme. Cela dit, je suis actuellement Team Lead / CP et non Scrum Master donc il doit y avoir un peu de ça malgré moi…

Du coup, ça me fait un peu peur que cela fonctionne sous serre, comme tu le disais, et que ça s’effondre dès que je ne serai plus derrière. J’aimerais bien que ça fonctionne tout seul. Bon, au pire, ça me permet de passer un peu de temps avec la personne en charge du rôle de CM pour la semaine, pour lui expliquer/montrer ce dont on a besoin. C’est un petit moment privilégié. Mais en disant ça, j’ai l’impression que je suis en train de parler de ma fille de trois ans… aie !

Dans tous les cas, je vais continuer encore un peu cette expérience. Je vous tiens au courant. Si vous avez des idées, elles sont les bienvenues.

Commentaires sur Le Croissant Master Agile par Luckyluke34

Luckyluke34 — Mon, 23 Sep 2013 15:08:41 +0000

Est-ce une blague ? Le concept de « Croissant Master » me semble assez parodique… mais bon pourquoi pas

Je ne sais pas si l’agilité est en point de mire (référence au Scrum Master) – sur le fond, je trouve l’idée d’aider l’équipe à adopter une approche un peu plus auto-organisée intéressante. Là où je suis plus sceptique, c’est quand cette auto-organisation est amenée de manière assez scolaire voire un peu paternaliste : « je viens d’introduire dans mon équipe », « sur la base du volontariat », « ainsi désigné », « une punition de son choix »… en tout cas c’est la vision qu’on pourrait en avoir de l’extérieur.

Si la sauce prend, que l’équipe se pique au jeu et prend en main sa propre autonomie grâce à ça, tant mieux et c’est tout le mal que je souhaite, mais une approche trop « top-down » et directive fait aussi courir le risque que ça devienne de l’auto-organisation/agilité « sous serre » et que la dynamique ne soit qu’artificielle, sans réelle adhésion des individus et sans sentiment d’accomplissement.

L’idéal selon moi est une équipe dont les membres sont à la base assez enthousiastes, autonomes et impliqués pour éviter les problèmes d’animation, de convivialité, de retards que tu évoques. Je sais, c’est un peu le serpent qui se mord la queue, mais jusqu’ici je n’ai jamais rencontré de team « lambda » qu’on a *rendue* agile/auto-animée, seulement des groupes agiles dont la plupart des individus étaient déjà sensibles à ces thématiques et ces approches à la base et éventuellement spécialement recrutés pour ça.

En tout cas s’il y a une solution, je pense qu’elle passe plutôt par le questionnement, le coaching, l’éclairement que par l’obligation et la hiérarchie.

Commentaires sur Stop aux QCM techniques en entretien par Lana.Bauer

Lana.Bauer — Wed, 15 May 2013 13:44:53 +0000

Salut,

J’aime bien l’article. C’est tout à fait vrai. On est tous passé par là.

Merci

Commentaires sur Le bon mot de passe par thierryler

thierryler — Sat, 11 May 2013 18:15:06 +0000

En effet ce soft est vraiment bien. Pour ma part, dans une moindre mesure, j’utilise aussi une fonction de Firefox qui s’appelle « password principal » je crois.

Pour la remarque sur Google et le SMS, c’est un point très important. Chez Google, ils appellent ça le « has » de l’anglais « posséder ». Le principe est d’envoyer une double information sur un terminal que seul le destinataire peut posséder. Le téléphone portable est un bon exemple.

Commentaires sur Le bon mot de passe par romaintaz

romaintaz — Fri, 10 May 2013 19:47:40 +0000

Rien ne vaut un bon soft pour créer et retenir ses mots de passe. Moi j’utilise 1Password, et j’en suis très content.
Un autre truc : avec Google, il est primordial de mettre en place la double authentification (avec un code reçu par SMS). Ca évite les mauvaises surprises si l’on perd son mot de passe.

Commentaires sur Un Boolean peut prendre trois valeurs par thierryler

thierryler — Thu, 25 Apr 2013 13:34:26 +0000

Oui c’est exact, forcément. Mais bizarrement aucun de mes élèves/collègues ne se fait avoir sur les chiffres… Et j’ai le sentiment qu’ils n’utilisent pas du tout les chars…

Commentaires sur Un Boolean peut prendre trois valeurs par rg77140

rg77140 — Thu, 25 Apr 2013 13:29:52 +0000

Bonjour,

Il faut noter que ce problème lié à l’autoboxing peut se produire avec d’autre type primitifs qui ont une représentation Objet (Long, Integer, …). Cette méthode renvoie une NPE sur le return (il vaut avouer qu’une NPE sur un return aussi simple peut surprendre) :

1
2
3
4
5
6
7
8

public long calculMontant()
{
Long montant = null;

// du code ici qui peut initialiser montant sous certaines conditions

return montant;
}

Romain.

Commentaires sur Devoxx France n’est pas un picnic par agoncal

agoncal — Tue, 02 Apr 2013 18:28:42 +0000

J’ai été extremement transparent durant notre keynote : nous avions 74 conférences de disponibles, 14 étaient « données » au sponsors PREMIUM et MEDIUM (vous pouvez lire le terme « partner slot » dans l’agenda) ce qui faisait 60 conférences sur 320 de proposé. Bref, un rejet de 82%.

Encore désolé pour les non-retenus. Nous allons cependant mettre en place un « listing » de speakers potentiels pour les JUGs de France et de Navarre. Sachez qu’il y a plus de 20 JUGs en France (unique au monde avec cette densité là). Prenez votre sac à dos, votre MacBook Pro et parcourez les JUGs.

Et on se dit à 2014 ;o)

Commentaires sur Devoxx France n’est pas un picnic par GabyKast

GabyKast — Tue, 02 Apr 2013 13:39:14 +0000

Je confirme, 150 talks retenus sur 550 c’est une sélection à la dure.
Et juste pour les conférences, de tête on a une proposition de 50 sur 300.
Souvent ce sont des détails qui font la différence. La cohérence de la proposition, l’intérêt (technique) et la fraîcheur du sujet, le renom de speaker, a-t-il participé à Devoxx l’an dernier, et même l’orthographe (qui montre si celui qui propose le sujet fait attention à ce qu’il fait), la fraîcheur du talk, la clarté du propos (qui montre la capacité de celui qui propose un talk à se faire comprendre), ce talk vient-il concurrencer un autre talk beaucoup plus renommé, la participation de la personne à l’open source et aux communautés, est-ce qu’on a des slides de sa proposition ou de propositions précédentes, mieux, y a-t-il une vidéo, y a-t-il une volonté de « vendre » son sujet ou juste de convaincre de la justesse technique, le speaker est-il bon (si quelqu’un du comité de programme a vu le speaker on se fie en général à son avis)…
Comme disent les sportifs de haut niveau, « ça se joue sur des détails ».

Plus on trouve d’informations plus le speaker a des chances d’être sélectionné. De toutes façons à la fin c’est le chat qui choisit

Commentaires sur Les 10 pièges à éviter dans un projet agile par thierryler

thierryler — Sun, 25 Nov 2012 08:30:44 +0000

Bonjour et merci pour ces précisions constructives.

Pour le point (2) il n’est pas question de pinailler sur le coût mais d’en être conscient. En effet, trop de « chefs » oublient de compter la durée des différentes cérémonies dans le budget. Elles sont pourtant indispensables et elles coûtent cher une fois mises bout à bout. Ce coût est toutefois compensé ailleurs et assumé.

Je n’ai pas encore l’article dont tu parles à propos du point (5) mais je voudrais donner mon avis personnelle. À mon sens, la confiance ne devrait jamais exister dans un projet. La méfiance n’a pas sa place non plus. Je m’explique, on dispose d’un grand nombre d’outils pour tester les applications avec des méthodes comme 3T et TDD à leur tête. Je demande donc toujours à mes clients de ne jamais me faire confiance mais d’exiger des preuves. Ceci doit rester dans la limite du raisonnable.

Quant à la confiance entre les membres de l’équipe, j’aurais plutôt tendance à me baser sur l’historique en me disant qu’une personne va fonctionner pareil d’un sprint sur l’autre. Pour un « chef », le pire truc, ce n’est ni les diva ni les blaireaux mais les lunatiques.

Pour le point (7), je répondrais simplement qu’il ne faut pas faire de scrum (ou d’agile) si on ne veut pas en suivre les règles de base. Les PO qui demandent des petits trucs en plus, sauf quand c’est vraiment indispensable, c’est souvent pour rattraper leurs conneries ou pour gagner des points bidons. Le rôle du chef, ou du scrum´master, c’est de préserver l’équipe de ce genre de connerie. On ne va pas foutre en l’air le projet pour faire plaisir à Intel.

Alors on peut se dire qu’une fois ou deux, ça passe encore mais c’est la porte ouverte aux abus. Bien entendu, il faut rester ouvert aux événements importants. Si on prend Kanban, on a justement la première ligne qui est réservée pour des urgences. Notez que je parle d’urgence et pas de aire plaisir à untel.

Pour la demo (8) c’est justement une erreur de faire un raccourci entre une fonction qui marche au sens et la demo et une fonction qui marche au sens général. Dans la demo, on te montre les cas qui fonctionnent, ceux la peuvent passer en prod. Mais les cas annexes, aux limites ou non, c’est une autre histoire.

Je vais donner un exemple abusif mais concret pour expliquer. Disons qu’on calcule le factoriel d’un entier positif. On fait la demo avec factoriel de 3 et de 5. Ça me parait légitime de penser que factoriel de 4 va marcher aussi. Mais on a rien dit à propos de 6, 7, 8… Et beaucoup de gens croient à tort que c’est implicite.

Commentaires sur Les 10 pièges à éviter dans un projet agile par _oaz_

_oaz_ — Sat, 24 Nov 2012 10:38:14 +0000

Bonjour,

Certains des points présentés dans ce billet risquent, à mon avis, d’apporter de la confusion pour qui débuterait dans l’agilité.

#2 : se focaliser sur le coût est un plus grand risque que d’oublier de tenir des comptes précis. Le plus important c’est la *valeur produite* pour un coût fixé, quel que soit celui-ci. Si on a une équipe de 8 personnes, intéressons-nous à ce qu’elles peuvent concrètement apporter à des utilisateurs en une itération et essayons d’oublier les comptes d’apothicaires.

#5 : on donne souvent à l’engagement une place trop importante par rapport à la confiance nécessaire entre les membres de l’équipe. Plus de détails ici : http://agilitateur.azeau.com/post/2012/10/15/Engagez-vous-ils-disaient…

#7 : Il ne faut pas oublier que s’il n’y a pas de client, on ne travaille pas. C’est peut être une banalité mais ça peut être utile de le répéter de temps en temps. Donc, l’objectif est quand même quelque part de faire plaisir au client. A partir de là, on peut légitimement se demander en quoi une tâche est importante si elle n’est pas en accord avec cet objectif.

#8 : Quand on arrive à une démo, c’est que le logiciel est potentiellement livrable. Cela signifie que les fonctionnalités sont terminées, au sens où elles sont réellement utilisables dans le monde réel même si elles ne sont pas aussi complètes que ce que le client attend sur le long terme.

#10 : le chef doit surtout faire en sorte, dans la durée, d’être de moins en moins utile en tant que « chef ». L’autonomie d’une équipe est à ce prix. Sur la place des chefs, je conseille vivement la lecture de ce livre sur le lean management : http://informatique-conviviale.eyrolles.com/

Commentaires sur @ExtensionMethod de Lombok-pg par thierryler

thierryler — Fri, 20 Jul 2012 08:05:43 +0000

Regarde http://thierry-leriche-dessirier.developpez.com/tutoriels/java/simplifier-code-guava-lombok/

Commentaires sur @ExtensionMethod de Lombok-pg par jpoulson

jpoulson — Fri, 20 Jul 2012 05:24:24 +0000

Bonjour,

Je ne connais pas ce framework. Si j'ai bien compris l'annotation permet d'ajouter des méthodes à un bean ou d'ajouter un genre de wrapper. Mais que est l'avantage de cette approche ? Dans l'exemple que tu as donné il semble que cela remplace une méthode utilitaire.

Commentaires sur Un dernier fantastique café à Devoxx France 2012 par thierryler

thierryler — Thu, 26 Apr 2012 08:10:01 +0000

Les castcodeurs disent que le wall a été éteint suite au nombre grandissant de messages négatifs envers la keynote d’ibm.

Commentaires sur Un dernier fantastique café à Devoxx France 2012 par lunatix

lunatix — Fri, 20 Apr 2012 20:12:26 +0000

la rumeur dit que le tweet wall était pas KO, mais plutôt éteint suite a un tweet bash

Commentaires sur Faire pleurer vos collègues par thierryler

thierryler — Fri, 19 Nov 2010 12:15:24 +0000

Déjà le (1) ne compile pas. Ca c’était juste pour l’échauffement. Après si je te dis quoi est faux, ça te donne la solution pour tout.

Commentaires sur Faire pleurer vos collègues par Bourgui

Bourgui — Fri, 19 Nov 2010 12:12:41 +0000

qu’est ce que j’ai faux ? tout ?

Commentaires sur Faire pleurer vos collègues par thierryler

thierryler — Fri, 19 Nov 2010 12:10:04 +0000

toujours faux lol

Commentaires sur Faire pleurer vos collègues par Bourgui

Bourgui — Fri, 19 Nov 2010 11:07:31 +0000

le 1/ ne marche pas car il n'y a pas de valeur assignée, mais selon les langage i vaudra peut etre 0.

le 2/ le ++ est fait avant l'instruction donc au moment de l'assignation i vaut 2.

le 3/ pareil mais vu qu'il y a +1...

le 4 le ++ est fait apres quand il est avant le i donc ça fait i = 1 + 1 + 2

Commentaires sur Faire pleurer vos collègues par thierryler

thierryler — Thu, 18 Nov 2010 16:12:24 +0000

Ne trichez pas. Vous n'avez pas le droit de copier le code dans Eclipse pour avoir la solution et ensuite en déduire l'explication.

Commentaires sur Faire pleurer vos collègues par thierryler

thierryler — Thu, 18 Nov 2010 16:10:43 +0000

Il ne faut pas juste trouver la solution (qui n'est pas "ko-1-3-4" désolé) mais l'expliquer.

Je pense que la plus dure est testCalcul2().

Commentaires sur Faire pleurer vos collègues par Bourgui

Bourgui — Thu, 18 Nov 2010 15:24:47 +0000

le premier ne marche pas (pas sur), genre erreur
le deuxième « 1 »
le troisieme « 3 »
le quatrieme « 4 »

Commentaires sur Des itérators et des boucles par adiguba

adiguba — Tue, 02 Nov 2010 11:06:57 +0000

L'interface Iterable n'est apparut qu'avec Java 5.0. Donc les librairies plus anciennes utilisaient l'Iterator directement.

a++

Commentaires sur Des itérators et des boucles par thierryler

thierryler — Tue, 02 Nov 2010 10:31:38 +0000

Bonne question. Il se trouve qu’on travaille (là où je suis) avec des lib qui nous donnent des itérators directement. Je ne sais pas pourquoi. Toutes les raisons que je peux imaginer ne s’applique pas à ce cas donc… On fait avec. Du coup soit on utilise la méthode iterate(), qui peut être appliquée à d’autres types comme tu le signales, soit on l’englobe directement… C’est un peu au choix…

Commentaires sur Des itérators et des boucles par adiguba

adiguba — Tue, 02 Nov 2010 10:23:26 +0000

Salut,

Pourquoi ne pas simplement retourner la liste déclarée en Iterable :

1
2
3
private Iterable amisIterable() {

return amis;

}

Si c’est pour une question de sécurité (afin d’éviter les casts méchant), il suffit d’englober cela dans une nouvelle instance d’Iterable :

1
2
3
4
5
6
7
private Iterable amisIterable() {

return new Iterable() {

@Overrides public Iterator iterator() {

return amis.iterator();

}

};

}

Bien sûr le code de la méthode iterable() reste utile avec les APIs existantes retournant déjà un Iterator. Et la même astuce s’applique également à d’autres types d’objets (Enumeration par exemple)

a++