Letho a écrit 342 commentaires

J'ai utilisé Window Maker lors de mes premiers émois Linuxiens – ce qui doit remonter à une RedHat 5.2. J'en garde un super souvenir.

Sur un sujet proche, quelqu'un saurait-il ce que devient le projet GNUstep ? Étoilé donnait envie il y a quelques années, mais cela semble au point mort.

C'est clairement plus qu'un simple système de messagerie, mais il y a le module Talk de Nextcloud : https://nextcloud.com/talk/

Merci de la découverte, je viens d'acheter les 5 premiers tomes 🙂

Eh bien bravo, je viens encore de commander un livre. Je ne te remercie pas.

C'est à mon sens une excellente idée, qui me trotte également dans la tête depuis quelques temps. Et en tant que dev, je serai ravi de pouvoir participer.

Simple suggestion : je vois qu'il existe deux ressources distinctes pour les représentations JSON des factures et le téléchargement du PDF. Il s'agit pourtant conceptuellement de la même ressource. Ne serait-il pas plus simple de pouvoir préciser dans le header accept le format souhaité ?

# Liste des factures en JSON
GET {apiRoot}/invoices
Accept "application/json"

# Détail d'une facture en JSON
GET {apiRoot}/invoices/{idFacture}
Accept "application/json"

# Détail d'une facture en PDF
GET {apiRoot}/invoices/{idFacture}
Accept "application/pdf"

La norme Obapi pourrait dans ce cas préciser que proposer une représentation PDF de la facture est obligatoire.

C'est ce que j'avais cru comprendre en survolant un peu de documentation. En gros, l'opérateur new renvoie en C++ un raw pointer référençant le tas, et l'idée est de ne jamais utiliser de variable intermédiaire pour ce dernier mais par convention de le passer directement au « constructeur » de smart pointer qui lui sera sur la pile ?

var foobar = std::unique_ptr(new SomeFantasticClass());

(syntaxe sans doute très très approximative)

Le smart pointer est le seul à connaître le raw pointer, et je suppose qu'il libère la mémoire quand foobar sort du scope.

J'ai bon ?

Ça ressemblerait effectivement un peu aux types Box<T> et Rc<T> en Rust (ou Arc<T>, je ne sais pas si shared_ptr est thread-safe ?)

…
…

C'est malin, je vais devoir ajouter C++ à ma liste de langages à tester.

Question sans doute naïve, mais je suis curieux :)

J'ai pratiqué un peu de Rust, mais pas de C++. De ce que j'en comprends, le principe de borrowing via & en Rust permet de libérer la mémoire de façon déterministe au moment de la compilation. Ce n'est pas le cas quand on utilise par exemple le type Arc<T>, qui fonctionne avec un compteur de référence – et donc au runtime.

Les smart pointers de C++ semblent plus proches de ce dernier cas ?

Je me suis promis d'essayer Gleam un jour prochain.

Typage statique + VM Erlang + modèle acteur. Miam.

https://gleam.run/
https://github.com/gleam-lang/gleam

Je ne l'ai jamais essayé, mais j'ai trouvé ceci :

https://age.apache.org/

C'est une extension PostGres pour faire de l'orienté graphe. Et cela gère Cypher. Deux points plutôt positifs pour toi ;)

Un article en parlant : https://www.fabiomarini.net/going-multi-model-with-postgresql-and-apache-age-experimenting-with-graph-databases/

des libertaires

Des libertariens. S'il te plaît ;)

Du coup, ca sera un clavier compatible avec votre futur laptop ; est-ce qu'au moment de sa sortie il sera prévu une option pour le prendre sans clavier ? Ma collection qui prend la poussière commence à devenir assez imposante ;)

Il semblerait que oui, dixit la page KissKissBankBank :

« Mais, [le clavier] est surtout compatible avec notre ordinateur modulaire le Cairn Mesa, étant un de ses… modules ! Vous pourrez le fixer et l’enlever d'un simple geste. Bien entendu, il sera possible d'acquérir l'ordinateur portable modulaire sans le clavier, si vous l'avez déjà acheté. »

Merci pour l'article, j'utilisais ce pattern sans en connaître le nom.
De façon générale, les publications de ce site ont l'air super intéressantes ; ça me donnerait presque envie de me mettre à F# ou OCaml.

De tout cœur, merci.

Visual Studio Code étant apparu en 2015, je suppose que tu parles de Visual Studio ? ;)

Et en français, l'excellente vidéo de Science Étonnante :

JE CRAQUE WORDLE ! 🟩⬛🟨⬛🟨 (grâce aux maths)

C'est ce que propose Compose en Kotlin. C'est assez génial à utiliser, et en ce qui me concerne je l'ai déjà adopté pour le dev Android. Et il y a un support multi-plateforme.

Je rêverais de pouvoir faire du GTK4 de cette façon.

https://developer.android.com/jetpack/compose
https://www.jetbrains.com/lp/compose-mpp/

À propos de l'adaptation (avortée) de Jodorowsky, il faut absolument voir cet extraordinaire documentaire :

Jodorowsky's Dune (2016)
https://www.allocine.fr/film/fichefilm_gen_cfilm=220938.html

Merci (sincèrement).

Je suis développeur, mais ne suis pas passé par une école d'ingénieur. Je touche assez rapidement à mes limites quand il s'agit de mathématiques – ce qui est d'autant plus frustrant que je trouve cela passionnant.

Je viens de me trouver un cours sur ZFC, je vais aller potasser cela ;)

Pardon, il fallait lire if (x = 3) ## false sur la dernière ligne. Si un gentil modo passait dans le coin ;)

Je dis peut-être une bêtise, mais ne pourrait-on pas considérer qu'une variable représente l'ensemble des valeurs possibles selon les contraintes définies ?

Définir x := 2 reviendrait à affecter à x le singleton { 2 }.

L'opérateur = ne serait alors que du sucre syntaxique pour les ensembles à un seul élément : pour une variable x représentant un singleton et une valeur n, x = n serait équivalent à n in x.

Et l'on pourrait réécrire le code ci-dessus de cette façon :

let x: int

if (3 in x) ## true

if (3 = x) ## false

À vrai dire, le seul logiciel à télécharger est Android Studio. C'est lui qui s'occupe de manager les SDKs, l'émulateur, etc. Ce n'est pas tout léger, j'en conviens. Mais c'est à mon sens un outil efficace, et même plutôt agréable une fois qu'on a pris le temps de le connaître un peu.

Et non, pas besoin du moindre compte Google (ni de quelque compte que ce soit) pour développer une application, encore heureux. Par contre, si tu veux qu'elle soit disponible sur le Play Store, il te faudra effectivement un compte développeur Google. Mais rien n'empêche de fournir ton logiciel sur un store alternatif, ou encore directement sous forme d'apk.

Je m'avance sans doute, mais quand j'ai lu « réinsertion », « adulte », et « coupé du monde », j'ai tout de suite pensé à de la réinsertion de prisonniers.

Si tel était le cas, l'image du boulet serait peut-être un peu limite ;)

Je m'auto-corrige. Il ne s'agit pas de

const Receiver<MyProtocol> receiver = {
    onSomeMessage: (payload) => {
        console.log(payload);
        return true;
    }
}

Mais plutôt de :

const receiver: Receiver<MyProtocol> = {
    onSomeMessage: (payload) => {
        console.log(payload);
        return true;
    }
}

Si un gentil modo passait par ici ;)

Les types somme sont représentables en Kotlin via les sealed classes :

// Dans le même fichier
sealed class Player()

class Warrior(var strength: Int): Player()
class Wizard(var mana: Int): Player()

// Pattern matching exhaustif
when (player) {
    is Warrior -> player.strength
    is Wizard -> player.mana
}

Après, j'en conviens, c'est peut-être un chouïa moins élégant qu'en TypeScript :

type Warrior = { strength: number };
type Wizard = { mana: number };
type Player = Warrior | Wizard;

De façon plus générale, et bien qu'étant plus habitué au typage nominal, je trouve incroyablement expressif le typage structurel de TypeScript (je pense entre autres à toi, keyof) ; on a pu faire des choses vraiment sympas avec. Du genre :

type MyProtocol = {
    someMessage: {
        payload: string,
        response: boolean,
    }
}

const receiver: Receiver<MyProtocol> = {
    onSomeMessage: (payload) => {
        console.log(payload);
        return true;
    }
}

Cela peut paraître tout bête, mais je trouve chouette de pouvoir exprimer le fait qu'une structure prenant en charge MyProtocol doive implémenter des handlers de la forme onLeNomDuMessage. Avec bien sûr la vérification des types d'entrée et de sortie.

J'avais adoré Code de Charles Petzold, et je le recommande à quiconque veut en savoir plus sur le fonctionnement d'un ordinateur. Mais bien que ce soit un livre extrêmement didactique, j'ai peur que ce ton neveu ne soit tout de même un peu jeune. Et je ne suis même pas certain qu'il soit traduit en français. :/