GaMa a écrit 446 commentaires

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

Et j'ai pas demander de faire une boucle sur un iterable, juste de tester si ça l'est (principe du duck-typing)

Je te cite, tu veux savoir si c'est iterable avant de le faire.
Et je me répète, la syntaxe "(x for x in iterable)" ne parcourt pas iterable. Ça crée un générateur qui parcourra iterable quand on itèrera le générateur.

Raté, c'est pas mon code, mais le code d'exemple que j'ai donné est issu de très grosses librairies python mondialement utilisées. Rhodecode, DJango, Pylon, et même la lib standard Python si mes souvenirs sont exacts !!!…

Si des softs sont mal codé, c'est la faute au dev, pas du langage et son de typage dynamique.

Matthieu Gautier|irc:starmad