Aller au contenu
Korben, roi d’internet, logo bébé avec des lunettes en mode thug life

Lien affilié – 🍒🍕🥝🍔🥑🥗 ~ 10 € offerts sur vos prochaines courses de bouffe avec JOW avec le code 2LE2QR ~ 🍒🍕🥝🍔🥑🥗

@  — 

Ah, PalmOS… Ce bon vieux système d’exploitation qui a équipé nos PDA adorés dans les années 90-2000. Ça ne nous rajeunit pas tout ça ! Et bien figurez-vous qu’un passionné a décidé de lui redonner vie à travers un projet complètement dingue : PumpkinOS.

Derrière ce nom qui fleure bon l’automne et la tarte à la citrouille se cache en fait une réimplémentation moderne de PalmOS. Mais je ne parle pas ici d’un simple émulateur comme on en trouve des tonnes sur Internet puisque PumpkinOS a l’ambition de faire tourner de vraies applications PalmOS, les fameuses applications m68k, sur nos machines actuelles. Et cela qu’elles soient équipées de processeurs x86 ou ARM.

Le créateur de PumpkinOS, un certain Miguel Letto a publié une série d’articles passionnants sur son blog pour détailler les différents aspects de son projet. Je vous mets le lien juste ici, ça vaut vraiment le détour.

Mais alors, qu’est-ce que PumpkinOS a dans le ventre ?

Et bien déjà, on retrouve un launcher, ce fameux écran d’accueil qui liste toutes les applications mais aussi une appli Preferences pour configurer le système à votre sauce. Et le plus excitant (lol), c’est la présence des 4 applications phares de PalmOS : le carnet d’adresse (AddressBook), le mémo (MemoPad), la liste de tâches (ToDoList) et l’agenda (DateBook).

Miguel est allé repêcher le code source de ces applications dans les SDK de PalmOS et les a adaptées pour qu’elles puissent compiler et s’exécuter correctement sous PumpkinOS. Un travail de titan quand on imagine le nombre de lignes de code et les différences d’architecture entre les vénérables m68k et nos processeurs modernes.

Il explique qu’il reste des petits bugs par ci par là et que certaines fonctionnalités n’ont pas été testées de fond en comble mais il a déjà sacrément avancé dans son projet.

Bon, maintenant que je vous ai mis l’eau à la bouche, vous vous demandez sûrement comment faire pour mettre la main dessus et surtout comment l’installer ? Eh bien, il va falloir retrousser vos manches et compiler le bouzin vous-même donc aller chercher les sources sur GitHub et ouvrir votre plus beau terminal.

Mais rassurez-vous, Miguel a pensé à tout puisqu’il a écrit un guide pour compiler PumpkinOS sur Windows avec MSYS2. Et pour les accros de Linux, c’est aussi possible de compiler ça sous votre OS préféré. Une fois compilé, il ne vous reste plus qu’à lancer PumpkinOS et à profiter de la nostalgie de l’interface de PalmOS. Le dev a d’ailleurs prévu des scripts de lancement pour Windows, Linux et même WSL, histoire que tout le monde puisse en profiter.

Et pour installer une appli PalmOS dessus, c’est très simple. Sous Windows, il suffit de glisser-déposer le fichier PRC de l’application sur la fenêtre de PumpkinOS et hop, magie, ça s’installe tout seul ! Bon et bien sûr sous Linux, c’est un peu moins automatisé car il faudra copier le PRC à la main dans le répertoire vfs/app_install et relancer PumpkinOS mais comme c’est vous les plus intelligents de la Terre, les linuxiens, je pense pas que ce soit un souci.

Amusez-vous bien !


@  — 

rPGP c’est un bibliothèque Rust qui va vous permettre de jouer avec OpenPGP comme des grands ! Plus besoin de vous taper des kilomètres de C pour avoir un bout de code qui chiffre trois mails bourrés de fautes. Maintenant, on a le droit à une implémentation 100% Rust, avec une API minimaliste mais qui fait le taf. Et en plus, c’est sous licence libre, donc on peut en faire ce qu’on veut !

Le top du top, c’est que rPGP gère tout ce qu’il faut pour être compatible avec Autocrypt 1.1. Si vous ne connaissez pas, c’est une spécification pour chiffrer les mails qui est censée être facile à utiliser pour monsieur et madame tout-le-monde.

Côté technique, rPGP est mis à jour régulièrement en tant que crate pgp (oui, ils ont pensé à nous, les flemmards qui ne veulent pas taper plus de trois lettres). Et pour la partie RSA, ça vit tranquillou sous le parapluie collectif RustCrypto. Et pour les petits malins qui voudraient se la jouer elliptique, pas de panique : le support ECC est assuré par la crate Curve25519-dalek. J’adore le nom 🙂

Bon, après, faut avouer que la doc de l’API est encore un peu légère mais si vraiment vous séchez, vous pouvez toujours ouvrir une issue sur GitHub. Les devs sont sympas, ils répondent (des fois).

D’ailleurs, rPGP s’est payé un petit audit de sécurité indépendant en 2019, réalisé par les gars d’IncludeSecurity et pas de failles critiques ! Bon, quelques trucs à corriger par ci par là, mais globalement, c’est du solide. Si vous voulez jeter un œil au rapport, c’est par ici.

Notez que rPGP est utilisé en prod par Delta Chat, l’app de messagerie basée sur les mails et ça tourne nickel sur Windows, Linux, macOS, Android et iOS, en 32 et 64 bits. Que demande le peuple ?

Et si vous êtes du genre à tout vouloir faire tourner dans votre navigateur (ou dans Node.js, on ne juge pas), rPGP a même pensé à vous avec une feature wasm ! Par contre, les bindings sont encore expérimentaux, mais tout se trouve dans le repo rpgp/rpgp-js.

Allez, je vous laisse, j’ai des messages secrets à chiffrer moi !

@  — 

Je suis tombé sur cette vidéo YouTube qui explique les différentes formes de gouvernement en seulement 10 minutes chrono et je vous la partage parce que je pense que c’est le genre de vidéo qu’on devrait tous regarder pour comprendre un peu mieux les différents régimes politiques, de manière ludique.

Le youtubeur passe en revue tous les systèmes politiques imaginables, de l’oligarchie à la noocracie en passant par la ploutocratie et l’anarchie et chaque concept est expliqué de façon simple et imagée, avec des exemples concrets.

Ce que j’ai kiffé, c’est que la vidéo ne se contente pas d’aligner les définitions comme dans un dico poussiéreux puisqu’on a droit à des petites anecdotes historiques et des traits d’humour, ce qui rend le tout super digeste, même pour les néophytes en politique comme moi.

Bref, à mater !

@  — 

Vous rêvez d’exploiter la puissance des grands modèles de langage pour interagir avec vos documents, mais vous ne voulez pas que vos données quittent votre ordinateur ? Et bien j’ai ce qu’il vous faut !

Admettons que vous avez une tonne de documents sur votre disque dur, des PDFs, des fichiers Word, des présentations PowerPoint, des feuilles de calcul Excel et même des fichiers Markdown… Vous aimeriez pouvoir obtenir des réponses à vos questions à partir de leur contenu, avoir des résumés, générer de nouvelles idées à partir de ces informations… Bref, avoir un genre d’assistant intelligent qui pourrait comprendre et manipuler toutes ces données. Et bien c’est exactement ce que propose Dot !

Au cœur de son fonctionnement, on trouve un modèle de langage pré-entraîné, en l’occurrence une version de Mistral 7B au moment où j’écris ces lignes, qui tourne en local et permet de faire ce qu’on appelle du « Retrieval Augmented Generation » ou RAG.

En gros, ça veut dire que l’IA ne se contente pas de générer du texte à partir de ce qu’elle a appris, mais qu’elle va aussi chercher des informations pertinentes dans une base de connaissances locale. Vous sélectionnez un dossier contenant les documents que vous voulez indexer, Dot va les analyser, les découper en morceaux, calculer des embeddings et construire un index permettant de retrouver rapidement les passages les plus pertinents pour une requête donnée.

Et ensuite, vous pouvez discuter avec Dot comme vous le feriez avec un assistant IA classique. Vous lui posez une question, et il utiliser ses connaissances générales pour formuler une réponse, mais aussi aller piocher dans votre base documentaire pour l’enrichir avec des informations spécifiques. Du coup, ça booste d’un cran la pertinence et la qualité des réponses obtenues !

Bien sûr, comme Dot tourne exclusivement en local, vous n’avez pas à vous inquiéter pour la confidentialité de vos données puisque rien ne quitte jamais votre machine. C’est un gros avantage par rapport aux solutions cloud qui vont envoyer vos documents sur des serveurs distants. Et si vous avez besoin d’un coup de main pour des tâches qui ne nécessitent pas forcément d’accéder à vos documents, Dot intègre un mode « Big Dot ». Vous basculez dessus en un clic, et vous vous retrouvez avec un assistant IA généraliste, capable de tenir des conversations sur n’importe quel sujet, d’aider à la rédaction, de faire du brainstorming, etc. C’est comme avoir un ChatGPT en local sous la main à tout moment.

Si ça vous dit de tester, c’est gratuit, open source, dispo sous macOS, Windows, Linux et disponible ici : https://dotapp.uk/

@  — 

Vous vous souvenez de l’époque mythique du Commodore 64 ?

Ce bon vieux clavier qui claque, les disquettes qu’on insère délicatement dans le lecteur, les heures passées à dompter l’assembleur pour créer des petites merveilles de pixels et de sons… Ah, c’était le bon vieux temps !

Eh bien, figurez-vous qu’on peut retrouver un peu de cette magie en 2023, avec des outils modernes et sur un bon gros PC.

Pour cela, vous allez avoir besoin de quelques ingrédients de base :

  • Visual Studio Code, l’éditeur de code ultra polyvalent qui s’adapte à tous les langages
  • L’émulateur VICE (what else?) pour faire tourner vos programmes comme sur un vrai C64
  • Le compilateur Kick Assembler pour transpiler votre code en binaire (il vous faudra java)
  • Git pour versionner votre code comme un pro

Installer et configurer tout ça, c’est un peu le parcours du combattant mais rassurez-vous, tout est expliqué dans cette vidéo qui vous prend par la main et vous explique tout pas à pas, même si vous débutez.

Alors, vous commencez par installer Git, Java et Visual Studio Code. Ça, c’est la partie facile. Ensuite, vous récupérez Kick Assembler et VICE, et c’est là que ça se corse un peu. Mais suivez bien les instructions, et vous verrez, au bout de quelques minutes, vous aurez un environnement de développement parfaitement opérationnel !

Visual Studio Code dispose d’extensions pour faire tout un tas de trucs, et bien sûr, il en existe une pour l’assembleur C64. Une fois installée, vous pourrez profiter de la coloration syntaxique, de la complétion de code et même du débogage en temps réel avec VICE.

Ensuite, avec Kick Assembler, vous allez pouvoir écrire votre code source de manière beaucoup plus confortable qu’à l’époque. Déjà, vous n’êtes plus limité à 40 colonnes, et l’éditeur vous évitera bien des fautes de frappe. Mais le plus sympa, c’est que vous pouvez utiliser des macros, des constantes et même des instructions de haut niveau pour vous faciliter la vie. Et au final, Kick Assembler transpile tout ça en bon vieil assembleur 6502.

Quant à VICE, c’est tout simplement le meilleur émulateur C64 disponible actuellement. Il est hyper fidèle au hardware d’origine, et il propose une tripotée d’options pour faciliter le développement : exécution pas à pas, points d’arrêt, inspection des registres et de la mémoire, etc. Un vrai bonheur pour déboguer vos programmes !

Voici pour tester, un petit Hello World qui affiche un message à l’écran et change la couleur de la bordure.

;===============================================================================
; Ceci est un exemple de programme en assembleur pour Commodore 64
; utilisant l'assembleur KickAssembler.
;===============================================================================
; Constantes pour les couleurs du C64
BLACK = 0
WHITE = 1
*= $0801
;===============================================================================
; Le code BASIC au début sert à lancer notre programme en assembleur.
; Nous utilisons ici la macro BasicUpstart2 de KickAssembler qui génère
; automatiquement le code BASIC approprié.
;===============================================================================
BasicUpstart2(start)
;===============================================================================
; Notre programme en assembleur commence ici
;===============================================================================
start:
; Change la couleur de la bordure en noir
lda #BLACK
sta $d020

Et pour compiler, charger et exécuter le programme :

  • Presser F5 dans VSCode pour compiler avec KickAssembler
  • Dans VICE, utiliser LOAD "HELLO.PRG",8,1 pour charger le programme puis RUN pour l’exécuter

Pour compiler ce programme, assurez-vous d’utiliser l’assembleur KickAssembler. Vous pouvez le compiler en pressant F5 dans Visual Studio Code si vous avez configuré KickAssembler comme assembleur par défaut. Une fois compilé, vous obtiendrez un fichier PRG que vous pouvez charger dans l’émulateur VICE avec la commande suivante : LOAD "HELLO.PRG",8,1

Puis tapez RUN pour exécuter le programme. Vous devriez voir apparaître « HELLO WORLD! » à l’écran, avec la bordure de l’écran en noir.

Voilà, vous savez maintenant comment redonner vie à vos vieilles machines 8 bits dans un environnement ultra moderne et confortable. Plus d’excuse pour ne pas vous remettre à l’assembleur et pondre les démos et les jeux de vos rêves !

Et si vous êtes un peu nostalgique, rien ne vous empêche de transférer vos programmes sur une vraie machine, armé d’un vieux lecteur de disquettes Commodore 1541 et d’une pile de D7. Et puis il y a une sacrée communauté de passionnés toujours prêts à vous filer un coup de main ou une bonne vieille rustine. N’hésitez pas à traîner sur les forums spécialisés comme Lemon64 ou C64-Wiki, vous y trouverez une mine d’infos, de démos et de bouts de code à recycler.

Avec ce setup VS Code + Kick Assembler + émulateur, vous pouvez également vous attaquer à plein d’autres machines mythiques : Atari 800, Apple II, ZX Spectrum, la liste est longue. Chaque hardware a ses spécificités et ses petits trucs à découvrir, de quoi vous occuper pendant des années !

Source