Michaël a écrit 2929 commentaires

Sûrement. Dis-moi c'est dans les anneaux ou les corps que tu justifies ce comportement actuel ?

Le comportement que tu pointes n'a rien à voir avec les structures algébriques, c'est encore une manifestation du fait que Python utilises des nombres en virgule flottante pour effectuer ce calcul que tu lui demandes. Vérifier l'égalité de deux nombres en virgule flottante n'est presque jamais la bonne chose à faire et à la place on étudie la taille de la différence, soit en unité absolues soit, plus communément en unités relatives.

Tout cela est expliqué dans le livre de Knuth (Art of Computer Programming) et certainement dans beaucoup d'autres sources.

De la tartine de posts je déduis donc qu'on peut rajouter :

c'est très bien comme ça, on voit pas pourquoi ça devrait changer

Si tu penses qu'il serait plus judicieux que Python utilise de l'arithmétique exacte tant qu'il le peut pour effectuer les calculs, c'est certainement un point de vue défendable, mais je ne vois pas dans tes commentaires ce qui ressemblerait à un effort pour construire un argumentaire là-dessus et à comparer avec les avantages et les inconvénients d'un changement par rapport au status quo.

On a de temps en temps des discussions ici sur le calcul en virgule flottante et les désagrément qu'il peut causer à ceux qui en découvrent les limitations, mais on ne parle presque jamais de ce à quoi sert le calcul en virgule flottante… c'est-à-dire de la raison pour laquelle on a développé cet outil! Réparons cet oubli.

Quand on calcule, disons avec des nombres réels, il y a très peu de nombres que l'on sait représenter et très peu d'opérations que l'on sait mener exactement. Les nombres que l'on sait bien représenter sont les nombres rationnels (avec un numérateur et un dénominateur pas trop gros) et les opérations que l'on sait bien mener sont l'addition, la soustraction, la multiplication, la division et la comparaison.

Si on veut faire exactement ces cinq opérations les nombres rationnels sont le plus grand sous-ensemble (sous-anneau pour être précis) des nombres réels qui marche. Si par exemple j'ajoute un nombre irrationnel comme la racine carrée de 2 par exemple, le calcul symbolique exact reste possible mais la comparaison devient un problème difficile: d'une part il devient coûteux en temps et en espace de déterminer si un nombre est plus grand qu'un autre et tester l'égalité devient aussi un problème – et si on fait abstraction de quelques cas faciles, ces problèmes sont largement irrésolus si on veut travailler avec plusieurs irrationnels simultanément. Ainsi, pour calculer exactement, si on s'en tient aux opérations arithmétique de base, il faut utiliser les nombres rationnels.

Mais les opérations arithmétiques de base ne recoupent pas tout ce qu'on fait en calcul scientifique.

Par exemple la fonction exponentielle, et partant la fonction logarithme et toutes les fonctions trigonométriques prennent des valeur irrationnelles aux point rationnels de la droite réelle (à quelques exceptions notoires, comme exp 0 = 1). Ainsi par exemple exp 2 n'est pas rationnel, comment calculer avec ce nombre? Il y a deux approches, et seulement deux car on ne sait pas faire grand chose d'autre: soit on calcule de façon symbolique soit en prenant une valeur approchée. Le calcul symbolique ne marche que dans les cas les plus simples, si je construis deux expression complexes avec des nombres entiers et des nombres irrationnels obtenus par divers moyens, on ne peut pas les comparer facilement par exemple, et toutes les opérations plus complexes sont impraticables. Le calcul d'une valeur approchée lui est parfois possible. (Mais pas toujours: parfois on sait démontrer l'existence d'un nombre sans que cela en fournisse une méthode de calcul approché, en mathématiques il y a aussi des “constantes universelles”.)

Mais l'exponentielle n'est qu'un exemple! Il existe beaucoup d'autres fonctions classiques comme les fonctions de Bessel, les fonctions gamma d'Euler, par exemple, dont on ne sait pas calculer les valeurs exactement. Si on pratique le calcul intégral, qu'on travaille avec des limites de suites ou de séries, qu'on recherche les zéros d'une fonction, ou encore qu'on recherche la solution d'une équation différentielle, on se retrouve avec autant d'exemples où le calcul symbolique (et a fortiori le calcul sur les nombres rationnels) est impossible à utiliser. C'est précisément à ce genre de calculs que servent les nombres en virgule flottante, et fournissent une très bonne solution: puisque par nature le calcul exact n'est pas possible, autant privilégier la vitesse de calcul. De plus le calcul en virgule flottante donne un cadre où l'on peut utiliser diverses techniques pour maîtriser l'erreur commise – c'est bien-sûr un sujet de recherche en soi! Un exemple simple de ces techniques est la méthode de sommation de Kahan. Pour résumer, le problème de physique les plus complexe qu'on sache résoudre exactement avec les moyens de l'arithmétique exacte est celui de la chute d'un corps soumis à une force (son poids) et pour tout le reste on doit utiliser des techniques de calcul approché. En pratique on utilise une approche mixte: c'est très difficile de construire une bonne approximation pour une fonction arbitraire, donc en pratique on utilise le calcul symbolique pour essayer de construire une méthode de calcul qui tire parti de calculs numériques bien compris!

Pour en revenir à la découverte du journal:

>>> 2 - 1.8 - 0.2
-5.551115123125783e-1

C'est la démonstration que Python n'utilise pas l'arithmétique exacte pour mener ce calcul et si ce n'est pas le comportement escompté il faut se documenter et rechercher la méthode appropriée!

B. Il n'y a pas d'impact performances critiques. En effet un calcul en décimal n'est rien d'autre qu'un calcul avec des entiers en prenant pour convention un placement de la virgule dans la représentation des nombres.

De temps en temps il y a quand-même un petit calcul de PGCD à faire et les calculs sur les grands entiers ne peuvent se faire sur les registres de la machine, donc il y a des va et viens constants entre les registres et la mémoire: le résultat est une pénalité de performance loin d'être négligeable – même si elle peut être parfaitement acceptable!

“On obtient alors le nombre inscrit sur ce carton, qui laisse derrière lui un bon paquet…” dans *Le Professeur Rollin a toujours quelque chose à dire!” :D

Non mais je connais le truc, j'ai fait un IUT informatique, du IEEE-machin j'en ai bouffé. Mais 20 ans après… rien n'a changé, y compris dans un langage qui n'existait pas à l'époque[1]. On voit des chats qui tombent des chaises en fullHD sur Youtube, mais on fait toujours pas une soustraction de nombre difficilement représentables en binaire.

Les nombres en virgule flottante servent à faire du calcul scientifique, si on veut faire de l'arithmétique exacte il faut utiliser une autre structure de données.

Par nature le calcul scientifique est un calcul approché parcequ'on passe son temps à calculer des quantités qu'on ne sait pas calculer de façon exacte, à commencer par les valeurs de la fonction exponentielle ou les racines.

Choisir les structures de données adaptées au problème qu'il veut résoudre – et plus généralement les langages et outils – fait partie des compétences et du métier de programmeur et j'ai bien du mal à comprendre ce qui déplaît?

Il y a des langages qui privilégient l'arithmétique exacte sur le calcul en virgule flottante tant que c'est possible (Common Lisp) mais ce n'est un choix raisonnable que si le langage permet d'une manière ou d'une autre d'insister pour que tel ou tel calcul soit bel et bien exécuté en virgule flottante et beaucoup de langages n'ont pas fait ce choix.

redirection hautaine et foireuse vers wikipédia

Il te taquine sur ton

Je parle de Qwant, (flemme de faire une capture t'as juste à tester pour constater).

faut pas se braquer! Et si tu faisais l'effort de lire la page en question tu lirais:

Because HTTPS piggybacks HTTP entirely on top of TLS, the entirety of the underlying HTTP protocol can be encrypted. This includes the request URL (which particular web page was requested), query parameters, headers, and cookies (which often contain identity information about the user).

Le graissage est de moi!

Si le challenge, c'est de le faire en une seule commande, awk sait écrire sur stderr

En fait awk sait même écrire dans des fichiers, par exemple voici comment obtenir la sortie dans deux fichiers output.a et output.b:

awk -v expr='^a' '{if(match($0,expr)){print $0 >> "output.a"}else{print $0 >> "output.b"}}'

Au passage l'extrait illustre le passage de paramètres à awk ce qu'on peut utiliser pour choisir les noms de fichiers depuis la procédure appelante.

(Cela marche avec awk sans tirer parti d'aucune extension, ce que je souligne pour la portabilité!)

C'est vrai, et le fait que FB pousse le développement de Hack (PHP 7) devrait mettre la pluce à l'oreille…

Là où je travaille (en fait c'était mon dernier jour aujourd;hui, youpi) – c'est pas très gros mais on a déjà plein de clients, on a 1847297 lignes de PHP – mais pas que ;)

Oui mais grâce à l'écriture inclusive avec point milieux on peut tirer sa couette sur son nez et s'endormir en étant persuadé qu'on a œuvré à l'amélioration de la condition des femmes par quelques tweets ou stories facebook, et ça c'est un progrès considérable.

En allemand il y a un genre neutre mais ce n'est pas le genre a priori des objets, par exemple der Tod, la mort, est masculin, das Leben, la vie est neutre, et die Liebe, l'amour est féminin (en français amour n'a d'ailleurs pas de genre bien arrêté, ce que je trouve très juste et très beau). En général l'assignation d'un genre à un mot ne se fait pas selon une règle générale, même s'il y a bien sûr quelques catégories importantes comme tous les individus animés et pas encore sexuellement matures sont neutre, ou les mots formés avec un diminutifs sont neutre. Une autre catégorie importante sont les genres des substantifs dérivés des verbes, où il y a un motif général: ziehen (tirer, traîner, etc.) donne der Zug (le train), die Ziehung (l'attraction, la force de tractation), das Ziehen (le tirage, le fait de tirer).

C'est intéressant qu'en pratique la différence entre genres et nombres (le pluriel ne distingue ni masculin ni féminin dans l'accord, seulement parfois dans la formation des pluriels des noms) peut se partager en deux groupes, avec d'une part le masculin et le neutre qui sont souvent pareil et d'autre part le féminin et le pluriel qui sont souvent pareils (qui portent la même marque d'accord).

Je ne possède aucun bitcoin mais pour taquiner mes collègues, riches de 0.2 à 2.4 bitcoins, j'ai mis un bitcoin ticker dans le prompt du shell. C'est bien, faisez tous comme moi!

➜  jscl git:(explore/react) ✗
bitcoin_ticker_value()
{
    node -e "jsonticker=$(curl -s https://blockchain.info/ticker);console.log(jsonticker['EUR']['15m']);"
}

bitcoin_ticker_info()
{
    printf '[EUR %s]' "$(bitcoin_ticker_value)"
}

bitcoin_ticker_install()
{
    PROMPT='$(bitcoin_ticker_info) '"${PROMPT}"
}

Et le voilà en action (ZSH):

➜  jscl git:(explore/react) ✗ bitcoin_ticker_install
[EUR 14005.31] ➜  jscl git:(explore/react) ✗ 
[EUR 14005.31] ➜  jscl git:(explore/react) ✗ git status 
On branch explore/react
Your branch is ahead of 'origin/explore/react' by 3 commits.
  (use "git push" to publish your local commits)

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   react.html
    modified:   react/example-2.lisp
    modified:   react/react.lisp

Untracked files:
  (use "git add <file>..." to include in what will be committed)

    FFI.md
    HACKING.pdf
    HACKING.tex
    babel-example.js
    lfreact/
    react/example-1.js
    react/example-2.js

no changes added to commit (use "git add" and/or "git commit -a")
[EUR 13969.59] ➜  jscl git:(explore/react) ✗ git add react.html react/react.lisp
[EUR 14530.99] ➜  jscl git:(explore/react) ✗ git commit --fixup=0f6b7b5
[explore/react eaf1779] fixup! Work on the definition of CREATE-CLASS
 2 files changed, 27 insertions(+), 20 deletions(-)
[EUR 13969.59] ➜  jscl git:(explore/react) ✗ 
[EUR 13855.45] ➜  jscl git:(explore/react) ✗ 

L'inconvénient est que si blockchain.info commence à retourner des exploits… etc.

Le virement est uniquement compliqué à suivre parce que les banques ne font aucun effort pour faire autrement.

C'est on ne peut plus vrai. J'habite en Allemagne et on fait tout par virement. Si je paie une facture par virement, je me connecte sur le site de ma banque, dans le formulaire adéquat je saisis l'IBAN, le montant et la référence de mon virement, et voilà: en 4 minutes, c'est réglé.

(Les bazouins papier ça marche aussi, mais c'est un peu rétro, non?)

Top, merci!

Sinon, y'a des chances que ce soit le genre de service qui soit populaire avec des cartes volées. Du coup le système de detection de fraude peut bloquer par défaut.

Sans trancher le sujet on peut laisser ouverte la question de savoir si c'est une bonne chose, en revanche ce dont je suis sûr c'est qu'une banque qui opère ce genre de filtrages a intérêt à avoir une service clientèle qui assure le steackos derrière, ce qui n'est visiblement pas le cas – pour rester poli.

"Curiosité" révélatrice (?) ; si je tape dans la barre de recherche du Menu Mint : "Apache", puis "Mysql-server", il ne me trouve rien.

Démarrer ces services se fait habituellement par la ligne de commande. Ces logiciels sont complexes et ont besoin d'être configurés avant de les démarrer… c'est un sujet en soi!

Remarque pertinente de Michaël, même si je n'ai pas compris tout ce qu'il voulais dire…

Pour développer avec PHP l'interpréteur (le programme /usr/local/bin/php) peut aussi faire office de serveur web. ad hoc c'est du lateing: “Ad hoc est une locution latine qui signifie « pour cela ». Elle s'emploie de nos jours pour « qui a été institué spécialement pour répondre à un besoin.” – tandis que haddock, c'est du poisson! Ici il faut comprendre que le serveur est destiné à être utilisé pour le développement, il permet de commencer à travailler sans se pencher sur la configuration d'un serveur de qualité industrielle comme Apache.

Pour un débutant en PHP ne serait-il pas plus judicieux d'utiliser le serveur ad-hoc livré avec l'interpréteur au lieu de s'occuper de la configuration d'un serveur web? Du style php -S 127.0.0.1:80 -t mon-dossier-de-developpement ?

C'est une bonne question, et moi qui n'ai pas une grande expérience de ce type de contrats, je me demande quelles genre de clauses on trouve pour se protéger de consultants complètements incompétents. (Le plus simple est peut-être d'essayer de parler à leurs anciens clients?)

Il faut importer les bons modules avant. Au delà d'être lourdingue, cela oblige à bien connaître les fonctions de la doc.

Oui bref, c'est un peu longuet et tout par rapport au shell, mais l'avantage c'est qu'on a un vrai langage de programmation (but recherché). Si la concision est vraiment importante on peut se poser la question d'écrire un PPX – ce qui est a priori bien plus simple que d'écrire un langage complet!

Dans un sens dans Gufo, j'ai deux langages qui s'imbriquent: un langage fonctionnel basique qui peut contenir un sous-langage de commande (qui vise a imiter bash). C'est aussi une façon d'aider le nouveau venu: il peut au début utiliser la partie commande et découvrir au fur et à mesure le langage au dessus.

Je comprends bien, mais il ne faut pas perdre de vue qu'il y a une longue histoire de remplacements au shell qui sont tous de façon tout à fait défendable mieux que le shell de Bourne (le /bin/sh historique) mais en pratique ils restent d'utilisation relativement marginale et presque uniquement pour l'usage interactif. La seule explication que j'y trouve est le problème du déploiement que j'évoque dans le commentaire auquel tu réponds: les solutions les plus faciles sont soit d'utiliser ce qui est déjà là soit d'utiliser un langage plus complet qu'on connaît bien et qui permet de programmer concisément, comme par exemple OCaml, Common Lisp, Python, Perl, Ruby, TCL, ou autre…

Je sens qu'a ce moment on va me dire, "oui donc pourquoi c'est mieux que bash", moi, je vais répondre parce que:

À mon avis ce n'est pas du tout la question qui se pose, je pense que tout le monde sera d'accord pour dire que Gufo est mieux que bash, puisque bash est assez limité comme langage de programmation: encore une fois le problème c'est le choix d'une solution par un programmeur qui veut décrire un traitement sur une machine: si je connais bien Bourne et perl disons, qu'est-ce qui me pousserait à apprendre et installer gufo au lieu de soit utiliser Bourne qui est déjà là soit si mon programme est plus complexe, installer perl et toutes les libraries dont j'ai besoin pour programmer ma solution?

2) bash ne dispose pas de vrai fonction (je crois que toute les variables sont globales ou des choses comme ça).

C'est inexact, il y a deux mécanismes qui permettent de limiter la portée des variables: le mot clef local et l'exécution d'un sous-shell.

Puisque tu programmes en OCaml je te signale l'existence de Rashell, une bibliothèque qui permet de facilement interagir avec des programmes externes à la manière de ce que le shell propose. Tu peux l l'essayer avec opam: opam install rashell.

https://github.com/michipili/rashell

En gros je reconnais 3-4 modes d'interaction typiques avec les programmes externes, comme par exemple l'utilitaire qui nous intéresse pour son effet de bord ou sa sortie:

(** Execute the given command and return its exit status, the content
    of stdout and of stderr. *)
val exec_utility : t -> string Lwt.t

La recherche qui produit ses résultats en mode ligne à ligne:

(** Execute the given command and return a stream reading the output
    of the command and its exit status with error output. *)
val exec_query : t -> string Lwt_stream.t

Le test qui nous intéresse par son code de retour

(** Execute the given command and test its exit status. An exit status
    of [0] indicates success of the test, [1] indicates failure of the
    test and other values indicate a general error. *)
val exec_test : t -> bool Lwt.t

et le filtre, qui permet de passer un flot de lignes à travers in filtre UNIX:

(** Execute the given command and return a function mapping streams,
    and its exit status with error output. *)
val exec_filter : t -> string Lwt_stream.t -> string Lwt_stream.t

Avec ces nouvelles primitives, il est facile d'écrire des interfaces bien typées pour plein de commandes Unix, voir le dossier [src](https://github.com/michipili/rashell/tree/master/src) dans le code du projet. Par exemple Rashell_Posix fournit une interface à quelques utilitaires définis par POSIX (find, test, cp, rm, mv, ln, sed, awk, df and du) des fonctions pour utiliser des dossiers ou des fichiers temporaires, ainsi que des interfaces à quelques fonctions de git ou de docker. Par exemple voici le code de Rashell_Git.topleveldir qui retourne le dossier racine d'un dépôt git:

let topleveldir ?workdir () =
  exec_utility ~chomp:true
    (command ?workdir ("", [| ac_path_git; "rev-parse"; "--show-toplevel" |]))

et celui de la commande Rashell_Git.branch_current qui donne le nom de la branche visitée, ou signale une exception lorsque la copie de travail est en “detached HEAD state”:

let branch_current ?workdir ?env () =
  let argv = [| ac_path_git; "rev-parse"; "--abbrev-ref";  "HEAD" |] in
  exec_utility ~chomp:true (command ?workdir ?env (ac_path_git, argv))
  >>= function
  | "HEAD" -> Printf.ksprintf Lwt.fail_with "Rashell_Git.branch_current: %S: The repository is in detached HEAD state."
                (match workdir with Some(path) -> path | None -> ".")
  | branch -> Lwt.return branch

La commande clone de git a de nombreuses options, même en ne tenant compte que d'une fraction d'entre elles on obtient quelque chose de plus touffu:

let clone ?workdir ?env ?template ?bare ?mirror ?origin ?branch ?(config = []) ?depth ?single_branch ?recursive ?reference ?dissociate ?destdir repository =
  let open Printf in
  let configuration =
    Array.concat(List.map (fun (k,v) -> [| "--config"; sprintf "%s=%s" k v; |]) config)
  in
  let argv =
    Array.concat [
      [| ac_path_git; "clone"; |];
      (option "--template" template);
      (flag "--bare" bare);
      (flag "--mirror" mirror);
      (option "--origin" origin);
      (option "--branch" branch);
      configuration;
      (option "--depth" (Maybe.map string_of_int depth));
      (flag "--single-branch" single_branch);
      (flag "--recursive" recursive);
      (option "--reference" reference);
      (flag "--dissociate" dissociate);
      [| repository |];
      (match destdir with
       | Some(x) -> [| x |]
       | None -> [| |]);
    ]
  in
  exec_utility
    (command ?workdir (ac_path_git,  argv))
  >>= fun _ -> Lwt.return_unit

Le module Rashell_Docker et les projets https://github.com/michipili/anvil ainsi que https://github.com/michipili/dockertk fournissent d'autres exemples d'utilisation de Rashell.

Pour en revenir à Gufo c'est un projet certainement intéressant comme véhicule d'apprentissage mais il me semble adopter une approche étrange. Si j'ai à coordonner l'exécution de programmes, il me semble voir deux approches naturelles:

• Utiliser le shell Bourne Cette solution a deux avantages: Prenièrement la présence d'un shell compatible Bourne est garantie sur presque tous les systèmes Unix, soit ni configuration, ni prérequis; deuxièmement le parallélisme et la concurrence y sont facilement utilisables (pour les tâches simples). Les inconvénients sont aussi bien connus que nombreux: langage rustre, difficile d'accès, pas très adapté à la gestion des erreurs ni au traitement de données… etc.

• Utiliser un langage de haut niveau Cette solution résout en principe tous les problèmes du shell, mais il y a un problème de déploiement à résoudre, éventuellement le besoin d'écrire une interface agréable pour utiliser les programmes extérieurs , et le besoin d'apprendre la gestion du parallélisme dans le langage en question – pas forcément difficile mais a priori bien plus complexe que le modèle du shell.

Dans cette grille de lecture, j'ai un peu du mal à voir la place que peut occuper Gufo: si j'ai besoin de configurer la machine sur laquelle je dois effectuer une tâche complexe, autant y installer mon langage préféré et tirer pleinement parti d'un langage puissant et complet.

Dans ce cas, s'il y a un méta à mettre, il faut utiliser la touche escape (J'ai pas trouvé comment faire autrement, alt + alt-gr fait pas ce qu'on espère).

Pour cela il me semble qu'il faut se pencher sur la configuration de xmodmap pour comprendre ce qui se passe. Mes souvenirs sont très lointains mais il me semble que la touche Alt-Gr a un comportement différent de toutes les autres touches (à confirmer avec xev) et qu'elle est plus proche d'une touche d'accent que d'une touche de modification comme SHIFT ou CONTROL.

En ce qui me concerne je préfère utiliser un clavier américain et entrer les caractères exotiques soit en utilisant la TeX-input-method ou bien en saisissant leur nom Unicode via C-x 8 RET.

J'ai pris conscience que l'on pense avec les mots. Et que le gloubiboulga de vocabulaire que j'utilisais quotidiennement avait transformé ma pensée en un gloubiboulga.

Peut-être, mais pas seulement. Je passe sur le fait qu'il existe des contenus de qualité en anglais (p.ex. 1984). En pratiquant des langues étrangères (l'allemand et l'anglais) j'ai constaté un phénomène intéressant: alors qu'en français j'étais amené à amener des jugements toujours mesurés, retenus, ou pondérés, prisonnier d'une sorte d'esprit de finesse ou de finasserie en somme. j'étais dans un premier temps bien loin d'être capable d'exprimer ces nuances dans ces langues étrangères ce qui m'a forcé à revenir vers des catégories plus simples… et à me rendre compte que j'avais en quelque sorte perdu le pouvoir de dire simplement que j'aimais une chose ou non, que j'en souhaitais ou non une autre, et ainsi de suite.

Je ne sais pas parler anglais et je déteste ça, je dois « animer des calls » et je me retrouve à bafouiller, chercher mes mots et à finir par répondre « euh yes » à des phrases provenant d’accents texans ou chinois que je ne comprends pas.

Apparemment c'est une source de frustration ou de tracas pour toi et outre l'aspect “thérapie de groupe” que peuvent avoir les commentaires il me semble ici que tu aurais intérêt à changer ta situation. Il y a plein d'actions possibles, comme par exemple

• Changer d'employeur
• Demander à ton employeur de ne plus participer aux calls
• Demander à ton employeur de t'aider à apprendre l'anglais – vu la place que ça semble prendre dans ta vie pro, c'est une demande certainement légitime et qui va dans l'intérêt de l'entreprise.
• T'intéresser à des contenus en anglais.
• Te lier avec des gens avec qui la langue de communication naturelle serait l'anglais.

Ce qui est à privilégier dépend de ce dont tu as envie, pour moi, si j'ai longtemps utilisé l'anglais au boulot (recherche maths: écrit, exposés, etc.) j'ai commencé à apprécier l'anglais à partir du moment où j'ai eu des amis avec qui la langue d'échange était l'anglais: à partir de ce moment il y avait une dimension de plaisir dans la pratique de la langue. Si tu habites dans une ville de taille moyenne ou plus grande ou une ville universitaire, il y a certainement des des lieux d'échanges internationaux, cela pourrait être un endroit à visiter, et puis il y a évidemment les voyages.

J'ai appris l'allemand pour beaucoup en regardant Verbotene Liebe un soap-opéra caricatural à en donner la nausée. Mais pour la langue c'est idéal: 25 minutes par jour en semaine, peu de personnages donc on s'habitue à leur façon de parler, situations banales, attendues et récurrentes, donc on comprend même sans complètement saisir les dialogues… et puis j'au regardé le cœur a ses raisons un pastiche de grande qualité qui donne une bonne grille de lecture du soap-opéra et rend le genre drôlissime.

C'est un monde un peu touffu, je pense que le plus simple est de prendre les choses dans l'ordre historique: dans un ordinateur il y a une partie facilement remplaçable, le logiciel et une partie difficilement remplaçable le matériel. Jusque les années 60 les logiciels étaient écrits pour tourner sur des ordinateurs spécifiques puis on a isolé un ensemble de fonctions qu'on pouvait réutiliser d'un programme à l'autre: les fonctions pour écrire ou lire des fichiers, intéragir avec l'utilisateur, notamment. Ce sont les prémisses de ce qu'on appelle aujourd;hui un système d'exploitation. UNIX est un système d'exploitation qui est apparu à cette époque, et de nombreuses parties en ont été copiées, il y a eu trois projets libres principaux (jusqu'au début des années 90) que l'on connaît encore aujourd'hui.

• GNU, dont le but a été de créer tous les programmes de base qui permettent de travailler sur UNIX, sous forme de logiciels libres.

• BSD, qui a en gros le même but que GNU mais une généalogie et une idée différente de ce que veut dire “libre” dans logiciel libre.

• Linux, qui est un noyau, c'est à dire la partie du sytème d'exploitation qui connaît les détails du matériel qu'elle fait fonctionner.

Donc pour récapituler, UNIX était le nom d'un système d'exploitation dans les années 60 et aujourd'hui c'est une grande famille avec plein de cousins. Ubuntu est un de ces cousins, c'est un système d'exploitation dont une partie est le noyau Linux, une autre partie des logiciels du projet GNU, et enfin des logiciels de plein d'autres sources – comme il y a des parties d'origines différentes, on parle de distribution et Debian, RedHat, OpenSuse, Gentoo, etc. sont autant de distributions qui se basent aussi sur Linux et le projet GNU, on parle de distribution GNU/Linux, ou par raccourci (qui ajoute à la confusion des débutants) juste de “Linux”, comme on parle parfois de la table pour désigner le repas.

Mais c'est vrai que par rapport à Windows, où il me semblait que je "comprenais tout" (sans rien comprendre en fait), là j'ai plus peur de faire de mauvaises manipulations. Par contre, c'est beaucoup plus excitant car on à moins le sentiment de consommer des plats tout préparés.

Ce qui empêche de faire des progrès dans Windows, c'est que les notions ne sont pas très clairement séparées et plutôt cachées alors que avec un système du style de Linux on est très vite confronté à la complexité du système: fichiers, processus, programmes, etc., ce qui donne la chance de se faire une idée claire de ce que sont toutes ces choses. Savoir si c'est une bonne ou mauvaise chose dépend grandement de tes motivations: que tu sois animée par la curiosité, le désir d'apprendre à travailler de façon plus productive, l'envie d'apprendre à programmer, intéressée par les aspects moraux des logiciels libres, etc. ou bien un mélange de tout cela, sont autant de raisons pour préférer Linux ou plus généralement un système de type UNIX.

L'idéal serait que tu apprennes rapidement à faire des sauvegardes: si tu casses tout sur ta machine tu pourras facilement la restaurer, sans perdre tes données personnelles, ce qui te permettra d'expérimenter plus librement. Une approche plus sophistiquée consiste à utiliser une machine virtuelle. Un logiciel comme VirtualBox te permet de “simuler un ordinateur dans ton ordinateur” (box est un argot/slang pour ordinateur) ce qui te fournit un autre terrain d'expérimentation. Si tu as besoin de ton ordinateur pour travailler, c'est certainement cette solution que tu devrais privilégier. Essayer de réparer le logiciel d'un ordinateur qu'on a cassé est justement une bonne occasion d'affiner ses compétences en diagnostic!

Je suis désolée pour mes questions bêtes, mais du coup même en essayant de suivre les tutoriels je suis bloquée…

Salut Delphine, il n'y a pas de questions bêtes! Pour beaucoup de communautés en ligne “grand-public” comme LinuxFR un des termes du contrat implicite de vie commune est qu'on est en général ravi d'aider les débutants à surmonter leurs blocages et à affiner leurs compétences. Tes messages sont bien écrits, polis et enjoués et témoignent de ta rechercher personnelle et de ta volonté de structurer les difficultés que tu rencontres: ne change rien, tout est très bien! (D'autres visiteurs qui semblent plus à la recherche d'une bonne âme pour faire leurs devoirs ou leur travail à leur place peuvent être accueillis fraîchement mais cela ne concerne pas ta démarche!)

Si tu es intéressée par la configuration de ton système, comme le suggère ta question, tu pourrais t'aider d'un document qui explique les bases du travail sous Unix, qui te permettrait d'avoir une vision claire sur le système de fichiers et les programmes… un texte que je pourrais te recommander s'il s'appliquait à Linux serait le chapitre 4 du manuel de FreeBSD un autre système libre de type Unix. Debian semble fournir un équivalent pour GNU/Linux: https://www.debian.org/doc/manuals/debian-reference/ch01.fr.html mais la traduction en français n'est pas complète… peut-être que quelqu'un aurait une autre référence à proposer?

Surtout, n'hésite pas à poser tes questions ici ou ailleurs, à expérimenter sur ton système – ou sur une machine virtuelle si tu veux être sûre de ne pas tout casser, et bon courage!