anaseto a écrit 2229 commentaires

  • [^] # Re: bitcoin

    Posté par  . En réponse au journal Solution au conflit de la ZAD de Notre-Dame-des-Landes. Évalué à 5.

    Le monde actuel, ça n'est pas un paradis, mais c'est probablement le monde le plus sûr, en moyenne, que l'humanité n'ait jamais connu.

    Honnêtement, au niveau mondial ce n'est pas exact (source) : la période 1950-2000, c'est de l'ordre des taux de morts dans les siècles 1400-1600, malgré l'explosion démographique énorme à certains endroits qui contribue grandement à faire diminuer les taux. Et le graphique en question s'arrête en 2000 et ne compte pas les cinq ou six millions de morts de la guerre du Congo.

    Si on veut vraiment voir le côté positif, c'est que ça pourrait être encore pire, car au moins aujourd'hui il y a moins de morts du fait de famines et maladies, grâce aux avancées technologiques — par exemple, des déplacements de populations de plusieurs millions de personnes, comme pour la Syrie, auraient été probablement accompagnés de plus de famines et maladies il y a quelques centaines d'années.

  • [^] # Re: Testé tous les jeux :)

    Posté par  . En réponse au journal Gamedev Framework 0.7.0 et 0.8.0. Évalué à 3. Dernière modification le 25 avril 2018 à 12:16.

    Je ne savais pas que sur certains systèmes, cette fonctionnalité étaient absente.

    La plupart des OS passent par procfs, mais pas tous, d'autres ont un syscall. Sur OpenBSD il n'y a ni l'un ni l'autre, même si il y a un moyen détourné d'y arriver : par exemple en Go ils récupèrent le dossier courant en début d'exécution, puis déduisent ensuite le chemin de l'exécutable à partir du premier argument du programme et suivant les cas déterminent s'il faut aller jusqu'à chercher dans $PATH (juste le nom de la commande, auquel cas c'est plus forcément fiable si l'environnement a changé) ou non (chemin complet ou relatif, auquel cas c'est fiable).

  • [^] # Re: Tant que tout va bien

    Posté par  . En réponse au journal Solution au conflit de la ZAD de Notre-Dame-des-Landes. Évalué à 0.

    Les millénaires passés n'ont accouchés d'aucune grandes communautés sans tout le fourbi social : loi, taxes, etc. Je ne trouve pas que c'est de la spéculation.

    Un peu, au sens, ça n'a pas été testé à grande échelle depuis la révolution industrielle, du coup on ne sait pas si dans le monde actuel ça peut marcher, mais avant on peut considérer que les communautés agricoles étaient des tests décentralisés à échelle assez grande, même si dans les leçons d'Histoire on parle surtout des grands faits et gestes politiques des rois et seigneurs. Les lois, taxes, etc. ont souvent eu du mal à s'imposer et ça ne s'est pas toujours fait dans la douceur, car les paysans étaient attachés à leur vie collective. Il a fallu des siècles pour réussir à détruire les dernières communautés agricoles, leur faire payer des taxes, leur enlever le pouvoir de justice et, enfin, leur imposer la propriété privée (la révolution en France, par exemple). Peut-être que c'est l'évolution naturelle des civilisations humaines, mais la société individualiste actuelle est un phénomène relativement récent, donc conclure sur la base de deux-trois siècles, c'est pas évident, surtout avec la mondialisation actuelle qui fait un peu effet boule de neige et rend difficile la construction d'une société différente au sein du système globalisé.

    J'ai vaguement en mémoire qu'à partir du moment où chaque personne ne connais pas plus de 66 % des individus de la communauté, les violences sont inévitables s'il n'y a pas une sorte d'autorité pour gérer cet aspect.

    Organisation décentralisée collective ne veut pas dire absence d'autorité, juste absence d'autorité administrative centralisée.

  • [^] # Re: Testé tous les jeux :)

    Posté par  . En réponse au journal Gamedev Framework 0.7.0 et 0.8.0. Évalué à 2.

    Moi ce qui me chagrine là dedans, c'est le vide après «Base path». Mais bon, sur un système Unix, ce n'est pas très grave.

    Sur OpenBSD il n'est en effet pas possible d'avoir accès au répertoire du binaire exécuté, du coup en général les packageurs patchent si nécessaire avec un chemin en dur.

  • [^] # Re: Testé tous les jeux :)

    Posté par  . En réponse au journal Gamedev Framework 0.7.0 et 0.8.0. Évalué à 3.

    Et je suis très satisfait de savoir que sous OpenBSD, ça compile et ça fonctionne correctement.

    Ça m'encourage aussi à penser qu'il y a probablement pas trop de bugs du genre buffer overflow — des logiciels qui tournent “normalement” sous Linux ont tendance à faire segfault sous OpenBSD du fait des protections mémoire du noyau (c'est le genre de trucs qui m'arrive parfois, par exemple à un moment une version d'inkscape était inutilisable sous OpenBSD).

    Et voilà le gf_info !

    Le seul truc qui m'a fait bugguer, c'est le Platform: Linux, mais j'ai découvert qu'en fait c'est normal :

    modify SDL_GetPlatform to pretend we are Linux which allows FNA based games to run before the upstreamed change trickles down to released games

    gf 0.8.0
    
    Dependencies:
    - Boost: 1.66.0
    - SDL: 2.0.8 [2.0.8]
    - Freetype: 2.8.1 [2.8.1]
    
    System:
    - Platform: Linux
    - CPU count: 2
    - RAM size: 3752 MiB
    - Cache line size: 64 kiB
    
    Paths:
    - Current path: /home/anaseto/local/bin
    - Base path: 
    - Temporary directory: /tmp
    
    Monitors (1):
    - Monitor '22M35 22"':
        Physical size: 1920x1080
        Position: 0x0
        Modes (19):
            1920x1080 | 24 bpp | 60 Hz
            1680x1050 | 24 bpp | 60 Hz
            1600x900 | 24 bpp | 60 Hz
            1440x900 | 24 bpp | 60 Hz
            1400x1050 | 24 bpp | 60 Hz
            1280x1024 | 24 bpp | 75 Hz
            1280x1024 | 24 bpp | 60 Hz
            1280x800 | 24 bpp | 60 Hz
            1280x720 | 24 bpp | 60 Hz
            1152x864 | 24 bpp | 75 Hz
            1024x768 | 24 bpp | 75 Hz
            1024x768 | 24 bpp | 60 Hz
            832x624 | 24 bpp | 75 Hz
            800x600 | 24 bpp | 75 Hz
            800x600 | 24 bpp | 60 Hz
            800x600 | 24 bpp | 56 Hz
            720x400 | 24 bpp | 70 Hz
            640x480 | 24 bpp | 75 Hz
            640x480 | 24 bpp | 60 Hz
        Current mode: 1920x1080 | 24 bpp | 60 Hz
    
    GL:
    - Vendor: Intel Open Source Technology Center
    - Renderer: Mesa DRI Intel(R) Haswell Desktop 
    - Version: OpenGL ES 3.1 Mesa 13.0.6
    - Shading language version: OpenGL ES GLSL ES 3.10
    - Extensions (84):
        GL_ANGLE_texture_compression_dxt3 GL_ANGLE_texture_compression_dxt5 GL_APPLE_texture_max_level 
        GL_EXT_blend_func_extended GL_EXT_blend_minmax GL_EXT_buffer_storage 
        GL_EXT_clip_cull_distance GL_EXT_color_buffer_float GL_EXT_discard_framebuffer 
        GL_EXT_draw_buffers GL_EXT_draw_buffers_indexed GL_EXT_draw_elements_base_vertex 
        GL_EXT_gpu_shader5 GL_EXT_map_buffer_range GL_EXT_multi_draw_arrays 
        GL_EXT_polygon_offset_clamp GL_EXT_primitive_bounding_box GL_EXT_read_format_bgra 
        GL_EXT_separate_shader_objects GL_EXT_shader_integer_mix GL_EXT_shader_io_blocks 
        GL_EXT_shader_samples_identical GL_EXT_tessellation_point_size GL_EXT_tessellation_shader 
        GL_EXT_texture_border_clamp GL_EXT_texture_buffer GL_EXT_texture_compression_dxt1 
        GL_EXT_texture_filter_anisotropic GL_EXT_texture_format_BGRA8888 GL_EXT_texture_rg 
        GL_EXT_texture_sRGB_decode GL_EXT_texture_type_2_10_10_10_REV GL_EXT_unpack_subimage 
        GL_INTEL_performance_query GL_KHR_blend_equation_advanced GL_KHR_context_flush_control 
        GL_KHR_debug GL_KHR_robust_buffer_access_behavior GL_KHR_robustness 
        GL_MESA_shader_integer_functions GL_NV_draw_buffers GL_NV_fbo_color_attachments 
        GL_NV_read_buffer GL_NV_read_depth GL_NV_read_depth_stencil 
        GL_NV_read_stencil GL_OES_EGL_image GL_OES_EGL_image_external 
        GL_OES_EGL_sync GL_OES_compressed_ETC1_RGB8_texture GL_OES_depth24 
        GL_OES_depth_texture GL_OES_depth_texture_cube_map GL_OES_draw_buffers_indexed 
        GL_OES_draw_elements_base_vertex GL_OES_element_index_uint GL_OES_fbo_render_mipmap 
        GL_OES_get_program_binary GL_OES_gpu_shader5 GL_OES_mapbuffer 
        GL_OES_packed_depth_stencil GL_OES_primitive_bounding_box GL_OES_rgb8_rgba8 
        GL_OES_sample_shading GL_OES_sample_variables GL_OES_shader_image_atomic 
        GL_OES_shader_io_blocks GL_OES_shader_multisample_interpolation GL_OES_standard_derivatives 
        GL_OES_stencil8 GL_OES_surfaceless_context GL_OES_tessellation_point_size 
        GL_OES_tessellation_shader GL_OES_texture_3D GL_OES_texture_border_clamp 
        GL_OES_texture_buffer GL_OES_texture_float GL_OES_texture_float_linear 
        GL_OES_texture_half_float GL_OES_texture_half_float_linear GL_OES_texture_npot 
        GL_OES_texture_stencil8 GL_OES_texture_storage_multisample_2d_array GL_OES_vertex_array_object 
    - Compressed texture formats (15):
        GL_COMPRESSED_RGB_S3TC_DXT1_EXT (0x83F0)
        GL_COMPRESSED_RGBA_S3TC_DXT1_EXT (0x83F1)
        GL_COMPRESSED_RGBA_S3TC_DXT3_EXT (0x83F2)
        GL_COMPRESSED_RGBA_S3TC_DXT5_EXT (0x83F3)
        ETC1_RGB8_OES (0x8D64)
        COMPRESSED_R11_EAC (0x9270)
        COMPRESSED_SIGNED_R11_EAC (0x9271)
        COMPRESSED_RG11_EAC (0x9272)
        COMPRESSED_SIGNED_RG11_EAC (0x9273)
        COMPRESSED_RGB8_ETC2 (0x9274)
        COMPRESSED_SRGB8_ETC2 (0x9275)
        COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 (0x9276)
        COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 (0x9277)
        COMPRESSED_RGBA8_ETC2_EAC (0x9278)
        COMPRESSED_SRGB8_ALPHA8_ETC2_EAC (0x9279)
    - Shader binary formats (0):
    - Parameters:
        GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: 192
        GL_MAX_CUBE_MAP_TEXTURE_SIZE: 8192
        GL_MAX_FRAGMENT_UNIFORM_VECTORS: 4096
        GL_MAX_RENDERBUFFER_SIZE: 8192
        GL_MAX_TEXTURE_IMAGE_UNITS: 32
        GL_MAX_TEXTURE_SIZE: 8192
        GL_MAX_VARYING_VECTORS: 32
        GL_MAX_VERTEX_ATTRIBS: 16
        GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: 32
        GL_MAX_VERTEX_UNIFORM_VECTORS: 4096
        GL_MAX_VIEWPORT_DIMS: 32768x32768
        GL_SUBPIXEL_BITS: 4
    
  • [^] # Re: Testé tous les jeux :)

    Posté par  . En réponse au journal Gamedev Framework 0.7.0 et 0.8.0. Évalué à 3.

    Du coup, j'ai trouvé. La version de zlib utilisée par OpenBSD est un peu trop vieille (version 1.2.3).

    Ah là là, c'est vraiment pas évident d'être portable ! Ceci dit, d'habitude j'ai souvent bien plus de problèmes lorsque j'essaie de compiler des jeux sous OpenBSD qui sont pas dans les ports, gf s'en sort plutôt bien :)

  • [^] # Re: Contradictions

    Posté par  . En réponse au journal Solution au conflit de la ZAD de Notre-Dame-des-Landes. Évalué à 1.

    Nous sommes donc en face de jeunes idéalistes

    Moi je parie qu'il y a aussi des vieux idéalistes, et tout un tas de jeunes anti-idéalistes aussi :)

    On reparlera de tout ça à la première récolte ruinée par une mauvaise météo.

    Dans l'environnement étatique actuel, ils vont sans doute avoir du mal à faire des alliances avec des copains ailleurs, donc c'est pas (du tout) gagné, en effet.

    Encore une très grosse concession. Imagine le risque qu'ils prennent: si leur mode de vie est massivement adopté, qui s'occupera de tous les services publiques dont ils dépendent comme l'a souligné Zenitram?

    Si je devais parier aussi, je dirais les mêmes personnes qui s'en occupent aujourd'hui, moins quelques personnes dégoûtées par leur métier actuel, plus quelques-uns qui trouvent leur vocation sans devoir passer par une administration qui les avait freinés précédemment.

  • [^] # Re: Ha l'utopie..

    Posté par  . En réponse au journal Solution au conflit de la ZAD de Notre-Dame-des-Landes. Évalué à 6.

    Par contre j'arrive à entendre qu'ils exprime un besoin de conflit (sinon ils iraient squatter ailleurs, mais ailleurs il n'y a pas de conflit on les laisserai tranquilles), tout en récupérant le RSA ("autonome", mais bon avec l'argent des autres).

    En attendant d'avoir le droit d'être libérés de l'État, autant qu'ils fassent valoir leurs droits :)

  • [^] # Re: Tant que tout va bien

    Posté par  . En réponse au journal Solution au conflit de la ZAD de Notre-Dame-des-Landes. Évalué à 3.

    La partie sur le passage à l'échelle est importante

    Sans doute, mais tes arguments sont essentiellement de la spéculation, ce n'est pas évident d'avoir quelque chose qui ressemble à une preuve à ce sujet, on manque trop d'expérimentation. Des communautés agricoles (pas forcément homogène politiquement a priori) ont par exemple existé jusqu'à la révolution française — au cours des siècles elles ont peu à peu perdu des pouvoirs au profit d'un seigneur ou d'un roi, jusqu'à les perdre totalement au profit de l'État, mais ces idées n'ont vraiment rien de nouveau et on retrouve des exemples jusqu'au moyen âge et sans doute bien avant — contrairement à ce que pourrait laisser penser le journal, d'ailleurs, qui présente un peu tout ceci comme une nouveauté sans précédents :)

  • # Testé tous les jeux :)

    Posté par  . En réponse au journal Gamedev Framework 0.7.0 et 0.8.0. Évalué à 5.

    Voilà, j'ai testé tous les jeux :) J'ai pas trop d'expérience en C++, mais j'aime bien les jeux 2D donc ça fait plaisir de voir des bibliothèques libres et qui plus est ça a l'air solide et pas gourmant en ressources.

    Juste deux petits soucis lors de la compilation (sous OpenBSD, clang 5.0.1), je ne saurais pas dire exactement pourquoi vu mon manque d'expérience en C++.

    diff --git a/include/gf/DataObject.h b/include/gf/DataObject.h
    index eae55da..ca4a1c5 100644
    --- a/include/gf/DataObject.h
    +++ b/include/gf/DataObject.h
    @@ -22,6 +22,7 @@
     #define GF_DATA_OBJECT_H
    
     #include <cstdint>
    +#include <cstddef>
    
     #include "Portability.h"
    
    diff --git a/library/Tmx.cc b/library/Tmx.cc
    index 85a070b..501c110 100644
    --- a/library/Tmx.cc
    +++ b/library/Tmx.cc
    @@ -488,7 +488,7 @@ inline namespace v1 {
           z_stream stream;
           std::memset(&stream, 0, sizeof(stream));
    
    -      stream.next_in = input.data();
    +      //stream.next_in = input.data(); // XXX
           stream.avail_in = input.size();
           stream.zalloc = Z_NULL;
           stream.zfree = Z_NULL;

    Première erreur :

    include/gf/DataObject.h:229:30: error: no type named 'nullptr_t' in namespace 'std'
        explicit DataObject(std::nullptr_t)
    

    Pour cette première erreur, j'imagine que glibc doit inclure <cstddef> dans un autre header de façon non standard.

    Deuxième erreur :

    gf/library/Tmx.cc:491:30: error: assigning to 'Bytef *' (aka 'unsigned char *') from incompatible type 'const
          std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >::value_type *' (aka 'const unsigned char *')
          stream.next_in = input.data();
    
  • [^] # Re: Pandoc

    Posté par  . En réponse à la dépêche Trois outils pour développeur : MailHog, Tokei et Pandoc. Évalué à 4.

    nombre de dépendances directes

    Je pense que personne ne voulait faire référence aux dépendances directes, mais bien aux dépendances vers des paquets Haskell (directes ou indirectes, sans compter les paquets standard qui viennent avec GHC), qui sont au moins au nombre de cent.

    Mais c'est plus une observation qu'une critique en ce qui me concerne, au sens, si un jour Haskell devient très populaire et tous les OS disposent de suffisamment de main d'œuvre pour assurer un support de base fiable de tous ces paquets, ça deviendra raisonnable pour plus de monde, comme pour d'autres logiciels connus en C/C++/Python/… tout sauf minimalistes et avec beaucoup de dépendances. En attendant, il faut juste être conscient que dépendre de pandoc est un choix personnel, dans le sens où ça ne me surprendrait pas que sur un OS ou distrib donnée, des difficultés empêchent occasionnellement d'utiliser le logiciel pendant plusieurs semaines/mois/années — si j'ai fui pandoc il y a déjà quelques années, c'était en partie parce que je me suis justement retrouvé à ne pas réussir à le compiler sous OpenBSD à un moment donné et que je n'ai pas suffisamment l'âme d'un packageur pour y passer des heures et des heures.

    Vu la quantité de formats que supporte Pandoc et sans parler des extensions (à la fois celles mentionnées dans la dépêche et celles-ci), il n'est pas étonnant d'avoir des dizaines de paquets comme dépendances.

    En effet, ce n'est pas étonnant, il s'agit plutôt d'un choix, typique pour des logiciels dans des langages comme Haskell/Python/Perl/Javascript : priorité à intégrer un maximum de fonctionnalités en réutilisant ce qui est fait ailleurs (même de tous petits paquets), même si ça explose le nombre de dépendances. Ça a du bon comme du mauvais.

  • # Pandoc

    Posté par  . En réponse à la dépêche Trois outils pour développeur : MailHog, Tokei et Pandoc. Évalué à 7.

    Pandoc est en effet devenu assez impressionnant avec le temps et extrêmement complet pour transformer entre langages de balisage légers et de là vers d'autres formats. L'auteur du logiciel est d'ailleurs, me semble-t-il, la personne la plus impliquée dans l'effort de standardisation de Common Mark (même si pandoc offre par défaut beaucoup d'extensions sur celui-ci, plus que toute autre implémentation du langage).

    La lecture de formats plus complexes comme LaTeX n'est pas contre pas très fiable (même si ça s'améliore avec le temps j'imagine), ni bien définie : il faut vérifier le résultat à la main et ajuster le LaTeX pour rester dans le sous-ensemble géré — ce qui n'est pas évident, car ce n'est pas quelque chose de bien défini (définir de façon concise un sous-ensemble de LaTeX, c'est peine perdue) et qui pourra difficilement devenir complet, vu que le langage utilisé en interne est (et doit être) beaucoup plus pauvre que LaTeX.

    Dans les points qui me chagrinent un peu dans ce logiciel, c'est qu'il est assez lent (pas gênant pour de petits documents ou si on va exécuter LaTeX de toutes façons après), et surtout le nombre de dépendances (exagéré même selon les standards Haskell, autour de 100 !), qui fait que je ne me risquerais pas à dépendre de ce logiciel pour un truc important que je voudrais pérenne.

  • [^] # Re: Fonctionnel vs Impératif

    Posté par  . En réponse au lien État des lieux des langages fonctionnels. Évalué à 2.

    Avec des goto ? :-P

    C'est pour ça que j'avais écris « de façon commode » :)

  • [^] # Re: Fonctionnel vs Impératif

    Posté par  . En réponse au lien État des lieux des langages fonctionnels. Évalué à 2.

    Plus compact, je veux bien — et encore, pas tant que ça dès que la fonction anonyme à appliquer n'est pas triviale et ne tient pas sur une ligne.

    Plus lisible, honnêtement, je suis mitigé là-dessus. D'un point de vue scientifique, la lisibilité me semble être un sujet pas évident : il ne s'agit pas de compter le nombre de caractères ou de lignes, mais la vitesse avec laquelle on les comprend, qui dépend de beaucoup de facteurs, entre autres individuels. Comme cas extrême, les langages style APL comme J permettent d'écrire des fold et des map de façon plus concise que OCaml ou Haskell, et se vantent d'être plus lisibles et productifs avec suffisamment d'entraînement. Certains allergiques au scroll vont jusqu'à essayer d'APLiser du C et soutenir qu'il s'agit là d'un style avec une longue courbe d'apprentissage mais plus lisible et moins propice aux erreurs avec de l'entraînement (si, si, il y en a qui soutiennent ça).

    Personnellement, je suis assez sceptique — j'ai pas d'avis tranché, car pas assez d'habitude avec ces langages extrêmement concis pour les fonctions d'ordre supérieur (et encore, j'ai passé quand même pas mal d'heure à m'amuser avec, car c'est sympa de pouvoir écrire des algos non triviaux interactivement en repl). En vrai, j'ai quand même l'impression que pour un logiciel « normal » (disons où tout ne s'emboîte pas à coup de fold/map et avec 90% de logique simple), c'est même pas significativement plus court. Donc on met tous quelque part la barre pour un optimum de densité du code pour une meilleure lisibilité, est-ce que ça penche plutôt vers le fold/map d'OCaml ou un range de Go, ou du code à la J, je pense que ça dépend des gens, mais sauf besoin spécifique, je parie que plus de monde pencherait pour un simple range à la Go (perso, je saurais pas trop dire).

  • [^] # Re: Fonctionnel vs Impératif

    Posté par  . En réponse au lien État des lieux des langages fonctionnels. Évalué à 2.

    S'il s'agissait de C j'aurais tendance à penser pareil, mais les map ou fold sur des listes deviennent des itérations avec range sur un tableau en Go, donc ça évite les soucis typiques des boucles, ça demande juste d'introduire explicitement la variable ou le tableau où on construit un nouveau résultat, donc c'est juste plus verbeux, avec l'avantage que la même construction sert à faire map et fold, et qu'il n'y a pas à se souvenir que c'est fold_left qu'il faut faire et pas fold_right, ni se rappeler (ou demander à merlin) l'ordre des arguments pas forcément intuitif (l'inverse entre OCaml et Coq, par exemple). Pour les types somme, je suis assez d'accord, mais c'est pas intrinsèquement fonctionnel comme truc, je dirais.

    La seule construction que je ne vois pas comment réaliser à la fois efficacement et de façon commode dans un langage impératif un peu haut-niveau, c'est la récursivité terminale entre fonctions mutuellement récursives (comme truc approchant, je vois que le retour de pointeur vers une fonction, qui a le défaut de faire des sauts calculés non prévisibles).

  • # Fonctionnel vs Impératif

    Posté par  . En réponse au lien État des lieux des langages fonctionnels. Évalué à 4.

    Autant je suis d'accord que les langages fonctionnels sont souvent très pratiques pour manipuler des structures de données non mutables (comme les arbres), autant je trouve que le résumé sur le « style impératif » est un peu simpliste : sur beaucoup d'algorithmes, boucle while avec variables locales ou récursivité terminale, c'est à peu près équivalent pour relecture et maintenance (de ce point de vue, la récursivité terminale, c'est juste une espèce de boucle while avec potentiellement des returns prématurés).

    Et la partie sur les performances, le « efficacité d'exécution comparable, … voire un peu supérieure », est un peu simpliste aussi : sur certains algorithmes, la possibilité de les faire en place et en évitant des allocations mémoire inutiles (donc en utilisant la partie impérative du langage), change beaucoup les performances, rester dans le fonctionnel pur ça coûte cher. Le pdf d'état des lieux dit que « L'usage de traits impératifs peut se justifier dans certains cas », mais ils donnent comme exemple le fait d'éviter de passer un argument en paramètre à toutes les fonctions, qui me semble pour le coup évitable (rien n'empêche d'utiliser un record pour ne pas avoir une prolifération du nombre d'arguments).

  • [^] # Re: Bêtise naturelle

    Posté par  . En réponse au journal "Intelligence artificielle", vraiment?. Évalué à 3.

    Un truc qui serait intéressant, du coup, ce serait d'évaluer l'intelligence d'un tel algo en lui laissant s'entraîner que sur un nombre de parties correspondant au nombre de parties jouées par un joueur humain. S'il perd, c'est qu'il est plus bête, au sens, il a besoin de s'entraîner sur plus de parties. Après, c'est sûr, d'un point de vue pratique une telle comparaison est artificielle, vu que la machine peut se permettre de s'entraîner plus, car plus rapide.

  • [^] # Re: fzf

    Posté par  . En réponse à la dépêche Des alternatives à grep, ls et find. Évalué à 3.

    fzf a plus de fonctionnalités, dont le support Unicode (ou alors fzy a un bug chez moi), et j'ai remarqué à l'utilisation que fzy attend de recevoir toute l'entrée, alors qu'avec fzf on peut commencer à taper le motif et ça filtre au fur et à mesure que l'entrée se complète, ce qui peut se faire sentir dans des cas comme locate / | fzy (cas un peu limite, mais bon).

  • # D'autres

    Posté par  . En réponse à la dépêche Des alternatives à grep, ls et find. Évalué à 9.

    il est plus surprenant de ne pas retrouver d'outils en Go, en D, en OCaml ou en Haskell.

    Le platinium searcher que tu cites (pt), est en fait écrit en Go. Il y a aussi sift en Go. En C++ il y a ucg, mais j'ai pas testé, et il y en a d'autres. Après, c'est possible en effet que ripgrep soit le plus avancé de tous ces projets, en tous cas l'auteur semble étudier la chose à fond.

  • [^] # Re: version awk

    Posté par  . En réponse au journal Le vrai problème avec toutes ces ré-implémentations de TapTempo c'est .... Évalué à 2. Dernière modification le 16 mars 2018 à 13:33.

    Deux petites chaînes de caractères, je pense que ça rentre dans le droit de citation ou quelque chose comme ça. Et de toutes façon, ça m'a l'air fort : j'imagine un cas analogue où un langage de programmation renvoit un certain message d'erreur dans certains cas, est-ce que différentes implémentations du langage (avec licences incompatibles) peuvent utiliser le même message d'erreur ?

    Sinon la plupart des journaux sont illégaux vus qu'ils disent publier le code sous CC-BY-SA et pas sous GPLv3 :)

    PS : En passant, je publie les miens aussi sous license ISC ou CC0, en plus de CC-BY-SA, au choix (même si j'ai du mal à considérer qu'on puisse mettre une licence sur si peu de code).

  • [^] # Re: Didactique

    Posté par  . En réponse au journal À propos du langage APL et portage de TapTempo en bonus. Évalué à 3. Dernière modification le 12 mars 2018 à 09:03.

    Avec tous ces caractères Unicode j'ai l'impression de jouer à Dwarf Fortress ;-)

    Maintenant que tu le dis, ça me fait penser à Brogue :)

    Au passage, il y a quelques phrases marrantes sur la page Wikipédia à la rubrique Quelques_opinions.

    Celle de Dijkstra est marrante, mais c'est pas trop surprenant venant de lui, il avait l'habitude de sortir des phrases comme ça sur tout et n'importe quoi. Entre autres, il y a aussi FORTRAN, Cobol, la programmation objets, etc. qui prennent cher :)

  • # Petite erreur…

    Posté par  . En réponse au journal Portage de TapTempo en Tcl. Évalué à 3.

       set mean [expr {$mean / [llength $times]}]

    Il manque un -1, m'en suis rendu compte en faisant la version en C. D'ailleurs, tout le calcul du tempo se simplifie en :

       set tempo [expr {60 * ([llength $times] - 1) / ($now - [lindex $times 0])}]
  • [^] # Re: Risque ?

    Posté par  . En réponse au journal Noyau vulnérable ou pas ?. Évalué à 4.

    Disons que pour Meltdown, le débit de fuite c'est jusqu'à 500KB/s, c'est-à-dire beaucoup et c'est en partie là le problème qui rend la vulnérabilité vraiment pratique. Pour Spectre c'est moins, je me souviens plus exactement, quelque chose comme 10 fois moins je crois (ce qui n'est pas négligeable non plus).

  • [^] # Re: OpenBSD

    Posté par  . En réponse à la dépêche Deux failles critiques : Meltdown et Spectre. Évalué à 10.

    Oui, enfin, “late December” pour un embargo de six mois, qui a en plus été écourté d'une semaine à la fin suite aux déductions de la communauté par rapport aux patches appliqués dans Linux (qui même sans le patch bavard du gars d'AMD étaient très curieux pour une rc6), c'est pas vraiment être prévenu, ils en sont au même stade que les autres (voire en retard par rapport à DragonFly).

  • [^] # Re: OpenBSD

    Posté par  . En réponse à la dépêche Deux failles critiques : Meltdown et Spectre. Évalué à 9.

    Les autres BSDs n'ont pas été prévenus non plus (ou juste un peu avant) aussi, on dirait, donc cela semble ne pas être lié à une quelconque philosophie vis-à-vis des embargos. Dragonfly semble avoir patché déjà, mais pas dans -stable, uniquement dans la branche de développement, mais la vitesse de réaction est impressionante.

    Ceci dit, au moins maintenant on est conscients de la faille, ce qui permet de savoir quels genre de services sont particulièrement risqués et à désactiver si possible (grosso modo, n'importe quoi qui permette d'exécuter à un tiers du code en tant qu'utilisateur local du système ou dans une vm).

    Il est intéressant, mais pas surprenant (divulguer plus largement est un risque), de voir que pour des failles moins critiques, avec des embargos plus courts, la plupart des BSDs, ainsi que beaucoup de distros sont mis au courant, alors que pour une faille de ce type avec 6 mois d'embargo uniquement Linux, Mac OS et Windows reçoient une alerte bien à l'avance.