THE_ALF_ a écrit 531 commentaires

Si ce n'était pas rentable, il n'y aurait pas de mineurs.

Si le Loto n'était pas rentable, il n'y aurait pas de joueurs…

C'est effectivement le problème essentiel de ce projet. On ne se dit pas "Wow! voilà ce qu'il nous faut" mais plutôt "Bah! encore un projet de journal open access".

Pour que ce projet puisse intéresser quelqu'un, ce n'est pas avec le mode de publication classique qu'il faut le comparer, mais bien avec le(s) modèle(s) de publication des autres journal open access qui existent (et sont légions).

Qu'est-ce que ce projet apporte de nouveau dans le monde de l'open access? C'est cela qui faut mettre en avant…

Juste un petit alias tout bête pour compléter ceux qui sont donnés, et que j'utilise souvent:
alias lt='ls -lhtr'

Ce qui nous fait un petit ls détaillé en classant les fichiers par date, en indiquant les plus récents en dernier. Pratique pour repérer en un clin d’œil les derniers fichiers d'un dossier fouillis :)

Il y a plus simple comme analogie.

Par contre, je passe tous les jours devant une mairie ouverte quand je passe devant, et j'y ai même fait mon passeport.

Justement, la carte d'identité doit être faite dans la mairie de domicile, alors qu'un passeport peut être effectué partout.

Le lien avec le bio est intéressant. On pourrait voir cela non comme une taxe, mais comme un label. Une entreprise paie pour un label "libre" qu'elle peut apposer sur ces produits, garantissant le respect d'une charte (utilisation de code libre/contribution pour le libre avec un cadre précis).

Avec l'idée bien entendu que ce label puisse être présenté comme un plus, comme un gage (a priori) de qualité. Certes pour beaucoup le "libre" est encore vu comme "gratuit", mais ce label pourrait aussi permettre de mieux "créer" l'image de ce qu'est le libre, de la même manière qu'un label bio donne une image facilement identifiable, qui fait que l'on peut être prêt à payer un peu plus pour le gain environemental apporté par le label bio.

En plus de permettre de financer le libre, cela peut apporter une meilleur visibilité des produits libres.

Tiens, je ne connaissais pas cette méthode. Merci, cela peut être intéressant à tester.

Je confirme qu'un serveur se fait systématiquement scanner. Je filtre mon serveur (avec juste du ssh autorisé, tout le reste est fermé; il ne me sert en fait à pas grand chose d'autre que d'observer des tentatives de connexions en ce moment…) avec fail2ban + UFW. L'intérêt de UFW (qui permet de gérer simplement les iptables) et de rapporter toutes les tentatives de connections non autorisées (et donc les tentatives de connections sur tous les ports, ce qui permet aussi de détecter ceux qui scannent en barbare à la recherche de portes ouvertes). Très rapidement, cela s'est stabilisé à en gros un ban d'IP toutes les 8 minutes!
Les IP proviennent d'un peu partout (TOP 5: Chine, USA, Corée, Russie, Brésil), ce qui laisse penser à des scans patients lancés à partir d'un grand nombre ordis disséminés (bots?) sur des grand ranges d'IP et de ports pour conserver une attaque constante malgré les bans.
Du brute force au carré, bien organisé…

C'est ce que je ne comprends pas dans cette histoire: qu'est-ce qui empêche Canonical de distribuer ZFS par DKMS, vu que c'est de toute manière totalement transparent pour l'utilisateur lambda?

Il y a je pense une explication assez simple si on regarde l'évolution sur les deux courbes de ton lien wikipedia. La chute commence en gros vers 2009-2010. Simultanément, on voit la montée de chrome (et la chute continue de IE, mais pas de changement depuis une éternité).

Mais il y a aussi et surtout une énorme évolution: c'est sur cette même période que l'on a la bascule mobile/desktop (en gros nulle en 2009, et 35% en 2015). Il se pourrait donc qu'il y ait moins de gens sur firefox non pas tant pour une bascule vers un autre logiciel logiciel, mais simplement parce que de plus en plus de gens vont sur internet avec leur mobile, où firefox est peu présent (et ou il n'y a pas de IE préinstallé, donc pas besoin d'installer autre chose que le browser par défaut).

Je fais moi aussi souvent la confusion, sans avoir de problème avec cp. La raison me semble en fait assez naturelle: "cp a b", je pense "copie a vers b"; "ln -s a b", je pense "crée un lien a vers b", dans le sens "un lien nommé a qui pointe vers b", alors qu'il faudrait voir ça comme "crée un lien sur a nommé b".

Le seul qui m'a vraiment fait rire est celui du CERN. Au moins on sent qu'ils se sont vraiment amusés a écrire cet article.

Yep, mais cette piste est quand meme plus lisible. Dans le même esprit, on peut en tout cas simplifier pas mal la fonction de départ par:

def zorglang(text):
    last_index = 0 
    res = ""  
    for match in word_re.finditer(text):
        res += text[last_index:match.start()]
        word = match.group()
        wasup = word[0].isupper()
        word = ''.join(reversed(word))
        if wasup:
            word = word.capitalize()
        res += word
        last_index = match.end()
    res += text[last_index:]
    return res

D'un autre coté, le fait ne pas avoir l'exploit associé empêche de pouvoir tester l'efficacité du patch, non? On se retrouve alors à devoir faire confiance au développeur closed-source: on sait qu'il y a eu un problème, que celui-ci est censé être corrigé, mais cela reste obscur sur ce qui a été effectivement corrigé, et sur la nature de ce correctif (le problème est-il vraiment résolu? Est-ce un gros quick and dirty hack pour boucher le trou le temps de trouver plus propre?).

D'où ma question (naïve?): est-il possible de patcher un faille de sécurité sans en révéler l'exploit associé?

Il suffit d'activer le Multi_key (je l'ai mappée à la place du CapsLock, touche qui ne sert pas à grand chose, par un "remove Lock = Caps_Lock
keysym Caps_Lock = Multi_key" dans mon .Xmodmap, mais il y a surement des moyens plus directs), et tout est accessible par des combinaisons intuitives:

Multi + "-" + "a" => ā
Multi + "_" + "2" => ₂
Multi + "^" + "1" => ¹
Multi + "o" + "o" => °
Multi+"-"+"-" +"-" => — 
Multi+"."+"." => …
Multi + ":" + ")" => ☺
Multi + "C" + "C" + "C" + "P" => ☭
… etc

C'est par ici Landing :-)

Oui, effectivement, tu ne peux pas empêcher python de n'évaluer le code que lors de l'exécution du code en question, donc vu que la ligne Int.a="toto" ne sera jamais évaluée, cela ne va jamais poser de problème (à condition de remplacer false par False :) )

Ce code ne fait rien d'autre que de créer un objet contenant un nombre arbitraire d'attributs dont le type est vérifié à chaque création/modification.

À noter que self.dict["name"]=value est strictement équivalent à self.name=value. On est juste obligé de passer explicitement par le dict pour éviter les appels récursifs de setattr …

En bonus, une version améliorée qui ne caste pas, mais teste juste le type (et lève une exception correcte dans tout les cas), et est donc plus stricte.

In [31]: class StrictTyped(object):
    ...:     def __init__(self, t):
    ...:         self.__dict__["type"] = t
    ...:     def __setattr__(self, name, value):
    ...:         if type(value) is self.type:
    ...:             self.__dict__[name] = self.type(value)
    ...:         else:
    ...:             raise TypeError("'{0}' must be of {1}".format(name,self.type))
    ...:         

In [32]: SInt = StrictTyped(int)

In [33]: SInt.a = 1

In [34]: SInt.a = 1.4
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-34-56644a32470c> in <module>()
----> 1 SInt.a = 1.4

<ipython-input-31-dbe3445a022c> in __setattr__(self, name, value)
      6             self.__dict__[name] = self.type(value)
      7         else:
----> 8             raise TypeError("'{0}' must be of {1}".format(name,self.type))
      9 
TypeError: 'a' must be of <type 'int'>

Facile !

In [1]: class Typed(object):
   ...:     def __init__(self, t):
   ...:         self.type = t
   ...:     def __setattr__(self, name, value):
   ...:         if hasattr(self,"type"):
   ...:             self.__dict__[name] = self.type(value)
   ...:         else:
   ...:             self.__dict__["type"] = value
   ...:             

In [2]: Int = Typed(int)

In [3]: Int.a = 1.23

In [4]: Int.a
Out[4]: 1

In [5]: Int.a = "toto"
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-21393c614655> in <module>()
----> 1 Int.a = "toto"

<ipython-input-1-e04bf26fc6b5> in __setattr__(self, name, value)
      4     def __setattr__(self, name, value):
      5         if hasattr(self,"type"):
----> 6             self.__dict__[name] = self.type(value)
      7         else:
      8             self.__dict__["type"] = value

ValueError: invalid literal for int() with base 10: 'toto'

In [6]: Float = Typed(float)

In [7]: Float.toto = 1

In [8]: Float.toto
Out[8]: 1.0

In [9]: Str = Typed(str)

In [10]: Str.truc = 1

In [11]: Str.truc
Out[11]: '1'

Implémentation minimale, on peut raffiner, mais c'est l'idée ;-)

Très bien, merci. Ça donne une meilleure idée du gain possible, et c'est effectivement l'ordre de grandeur auquel je m'attendais (j'ai en tête comme ordre de grandeur un gain de ×30 entre une boucle CPython sur une matrice et le calcul direct en Numpy).

Effectivement, j'avais remarqué qu'il y avait des problèmes d'overflow. Je ne penses pas que ça ralentisse le calcul, on se retrouves juste avec des valeurs "nan". De toute manière, quelque soit l'implémentation, ça va déborder. Même avec un complex256 à la place d'un complex simple, on se retrouve avec des valeur en 1e4000 aux alentours d'une quatorzaine de boucles… alors forcément, en 20 boucles, ça dépasse.

Et quelle est le gain de vitesse par rapport à une implémentation en pur numpy?

def mandelbrot(width,height, max_iters):
    stepx = 4./(width-1.)
    stepy = 4./(height-1.)
    c = numpy.fromfunction(lambda x,y: 
                           (-2.+x*stepx)+(-2+y*stepy)*1j, 
                           (width, height))
    arr = numpy.zeros((width, height), 
                      dtype=complex)
    for i in range(max_iters):
        arr = arr**2 + c
    return abs(arr)>=2.

In [77]: time mandelbrot(200,200,20)
CPU times: user 8 ms, sys: 0 ns, total: 8 ms
Wall time: 6.29 ms

Une implémentation avec plein de for imbriqués est forcément très lente…

Tout a fait, tout dépends de l'utilisation envisagée. Mon utilisation est plutôt un serveur de données via ssh pour la sécurité, et qui consomme peu. Pour le stockage, mettre un disque dur SATA te permet d'avoir 1To pour en gros le prix d'une clé ou d'une carte de 128Go. Passer en SSD permettrait sûrement de diminuer encore la conso, mais au détriment du prix ou de l'espace de stockage.

En fait l'idéal serait une carte vraiment modulaire, où l'on pourrait ajouter carte vidéo, son, sata, ethernet, … bref, ce que l'on a pour le desktop pour le RPi ou similaire. Le Compute module serait une bonne base, il faut voir ce que l'on va pouvoir y connecter :-)

Bien se rappeler que c'est une petite machine, un HDD n'est pas petit ;-).

En fait c'est justement un des arguments pour avoir une prise SATA: brancher directement un disque dur interne (2.5" voire 1.8") sur le RPi. Pour le brancher sur un port USB, ça demande de passer par un adaptateur, donc un port SATA sur le RPi permettrait de gagner (un peu) de la place.

Par contre, je ne sais pas si passer en SATA diminuerait ou augmenterait la consommation électrique. J'aurais tendance à penser que passer via USB ajoute une couche intermédiaire, donc augmente la puissance dissipée. Je me trompes?

OK, comme présenté par Microsoft: plus de 18000 hostname propagent ces malwares (seul 2000 parmi ceux-ci seraient actifs d'après no-ip Source), ce qui représente 93% de leur origine, donc il faut les bloquer.

Certes, ça a l'air imparable vu de ce coté, mais il faut voir la mise en pratique: 4 millions de hostnames down. soit plus de 200 hostnames bloqués (2000 selon le chiffre de no-ip) pour 1 hostname incriminé. Le problème est bien là.

Soit il y a eu une incompétence du coté de Microsoft — qui se retrouve à devoir filtrer les hostnames sans en avoir les moyens techniques — soit MS trouve normal de couper un grand nombre de hostname, dont 99.5 à 99.95% sont sans lien avec les malwares concernés.

Dans tous les cas, Microsoft a bien failli à la mission confiée par les juges.

Le problème n'est pas (seulement?) dans la décision du juge. Il y a eu une décision de justice comme quoi no-ip étant une source de malware**, le fonctionnement des subdomaines DNS de no-ip incriminés a été confié aux bons soins de Microsoft pour filtrer les dits malwares dont ils sont victimes. A priori, pourquoi pas.

Mais bon, il s'est trouvé que du coup, Microsoft n'a pas les infrastructures suffisantes pour faire le boulot de filtrage qu'ils ont demandé à la justice (et obtenu), et c'est donc l'essentiel du DNS no-ip qui est cassé… C'est ballot.

Bref, au-delà des problèmes éthico-judiciaires, on voit surtout ici une action et décision de justice totalement déconnectées de la réalité technique. A vous de conclure sur les incompétences/amateurismes/autres des entités concernées.

** L'argument microsoft est que 93% des malwares dont il est question passent par les subdomaines no-ip… Attention, il n'est nul part dit qu'une majorité des subdomaines no-ip sont concernés…

emacs, 38 ans.