GaMa a écrit 447 commentaires

Bon, beaucoup de points ont déjà été abordé dans d'autres commentaires mais comme c'est ma vie, je les reprend en parti.

Comme toi (et beaucoup d'autres, vu les commentaires), j'ai longtemps voulu contribuer à des projets libres.

Au niveau code, j'ai trouvé ça très compliqué. La plupart du temps, quand j'aurai pu contribuer ça aurai été "seulement" pour des corrections de bugs. Et il faut être honnête: le temps nécessaire à investir (comprendre le code, le corriger, soumettre un patch, se faire jeter, soumettre un nouveau patch, …) est en général bien trop long pour ce que ça rapporte. Il faut vraiment être intéressé (comprendre: avoir besoin) pour le faire jusqu'au bout.

Par contre, j'ai pas mal contribué au projet Fedora en tant qu'ambassadeur. C'est probablement dans ce genre de contribution qu'il est le plus facile de rentrer. La plupart des projets sont fait par des développeurs (qui le font en général pour eux). Tous les "à coté" des projets (doc, site web, com) manquent souvent de gens de bonne volonté.

De manière générale, contribuer pour contribuer ne mène à rien : au début on est plein de bonne volonté, puis on se lasse et comme on ne le fait pas pour répondre à un besoin, on passe à autre chose. Et comme le temps d'entré dans un projet est relativement long, on se retrouve à (avoir l'impression de) rien faire.
Ça déjà été dit mais c'est à mon sens le plus important : Il faut avoir un besoin, sinon tu ne continuera pas.

J'ai eu pas mal d'idée de projet intéressant à démarrer. Mais ils étaient plus sur le mode "ça serait cool de faire ça" que "j'ai besoin de ça". Ça n'a donc jamais abouti. Ma planche de salut a été le projet devparrot (il est ici l'appel à contribution :) ). Pour faire rapide (c'est la première fois que j'en parle, soyez gentils):

• Je l'utilise!! (et c'est probablement le seul point qui fait que je code encore dessus)
• C'est un éditeur de texte (qui veut devenir un ide) écrit en python/tk.
• Je travaille seul dessus depuis environ 1 an et demi.
• Le code est encore jeune (certain diront trop) et pas trop gros (60 fichiers/4000 lignes) . Il devait pas trop être compliqué de rentrer dedans (j'espère)
• Je suis le seul à l'utilisé et c'est la première fois que j'en parle. Il y a donc … aucune doc, des bugs que j'évite inconsciemment. C'est la grosse lacune du projet. J'y travaille, je suis en pleine stabilisation du code et j'ai récemment créé un compte chez tuxfamily qu'il faut que je le remplisse. Dans une semaine il devrait y avoir qqchose.
• Il y a plein de chose à faire:
  • de la doc
  • du debug
  • de la petite fonctionnalité (dans le core ou sous forme de plugin)
  • de la grosse fonctionnalité
• C'est du "eat your own dog food". Une fois qu'ont est dedans c'est extrêmement motivant de coder des fonctionnalités améliorant l'outil qui sert à coder.
• Je suis sympa (oui, oui :)), c'est avec plaisir que je te mettrait le pied à l'étrier pour accepter tes contributions.

Matthieu Gautier|irc:starmad

Je ne connaissais pas ce terme mais je comprend ce qu'il veut dire, m'en vais donc te l'expliquer (enfin, je vais essayer)

Prenons l'exemple du lisp (que j'ai appris à l'école et que je n'ai pas touché depuis, il peut y avoir des fautes).

En lisp tout ce représente par des listes. Un liste pouvant contenir des atomes (entier,…) ou d'autre listes. Ainsi

(1 2 3 4)

représente une liste d'entier et

((1 2) (3 4))

représente une liste de liste d'entier (jusque là rien de compliqué)

Là où ça se corse (ça devient intéressant) c'est que le programme
s’écrit aussi avec des listes (Homoiconicité):

(+ 1 2 3 4)

représente la somme des 4 entiers.

Ainsi on a : "la principale représentation des programmes est aussi une structure de données d'un type primitif du langage." Tada!!!

Ça permet d'écrire des programmes qui manipulent leur propre code comme si c'était des données (car c'est des données)

(defun operate (operators index arg1 arg2)
   ( (nth index operators) arg1 arg2 )
)
(operate (list + - / *) 0 3 4) # => (+ 3 4) => 7
(operate (list + - / *) 2 12 4) # => (/ 12 4) => 3
(operate (list min max) 1 12 4) # => (max 12 4) => 12

en c on serait obligé de passer par des (tableaux de) pointeurs de fonction. C'est jouable pour un cas d'école comme celui-ci, mais tout l’intérêt du lisp est justement de l'utiliser pour des cas qui ne sont pas évident.

Matthieu Gautier|irc:starmad

je comprends pas pourquoi tant de gens dans Gnome qui utilisent ça.

Par que gobject est une horreur (enfin de mon point de vu) et que Vala permet de faire de la POO compatible gobject mais avec un vrai langage orienté objet ?

Matthieu Gautier|irc:starmad

C'est déjà le cas avec gnome2 et ce depuis … très longtemps :

• «Ctrl» + «Alt» + «Gauche/Droite» pour passer au bureau d'à coté.
• «Ctrl» + «Alt» + «Shift» + «Gauche/Droite» pour passer au bureau d'à coté en «emportant» la fenêtre actuelle avec soi.

(Et c'est très pratique)

Matthieu Gautier|irc:starmad

Sauf qu'un utilisateur lambda, il ne sait pas ce qu'il cherche donc du coup, c'est beaucoup plus difficile… Essaye de virer l'icone de Firefox (enfin la navigateur que la personne a l'habitude d'utiliser) d'un bureau Windows et regarde le galérer…

C'est pour ça que les appli s'appellent Web, Fichier, Document, Mail, …

Matthieu Gautier|irc:starmad

Et si le mec en face il fait la même chose, vous faites comment pour entrer en contact ?

Matthieu Gautier|irc:starmad

Elle consiste à lancer une application graphique sur un serveur et y accéder depuis un client

En fait techniquement (pour X), c'est l'inverse. Lorsque tu lances une appli sur une machine distante et que l'affichage ce fait sur ton ordi alors:
- C'est l'appli distante (sur un serveur ssh) qui est le client (X)
- Le serveur X est sur ta machine locale et c'est l'appli qui se connecte dessus.

Le serveur graphique à utiliser est donné dans la variable d'environnement DISPLAY:

$ echo $DISPLAY
:0.0

Il est possible de spécifier un autre serveur X et de lancer un xterm local qui s'affiche une autre machine:

$ export DISPLAY=<adresse.ip.machine.distante>:0.0
$ xterm

Il faut par contre que le serveur X distant soit configuré pour accepter les applis distantes.
La solution la plus simple historique est de faire un "xhost + [ip acceptée]". (Par contre ça ouvre de grosses failles de sécu. À utiliser avec parcimonie)

Le ssh -X ne fait que rendre tous ça transparent.

Il est aussi possible de lancer d'autres serveurs X locaux "emboités" (? nested en anglais) (xnest, xserver-xephyr)

Matthieu Gautier|irc:starmad

Mais c'est énorme !!!!!

Comment je vais faire pour bosser aujourd'hui (et le reste de la semaine) ?

Matthieu Gautier|irc:starmad

A ouai, en fait vous avez aucun humour dès que c'est un peu sexuel, c'est ça ?

(Et qu'on ne me parle pas de sexisme, je ne vois pas pourquoi les filles devraient être plus choquées que les garçon, ou inversement)

La prochaine fois, je ne m'excuserai pas. Na!

Matthieu Gautier|irc:starmad

Bon c'est plus pour le fun la rigolade qu'autre chose, mais je l'ai fait avec un tableau circulaire.

Je ne suis pas sur que ça sois plus performant …

#include <string.h>


#define readMask            0b00110000
#define readOverflowMask    0b10111111
#define writeMask           0b00000011
#define writeOverflowMask   0b11110011

#define dataPresentMask     0b10000000

#define GET_READ(X)  (((X)&readMask)>>4)
#define INC_READ(X)  (((X)+(1<<4))&readOverflowMask)

#define GET_WRITE(X)  ((X)&writeMask)
#define INC_WRITE(X)  (((X)+1)&writeOverflowMask)

/* Pas taper, c'est pas moi qui ai choisi le nom */
typedef struct s_small_dick { /* /o\ */
    unsigned char index;
    char data[4];
} SmallFifo;

void sf_init(SmallFifo * f)
{
    if (f == NULL) return;
    f->index=0;
    memset(f->data, 0, 4);
    return;
}

void sf_push(SmallFifo * f, unsigned char b)
{
    if(f==NULL) return;
    /* C'est une FIFO qui, si elle est pleine, éliminent les valeurs les plus
     * anciennes (pas conseillé pour la retraite ^^).
     * On increment avant. C'est utile au moment du read, on incremente avant et on a pas besoin de stoker la valeur de retour dans une variable temporaire.
     */

    if ( f->index&dataPresentMask && (f->index&writeMask)==((f->index&readMask)>>4) )
    {
        /* On est en train de boucler en écriture et on efface les anciennes valeures.
         * On avance aussi le readIndex
         */
         f->index = INC_READ(f->index);
    }

    f->index = INC_WRITE(f->index)|dataPresentMask;


    f->data[GET_WRITE(f->index)] = b;

}

unsigned char sf_pop(SmallFifo * f)
{
    if(f==NULL) return 0x00;
    f->index = INC_READ(f->index);
    if ( GET_WRITE(f->index) == GET_READ(f->index) )
        /* si on a "ratraper" le writeIndex, il n'y a plus de donnée */
        f->index &= ~dataPresentMask;
    return f->data[GET_READ(f->index)];
}

unsigned char sf_has_data(SmallFifo * f)
{
    if(f==NULL) return 0x00;
    if( f->index&dataPresentMask ) return 0xEB;
    return 0x00;
}

int main(int argc, char ** argv)
{
    SmallFifo ma_fifo;
    char des_valeurs[]="abcdefghijklmnopqrstuvwxyz";
    int i=0; /* un compteur */

    sf_init(&ma_fifo);

    for(i=0;i<4;i++) {
        sf_push(&ma_fifo, des_valeurs[i]);
    }

    while(sf_has_data(&ma_fifo)) {
        printf("%c ", sf_pop(&ma_fifo));
    }
    printf("\n");

    for(i=0;i<26;i++) {
        sf_push(&ma_fifo, des_valeurs[i]);
    }

    while(sf_has_data(&ma_fifo)) {
        printf("%c ", sf_pop(&ma_fifo));
    }
    printf("\n");

    return 0;
}

Matthieu Gautier|irc:starmad

Si il n'y avait que ça…

Mais bon, je me suis déjà excusé par avance.

Matthieu Gautier|irc:starmad

Ouai, enfin à ce moment là, t'es en train de manipuler des entiers 32 bits avec un proc 8 bits. Tu gagnes peut-être en mémoire mais ça coute cher derrière au niveau proc. (Surtout que tu as l'air de vouloir faire ça rapidement, au regard d'un de tes autres commentaires)

Et puis ma première solution tient toujours :P

Matthieu Gautier|irc:starmad

Si tu veux jouer à ça :

• Si tu te limite à un queue de 4(8) chars, tes index tiennent sur 2(3) bites. Au total tu as 4(6) bites utilisées. C'est bien moins que ton "unsigned char count" pour compter jusqu'à 4.
• Quand on sait que, en général, tes structures sont alignées sur 32 bites (voir 64 sur les porcs boostés aux hormones), tu as de l'espace à remplir, tu peux avoir quelque bites de plus.

Pardon aux familles …

Matthieu Gautier|irc:starmad

De mon avis d'un mec (je m’appellerai pas expert) qui a bossé dans le monde du jeux vidéo et qui a fait des jeux pas du tout libre pour console…

J'aurai beaucoup plus de facilité à refaire un deuxième Warsow si j'avais les assets libres mais pas le code. Avoir le code mais pas les assets m'est plus difficile (et pas qu'un peu)

Avec l'expérience que j'en ai, je peux te dire que le dev brut du moteur, c'est pas grand chose (enfin, c'est pas si important). Il y a le code pour afficher de la jolie 3D, mais il y a aussi :

• Le graphisme (les meshes, les textures, les anims)
• Le son (musique, fx)
• Le gameplay
• Le gamedesign
• Le leveldesign
• L'IA

Au final, le code vaut pas pour grand chose. Je dirai que le ratio dev/graphiste dans une équipe dépasse rarement 0.5. On peut voir sur le wiki de Warsow: 6 personnes qui touchent du code, 12 pour le reste (et je compte pas la partie site web)

D’ailleurs les mecs de Warsow ne s'y sont pas trompé : Il ne veulent pas de fork, ils ont verrouillé les ressources, pas le code.

Freedoom est un clone du moteur de doom, pas de doom au complet.

Matthieu Gautier|irc:starmad

Justement, Firefox.
La Fondation Mozilla essaie de protéger la marque Firefox. C'est tout.
J'ai accès au code source, j'ai accès aux assets. Si demain j'ai une super idée, je peut modifier le code (sans toucher aux assets). Je diffuse le patch. Si le patch est plébiscité par plein de monde et Mozilla n'en veut pas, je peux forker. Je peux pas dire que c'est Firefox, je peux par reprendre le logo, mais je peux reprendre l'ensemble du projet et le redistribuer. Je ne suis pas (et l'ensemble des utilisateurs non plus) dépendant du bon vouloir de la MoFo. Le jour où la MoFo commence à faire de la merde, je la vire, je me retrouve avec plein de boulot en plus parce que je me retrouve responsable d'un navigateur web, mais je peux la virer.

Pour Warsow, c'est différent. J'ai une super idée de gameplay, je patch le moteur de jeu et je diffuse le patch. Si le patch est plébiscité par plein de monde et Warsow n'en veut pas, je fait comment ? Je peux forker ?

On aurait une licence non-libre (non modifications) pour les artworks mais qui autorise quand même leur utilisation dans un fork, alors oui ça serait "dans l'esprit du libre".

En l'état les joueurs sont dépendant du bon vouloir de Warsow. Le jour où ils commencent à faire de la merde, ben… t'es dedans avec eux. C'est pas libre et c'est pas dans l'esprit du libre.

Que Warsow ne soit pas libre, c'est pas grave. J'ai joué à Warsow et il est très bien. Je joue à d'autres jeux qui ne sont pas du tous libre et je l'accepte. Mais Warsow n'est pas dans l'esprit du libre.

Matthieu Gautier|irc:starmad

Pour les options j'utiliserais plutôt un truc de ce style:

def append_one(*args, **kwords):
    a = kwords.get("a", list())
    a.append(1)
    return a

append_one(a=[1, 2, 3])
append_one()
append_one(a = None) # raise AttributeError: 'NoneType' object has no attribute 'append'

Matthieu Gautier|irc:starmad

J'ai dit lambda mais c'est exactement la même chose avec les fonction

i = 1

def f1():
    return i

def f2(i=i):
    return i

print f1() #1
print f2() #1

i=2

print f1() #2
print f2() #1

def create_mult_functions_bad(coefs):
    ret = []
    for coef if coefs:
        def f(val):
            return val*coef
    return ret

def create_mult_functions(coefs):
    ret = []
    for coef if coefs:
        def f(val, coef=coef):
            return val*coef
    return ret

mult1, mult2, mult3 = create_mult_functions_bad([1,2,3])

print mult1(1) # 3
print mult2(1) # 3
print mult3(1) # 3

mult1, mult2, mult3 = create_mult_functions([1,2,3])

print mult1(1) # 1
print mult2(1) # 2
print mult3(1) # 3

Matthieu Gautier|irc:starmad

C'est même extrêmement important à comprendre au sujet des lambda :

i = 1

# i est résolu dans l'espace de nommage courant
lambda1 = lambda : i

# i est résolu une fois à la création de la lambda et c'est ensuite le i "local" qui est résolu à l'execution
lambda2 = lambda i=i: i

print "lambda1:",lambda1() # 1 (i global)
print "lambda2:",lambda2() # 1 (i à la création)

i = 2

print "lambda1:",lambda1() # 2 
print "lambda2:",lambda2() # 1

Et en beaucoup plus vicieux :

def create_mult_functions_bad(coefs):
    # toutes les lambda utilisent le même coef.
    # il est résolu a l’exécution des lambda. À ce moment là coef == coefs[-1]
    return [lambda val : val*coef for coef in coefs]

def create_mult_functions(coefs):
    # coef est résolu à la création de la lamdba
    return [lambda val, coef=coef: val*coef for coef in coefs]

mult1, mult2, mult3 = create_mult_functions_bad([1,2,3])

print mult1(1) # 3
print mult2(1) # 3
print mult3(1) # 3



mult1, mult2, mult3 = create_mult_functions([1,2,3])

print mult1(1) # 1
print mult2(1) # 2
print mult3(1) # 3

Matthieu Gautier|irc:starmad

Attention, c'est avec la version de ce commentaire

Avec la version d'origine, je suis entièrement d'accord, je me prend un rapport 5. Les commentaires se sont croisés entre les threads.

Tu as raison, le générateur coute cher (bien plus que je pensait). Mais la correction est pas compliquée.

J'ai pas parlé de faire quelque chose de stupide. Mais au final ta fonction peut très bien se retrouver appeler très souvent avec un int. C'est le risque de se genre de chose; ca s'empile et au fil du temps ca pèse lourd. Tu retrouves énormément cette construction en JS ou tu peux passer soit une liste soit un objet unique.

Oui, mais là tu perds un quart de second pour 100000 appels.

• Soit tu peux pas faire un appel groupé. Ça sous-entend que c'est du cas par cas (interactif, serveur) et ça reste probablement négligeable.
• soit tu peux faire un appel groupé et c'est que c'est mal codé.

Dans tous les cas, quand tu vas faire de l'optimisation (et donc du profiling) tu vas vite te rendre compte qu'il faut soit appeler "do" au lieu de "function", soit faire du traitement par lot (utiliser la fonction comme il faut).

(Mea culpa pour les commentaires un peu sec, un fois relus chez moi au calme ça passe moins bien qu'entre deux compiles qui passent pas)

Matthieu Gautier|irc:starmad

Maintenant que tu as ton code. Tu changes do pour virer le print et le break à 10 pour consommer toute la liste. Et tu appelles function avec range(10000000).

Tu ajoutes function2 qui ne fait que do(input) sans vérification de type. Tu peux constater que tu as un facteur 2 entre les deux versions.

Avec la fonction du commentaire https://linuxfr.org/nodes/94784/comments/1367242

def do(it):
   for i in it:
      pass

print timeit.timeit("function(xrange(10000000))", "from __main__ import function", number=100)
# 21.3466279507
print timeit.timeit("do(xrange(10000000))", "from __main__ import do", number=100)
# 21.0114998817

Maintenant tu remodifies ton code pour faire une boucle dans laquelle tu appelles function avec 1 en paramètre puis ensuite function2 avec [1]. La maintenant tu as plus d'un facteur 4.

print timeit.timeit("function(1)", "from __main__ import function", number=100000)
#0.276041984558
print timeit.timeit("do([1])", "from __main__ import do", number=100000)
#0.033077955246
print timeit.timeit("function(xrange(100000))", "from __main__ import function", number=1)
#0.00220608711243

Rien à dire. Sauf que le premier qui m'appelle 100000 fois function avec un simple objet au lieu de m'appeler une fois function avec une liste de 100000 objets alors que function est prévu pour prendre un itérable, je l'envoie chier en lui conseillant de prendre des cours de dev.

L'optimisation ça se fait, quand ça marche, quand c'est nécessaire et là où c'est nécessaire.

Matthieu Gautier|irc:starmad

Pardon, abus de langage de ma part, remplacez liste par itérable. Le problème reste le même.

Matthieu Gautier|irc:starmad

Je te rappelle l'énoncé du problème:

On est clairement dans le cas « Ah wé mais merde, les mecs me passent aussi un singleton et pas une liste en paramètre, aller, ça va passer quand même… ».
Généralement, c'est aussi pour se simplifier la vie et pouvoir appeler du foo(toto) au lieu de foo([toto]).

Soit on fait du vrai duck-typing, et donc on arrête de se limiter qu'au list et tuple et on prend aussi du seq, du generator et tout ce qui est itérable. Et je met au défi quiconque ici de me donner le code python qui permettra de faire ça :þ

La fonction, à la base, elle prend une liste, pas n'importe nawak.

Je te repose la question, tu fais comment avec du polymorphisme adhoc ?

Matthieu Gautier|irc:starmad

Ok,

def function(input):
    """
    Take an input that may be a iterable or not.
    """

    iterable = input
    try:
        (x for x in input)
    except TypeError:
        iterable = (input, )
    else:
        """ it is an iterable, maybe it is a string """
        if isinstance(input, basestring):
            """ basestring is the only particular case as it is also an iterable"""
            iterable = (input, )
    do(iterable)

Et maintenant ?

On peut faire la conso mémoire, le coût du isinstance et de l'exception aussi si tu veux. Surcout de la version avec polymorphisme adhoc: 0%.
Tu fais comment avec du polymorphisme à 0% de surcout ?

Pour le cout de l'exception, ça dépend surtout de la proba que tu passes un itérable ou pas. Si c'est principalement des itérables, ton exception occasionnelle ne coute pas bien chère face à un if que tu fais tout le temps (http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Initializing_Dictionary_Elements)

Quant au isinstance, effectivement, j'ai pas d'autre solution qui limiter le test au cas où on sait que l'on a déjà un itérable.

Matthieu Gautier|irc:starmad

http://pastebin.com/xteDw182

Et là vous comprenez la différence entre generator expression et list comprehension ?

Matthieu Gautier|irc:starmad

Sauf que function ne parcourt pas l'iterable, donc ça se trouve on l'itère jamais.

Matthieu Gautier|irc:starmad