Blackknight a écrit 1244 commentaires

Des fois, on est obligés de subir ce genre de choses :(
J'ai le même problème, un employeur qui utilise du MS pour tout jusqu'à me demander d'implémenter la délégation d'authentification dans le SSO Apereo pour contrôler plus finement le MFA.
Heureusement, on résiste sur les applis web internes en installant du Linux, sinon, ce serait IIS à tous les étages.

Sinon, pour utiliser autre chose que Microsoft Authenticator, il fallait donner son numéro de portable (ou alors je me suis loupé) donc j'ai fait comme les copains, j'ai installé ce truc.

Par exemple, j'ai du corriger quelques bugs pour Ansible sur NetBSD et FreeBSD (la détection du système de paquet, ce genre de chose) parce que je devais être le premier à m'en servir.

En quoi est-ce la faute des BSD ? Ansible fait partie de l'installation de base ? Non, donc là, c'est plutôt du côté d'Ansible qu'il faut regarder.
D'ailleurs, ils le disent eux-mêmes:

BSD support is important to us at Ansible. Even though the majority of our contributors use and target Linux we have an active BSD community and strive to be as BSD-friendly as possible. Please feel free to report any issues or incompatibilities you discover with BSD; pull requests with an included fix are also welcome!

Ça ne dépend donc que de la communauté.

Par exemple, il y a 3 firewalls sur NetBSD (PF, NPF, IP Filter) et FreeBSD (PF, IPFW et IPFILTER). Ce n'est pas un souci, mais c'est pas ce que j'appelle de l'intégration.

Pourquoi ? Les trois fonctionnent très bien ? Perso, il y a 15 ans environ, j'étais passé d'IPFilter à PF sans aucun souci et sans rien installer de supplémentaire, juste une config noyau parce qu'à l'époque, je construisais mes noyaux.

Tu as du passer à coté de Redox c'est un OS pour le bureau entièrement en Rust qui semble quazi fonctionnel

En fait, quasi en Rust. Si tu regardes le code source :

• redoxfs est en pur Rust
• relibc est à 63% en Rust mais dépend d'autres libs dont certaines comme pthreads-emb ou openlibm sont en C à 100% ou core_io qui est en partie en C

Ça reste très bien mais de là à dire que c'est entièrement en Rust, y a un pas et pas un petit.
Écrire un OS complet, ça reste une tâche énorme.

L'agent puppet peut interpréter les manifestes directement via puppet apply, donc même sans puppet server ça reste un puppet à part entière. D'ailleurs il y a des environnements qui ont choisi de fonctionner en mode serverless avec git.

Effectivement, j'avais jamais pensé à cette utilisation-là :)

Autre utilisation que j'ai de l'écosystème, c'est Bolt.
Je continue à garder le DSL Puppet tout en faisant du fonctionnement à la Ansible.
Couplé à Vault pour la gestion des credentials, ça permet de faire pas mal de trucs.
Enfin, mes derniers essais ont été d'interfacer Bolt avec PuppetDB (cf. là), histoire de ne pas me trimballer un fichier Inventory.yml trop volumineux.

C'est exactement la raison pour laquelle je fais encore du Puppet :)
Je sais, je fais de l'Ada, je fais du Puppet, je code encore en Java comme il y a 20 ans… Ouais, chui un dino :D

je sais c'est une réponse de Normand

On a beaucoup exagéré sur les Normands :)

En 2019, AdaCore et NVidia ont signé un accord en vue de "sécuriser le logiciel des véhicules autonomes".
La présentation est un retour sur ce qui s'est passé depuis et une analyse des améliorations apportées par SPARK.

Je me renseignerai parce que c'est mon fils qui a récupéré pendant mes vacances.
Par contre, je n'ai pas reçu de SMS ou quoique ce soit d'autre.

Ça y est, j'ai reçu mon Machine Learning — Implémentation en Python avec Scikit-learn !
Bon il est arrivé pendant que j'étais en vacances mais pas grave, je vais pouvoir m'y mettre tranquillement ;)

De ce que j'ai pu lire pour l'instant, c'est très intéressant :D

Il m'a fallu un temps pour percuter pour Ada et le vote, j'avais un peu oublié l'épisode (et pourtant). C'est aussi ce qui a un peu retardé, d'ailleurs, la publication de la dépêche.

C'est quoi l'histoire complète ?
Comme c'était dans la tribune de modération, c'est très énigmatique :)

Ouf, je suis encore cohérent avec moi-même :)

De rien, c'est un plaisir :)

J'aimerai qu'Ada soit plus apprécié et connu à sa juste valeur, il se trouve qu'Alire est un moyen qui peut faciliter sa découverte et celle de SPARK.

Ça m'a rappelé avec émotion les pré et post conditions. La belle époque.

Et encore, si les pré et post conditions permettant de générer des assertions automatiques en Ada, elles ne sont qu'un bout de ce que l'on peut utiliser en Spark.
Il y a notamment toute une série d'aspects (c'est comme ça qu'on dit) spécifiques à Spark permettant entre autre de décrire les dépendances aux variables globales, à la description d'un état au sein d'un package…

C'est complexe et long mais super intéressant :)

En cadeau, quelques liens :
- Le user guide
- Une introduction à Spark
- Un guide pour passer son code Ada vers du code Spark. Attention, toutes les constructions Ada ne sont pas autorisées en Spark, ce dernier ne travaille que sur un subset sans ambiguïté pour un "prouveur"

Bonne lecture

En fait, en créant la section Ada (qui n'existait pas encore), Benoît a aussi fait un peu de rangement, ce dont je le remercie.

Oui, merci Benoît.

Du coup, je me suis demandé sous quelle section avait été publié la news sur Ada 2012 que j'ai écrite il y a 10 ans.
A l'époque, j'avais passé ça sous la rubrique Technologie :)

En tout cas, je suis bien content qu'il y ait une section pour la prochaine norme, Ada 2022, pour l'instant nommée Ada 202X.

Enfin, normalement, c'est pour cette année.

Il te faut regarder du côté des external releases.

Par exemple, pour les Ncurses, il y a ça. Plus généralement, cette partie de l'index contient pas mal d'exemples.

De toute façon, cela ne te dispense pas de préciser dans ton fichier GPR que tu linkes avec la lib en question.

Je pense pouvoir dire qu'il n'y a rien de tout ça :)

La seule chose qu'il y ait est un hash de l'archive du code source récupéré.
Par exemple, pour aPDF :

description = "Portable package for producing dynamically PDF documents"
name = "apdf"
version = "5.0.3"
authors = ["Gautier de Montmollin"]
licenses = "MIT"
maintainers = ["gdemont@hotmail.com"]
maintainers-logins = ["zertovitch", "Fabien-Chouteau"]
project-files = ["pdf_out_gnat_w_gid.gpr"]

[gpr-externals]
PDF_Build_Mode = ["Debug", "Fast"]

[[depends-on]]
gid = ">=9.0.0"

[origin]
url = "https://sourceforge.net/projects/apdf/files/apdf_005_r3.zip"
hashes = ["sha512:dbe27598986b1744b024803348350e48b9fe14a14b4137796b3bf12fc98e400b45fd16dc3902a5ffbfa407552131bec072c287444889d5984ade6ba6d2d981cf"]

Après, comment fait-on quand il s'agit de la récupération d'un commit précis dans un dépôt Git ?
Doit-on vérifier que le commit a bien été signé ?
Dans le cas d'un dépôt où le nombre de mainteneurs est élevé, doit-on vérifier le commit avec les signatures de chacun des contributeurs ?
Si on utilise une clé GPG, quid de la date de validité de la clé ?

Il y a effectivement une réflexion à avoir.

Pour le typosquatting, il n'y a, à ma connaissance, rien non plus.

Autre petite boulette

ProcessOne : https://www.process-one.net/en/ejabberd/ (MQTT + XMPP + SIP).

ProcessOne n'est pas qu'un prestataire, c'est la société qui développe ejabberd, un serveur XMPP opensource écrit en erlang.
Personnellement, c'est ce qui fait tourner mon serveur XMPP et qui fournit depuis peu un broker MQTT pour un pote.

C'est assez simple à installer et pas insurmontable à configurer. Pour la partie MQTT, c'est même très simple si on fait un truc open.

Ça veut dire quoi généralisée ? > 50% ?

D'après l'ARCEP, 70% des locaux sont connectés… Enfin, en mixte fibre, VDSL2 et câble.

Ça fait quand même 30% de non connectés très-haut-débit.

Heuuu, y a moyen de corriger ? Le lien, c'est https://alire.ada.dev/

Bien madame, je m'y attelle dès que possible :)

Et en dehors du "la plupart", y a Ada… Enfin presque :)

Le manuel de référence Ada est libre d'accès mais pas libre au sens que l'on entend ici et plusieurs implémentations, libre et non libres coexistent à commencer par GNAT, le frontend Ada pour GCC qui existe en version libre et en version commerciale.

Il y a aussi des subtilités avec les soustractions : notre résultat sera forcément positif, mais pas forcément certaines opérations intermédiaires… Par exemple : 1-5=-4; 7-4=3; 3*8=24; avec bonCompte(24, [1,5,3,8]) S'il le trouve pas, faudra probablement modifier
calcul(Res, Op1, Op2, [Op1, '-', Op2, '=', Res]):- Res is Op1 - Op2.

Alors, il faut aussi modifier choisir2elements qui ordonne les deux opérandes sinon on ne passe pas par les négatifs mais dans ce cas, on se récupère tous les doublons liés à la commutativité des opérateurs +, - et *.

Et en plus, pour une raison que j'ignore pour l'instant, cela ne ressort pas ta solution…

On va finir par y arriver à avoir la fédération trouve24 à la TapTempo Federation :D

Par contre, je viens de voir, d'après les commentaires plus bas, que cela ne gère pas les fractions.
Je pense qu'aux chiffres et aux lettres, on travaille toujours sur des entiers.

Le problème est que je n'ai pas le niveau en Prolog pour corriger cela rapidement.

Peut-être faut-il regarder du côté de rational/1

Bon, j'ai eu un peu de temps pour adapter le code trouvé sur l'autre jour et voici la solution en Prolog:

bonCompte(N, [N],[]):-!.
bonCompte(N, L,[Detail|Details]):- 
                  choisir2elements(Op1, Op2, Reste, L),
          calcul(Resultat, Op1, Op2, Detail),
          bonCompte(N, [Resultat|Reste],Details).

choisir2elements(Operande1, Operande2, Reste, Liste):-
    select(Operande1, Liste, Reste1),
    select(Operande2, Reste1, Reste),
    Operande1 >= Operande2.

calcul(Res, Op1, Op2, [Op1, '+', Op2, '=', Res]):- Res is Op1 + Op2.
calcul(Res, Op1, Op2, [Op1, '*', Op2, '=', Res]):- Op2 >= 1, 
                                                   Res is Op1 * Op2.
calcul(Res, Op1, Op2, [Op1, '-', Op2, '=', Res]):- Res is Op1 - Op2, 
                                                   Res > 0.
calcul(Res, Op1, Op2, [Op1, '/', Op2, '=', Res]):- Op2 >= 1, 
                                                   Res is Op1 / Op2, 
                                                   integer(Res),
                                                   Res \== Op2.

Le second paramètre de bonCompte étant une liste contenait en tête le résultat, il suffisait de vérifier que cette liste ne contenait que le résultat. C'est ce que dit la première règle.

J'ai autorisé le fait que le résultat de la soustraction puisse fournir la même chose que sa opérande (le cas 2-1=1) et autorisé qu'une division et une multiplication par 1 soit faisable.

Ca s'appelle simplement via bonCompte(24, [7,8,5,1]). par exemple

Voilà un défi intéressant pour s'y remettre :)
Je vais essayer de plancher dessus, c'est inutile donc indispensable.