hsyl20 a écrit 228 commentaires

Ça fait un moment que le Web tend vers Java (JVM -> Navigateur, Java Web Start -> WebApp, JIT, TCPSocket, etc.), sauf que c'est développé à la mode PHP (i.e. n'importe comment). Il manque Swing : est-ce que quelqu'un a fait un toolkit à base de canvas HTML5 ou pas encore ?

Tu veux mettre la propagande en lumière en citant les-crises.fr, le site qui reprend toutes les "actualités" des médias d'État Russes pour argent comptant

Ça nous change de tous nos médias qui reprennent la propagande de la CIA.

PS: J'ai passé ces trois dernière année plusieurs mois en Ukraine, j'y suis encore en ce moment.

Argument d'autorité qui ne vaut rien. BHL aussi est allé en Ukraine et il n'a vu aucun néonazi, donc il faudrait le croire ?

Il ne s'agit pas de défendre la Russie, mais la propagande anti-Russie me saoule encore plus.

Sinon pour revenir à Tor, j'imagine que notre pays des Droits de l'Homme va essayer de refourguer la technologie Qosmos. Si eux cherchent à l'acheter, nous on la produit et on la refourgue à des dictateurs : est-ce que c'est mieux ?

http://www.dailymotion.com/video/xocq6q

Avec ton commentaire en tout cas c'est facile d'évaluer le niveau de réflexion d'un anti "anti-austérité". Il y a tellement de bullshit que c'est trop long de tout reprendre.

Quelques pistes quand même :

1) un état ça ne fonctionne pas comme un ménage, il peut contrôler ses dépenses ET SES RECETTES. Donc dès qu'il veut il peut reprendre les 10 points qui sont passés de l'investissement/salaires à la rente (niches fiscales, fraude fiscale, etc.).

2) il n'y a aucun pays où les "réformes structurelles" austéritaires ont donné de bons résultats (pour quelqu'un de gauche. Pour quelqu'un de droite il s'en fout du chômage, de l'augmentation de la pauvreté, de la diminution de l'espérance de vie en bonne santé, des taux de suicide, etc. tant que la sainte croissance est maintenue et qu'il n'y a pas d'inflation qui ferait baisser sa retraite par capitalisation).

3) Il y a moins de 2500 inspecteurs du travail et la réforme de l'inspection du travail en cours de discussion va permettre des arrangements en toute indépendance bien sûr entre les entreprises qui fraudent et l'administration, donc non l'état ne cherche pas à trouver ceux qui fraudent (pour rappel, la fraude aux cotisations patronales est bien supérieure à celle aux prestations sociales). Pareil pour le fisc, la lutte contre la fraude fiscale et les paradis fiscaux est une vaste blague. L'argent qui est récupéré ne va pas "aux électeurs" comme tu dis, tu n'as pas du lire le projet de loi des finances et les cadeaux qu'il fait au grand patronat.

Les chantres de l'anti-austérité, je ne les ai jamais entendu quand il s'agissait de réduire les dépenses quand ça allait pas trop mal afin de remettre les compteurs au bon niveau

4) Je te sens nostalgique du gouvernement Jospin pendant lequel les comptes étaient à l'équilibre (même selon les critères de Maastricht) et où un fonds de réserve pour les retraites avait été mis en place en prévision de 2020 (depuis siphonné par la droite). C'était à ce moment là qu'il fallait qu'ils râlent ?

C'est aussi le projet de loi de finances qui accentue la politique d'austérité. Il serait encore mieux de militer pour qu'il ne soit pas voté du tout.

Parce qu'il est autant philosophe que n'importe quel joueur de foot ou pop star ? Donc pourquoi pas livreur en plus. ;)

https://www.youtube.com/watch?v=-pGTU-t_Duw

Les bases de l'UE ne sont pas humanistes non. Sinon les critères de convergence sociaux et écologiques auraient été prévus dès le début. Or c'est le contraire, et les traités interdisent à un Etat de faire du protectionnisme en fonction des droits sociaux ou environnementaux du pays producteur, donc c'est une invitation à la liberté d'entreprendre/exploiter dans les pays de l'Est.

Ce ne sont plus des libéraux au sens original, mais des néo-libéraux : même les fonctions régaliennes vont être privatisées (comme l'armée aux USA avec BlackWater) et les règles du jeu libéral ne sont plus respectées depuis longtemps (HFT, dark pools, etc.).

et ça me bouffe 700 Mo en tâche de fond

Il faut réviser les bases du fonctionnement d'un garbage collector ;-)
http://gfx.developpez.com/tutoriel/java/gc/

Mais sinon j'avoue que j'ai demandé l'indexation de wikipedia (tant qu'à faire) sur mon installation YaCy et c'est assez violent en terme de consommation CPU.

Cf Very Bad Trip

Peut-être parce que Scala permet de définir des "extracteurs" particuliers qui peuvent être utilisés lors du pattern-matching : http://www.scala-lang.org/old/node/112
Ça ressemble un peu aux Pattern Synonyms introduits dans GHC 7.8. Je ne connais pas assez Ocaml pour savoir s'il dispose de quelque chose d'équivalent.

Oui c'est bien ça.

L’équivalent Haskell d’une entrée comme input en Python est forcément impur.

Oui mais justement le gros intérêt de Haskell en comparaison avec d'autres langages comme OCaml par exemple, c'est qu'ils n'ont pas transigé sur la pureté pour intégrer les IOs. Donc on conserve toutes les propriétés liées à la pureté.

(Brièvement) pour ceux qui se demandent comment ça marche (j'avais présenté ça ici) :

Si on avait une fonction input qui renvoyait une chaîne en faisant un effet de bord (lecture de ce que tape l'utilisateur) et ayant pour type input :: String. Supposons qu'on fasse plusieurs lectures :

main = let
    nom = input
    prenom = input
    age = input
  in print ("salut " ++ prenom ++ " " ++ nom)

Comme Haskell est paresseux, prenom et nom seraient évalués seulement quand on aurait besoin d'afficher la chaîne (donc dans quel ordre ?) et age ne serait jamais évalué. Comme il y a la transparence référentielle et qu'on appelle input avec les mêmes paramètres (i.e. aucun), on peut dire que nom = prenom = age = input. Bref ça ne marche pas, d'autant plus que comme print ne renvoie rien, on n'a jamais besoin de l'évaluer donc il ne se passerait rien.

On s'en sort en disant que input prend en fait un paramètre, l'état du monde extérieur à Haskell et qu'en plus d'une chaîne il renvoie l'état du monde extérieur après avoir fait l'IO. Donc son type est en fait input :: RealWorld -> (RealWorld,String). De la même façon, on suppose que main reçoit l'état du monde extérieur avant le lancement du programme et renvoie l'état du monde extérieur après l'exécution. Maintenant il ne reste plus qu'à chaîner tout ça :

main w1 = let
     (w2,nom) = input w1
     (w3,prenom) = input w2
     (w4,age) = input w3
   in print ("salut " ++ prenom ++ " " ++ nom) w4

Donc là on est sûr que pour obtenir l'état du monde renvoyé par main, il faut évaluer print... w4, donc pour obtenir w4 il faut évaluer input w3 et ainsi de suite. Notez qu'on aurait pu faire autrement et dire que chaque fonction qui effectue une IO prend en paramètre une fonction qui va utiliser son résultat (continuation passing style, CPS) et on aurait obtenu Node.js, mais Haskell est un langage moderne qui a remplacé cette approche en 1992 (lancer de troll réussi ?).

On peut introduire un alias pour simplifier l'écriture des types :

type IO a = RealWorld -> (RealWorld,a)

Donc on aurait input :: IO String, print :: String -> IO () (où () veut dire void) et main :: IO ().

Le problème avec les variables world explicites est que si le programmeur fait n'importe quoi avec (s'il en utilise une plusieurs fois, etc.) ça n'est plus déterministe et c'est n'importe quoi. Donc soit on détecte statiquement que l'utilisateur fait n'importe quoi (ce qu'ils ont fait dans le langage Clean plus tard), soit on cache l'utilisation de ces variables en ne proposant que l'opérateur pour composer deux opérations qui font des IO (l'équivalent de ";" en C). Donc en Haskell c'est ça, on peut utiliser >>= pour composer deux opérations, avec (>>=) :: IO a -> (a -> IO b) -> IO b :

main = input >>= \nom -> input >>= \prenom -> input >>= \age -> print ("salut " ++ prenom ++ " " ++ nom)

Et comme c'est très moche, on utilise l'équivalent avec du sucre syntaxique (do-notation) :

main = do
   nom <- input
   prenom <- input
   age <- input
   print ("salut " ++ prenom ++ " " ++ nom)

Le principe et la notation se généralisent à d'autres cas où on cherche à "chaîner des opérations" (cf Monad), c'est pour ça qu'on la retrouve dans l'exemple utilisant la mémoire transactionnelle dans mon commentaire plus haut alors qu'il n'y a pas d'IOs.

Bref au final c'est resté pur tout en faisant des IOs, c'est pour ça que certains parlent de "meilleur langage impératif du monde" comme le mentionne la dépêche. J'aurais dit "univers" mais bon. ;)

Ouch, effectivement ça craint.

Pour leur défense, c'est vrai que les langages de haut-niveau ne sont pas vraiment mis en avant dans les cursus informatique (en tout cas le mien). On dégoutte les élèves en leur faisant faire de la programmation impérative en LISP et en leur disant que c'est ça la programmation fonctionnelle, on leur vend Java comme étant le top du haut-niveau et ils sont mûrs pour la SSII.

Donc ne parlons même pas de mémoire transactionnelle, de modèle data-flow, de modèle d'acteur, etc.

J'aurais du écrire "j'invite tout le monde" au lieu de "je vous invite", ce n'était pas du vouvoiement ;)

Pour la syntaxe de l'exemple utilisant la mémoire transactionnelle, c'est la façon dont on écrit du code "impératif" en Haskell avec la do-notation. Donc ça se lit comme on lirait du C ou autre :

-- On définit une fonction `transfertPognon` qui prend 3 paramètres (a,b,somme). Les types sont inférés.
-- `atomically` permet d'exécuter ce qui lui est passé en paramètre dans une transaction. On ne peut pas faire d'IO dans une transaction donc elle est forcément pure (donc on peut la rejouer, etc.). Quand on accède aux variables transactionnelles, les écritures sont invisibles de l'extérieur tant que la transaction n'est pas "validée" ('commit').
transfertPognon a b somme = atomically $ do 

   -- on lit la valeur stockée dans "a" qui est une variable de type `TVar Int` (donc qui ne peut être lue et écrite qu'avec readTVar et writeTVar respectivement au sein d'une transaction) et on l'affecte à `courantA`
   courantA <- readTVar a

   -- si le compte a n'a pas suffisamment d'argent, on appelle `retry`, ce qui aura pour effet de recommencer la transaction au début (donc de relire la valeur de `a`). Pour éviter de tourner pour rien comme sur un spinlock, le thread est bloqué jusqu'à ce qu'une des valeurs lues ait été modifiée (donc ici `a` vu qu'on a lu que cette variable). Pour rappel, les threads haskell sont des threads en espace utilisateur (green threads) donc ça ne coûte pas très cher.
   when (courantA < somme) retry 

   -- on lit `b` puis on écrit les 2 nouveaux montants dans les comptes
   courantB <- readTVar b 
   writeTVar a (courantA - somme) 
   writeTVar b (courantB + somme)

Pour montrer comment on peut composer des fonctions qui utilisent la mémoire transactionnelle, on peut introduire deux fonctions retirer et verser pour enlever ou ajouter de l'argent à un compte donné :

retirer compte somme = do
  courant <- readTVar compte
  when (courant < somme) retry
  writeTVar compte (courant - somme)

verser compte somme = do
  courant <- readTVar compte
  writeTVar compte (courant + somme)

transferer source dest somme = do
  retirer source somme
  verser dest somme

transfertPognon a b somme = atomically (transferer a b somme)

Le problème avec la mémoïsation automatique est de déterminer quand la faire. Il y a un compromis à trouver entre la vitesse d'exécution et l'espace mémoire (comme d'hab), pour quelles fonctions, selon quels paramètres en entrée, etc.

La version avec l'utilisation d'une liste infinie doit normalement éviter de calculer plusieurs fois le même élement et le garbage collector se charge de supprimer les éléments au début de la liste qui ne sont plus nécessaires.

Pour ton exemple C++, outre le fait qu'il manque des "::result", tu as conscience que c'est exécuté à la compilation et donc je suis moyennement surpris qu'afficher une constante soit efficace à l'exécution.

Après l'exemple de la suite de Fibonacci n'est pas terrible puisque personne ne se sert d'Haskell pour calculer ça. Il y a tellement de choses plus intéressantes. Quelques exemples :

1) Happstack (ou Yesod) pour intégrer un serveur web en quelques lignes dans une appli. L'analyse de l'url est type-safe, avec les modules de génération de HTML (comme blaze-html) on génère forcément des pages well-formed (vérifié statiquement par le système de types), en étant sûrs de ne renvoyer de façon non intentionnelle de chaînes de caractères qui ne soient pas converties en HTML ("échappées"), etc.

2) Intégration de la mémoire transactionnelle. Pas besoin de se prendre la tête à gérer des mutexes ou autres. L'exemple classique du transfert d'argent entre 2 comptes :

transfertPognon a b somme = atomically $ do
  courantA <- readTVar a
  when (courantA < somme) retry
  courantB <- readTVar b
  writeTVar a (courantA - somme)
  writeTVar b (courantB + somme)

Le gros avantage c'est que c'est composable (pas besoin de prendre de mutexes dans l'ordre, etc.).

3) QuickCheck pour tester automatiquement des fonctions en fonction de leurs types. Par exemple si vous écrivez une fonction de tri de caractères et que vous vouliez voir si elle a l'air conforme à un tri classique :

let myCompare x y = case (x,y) of { ('a','b') -> GT; _ -> compare x y }
    mySort = sortBy myCompare

ghci> quickCheck ((\s -> sort s == mySort s) :: String -> Bool)
*** Failed! Falsifiable (after 52 tests and 9 shrinks):    
"ab"

Je vous invite à découvrir Haskell si ça n'est pas déjà fait. L'apprentissage est peut-être un peu difficile mais ça en vaut la peine.

Ton score est déjà au max donc je rajoute un commentaire pour dire +1

Ça pourrait être pas mal pour voir les évolutions de ces listes, notamment les personnes qui ont été radiées sans motif.

http://www.leparisien.fr/espace-premium/paris-75/le-gros-couac-des-radiations-des-listes-electorales-31-12-2013-3450163.php

Je ne connaissais pas SystemTap, mais de ce que je viens d'en lire, c'est différent (donc ni mieux ni moins bien). On est plus bas niveau dans le sens où ne va typiquement pas instrumenter des appels système ou autres appels de fonctions mais des portions de codes de calcul (boucles avec instructions SIMD, etc.). On essaie de les caractériser autant que possible pour proposer des optimisations.

Je ne connaissais pas, mais pour ce que je viens d'en lire c'est un peu différent. Dans notre cas le but n'est pas de corriger un binaire mais de modifier le comportement temporairement et de façon générique (i.e. sans connaître à l'avance le binaire). Par exemple on peut demander à modifier un binaire de façon à ce qu'il dump les dates d'entrée et sortie dans les boucles les plus internes, etc. Enfin bon je ferai peut-être un journal quand ce sera libéré.

Il y aussi MAQAO (http://maqao.org/), dont j'ai intégré l'équipe de développement, qui devrait être libéré bientôt (fin février si tout se passe bien) et qui est plutôt orienté calcul haute performances. Il permet de faire du patchage de binaires pour ajouter du code à des endroits précis quitte à relocaliser du code ailleurs (e.g. des sondes), il y a des modules pour évaluer les performances statiquement et dynamiquement, pour donner des conseils d'optimisation, etc.

C'est pourtant bien l'objectif la convergence des règlements "vers le haut", c'est à dire pour eux vers celui le plus libéral. Extraits de résolution adoptée :

5 souligne que, s'il y a certes lieu de protéger de manière équilibrée les intérêts et secteurs sensibles de chacune des deux parties, il serait quand même avantageux de réaliser des progrès dans de nombreux domaines, en particulier dans le démantèlement des barrières commerciales, dans l'introduction de mesures visant à améliorer l'accès au marché, notamment des investissements, dans la protection des droits de propriété intellectuelle, dans l'ouverture des marchés publics pour garantir une réciprocité totale, dans la clarification, la simplification et l'harmonisation des règles d'origine, et dans la convergence vers une reconnaissance mutuelle des normes réglementaires, pas simplement en respectant une norme minimale requise qui se base sur l'accord de l'OMC concernant l'application des mesures sanitaires et phytosanitaires (accord SPS), mais en s'efforçant d'améliorer conjointement la qualité et la coopération lorsque les normes européennes et américaines divergent; considère qu'une telle intensification des relations économiques permettrait également un meilleur alignement de l'approche de chacune des parties à la résolution des difficultés économiques mondiales;

12 accorde son soutien aux effort déployés pour coopérer le plus étroitement possible dès le début du processus règlementaire pour l'élaboration de normes, pour la cohérence réglementaire et pour une meilleure harmonisation des normes, afin de promouvoir davantage le commerce et la croissance qui pourraient améliorer l'efficacité et s'attaquer de manière effective aux barrières non tarifaires; partage l'avis du groupe de travail à haut niveau selon lequel un accord négocié excluant la coopération et la réforme réglementaires serait insignifiant du point de vue économique et indéfendable au niveau politique, et ce pour les deux parties; souligne que la compatibilité réglementaire constitue le principal défi d'un accord transatlantique ambitieux et rappelle, à cet égard, que les différences en matière de réglementation et les mesures «après la frontière» constituent une entrave particulière aux échanges pour les PME;

http://www.europarl.europa.eu/sides/getDoc.do?type=TA&reference=P7-TA-2012-0388&language=FR

Moi j'ai fait de façon permanente depuis que c'est arrivé sous Arch :
alias git="LANG=C git"

D'ailleurs elle défraie régulièrement la chronique :

http://www.legorafi.fr/2013/03/06/provocation-la-coree-du-nord-va-rediger-tout-son-courrier-a-lattention-de-lonu-en-comic-sans/

http://www.legorafi.fr/2013/04/09/plus-de-80-000-signatures-contre-le-panneau-en-comic-sans-ms-de-la-station-campo-formio/

http://www.legorafi.fr/2013/08/09/des-parents-attristes-que-la-lettre-de-suicide-de-leur-enfant-soit-en-comic-sans/

Il parait que ça n'est pas exactement ça.

http://www.fosspatents.com/2013/08/new-zealand-parliament-adopts-uk.html
http://www.fosspatents.com/2013/08/follow-up-on-new-zealand-patent-offices.html

(vu ici : http://www.osnews.com/thread?570793 )

Ainsi, nos "élites" politiques sont des littéraires qui ne comprennent rien aux sciences et techniques ou parfois les méprisent. Il ne faut donc pas s'étonner de la désindustrialisation de notre pays.

La désindustrialisation n'a pas grand chose à voir avec le troll littéraires vs scientifiques. Il faut plutôt regarder du côté du modèle de développement : on refile l'industrie aux crève-la-dalle et on garde les services et la R&D (en théorie). Et aussi du côté de la politique économique (e.g. Airbus, l'euro et le dollar).

Réciter des vers de Lamartine ou de Victor Hugo, connaître les dieux de l'Olympe ou les détails de la guerre de cent ans ne permettent pas de créer des emplois productifs.

En même temps ça n'est pas le rôle de l'École que de formater des gens directement employables (transmission des savoirs, culture, formation de l'esprit critique, tout ça…). Et avec ce qui se passe en ce moment en Europe, on risque de regretter bientôt que l'Histoire n'ait pas été plus enseignée.

Heureusement qu'ils précisent que ça n'a pas été inventé par Google. Dans leur article de 2004 [1], ils ne s'embarrassent pas avec ça.

Brièvement, la plupart des opérations sur les collections de type liste non vide peuvent s'écrire sous la forme canonique (cf catamorphisme) : reduce f . map g
Si f est associative, ça se parallélise aisément, d'où MapReduce. Il existe la même chose pour des types de données plus compliqués : ensemble finis, arbres, tableaux à n dimensions… [2] Pour ceux que ça intéresse, les mots-clés sont Bird-Meertens Formalism (BMF) et théorie des catégories.

[1] http://research.google.com/archive/mapreduce-osdi04.pdf
[2] http://www.amazon.com/Foundations-Programming-Cambridge-International-Computation/dp/0521018560