Reprise du message précédent :
Sweet mother of WTF, il y a vraiment de masos: AOC 2022 en SQL

with ca prends un receiver et un block et fa applique le block au receiver comme si il était this dans le scope du block. Donc en gros ça permet de grouper des appels sur un objet en le référençant implicitement dans ce scope
 
Dit comme ça ça a l'air compliqué:
 

 
La tu as évite de déclarer une variable, trouver un nom et écrire le nom autant de fois que tu as d'appels
 
Pour let c'est pareil sauf que ça prends une lambda ou le paramètre est it et pas this, ça permet donc d'exécuter des lambda function sur des objets qui sont bien existants (non null), ou bien éviter comme pour le with de créer une variable
 
Tu as aussi apply, run et also, tu auras plus de détails ici https://kotlinlang.org/docs/scope-functions.html
 

 
J'ai une salle d'eau à refaire, c'est quoi tes disponibilités et tarifs ?
L'artisan sera logé, nourri et blanchi

Day 09:
 

Bonjour, je ne vois pas où est le point de départ, dans le problème ??
edit: ah, on découvre le terrain au fur et à mesure.

https://codeshare.io/RbMdVO allez on se refait des petites lib de géométrie pour les jours à venir...

J'ai beaucoup trop peiné à modéliser les règles de déplacement...

Bien sympa cet AoC jour 9 : https://github.com/ratibus/adventof [...] /solve.php

pas mal du tout
Moi ce sera pour février / mars le début des travaux

Très jolis supports de laser  

 
ici pour un sdb de 8m2 avec baignoire/douche et avait tout fait refaire du sol au plafond (tout casser, recarreler sol et murs full hauteur, douche à l'italienne, nouvelle baignoire, nouveau meuble vasque, montage d'une cloison qui a été carrelée pour faire une separation "buanderie" pour LL et SL) ... 14K (matériaux de qualité, carrelage > 40€/m2, robinetterie full grohe).

nraynaud porn : https://www.youtube.com/watch?v=M1-YeqGynlw

Hadès II annoncé

a peu prêt le meme cahier des charge et le même prixi l'an dernier chez moi

 
Top 3 des jeux que j'ai fait dans ma vie je pense. J'ai hâte.

 
J’ai bien aimé mais c’est un peu répétitif. Mais le style , la narration sont géniaux

Trop dur pour moi.

Ah merde, le file system check de ma Debian qui est en FAILED, avec une "dependency failed for /boot/efi", EXT4-FS en erreur sur le NVMe, GNOME qui ne démarre plus, etc
 
Bon, j'ai 2 semaines de dev à pusher avant la réinstall complète...

tu devrais pusher tous les jours

Much il ne push pas tant que la facture n'a pas été payée

Ca ne t'es jamais venu à l'idée que tu foutais tout dans une branche dans ton coin et de pousser plusieurs fois par jour ?

J'ai ajout un alias "acp"

git acp "yo j'add et je push tout en meme temps"

Comme ça je suis tranquille.

on n'est plus en 2000.

Chuis assez content d'avoir Backblaze perso.
Si demain j'ai un disque qui meurt en perdant toutes les données, je perds vraiment pas grand chose, en plus de tout ce qui est déjà synchro sur un cloud tiers (photos, mails, etc)

Voila, c'est la base du business

Bon, j'ai quand même pu sauvegarder mon code, et maintenant, on va pusher.

Bon par contre, j'aimerais bien savoir ce qui a causé ces corruptions. Probablement le fait que Virtualbox/Debian ne gère pas bien les mises en veille de Windows avec ce Dell ? Régulièrement, j'ai eu des bugs bizarres où Gnome ne répondait plus après retour au desktop.

Perso je push régulièrement aussi.

Pour mes data perso, j'ai pas grand chose car je garde très peu de chose. Je peux réinstaller mon system complet en moins d'une heure (WSL + configs et projets inclus).
Concernant mon drive (~2go de data), j'ai un script qui le backup tous les mois en zip sur mon second SSD et je mets ce backup sur un DD externe. Le tout protégé avec bitlocker/veracrypt mnt.

Tu as l'embarras du choix    
 
Sinon.

Je push régulièrement et je vais régulièrement pusher des wip pour être tranquille, mais un alias pour pousser de la merde je pourrais pas, si je décide de pousser de la merde je considère devoir faire l'effort
 
J'utilise beaucoup `commit --squash` et `commit --fixup` par contre. Et j'ai un alias pour `commit --amend --no-edit`.

J'essaye d'expliquer simplement et sans rentrer dans les détails la différence entre code synchrone et asynchrone avec une fonction qui réalise deux appels HTTP en utilisant du pseudo code.

J'ai écrit le pseudo code async avec des promises mais quand on a aucune base en JS je suis pas sûr que ce soit le mieux pour comprendre.

Avec await ça me semble plus compréhensible :

function getProductData(HttpClientInterface $httpClient, int $productId): array
{
    $metadataPromise = await get('https://product-metadata/api/' . $productId);
    $stockPromise = await get('https://product-stock/api/' . $productId);
 
    return ['metadata' => $metadata, 'stock' => $stock];    
}

Qu'en pensez-vous ?

J'espère qu'après tout ces git add -A cracra vous rebasez et vous sortez filter-branch pour enlever tous les binaires qui n'ont rien à y foutre

Tsss, c'est pourtant un GOTY... Et je dis ça en étant pas un grand fan des roguelite !  
 
 
Sinon day9 en rust: https://rehost.diberie.com/Picture/Get/f/113164
Je me suis vaguement posé la question si plutôt que de simuler chaque mouvement individuellement on pourrait avec un peu de math trouver directement la position de la tail, mais j'ai vite choisi l'option bourinne
 
Mask, tu as une idée si y a un façon plus élégante d'écrire ma boucle "for _ in 0..distance" ? J'ai eu besoin de faire comme ça vu que j'ai besoin de garder une référence à mon élément précédent. Je suppose que j'aurai pu cloner sa valeur aussi ? Mais je trouve pas ça beaucoup mieux.

sinon y'a un truc qui existe pour backuper un travail en cours sans trop se faire chier à filtrer ce qui doit l'être ou pas.... ça s'appelle les backup

J'utilise même plus la ligne de commande, la flemme, le Git dans IntelliJ est super bieng, c'est vraiment rare que j'ai un soucis qui me force à passer sur command line, et heureusement

function getProductData(HttpClientInterface $httpClient, int $productId): array
{
    $metadataPromise = await get('https://product-metadata/api/' . $productId);
    $stockPromise = await get('https://product-stock/api/' . $productId);
 
    return ['metadata' => $metadata, 'stock' => $stock];    
}

 
await ça cache tout le concept d'asynchronicité. Les noms sont faux, puisque ce que retourne await c'est une valeur, pas une Promise. Pour apprendre, il ne faut pas l'utiliser, mais utiliser juste des Promise:
 

function getProductData(HttpClientInterface $httpClient, int $productId): Promise<array>
{
    $metadataPromise = get('https://product-metadata/api/' . $productId);
    $stockPromise = get('https://product-stock/api/' . $productId);
 
    return $metadataPromise.then(m => etc)
}

 
 
Et dans un second temps tu expliques que await c'est du sucre syntactique pour dire "p.then(() => {})", mais que dans le cas présent par exemple ça ne permet pas un truc essentiel qui est de faire les deux requêtes en parallèle. await c'est juste pratique quand on veut utiliser des fonctions asynchrones comme si elles étaient synchrones, ça ne permet pas de prendre avantage de l'asynchronicité.

Finalement Linux a pu réparer le filesystem. Je peux redémarrer    
 
J'ai pas 100% confiance...

function getProductData(HttpClientInterface $httpClient, int $productId): Promise<array>
{
    $metadataPromise = get('https://product-metadata/api/' . $productId);
    $stockPromise = get('https://product-stock/api/' . $productId);
 
    return $metadataPromise.then(m => etc)
}

 
Je ne veux pas enseigner ce que sont les promesses ni comment elles fonctionnent, juste expliquer qu'avec du code asynchrone tu peux effectuer les deux appels "en même temps" mais que tu dois attendre la réponse des deux pour utiliser leur retour.
 
Initialement j'ai ça :
 

function getProductData(HttpClientInterface $httpClient, int $productId): array
{
    $metadataPromise = get('https://product-metadata/api/' . $productId);
    $stockPromise = get('https://product-stock/api/' . $productId);
 
    return all([$metadataPromise, $stockPromise])->then(array $responses) {
        return ['metadata' => $responses[0]->getContent(), 'stock' => $responses[1]->getContent()];
    });    
}

 
Mais j'ai pas l'impression que ce soit plus claire

function getProductData(HttpClientInterface $httpClient, int $productId): array
{
$metadataPromise = get('https://product-metadata/api/' . $productId);
$stockPromise = get('https://product-stock/api/' . $productId);
 
return all([$metadataPromise, $stockPromise])->then(array $responses) {
return ['metadata' => $responses[0]->getContent(), 'stock' => $responses[1]->getContent()];
}); 
}

C'est pas plus clair mais c'est plus correct. Avec le code que tu as donné avant, les deux appels ne sont pas parallèle. Pour faire ça il faut utiliser Promise.all, et pour expliquer Promise.all je pense qu'il faut expliquer les promesses.

function getProductData(HttpClientInterface $httpClient, int $productId): array
{
$metadataPromise = get('https://product-metadata/api/' . $productId);
$stockPromise = get('https://product-stock/api/' . $productId);
 
return all([$metadataPromise, $stockPromise])->then(array $responses) {
return ['metadata' => $responses[0]->getContent(), 'stock' => $responses[1]->getContent()];
}); 
}

C'est pas plus clair mais c'est plus correct. Avec le code que tu as donné avant, les deux appels ne sont pas parallèle. Pour faire ça il faut utiliser Promise.all, et pour expliquer Promise.all je pense qu'il faut expliquer les promesses.

Await c'est bien pour expliquer aux gens qui n'ont pas besoin de comprendre l'asynchronicité comment on se sert d'une promesse.

Mon pote taïwanais (celui qui a créé sa boîte) qui partage une photo où il était à un apéro avec Lisa Su et Jensen Huang oklm.

Tu dois nécessairement expliquer ce que sont les promesses, sinon ça n'a aucun sens. Toute la logique des promesses c'est de représenter une "valeur future", si t'expliques pas ce concept, tu peux pas clarifier l'async sauf à tout passer en callbacks (et ça c'est horrible).

Après expliquer comment elles fonctionnent peut être important à cause de la distinction entre l'async basé sur des tâches et l'async basé sur des coroutines, qui donnent des comportements très différents.

Sauf que ton code avec await comme dit hepha il fait rien en même temps, `await` ça crée un point de synchronisation, donc il fait deux appels séquentiellement comme du code bloquant. C'est tout l'intérêt de await en fait: ça permet de faire des appels async avec un modèle d'exécution séquentiel (donc bloquant).

function getProductData(HttpClientInterface $httpClient, int $productId): array
{
    $metadataPromise = get('https://product-metadata/api/' . $productId);
    $stockPromise = get('https://product-stock/api/' . $productId);
 
    return all([$metadataPromise, $stockPromise])->then(array $responses) {
        return ['metadata' => $responses[0]->getContent(), 'stock' => $responses[1]->getContent()];
    });    
}

function getProductData(HttpClientInterface $httpClient, int $productId): array
{
    $metadataPromise = get('https://product-metadata/api/' . $productId);
    $stockPromise = get('https://product-stock/api/' . $productId);
 
    [$metadata, $stock] = await all([$metadataPromise, $stockPromise]);
    return ['metadata' => $metadata, 'stock' => $stock];
}

Utiliser await n'empêche en rien d'utiliser des composition de promesses, au contraire.

manque C. C. Wei

 
C'est l'heure de tester le disque