Greg's Devblog Par un développeur, pour les développeurs

6jan/116

Android 3.0 enfin présenté !

Ca fait longtemps qu'on l'attendait, à tel point qu'hier au boulot on se disant ne pas comprendre la stratégie de Google sur Android, avec un système pas du tout adapté aux tablettes et une relative opacité dans le développement (pour un projet OpenSource).

Et bien voilà, ce matin est arrivée une belle vidéo illustrant ce que sera Android 3.0 (Honeycomb), et je dois avouer que contrairement à ce que je pensais, je ne suis pas déçu, bien au contraire ! Les fameuses 4 touches d'Android (parfois 3), à savoir Back, Menu, Home, et Search ne seront effectivement plus obligatoires, car intégrées directement dans l'interface. L'iPad n'a qu'à se tenir !

Sans plus attendre, je vous laisse découvrir la vidéo :

Et vous, vous en pensez quoi ?

Via googlesystem.blogspot.com

18déc/102

Temps des différents accès

L'année dernière, en "Compilation Avancée", on a vu différentes méthodes permettant de réduire les défauts de cache, ce qui permet de gagner un bon gros facteur en terme de performances.

Alors certes, pourquoi pas, mais on se rend compte qu'en règle général on a du mal à imaginer les écarts de temps... Un accès à une valeur du cache L2, est-ce vraiment beaucoup plus lent que pour le cache L1 ? Et que pour un accès en RAM ? Il existe donc un petit tableau "comparatif", histoire que tout programmeur puisse se faire une idée de l'importance de ce genre d'optimisations...
Je ne l'ai pas traduit car de toute façon c'est relativement simple à comprendre, je vous laisse donc vous instruire :)

L1 cache reference 0.5 ns
Branch mispredict 5 ns
L2 cache reference 7 ns
Mutex lock/unlock 25 ns
Main memory reference 100 ns
Compress 1K bytes w/ cheap algorithm 3,000 ns
Send 2K bytes over 1 Gbps network 20,000 ns
Read 1 MB sequentially from memory 250,000 ns
Round trip within same datacenter 500,000 ns
Disk seek 10,000,000 ns
Read 1 MB sequentially from disk 20,000,000 ns
Send packet CA->Netherlands->CA 150,000,000 ns

Un petit commentaire ? A la louche, un facteur 14 entre les accès au cache L1 et les accès au cache L2, et à nouveau un facteur de cet ordre pour un accès en mémoire principale. Comme quoi ça coûte vraiment cher !

Source : The Axis of Eval

Taggé comme: , , 2 Commentaires
18déc/102

Comment reconnait-on un programmeur ?

L'autre jour sur stackoverflow quelqu'un a posé une question assez marrante : comment reconnait-on un programmeur (ie, sans connaître la personne, juste à partir de petites manies/habitudes).

J'ai regardé les réponses par curiosité, et je dois avouer que certaines me correspondent bien. J'ai testé avec ma copine, et dans l'ensemble elle approuve (avec une mention spéciale pour une réponse en particulier). Voici donc un petit panel rapide et non exhaustif :

  • Utilisation des parenthèses imbriquées (je dois admettre que je le fais assez souvent (et même dans ce billet !))
  • Temps de latence anormalement long pour répondre à des questions pourtant très simples, du style "tu veux du thé ?". Ma copine râle beaucoup à propos de ça... Certains disent que c'est parce qu'il faut le temps de faire le pre-processing, l'analyse lexicale et syntaxique, et l'optimisation de la réponse, mais pour ma part je dirai que c'est juste que quand je suis concentré sur du code (ou un domaine relatif à la programmation) je suis un peu dans un mode de particulier (logique et proche de la machine, on va dire), et que du coup, effectivement, ça interrompt un peu le fil de ma pensée et il me faut un temps pour me "reconnecter". D'ailleurs, dans ma tête, souvent je suis en train de taper du code, et là ça fait "tiens, on me parle"... je continue à taper un peu, et puis au bout d'un même je switch sur le mode "social" et je réponds. Mais ça énerve ma copine d'attendre plus d'1 seconde pour ça.
  • Numérotation qui commence à 0. Je ne comprends d'ailleurs toujours pas pourquoi dans les éditeurs de code on numérote à partir de 1...
  • Pour un programmeur, 256 est un chiffre rond. Là je ne dirai que ce n'est pas forcément vrai pour tous les programmeurs, mais en tout cas pour ceux qui font pas mal de C/C++. En Java, je le vois beaucoup moins.
  • Le fait de revenir en arrière dans la call stack de la conversation. Ca j'ai tendance à le faire et c'est vrai que les gens n'aiment pas beaucoup, dans l'ensemble. Du style si je pensais à quelque chose à dire à un moment donné et qu'entre temps quelqu'un a parlé et que la conversation à avancé, dans ma tête c'est toujours présent, et à tout moment s'il y a un blanc je vais avoir tendance à revenir en arrière dans la conversation pour repartir de là où j'avais quelque chose à dire.

Il y a pas mal d'autres réponses sympas sur le site, donc si vous avez un peu de temps à perdre, je vous invite à aller voir ça :)

Taggé comme: , 2 Commentaires
13déc/103

Code Taiwanais : comeback !

Ca faisait assez longtemps que je n'avais pas eu à jouer avec du code fait à l'étranger, et là je suis tombé sur quelques éléments intéressants à nous.

Je vais commencer par ce qui me parait être le plus sympa, alors voilà, les magic number dans toute leur splendeur... On est dans une classe "Image", qui possède des getters pour largeur et hauteur :

// fix for null images
width(){
	if (myWidth > 2000)
		return 39;

	return myWidth;
}

Je vous épargne le reste du code, on a exactement la même chose pour la hauteur :) Pourquoi cette limite à 2000 ? Et pourquoi retourner 39 dans ce cas ? Aucune idée ! J'aime beaucoup le commentaire, par contre :p

Dans un registre un peu moins grave, une partie du code qui est copiée/collée un peu partout, et qui sert à convertir une valeur sur 8 bits (de 0 à 255, pour un niveau de gris) en 4 valeurs (0x00, 0x40, 0x80, et 0xC0) :

if (pixel < 64)
	pixel = 0x00;
else if (pixel < 128)
	pixel = 0x40;
else if (pixel < 192)
	pixel = 0x80;
else
	pixel = 0xC0;
	

Alors, cette fois-ci au moins on comprend le code, à quoi il sert. Par contre, ça fait 8 lignes copiées/collées à une dizaine d'endroits différents, ce n'est pas terrible, d'autant plus que ça revient juste à retirer les bits de poids faible :

pixel &= ~63;

Je me demande si GCC est capable d'optimiser ça, d'ailleurs.

Un petit dernier pour la route, mais cette fois-ci, ce n'était pas du code taiwanais, c'était du beau code de la fac :p. Vu dans une méthode :

if (this == null){
	doSomething();
} else {
	doSomethingElse();
}

Un avis ?

Taggé comme: , 3 Commentaires
10déc/101

Chrome Easter Egg

Si vous suivez un minimum l'actualité, vous avez du voir que ça bouge du côté de Google et de Chrome OS : les testeurs ont reçu les premières machines, on commence à voir tourner la bête, et une vidéo de promotion est sortie.

Jusque là, rien d'anormale... Certes... Sauf qu'en fait, au milieu de la vidéo on voit sur un tableau une équation à la con, et du coup des personnes de chez Jamendo se sont amusées à la résoudre... Je vais vous laisser lire la suite sur leur blog, mais pour faire simple, on obtient une fraction qui peut être convertie en URL, et en allant sur cette URL... Un portable sous Chrome OS est offert ! Bon, c'est trop tard, c'était uniquement pour le premier venu, mais je trouve ça sympa d'avoir mis un easter egg en plein milieu de la vidéo.

Bravo à Google, et puis surtout bravo à ceux qui ont trouvé la réponse, il fallait le faire !

29nov/101

Algorithmes génétiques : petite voiture

Voici un petit programme flash qui montre la puissance des algorithmes génétiques : http://www.qubit.devisland.net/ga/index.html

C'est sympa car très visuel, en fait, on voit la progression au fur et à mesure, avec le petit graph pour montrer ce que ça donne.

Premier essai...

Quand je suis tombé dessus ce matin, je me suis dit que j'allais laisser tourner le programme quelques heures histoire que ça évolue bien et que ça donne une voiture super efficace. J'ai regardé de temps en temps, et voici ce que j'ai pu voir :

  • Premières générations super aléatoires, car les roues ne sont pas forcément en bas !
  • Après 2-3 générations, la majorité des voitures générées ont au moins 1 roue en bas
  • Après une dizaine de générations, les voitures comment à pas mal avancer, mais l'évolution a été bizarre : elles ont toutes une roue en bas, et les poids sont mis de façon à équilibrer la voiture pour rouler ainsi. Du coup ça n'avance pas super loin car s'il y a trop de relief ça tombe
  • A un moment est apparue la première voiture avec 2 roues en bas, qui est allée 2 fois plus loin que les autres ! Mais les mutations à la génération suivante ont fait que les 2 roues du bas étaient très mal placées, du coup elle est allée moins loin que les voitures à 1 roue et a disparu...
  • Après quelques dizaines d'évolutions, les voitures à 2 roues ont remplacé les voitures à 1 roue, en gardant une disposition des poids similaires à celle des voitures à 1 roue
  • Après un peu de temps, une voiture beaucoup plus large que les autres est apparue, elle est beaucoup plus apte a franchir les obstacles, et a imposé son génome en 2-3 générations.

Et en gros à partir de là, très peu d'évolution. Toutes les voitures sont sensiblement identiques, dès qu'une voiture un peu différente est générée, elle est moins bonne. Au final, j'étais déçu car aucune ne parvenait à passer le creux qu'on voit sur l'image au-dessus : elles se retournaient toutes.

On peut faire mieux ?

J'ai fini par me dire que ça pourrait être sympa de recommencer pour voir si l'évolution peut faire mieux. Et là, radicalement différent :

  • Première génération, une voiture à 2 roues en bas qui avance un peu
  • Deuxième génération, plusieurs voitures à 2 roues assez efficaces, le génome se répand rapidement !
  • Cinquième génération, les voitures arrivent aussi loin que celles d'avant après une centaine de générations (...)
  • Huitième génération (à la louche), les voitures passent le creux et vont plus loin ! (comme on le voit sur l'image ci-dessus)

C'est allé super vite ! En fait, du fait que les bonnes mutations soient arrivées très tôt, l'ensemble des voitures était encore composé de voitures très différentes, et le brassage a donc fait évoluer les choses très rapidement. Dans le cas précédent, tout avait évolué lentement, menant à des générations beaucoup trop homogène. C'est donc bien de la différence et de la diversité que vient la force des algorithmes génétiques.

Une fois qu'une génération est arrivée dans un optimum local, il devient très difficile d'en sortir, car toutes voiture qui est différente est potentiellement moins bonne, et donc va être oubliée... C'est d'ailleurs ce que je voyais sur le graph de progression : l'évolution se faisait par "breakthrough", comme on dit, avec de grands pas d'évolution d'un coup. Il faut qu'une voiture apporte une énorme amélioration sur les autres pour qu'elle soit gardée et que son génome soit passé à tout le monde au bout de quelques générations...

A l'occasion je m'attaquerai un peu à ce genre de programmation, je trouve ça très sympa, pas forcément difficile à faire (plus difficile à tweaker pour trouver la bonne taille de population, le bon taux de mutation, etc.), et puis visuellement c'est sympa à regarder (ça ferait un bon screensaver d'ailleurs).

29nov/100

1337 code : un blog très instructif

Ce matin, au lieu de travailler (...) je farouillais encore un peu partout et je suis tombé sur un blog qui me parait très intéressant : http://www.ihas1337code.com

Ce qu'il a d'intéressant, ce qu'il y a expose des problèmes avec des énoncés très courts, qui sont en fait globalement des problèmes d'algorithmique simple que l'on peut avoir en entretien d'embauche. Bon, moi les entretiens je m'en fous, mais les problèmes sont tous de mini-casse-têtes, intéressants à résoudre, et il y apporte des solutions souvent originales, et parfois des discussions annexes intéressantes.

Je vais surement reprendre ici certain des problèmes dans les semaines à venir. Et si jamais je suis très motivé je ferai les codes correspondants en Caml !

27nov/100

The Story of Mel

Une histoire sympa sur ce qu'est un "vrai" programmeur. Je la trouve assez poétique. http://catb.org/esr/jargon/html/story-of-mel.html

Taggé comme: Aucun commentaire
24nov/102

Remplacer π par τ ???

Je suis tombé aujourd'hui sur un article de Michael Hartl qui explique, en somme, pourquoi π n'est pas si génial que ça, et pourquoi τ serait plus approprié... Je ne vais pas traduire et remettre ici l'ensemble de sa page web, mais je dois dire que dans l'ensemble j'ai trouvé ça plutôt convaincant...

L'idée de base part du constat que π a été défini par la division de la circonférence d'un cercle par son diamètre. Pourquoi c'est une mauvaise idée ? Parce qu'en pratique on utilise toujours le rayon... Et là, on se retrouve en fait avec une constante différente, τ = 2π.

Ca peut sembler anodin comme changement, mais il y a en fait pas mal de conséquences, dont la plupart sont des simplifications de formules existantes. Un angle en radian va alors de 0 à τ au lieu de 0 à 2π, ce qui est déjà plus logique pour symboliser un tour complet.

Dans l'article il y a beaucoup d'explications autour de ça, ainsi que d'autres formules, mais il y en a une, probablement la plus connue de toutes, qui a attiré mon attention : πr2... Pour le coup, cette formule parait belle, pure, et si on voulait utiliser τ ici on se retrouverait avec un horrible (1/2)τr2... Assez moche, non ? Bah en fait, oui et non. Si on regarde les formules utilisées un peu partie et qui sont quadratiques, notamment en physique, on a des formules qui ont quelle tête ? Et bien, pour la vitesse, on a energie cinétique = (1/2)mv2... En fait, dans en gros un des seuls cas où ça parait moins beau, on peut trouver une belle raison pour utiliser là encore τ : ça permet d'harmoniser un paquet de formules...

Je vous invite à lire ce petit article, c'est sans prétention et ça se lit tout seul. Ca parait complètement surréaliste de vouloir changer une constante, surtout la constante la plus utilisée et la plus emblématique, et pourtant...

A méditer...

Taggé comme: , 2 Commentaires
19nov/103

Worse is better… Keep it simple stupid !

En titre de ce billets, 2 expressions qui devraient plus souvent être prises en compte dans le développement d'applications.

"Worse is better" dicte en fait les 4 qualités essentielles d'une application, mais en imposant une hiérarchie :

  • Simplicité
  • Exactitude
  • Consistence
  • Exhaustivité

Au boulot, on a tendance à partir sur le maximum de fonctionnalité, de la façon la plus consistente possible. Il faut ensuite que chaque fonctionnalité marche (plus ou moins ^^) et si possible que ce soit simple. Pourquoi pas.

Le schéma "Worse is better" va en fait plutôt motiver une importance dans l'ordre inverse : le plus important reste avant tout la simplicité. Je ne vais pas faire une traduction de tout ce qu'il y a dans l'article wikipedia, qui est court et intéressant à la fois, mais pour faire simple, en lisant ça j'ai tout de suite pensé à Apple : quand Apple conçoit quelque chose, la priorité est que ce soit simple. Le produit sort, il est simple. Le premier iPhone était très loin d'être parfait, très loin d'être exhaustif (manque de la 3G, du MMS, de la vidéo, etc...), mais il était simple.

Une fois qu'on a sorti un produit simple, les gens s'y font et on a tout le loisir d'y ajouter les fonctionnalités manquantes. Sur ce, je vais essayer de motiver les autres dans ma boite à adopter la "worse is better" attitude, histoire qu'on arrive enfin à boucler le développement en cours !

11nov/100

Pallier aux erreurs des gens

Dans quelle mesure, dans une application, doit-on prendre en compte les erreurs/conneries que peuvent faire les gens ?

Je suis tombé sur un exemple tout à l'heure dans gmail, une idée toute bête qui a été mise en place pour éviter pas mal de problèmes, mais il fallait y penser. J'ai reçu un mail, mais j'ai remarqué quelque chose de bizarre à côté de mon adresse dans l'entête du message :

(Oui, il s'agit bien de votre adresse.) En savoir plus

Forcément, je suis curieux, j'ai regardé de plus près, et j'ai remarqué que l'adresse à laquelle ce mail a été envoyée n'est pas la mienne ! En fait, il lieux d'avoir prenom.nom@gmail.com, cette adresse est prenomnom@gmail.com, et pourtant j'ai reçu le mail. En cliquant sur le lien, on a l'explication de ce phénomène :

Gmail ne considère pas les points comme des caractères dans les noms d'utilisateur. Vous pouvez en ajouter à votre adresse Gmail ou en supprimer sans que l'adresse de destination ne soit modifiée. Les messages sont tout de même envoyés dans votre boîte de réception et nulle part ailleurs. En bref :

  • homerjsimpson@gmail.com = hom.er.j.sim.ps.on@gmail.com
  • homerjsimpson@gmail.com = HOMERJSIMPSON@gmail.com
  • homerjsimpson@gmail.com = Homer.J.Simpson@gmail.com

Toutes ces adresses correspondent à une seule et même personne.

Je ne le savais pas ! Je ne sais pas si c'est bon à savoir, mais c'est une belle démonstration de solution relativement simple à mettre en place et qui permet d'éviter de se tromper de destinataire. Bon, si ça se trouve je débarque complètement et tout le monde fait ça, mais tant pis ^^

Taggé comme: , Aucun commentaire
9nov/101

CoffeeScript : syntax javascript compact

Ca fait un moment que je me dis que la façon usuelle de changer la valeur d'une variable en mettant un if est un peu moche à lire.

Le classique, suivi du "propre" :

if (condition) toto = truc;

ou

if (condition){
    toto = truc;
}

J'aurais voulu une syntaxe plus propre et lisible que ça, un peu de la même manière que parfois c'est plus clair de ne pas utiliser le if/then/else et de faire la chose suivante :

toto = condition ? truc : machin;

Bref, je pourrais très bien mettre "toto = condition ? truc : toto", mais je trouve ça laid de dupliquer le "toto"...

Et là, je tombe sur CoffeeScript, qui se propose d'écrire son code Javascript avec une autre syntaxe, et de générer le code Javascript correspondant après coup. Ca peut paraitre étrange, mais après tout, pourquoi pas ? En tout cas, dans leur syntaxe on trouve la construction suivante :

toto = truc if condition

Exactement ce que je voulais ! Clair, lisible, conci.

Je ne fais pas de Javascript en ce moment, mais l'approche me parait intéressante, donc je jetterai un oeil à ça un jour :) En tout cas, pour voir tout ça, c'est sur le site de CoffeeScript.

7nov/100

Faut-il réinventer la roue ?

Avec certains profs à la fac, on a toujours le même débat : faut-il réinventer la roue ? Dans le cadre des projets universitaires, est-il mieux d'aller vite et de réutiliser des bouts de codes/outils déjà faits, ou alors partir "from scratch" ? Je ne pense pas qu'il y ait de bonne ou mauvaise réponse à cette question, puisqu'on peut trouver des argumentsconvaincants dans les 2 sens.

Non

Après tout, un développeur aura bien plus souvent la tache de compléter ou corriger des sources existantes que de faire un projet à partir de rien. Il est donc important de savoir se plonger dans le code des autres, se l'approprier, et pouvoir en tirer quelque chose.

De même, si on veut faire avancer la recherche, il vaut mieux avoir connaissance de ce qui existe déjà pour pouvoir aller plus loin : si tout le monde passe tout son temps à réinventer la même chose, personne n'avance.

A noter qu'il peut parfois être plus difficile de partir d'un squelette de projet imposé que de tout refaire à zéro, et que ce n'est pas forcément une solution de facilité, mais peut au contraire être un bon exercice.

Il est aussi important de voir qu'une chose très souvent négligée en informatique est la lecture de code. Dans toutes les autres disciplines scientifiques, on lit ce qu'ont fait les autres, on apprend leur méthodologie, leur façon de raisonner, et se les approprie. En informatique, on est souvent laissé là, on développe son propre style de programmation dans son coin au gré des projets qui se présentent, et on prend trop peu souvent le temps de voir comment font les autres. Lire du code, c'est l'occasion d'apprendre de nouvelles façon de faire et de remettre en question son propre travail. Je l'ai appris bien trop tard, et je le regrette aujourd'hui (mais j'essai de me rattrapper) !

Oui

Pourquoi réinventer la roue plutôt que de se contenter de réutiliser ce qui existe ? Parce que c'est comme ça qu'on apprend, pardi ! En fait le métier de développeur va consister en partie en la réutilisation de choses existantes, mais aussi en une partie de conception, qui peut parfois prendre beaucoup de temps. Comment concevoir un algorithme rapidement si on n'en a jamais conçu ?

Se documenter sur ce qu'ont fait les autres avant nous, c'est bien, mais c'est facile. Essayer de faire par soi-même, c'est prendre le risque d'échouer, et on apprend souvent beaucoup plus par l'échec que par la réussite "sans accroc".

L'exemple que je citerai va concerner l'algorithme "MinMax". Il y a quelques années, j'ai voulu coder une IA pour un petit jeu de plateau tout simple. J'ai réfléchi un peu à la façon de faire, et je me suis dit que le plus simple serait si on pouvait "noter" le plateau de jeu en cours, lui donner une note. Si on arrive à faire ça, alors on peut, tout bêtement, tester toutes les combinaisons... Ok, ça donne une petite IA, mais un poil limité. Comment faire pour aller un cran plus loin et lui faire anticiper les coups un peu plus ? Facile, on applique le même principe pour "deviner" les coups probables de l'adversaire, et on choisit le premier coup qui mène à l'issue la moins dramatique possible ! Et oui, c'est en gros l'algorithme MinMax. Mon binôme Benoit (sur javaz) a eu exactement la même reflexion cet été pour un jeu qu'il a fait de son côté.

Bon, ok, c'est chouette, mais on peut faire mieux ? Oui, en réfléchissant on peut faire mieux, et supprimer plus rapidement les branches qui ne vont pas participer au résultat final. C'est le fameux élagage AlphaBeta de l'algorithme MinMax.

Tout ça pour dire qu'avec un peu de reflexion, on peut souvent arriver à un résultat équivalent, ou au moins proche, à ce qui existe. Certes, ça prend un peu de temps, mais on apprend beaucoup. Et c'est toujours très instructif de voir après-coup la différence entre la solution développée et les solutions existantes : pourquoi n'a-t-on pas pensé à telle ou telle optimisation, quel est l'intérêt de notre méthode par rapport à celle documentée (et vis versa) ?

Personnellement, je trouve ça beaucoup plus instructif que ce qu'avaient appris nos collègues à la fac à qui Benoit avaient expliqué son algo et qui avaient juste répondu "bah t'as rien inventé, c'est juste l'algo MinMax". C'est tout de même plus difficile de le concevoir que de l'appliquer bêtement après l'avoir appris...

Certes, mais encore ?

Pourquoi je raconte tout ça ? Vaste débat ^^ Comme souvent, la solution réside dans le compromis, et non dans les extrêmes. Il est important de savoir partir d'une page vierge et de créer, de penser par soi-même, mais si on veut pouvoir avancer suffisamment loin, il est tout aussi important de savoir utiliser ce qu'ont fait nos prédécesseurs (ou nos collègues). Si j'ai fait ce billet sans trop d'intérêt, c'est en fait parce que je suis tombé tout à l'heure sur une citation de Richard Feynman que j'ai trouvée très intéressante :

If you keep proving stuff that others have done, getting confidence, increasing the complexities of your solutions - for the fun of it - then one day you'll turn around and discover that nobody actually did that one! And that's the way to become a computer scientist.

Ca reflète pas mal ma façon de penser la chose. In fine, je ne pense pas être en désaccord tant que ça avec mes profs à la fac, et dans un cadre purement professionnel il est évident que je vais réutiliser ce qui a été fait beaucoup plus que je ne vais repartir de zéro... C'est juste que là, on est à la fac, on doit apprendre, et apprendre à concevoir est tout aussi important que savoir ce qui existe.

L'autre point, c'est l'ouverture d'esprit. Si on vous donne la solution à un problème, on peut avoir tendance à ne concevoir le problème que sous cet angle donné, et on se coupe potentiellement de solutions très différentes et potentiellement très efficaces. Partir d'une page blanche, c'est donc aussi se donner la possibilité d'explorer d'autres voies, et ce n'est pas à négliger.

Edit : je conclurai sur une autre citation : "There's a reason that it is called research, as in re-search."

20oct/100

Samsung Smart TV

Smart TV

Hier soir j'étais au Developer Day Samsung Smart TV, histoire de voir de quoi il en retourne... Et puis ils lançaient un concours avec des lots sympas, par la même occasion...

Je dois dire qu'à la base, j'étais assez sceptique sur la réalisation d'applications pour le TV. Non pas que ça me paraisse infaisable, mais juste qu'en général ce que j'ai pu voir dans ce domaine (j'inclus là-dedans les box des opérateurs) est assez limité... Bref, j'y allais sans conviction, mais en ne demandant qu'à être convaincu.

19oct/102

newsmap : affichage trié par importance

Petit billet qui sort un peu du cadre habituel, je suis tombé sur ce site l'autre jour et j'ai trouvé la façon de disposer l'information assez intéressante : newsmap

Ca correspond aussi au formattage que je souhaiterai faire pour une application PC d'ici quelques semaines/mois (en gros quand j'aurai le temps), donc j'ai pris la peine de regarder comment ils font pour découper l'espace en bloc de tailles variable, c'est plutôt simple et bien pensé.

(pour info, l'application que je voudrais faire est une application simple d'aide au ménage sur PC : on représente pour un dossier donné tous les sous-dossiers/fichiers par des rectangles de format variable selon leur taille, ce qui permet en fait de repérer très rapidement les dossiers/fichiers qui prennent le plus de place. Et du coup, pourquoi pas rajouter un filtre par date de dernier accès, histoire de repérer les fichiers "morts" ^^)