moi1392 a écrit 740 commentaires

Sans entrer dans le débat pour ou contre exFat dans linux, quelles alternativent existent aujourd'hui ?
J'utilise un support externe pour lequel FAT ne me convient pas (à cause de ses nombreuses limitations) et qu'il m'arrive d'utiliser sur des machines ou mon uid est différent.
Pour l'instant il est en ext4 et je bidouille pour m'en sortir, mais je pense sincèrement qu'un système de fichier sans gestion des utilisateur serait plus pratique pour ce genre de support.

Est ce que des personnes ici ont le même soucis ? et si oui, quelle est leur solution ?

Ça dépends de ce que tu appelles la droite. Dans ton exemple, c'est juste utiliser pour trouver l'élément suivant de la liste des processus, parce qu'ils sont représentés sur un graphe planaire pour aider à la compréhension.
Mais dans le cas général, il n'y a pas de processus "à droite" d'un autre.
Si on reprends le formalisme de la page wikipédia, et en particulier le quatrième point :
"Circular wait: each process must be waiting for a resource which is being held by another process, which in turn is waiting for the first process to release the resource. In general, there is a set of waiting processes, P = {P1, P2, …, PN}, such that P1 is waiting for a resource held by P2, P2 is waiting for a resource held by P3 and so on until PN is waiting for a resource held by P1"

Il fonctionne avec n=1, comme dans le cas que j'ai explicité dans mon poste précédent :

Le premier process P1 detiens une resource, et est en attente d'une resource (la même en l'occurence) détenue par le process suivant, mais comme P1=PN car il n'y a qu'un process, le process suivant se trouve être P1 lui même ("PN is waiting for a resource held by P1").
La boucle est bouclé, sans faire intervenir de notion de droite.

Je ne vois pas pourquoi tu as besoin de séparer le cas >= 4 boules et les autres ?
Je suis allé voir la page wikipedia pour voir si cela parlait d'un cas particulier, mais, sauf si j'ai raté un truc, c'est bien une page sur les deadlock en général. (je ne sais pas s'il y a un terme dédié en français, j'utilise "interblocage" que j'ai lu à plusieurs endroits).

Et dans le cas général, un seul process est suffisant pour avoir un interblocage, exemple avec un pseudo code C :

RESSOURCE resource;
lock(resource);
lock(resource); // oups, to process est bloqué sans possibilité de se débloquer !

Donc, une boule suffit.
Après, si on exclu ce cas un peu particulier (qui peut tout de même arriver dans un programme complexe si on ne fais pas un minimum attention), ton exemple avec l'animation et les boules fonctionne très bien (ou très mal, selon le point de vue) avec 2 boules.

déjà un print après un return, ne risque pas d'écrire grand chose.
ensuite, tu peux débuter le compteur de ta seconde boucle après le compteur de la première, car toutes la valeurs précédentes auront déjà été testées lors d'itérations précédentes.

return std::set(tableau, tableau+taille).size() < taille;

Plus sérieusement,
1) il n'y a pas de question, donc difficile de donner une réponse.
2) je pense que c'est un exercice qui a pour but de te faire apprendre l'algorithmique et la manipulation de tableau en C, Et le mieux pour apprendre, c'est tatonner, se tromper, chercher pourquoi, comprendre, corriger l'erreur, et repartir pour un cycle.

on n'a vu une avancée sociale venir des patrons

Je t'invite à rechercher le nom d'Oscar Wünschendorff dans cette page : https://epitome.hypotheses.org/1429

Après, je suis d'accord que c'est un cas plutôt rare…

Je suis d'accord, c'est juste que je n'ai pas l'impression qu'il y a un consensus clair pour les setter de membre de classe.
Personnellement (je ne suis pas une référence, mais j'aime bien donner mon avis quand même :p) je conserve la version "const ref" dans la majorité des cas, et quand j'ai des cas particuliers ou cela peut faire une vraie différence, je me pose la question et je choisi au cas pas cas.

blablabla a […] des conséquences délirantes
et
blablabla impossible à mesurer pour la majorité des cas d’usages

tu n'as pas l'impression que ta remarque est auto contradictoire ?

C'est pour ça que depuis C++11 (depuis qu'on a la sémantique de déplacement), il est conseillé de passer ce genre de paramètre par valeur, et plus par référence.

Ce point n'est pas aussi clair. Prends l'exemple suivant :

void A::set_b(B b) {
  if(b == this->b) {
    return;
  }
  this->b = b;
}

et ailleurs dans le code :

B some_b = ...;
A* a = ...;
a->set_b(some_b);

si la variable some_b est égal à a::b, qui est un cas pas délirant du tout dans un contexte classique d'exécution de code, alors tu as une copie de B qui a lieu alors qu'elle n'aurait pas eu si B était passé en référence constante.

À mon avis, le C++ est un langage complexe et seuls des développeurs déjà un peu expérimentés avec d'autres langages devraient se lancer dans son apprentissage. Pour un premier langage, Python ou Go me semblent plus pertinents : ils permettent de faire beaucoup de choses avec moins de complexité que le C++.

Moi j'ai eu le chemin inverse, 1 mois de basic, quelques mois de C/C++, un petit passage par l'assembleur (x86), et je suis remonté vers du C++. Puis, j'ai appris d'autres langages.
Ça s'est très bien passé et avec le recul je trouve que je n'aurais pas fait mieux en commençant par autre chose pour arriver par la suite au c++
Je dirais donc que cela dépend de la personne, de sa façon d'apprendre et de comprendre les choses.

Ce qui est difficile, c'est de l'implémenter et comprendre comment cela marche, à utiliser je trouve ça aussi (peu) naturel que la séparation par des virgules ou autre. Voir même un poil mieux, mais je ne sais pas à quel point mon "naturel" est biaisé par mes habitudes.

Après, faire du c++ sans comprendre comment cela marche, ça n'est pas idéal et si une personne en arrive à faire cela, c'est que de toute façon elle n'aura ni les compétences ni la compréhension nécessaires pour tirer partie du langage.

J'avais zappé ces paramètres ! merci pour l'info.

Perso, la première chose que j'ai faite après avoir acheté mon téléphone, et démarrer en mode bootloader pour en installer un nouveau et mettre un lineageos sans les app google dessus.
Du coup le système constructeur n'a jamais démarré du tout (sauf peut etre en usine)
Après, cela ajoute pas mal de contraintes… déjà pour le choix du téléphone, ensuite pour ce que je peux installer dessus et faire.
J'utilise fdroid pour certaines fonctionnalités essentielles pour moi, comme osm pour la navigation.
Mais je comprends bien que cela puisse rebuter pas mal de monde de ne pas avoir accès au store google.

Après, j'ai l'avantage de n'avoir, à priori, aucun espiongiciel d'installé (je n'ai pas fait de recherche très poussée sur linéageos, si quelqu'un a des infos dessus, je suis preneur), que mon tel soit plutôt réactif et son interface relativement épurée.

Merci, c'est exactement ce que je cherchais.

mélanger différents technologies ?
C'est du code c++, quand tu lance firefox et battle for wesnoth sur ta machine, tu as déjà "différentes technologies" sur ton système.
As tu déjà rencontrer des soucis de stabilité dans ce cas de figure ?

Il y a peut être d'autres bonnes raisons de na pas faire cela (les services démarrés, les configurations/associations par défaut, …), mais le "ménlager différentes technologies" n'en est certainement pas une…

ça marche absolument sans soucis par bluetooth chez moi, et je n'ai rien eu à configurer ! j'ai remarqué cela par hasard sur mon (pc) portable.

https://www.freedesktop.org/wiki/Software/systemd/NetworkTarget/

As tu tenté un module (?) systemd ?
Tu as des cibles simple que tu peux mettre en dépendances qui ton module sera démarré/arrêté quand une de ces cibles deviens valide/invalide.

Je peux avoir des exemples ? parce que moi, qui n'utilise pas zsh, mais qui ait un collègue qui l'a, ai remarqué au moins une dégradation de performance nette : l'auto complétion des cible de compilation ninja quand il y en a beaucoup (pareil avec make, mais c'est moins flagrant)
Dans le projet de ma boite (un très gros logiciel avec plein de libs, plugins, … qui compile tout d'un coup), bash me complète mes cibles en 2/3 secondes, alors que zsh sur la machine de mon collègue, je l'ai ctrl+C au bout d'environ 10 secondes d'attente !
Le second point, mais avec bash cette fois (je n'ai pas testé avec zsh), c'est que la complétion ne se fait pas quand l'extension ne corresponds pas au programme utilisé, et ce même s'il n'y a qu'une seule possibilité !
exemple : tu sais que tu as une archivé zippée (et la commande file te confirme bien que c'est un zip), mais qui ne fini pas en .zip, l'auto complétion bash refuse de compléter, même quand c'est la seule possibilité, tu dois tout taper à la main…
Est ce que zsh est meilleur sur ce point ?

alors comme il y a beaucoup d'araignées, elles descendent au sol et font une colonne de 1 m de haut. La colonne se déplace jusqu'à la mouche et l'araignée du haut peut la manger

je parlais rétrospectivement de ce que j'ai vu/su de l'histoire récente de l'informatique (depuis le milieu de année 90 je dirais)
Je n'ai pas dit que ce qui était plus simple à utiliser était forcément moins fiable, mais que dans les fait récents, souvent, une relative simplicité d'utilisation allait de pair avec une fiabilité moindre, et que le choix des utilisateurs/acheteurs/clients allait dans ce sens là.
On choisi la simplicité d'utilisation même dans les cas où c'est moins fiable (en terme de bugs ou de sécurité), et mon étude très sérieuse basée sur la subjectivité de ma mémoire pifomètrisée me dit que cela à bien plus souvent été le cas que le contraire (plus simple et plus fiable)
Après, on peut discuter ce point bien sur.

ça dépends, on peut très bien imaginer un bit de protection dans les entrée de la TLB (j'ai fait une petite recherche sur le web, mais je n'arrive pas à trouver de réponse)
Dans ce cas la, l'exécution prédictive peut juste s'arrêter si la TLB renvoie une page seulement accessible en ring 0 (et que l'on est en Ring 3)
Après, si la page accédée n'est pas dans la TLB, de toute façon ça va être (relativement) lent, donc la encore, ajouter un bit de vérification ne tuera pas les perfs je pense.

ça semble jouable, quelqu'un sait si ce genre de protection existe, et si oui, pourquoi elles ont merdé dans le cas présent ?

elle est beaucoup liée à des décisions techniques et industrielles, voire commerciales (et même politiques) ; il y a peu de problèmes réellement intrinsèques au principe de commercialiser un logiciel.

Les utilisateurs/clients ne sont pas complètement à mettre hors de cause.
Beaucoup préfères un clickodrome bogué, mal conçu, qui rame et a des tas de souçis qu'un système plus sain mais plus complexe à appréhender et à maîtriser.
Du coup les efforts de développement vont plus facilement dans ce sens. Et c'est normal d'un point de vue commerciale pour une boite, sinon elle coule faute de clients.

Il semble dire que l'option "activer" à disparu du menu contextuel.

Peut être que le noyau est bien celui par défaut, et qu'il faut juste redémarrer pour y passer ?

Juste pour info, l'exemple du copy on write pour les std::string en c++ est aujourd'hui faux sur la plupart des implémentations de la bibliothèque standard.
Par exemple, la libstdc++ fournie par le projet GCC a changé cette implémentation lors de la sortie de gcc 5 car elle pose beaucoup de soucis de performance à cause des protections multi thread.

Ça explique effectivement la différence ! Merci.