Anthony Jaguenaud a écrit 1967 commentaires

L’operateur [] sera pour la norme 2017.

Rajouter le & devant ne résout pas le problème car ça ne compile pas.

J’ai le choix entre mettre les pointeurs historiques, ou faire un my_ptr<MyInt> qui me garanti juste qu’on pointe sur quelque chose de valide.

J’avais pensé mettre un shared_ptr à la place du vector, mais je ne pense pas qu’on puisse ensuite pointer sur les éléments individuellement, ni y accéder via l’operator [].

J’ai essayé, mais ça ne compile pas… il semble que make_shared alloue de la mémoire et recopie l’objet dedans.

La boisson est le réussite universitaire sont lié, mais pas forcément dans le sens d’implication voulu par celui à qui tu réponds. De ce que j’ai pu voir de mon temps à la FAC, c’est que certains étudiants brillants travaillaient beaucoup, et quand ils décompressaient, ils allaient trop loin dans l’alcool entre autre. Mais je pense que c’est plus corrélé au stress induit qu’à l’intelligence.

Donc si on regarde les étudiants en réussite une parti boivent trop. Proportionnellement plus que les étudiants moins fort. En corrélant ça au stress plus qu’à la réussite, je pense qu’on aurait une meilleurs vision des choses… comme toujours, les stat c’est pratique pour dire ce qu’on veut ;-)

Ajout:
Et puis, ça a un côté rassurant quand on est alcoolique de se dire : « Ce n’est pas ma faute, je suis intelligent ».

Dans la même veine que Scratch : https://code.org/

J’ai aimé aussi https://lightbot.com/

Pour apprendre le python : https://codecombat.com/ j’ai trouvé ça rigolo mais trop répétitif. Sinon il y a aussi https://www.codecademy.com/fr

Je n’aime pas l’utilisation d’une macro pour plusieurs paramètres.

Même si c’est pas mal, on ne comprend pas tout de suite où sont les paramètres manquants, pire, si tu veux faire de la traduction et utiliser la syntaxe permettant de prendre le deuxième paramètre, puis le premier… tu risques d’avoir du mal à compter correctement.

Le C permet de faire des choses sympas, de manière souple, mais il ne faut pas oublier la relecture par un futur collègue, ou même par toi même quand tu reviens quelques mois plus tard. Si tu passes un quart d’heure à re-comprendre alors que tu l’aurais écrit en 5 minutes de plus (je suis large), tu perds du temps globalement.

En fait, c’est un problème d’interpréteur… en prenant le même code dans un fichier : linuxfr.hs

Prelude> :l linuxfr.hs
[1 of 1] Compiling Main             ( linuxfr.hs, interpreted )
Ok, modules loaded: Main.
*Main> f [1,2]
[0.3333333333333333,0.6666666666666666]
*Main> f [1..10]
[1.818181818181818e-2,3.636363636363636e-2,5.454545454545454e-2,7.272727272727272e-2,9.090909090909091e-2,0.10909090909090909,0.12727272727272726,0.14545454545454545,0.16363636363636364,0.18181818181818182]
*Main>

Quand je définie tout dans l’interpréteur ça ne marche pas… bon, ce n’est pas grave. Merci pour la démonstration.

Source :

g s l =  ((map (/s) l),sum l)

f l = let (res,s) = g s l in res

main = putStrLn $ show $ f [1,2]

Je n’arrive pas à reproduire ce que tu décris. J’ai fait mes tests dans l’interpréteur ghci :

Prelude> let g s l =  ((map (/s) l),sum l)
Prelude> let f l = let (res,s) = g s l in res
Prelude> f [1,2]
*** Exception: <<loop>>
Prelude> let r = f [1,2]
Prelude> l
*** Exception: <<loop>>

Par contre :

Prelude> let f l = let (res,s) = g (sum l) l in res
Prelude>  f [1,2]
[0.3333333333333333,0.6666666666666666]
Prelude>

Je me demande si ce n’est pas ton implémentation de g qui ferait que ça marche ?

Du coup ma solution ressemblerait plus à :

char padding[255] = { [0 ... 253] = '.', [254] = 0 }; /* ATTENTION ggc uniquement */
int align = 15;
char *str = "hello";
printf("%.*s%s\n",align-strlen(str),padding,str);

Merci :

• De m’avoir confirmé l’impossibilité ;
• De m’avoir donné un work arround.

Si je dis qu'une Porsche ça se trouve à partir de 50k (j'en sais rien), en quoi ça ferait rire (même jaune)?

Pour rester dans le ton de kantien tu devrais écrire : « Si je dis qu'une voitureça se trouve à partir de 50k » tu comprendrais mieux où il veut en venir.

Si les gens achètent des téléphones si cher, c’est parce qu’il les payent à crédit dans leur abonnement.

Vu la quantité de gibier, les chasseurs amènent du gibier d’élevage (ils appellent ça un lâché). Puis reviennent le lendemain. Le gibier, incapable de se nourrir seul va voir directement les humains pour avoir à manger. Hélas ils digèrent mal le plomb. Quand à l’intérêt, en tant que non chasseur, je ne vois pas.

Ça me rappelle un monsieur au marché qui est revenu voir le marchand pour lui dire : « Il y a de la terre sur vos radis… » C’est un problème d’éducation, comme le fait de consommer n’importe quel légume quelque soit la saison. Les gens sont habitués à des légumes sans goût en toute saison.

Depuis que j’ai mes enfants, j’ai redécouvert le goût de plein de légume, pour moi seul je ne m’embêtais pas à acheter des légumes chez un producteur local.

Ok, je comprends mieux.

J’aurais bien aimé quand même pouvoir interpréter du code C brut.

Je parle d’un programme portable, pas d’installation. Le programme en question se trouve ici. Il y a eu récemment (1 mois) ici même un journal ou une dépêche pour un programme similaire sous Windows. L’auteur, de ce que j’en ai compris, semblait dire qu’il insérait son programme dans la chaîne d’INPUT de windows… et il n’y a pas de popup de sécurité pour dire ATTENTION.

Sous windows au boulot, je lance une application qui me permet de taper du BÉPO à la place de l’AZERTY. Cette application s’insère dans la chaîne d’INPUT du clavier. Quelle différence avec X ?
Si n’importe quelle application peut faire ça, comment être sûr qu’aucune ne le fasse silencieusement pour m’espionner ?

Il s’agit, àmha, ni plus ni moins qu’un niveau de confiance entre l’utilisateur et l’application que ce dernier démarre. Suis-je à côté de la plaque ?

En lisant libgccjit, je me suis dis : « Super on va pouvoir intégrer du code directement en live. » Faille de sécurité garanti, mais plutôt rigolo à mettre en œuvre.

Donc j’ai chercher libgccjit tutorial ce qui m’amène à ce hello world. Le code est le suivant :

    /* Smoketest example for libgccjit.so
       Copyright (C) 2014-2016 Free Software Foundation, Inc.

    This file is part of GCC.

    GCC is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3, or (at your option)
    any later version.

    GCC is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with GCC; see the file COPYING3.  If not see
    <http://www.gnu.org/licenses/>.  */

    #include <libgccjit.h>

    #include <stdlib.h>
    #include <stdio.h>

    static void
    create_code (gcc_jit_context *ctxt)
    {
      /* Let's try to inject the equivalent of:
         void
         greet (const char *name)
         {
            printf ("hello %s\n", name);
         }
      */
      gcc_jit_type *void_type =
        gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID);
      gcc_jit_type *const_char_ptr_type =
        gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CONST_CHAR_PTR);
      gcc_jit_param *param_name =
        gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "name");
      gcc_jit_function *func =
        gcc_jit_context_new_function (ctxt, NULL,
                                      GCC_JIT_FUNCTION_EXPORTED,
                                      void_type,
                                      "greet",
                                      1, &param_name,
                                      0);

      gcc_jit_param *param_format =
        gcc_jit_context_new_param (ctxt, NULL, const_char_ptr_type, "format");
      gcc_jit_function *printf_func =
        gcc_jit_context_new_function (ctxt, NULL,
                      GCC_JIT_FUNCTION_IMPORTED,
                      gcc_jit_context_get_type (
                         ctxt, GCC_JIT_TYPE_INT),
                      "printf",
                      1, &param_format,
                      1);
      gcc_jit_rvalue *args[2];
      args[0] = gcc_jit_context_new_string_literal (ctxt, "hello %s\n");
      args[1] = gcc_jit_param_as_rvalue (param_name);

      gcc_jit_block *block = gcc_jit_function_new_block (func, NULL);

      gcc_jit_block_add_eval (
        block, NULL,
        gcc_jit_context_new_call (ctxt,
                                  NULL,
                                  printf_func,
                                  2, args));
      gcc_jit_block_end_with_void_return (block, NULL);
    }

    int
    main (int argc, char **argv)
    {
      gcc_jit_context *ctxt;
      gcc_jit_result *result;

      /* Get a "context" object for working with the library.  */
      ctxt = gcc_jit_context_acquire ();
      if (!ctxt)
        {
          fprintf (stderr, "NULL ctxt");
          exit (1);
        }

      /* Set some options on the context.
         Let's see the code being generated, in assembler form.  */
      gcc_jit_context_set_bool_option (
        ctxt,
        GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE,
        0);

      /* Populate the context.  */
      create_code (ctxt);

      /* Compile the code.  */
      result = gcc_jit_context_compile (ctxt);
      if (!result)
        {
          fprintf (stderr, "NULL result");
          exit (1);
        }

      /* Extract the generated code from "result".  */
      typedef void (*fn_type) (const char *);
      fn_type greet =
        (fn_type)gcc_jit_result_get_code (result, "greet");
      if (!greet)
        {
          fprintf (stderr, "NULL greet");
          exit (1);
        }

      /* Now call the generated function: */
      greet ("world");
      fflush (stdout);

      gcc_jit_context_release (ctxt);
      gcc_jit_result_release (result);
      return 0;
    }

Heu, je m’attendais plus à un truc contenant également l’interpréteur de source, un truc dans ce genre :

const char source = "int hello (void) { int rc; rc = printf(\"Hello World\"); return rc;}"

int test_fct()
{
  /* (...) */

  /* Populate the context.  */
  compile_code (ctxt, source);

  /* Compile the code.  */
  result = gcc_jit_context_compile (ctxt);
  /* Check error */

  /* Extract the generated code from "result".  */
  typedef int(*fn_type) (void);
  fn_type greet =
        (fn_type)gcc_jit_result_get_code (result, "greet");
  /* Check error */

  /* Now call the generated function: */
  rc = greet ();
  fflush (stdout);

  gcc_jit_context_release (ctxt);
  gcc_jit_result_release (result);
  return 0;
}

On donne une chaine de caractère de code C, et on récupère du code assemblé pouvant être exécuté directement.

J’ai surement raté un truc.

Tous les autres, en chemise, short, basket, ou tong… Des candidat au don d'organe.

Une fois, j’en ai croisé un en tee-shirt, short mais il avait une dorsale… je n’ai pas compris l’intérêt de finir les os a vif mais d’éviter la paralysie.

Non la majorité des gens sur les routes respectent en très grande partie le code de la route, mis à part la priorité aux piétons devant les passages piétons.

Non la majorité des gens sur les routes respectent en très grande partie le code de la route, mis à part quelques règles qu’ils ne jugent pas utiles.

Après, on râle sur certains comportements, mais il faut néanmoins relativisé. Sur un trajet de 30km avec 5km d’interfile, combien de voiture je double ? 1000, 2000.

Combien font des bêtises que je repère car directement concerné ? 3 sur la partie interfile, une dizaine si je compte ceux qui veulent sortir en doublant la file qui patiente déjà. Le pourcentage n’est pas si élevé et la route n’est pas le théâtre d’opération militaires que certains ici semble décrire.

Je m’auto répond, il y a une page « The Javascript Problem » sur le wiki haskell. Ça parle notamment de haste.

Quelqu’un aurait déjà utilisé et pourrait nous aider à comparer avec elm ?

Je me demande également, s’il ne serait pas possible de compiler du haskell en javascript ? On le fait bien avec du C++(voir la présentation).

J'ajoute que pour laisser la voiture te passer devant il suffit de lâcher les gaz, à 85km/h, ça freine tout seul; Par contre s'il avait une remorque…

Il ne me semble pas t’y avoir vu… j’ai l’impression que comme je suis motard c’est moi qui ai fait l’infraction, il faut trouver quelque chose !

C’est comme ce pauvre automobiliste un matin de décembre 2006 à qui j’ai défoncé la porte, le pauvre, il a changer de voie en moins 1s, ça lui a permis de ne pas rentrer dans la voiture le précédent puisqu’il n’avait pas remarqué sa file freinait. Bon ma moto a été morte, mais lui, je te rassure ne s’est même pas arrêté. Mais il avait raison, il n’était pas en moto.

Je crois que ça clos la discussion. Heureusement que mon assureur n’a pas le même ressentiment que toi, sinon j’aurais pu être en tort.

Non, il dit que chaque usagé voit midi à sa porte (piéton, cycliste, motard, automobiliste, poids lourd…)

On m’a reproché de faire patiné la roue arrière à 90km/h en accélérant puisque la rocade Bordelaise est limité à 90km/h. Voici la version longue :
Roulant entre 90 et 95 km/h compteur, je suis la file de gauche. À ma droite je double une voiture depuis environ 1 minutes roulant un tout petit peu moins vite que moi. Un peu devant nous, une voiture roulant aux alentour de 80km/h se fait rattraper. Mon voisin mets son clignotant à gauche, contrôle (probablement dans son rétroviseur) et ne me voit pas puisque la moto est moins longue et moins large qu’une voiture (je suis dans son angle mort). Il commence donc à changer de file. Ici j’ai trois choix :

• J’accélère, ce que j’ai fait cette fois ci => j’ai fait patiné ma roue mon accélération à donc été plus faible que prévu et j’ai dû dépasser la vitesse limite ;
• Je freine, la route étant grasse le risque de bloquer la roue avant et de finir en luge sur le bitume est non négligeable ; (en plus j’ai déjà fait)
• Je klaxonne, à coup sûr je me fait pourrir par l’automobiliste parce que je n’ai qu’à pas arriver comme un fou, il ne m’a pas vu donc j’arrivais au moins à 200km/h… (C’est aussi du vécu)

Les deux derniers sont du vécu en moto thermique.

Quand j’ai passé mon permis moto, on m’a expliqué que la première règle est de facilité la circulation des autres.

Je me souviens de la photo de code avec une voiture sur la voie d’accélération, ma voiture sur la voie de droite et personne sur la voie de gauche dans le rétroviseur :

• (a) Je dois me déporter pour laisser passer la voiture ?
• (b) Je peux me déporter pour laisser passer la voiture ?

Si vous avez répondu (b) vous avez faux, vous avez l’obligation de vous déportez. C’était une question du DVD de formation du code.

Je ne répondrais pas aux attaques ad hominem à l’auteur du journal qui se cache derrière un pseudo.

Tu devrais plutôt aller là. En préparant mon lien je découvre que tu l’as fait.

Tu peux reprendre le paragraphe sur la baterie ? Je ne sais pas trop comment l’exprimer, mais ce qui est écrit est faux :

et qu’il ne faut pas la laisser débrancher par temps trop froid pour ne pas détériorer la batterie. En gros exit la moto s’il doit faire -5°C toute la journée, heureusement ce n’est pas courant par ici.

Soit tu rayes et tu mets un lien vers mon commentaire au-dessus :

et qu’il ne faut pas la laisser débrancher par temps trop froid pour ne pas détériorer la batterie. En gros exit la moto s’il doit faire -5°C toute la journée, heureusement ce n’est pas courant par ici. L’auteur du journal vous laisse interpréter la page correspondante de la notice cité ici.

Si l'orange signifiait simplement "attention, tu peux passer mais dans 10 secondes le feu passe au rouge" (10 et non 3, qu'on puisse ralentir sans piler), peut-être serait-ce préférable.

Sauf que dans les faits, quand c’était comme ça 1980-1990, dès que le feu passait à l’orange tout le monde accélérait pour essayer de passer avant le rouge… celui qui se ratait ne pouvait de toute façon pas s’arrêtait puisque à pleine vitesse. Cette règle a apaisé pas mal les choses. Et tu as le droit de passer à l’orange si tu ne pouvait pas t’arrêter en sécurité.