1
Hi, everyone! Welcome back to Ask the New Guy! If you have a simple question, contact me at copil.yanez@gmail.com. Today’s question is: Q: I hear people talk about ‘compiling from source.’ What does that mean? A: Seriously? You’re going there? Fine. Compiling from source is one of those things that separates the wheat from the chaff. The folding chair from the Aeron. Justin Bieber from Chris Martin (because, apparently, Chris is a hardcore Ubuntu user, and Justin still runs Windows 95 *snort*). There’s your life before you learned to compile from source, and everything that comes after.
Salut, tout le monde ! Bon retour dans Demandez au Petit Nouveau !
Si vous avez une question simple, contactez-moi à copil.yanez@gmail.com.
La question du jour est :
Q J'entends parler de la « compilation à partir des sources ». Qu'est-ce que cela veut dire ?
R Vous êtes sérieux ? Vous voulez en faire ?
Bien.
La compilation à partir des sources est un des trucs qui distingue les torchons des serviettes. Le bon grain de l'ivraie. Justin Bieber de Chris Martin (parce que, apparemment, Chris est un utilisateur Ubuntu convaincu et Justin est toujours sous Windows 95 *grognement*). Il y a votre vie avant d'apprendre à compiler à partir des sources et tout ce qui viendra après.
2
Let me be very clear about this. First, there’s no going back. Once you learn to compile from source, anything is possible. Second, contrary to everything you read online, learning to compile from source will not, I repeat, NOT, make you more attractive. Also, you won’t be able to move things with your mind, or breath underwater. Invisibility? Not even a real thing. Compiling from source opens up new dimensions in Ubuntuing (a word I’m still desperate to make happen). But it won’t give you superhuman powers. Are we all clear on the limitations? Okay, good. Let’s learn what compiling from source is. Then you can try it at home, under controlled conditions, and, preferably, with a loved one standing by to tell you how normal you still are when it’s all over. First, the dreaded explanation of what ‘compiling from source’ even means. This is where I go out and read page after mind-numbing page that explains what something means, all so that I can come back here and distill the information into a completely unintelligible, grossly unintelligent, marginally usable definition that’s almost always riddled with factual errors, and may even cast aspersions at your mother’s honor just for laughs. Just part of my charm.
Je voudrais être très clair à ce sujet. Primo, il n'y a pas de retour en arrière possible. Une fois que vous aurez appris à compiler à partir des sources, tout est possible.
Secundo, contrairement à tout ce qui se lit en ligne, apprendre à compiler à partir des sources ne vous rendra pas, je répète, PAS, plus attirant. Et aussi, vous ne pourrez pas déplacer des choses par télépathie ou respirer sous l'eau. L'invisibilité ? C'est même pas réel.
La compilation à partir des sources ouvre de nouveaux horizons dans votre façon d'utiliser Ubuntu (je ne désespère pas de créer le néologisme Ubuntuer). Mais cela ne vous donnera pas des pouvoirs surhumains. Vous avez bien saisi les limites ?
Bon, d'accord. Nous allons apprendre ce que c'est que la compilation à partir des sources. Après, vous pourrez l'essayer à la maison, dans des conditions contrôlées et, de préférence, avec un être cher à côté, prêt à vous dire combien vous êtes normal une fois que ce sera terminé.
D'abord, l'explication redoutée de ce que la « compilation à partir des sources » signifie. C'est ici que je pars lire un ouvrage abrutissant expliquant la signification d'un truc, afin que je puisse revenir distiller l'information en une définition qui soit complètement incompréhensible, extrêmement inintelligente, tout juste utilisable, presque toujours truffée d'erreurs factuelles et puisse même calomnier l'honneur de votre mère, juste pour rire. Ça fait partie de mon charme.
3
Let’s start with an explanation of an executable. What?! I thought we were talking about source code and compiling! And now you throw this curveball? Well, actually, I’m throwing you a tarball, but we’re getting ahead of ourselves. Look, just calm down and trust that I’ll lead you out of this dark cave we entered without a map. I know this place like the back of my hand, and there’s a backpack with light sticks and sandwiches right over here. . .er. . .over here. No, wait, it’s right here. . .you know what? We all gon die! Back to executables. An executable is simply a program your Ubuntu operating system can understand and use. If you’re using the graphical interface, and click on LibreOffice, the program that runs is an executable. Executables use binary code, a sort of magic and sorcery that humans can’t read unless they’re Neo from The Matrix. It’s just a bunch of ones and zeros that look like gibberish to you and me, but Ubuntu gets all hot and bothered about. How is it possible to create programs if humans can’t read, write, or work directly with the gibberish of an executable file? That question, my friend, leads us back to source code.
Commençons par une explication d'un fichier exécutable.
Quoi ?! Je pensais qu'on parlait de code source et de la compilation ! Et maintenant, vous me lancez cette balle pourrie ?
En fait, je vous lance un « tarball », mais, là, nous allons plus vite que la musique. Bon. Calmez-vous et faites-moi confiance. Je vais vous faire sortir de cette ténébreuse caverne dans laquelle nous sommes entrés sans carte. Je connais l'endroit par cœur et il y a un sac à dos avec des lampes torches et des sandwiches juste ici…, errr…, ici. Non, attendez, c'est ici… Vous savez quoi ? Nous allons tous mourir !
Retournons aux exécutables. Un exécutable est tout simplement un programme que le système d'exploitation Ubuntu peut comprendre et utiliser. Si vous vous servez d'une interface graphique et cliquez sur LibreOffice, le programme qui se lance est un exécutable.
Les exécutables utilisent du code binaire, un genre de magie et de sorcellerie que les êtres humains ne savent pas lire à moins d'être Neo dans Matrix. Ce n'est qu'un amas de uns et de zéros qui ressemble à du charabia à vous et à moi, mais cela fait chauffer Ubuntu.
Comment peut-on créer des programmes si les humains ne peuvent ni lire, ni écrire, ni travailler directement avec le charabia d'un fichier exécutable ? Cette question, mon ami, nous ramène au code source.
4
See? I told you we’d get out of that cave! Granted, we’re now knee deep in quicksand and sinking fast. But no worries. I have something in my backpack just for this. My backpack that’s over there, at the edge of the sandpit. Just out of arm’s reach. Dammit, we’re gonna die again! Relax, source code is just a list of instructions that a human can read, write, and interact with. Those instructions are written using a programming language like C++, and they can be turned into an executable (more on how in a minute). So writing a program in Linux goes something like this: The spark of creation > programmer fires up C++ > programmer writes a bunch of code she can read and understand > that code gets turned into an executable somehow > end user runs the executable. Why wouldn’t programmers go all the way through to turning their source code into an executable? Are programmers inherently lazy? Hm, not gonna touch that question with a ten foot pole.
Vous voyez ? Je vous avais bien dit qu'on sortirait de cette caverne ! Oui, d'accord, maintenant nous sommes dans du sable mouvant jusqu'aux genoux et nous coulons rapidement. Mais pas de problème. J'ai un truc dans mon sac à dos exprès pour ceci. Le sac à dos qui est là-bas, au bord de la sablière. Juste hors de portée. Merde, nous allons mourir à nouveau !
Détendez-vous. Le code source n'est qu'une liste d'instructions qu'un être humain peut lire, écrire et avec lesquelles il peut interagir. Les instructions sont écrites dans un langage de programmation comme C++ et elles peuvent être converties en exécutable (des détails sur comment dans une minute).
Donc, écrire un programme pour Linux se passe à peu près comme ceci : l'étincelle de l'inspiration > le programmeur lance C++ > il ou elle écrit des tonnes de code qu'il ou elle peut lire et comprendre > d'une façon ou d'une autre, ce code est transformé en un exécutable > l'utilisateur final lance l'exécutable.
Pourquoi les programmeurs n'iraient-ils pas jusqu'au bout et transformeraient-ils pas leur code source en exécutable ? Les programmeurs sont-ils foncièrement paresseux ?
Hmmmm, je ne vais absolument pas me mêler de cela.
5
Actually, there are plenty of reasons why a programmer wouldn’t want to go all the way through to creating the executable. First, it takes time. And the bigger and more complex the program, the longer it takes to create the executable. More importantly, each distro is slightly different. The programmer would have to create a slightly different executable for each distro. So even with smaller programs, a few minutes for each executable needed for different distros would mean a programmer could spend hours just on executables. That’s a lot of time that could be better spent creating new programs or consuming vast amounts of bacon. What’s more, having an executable that can’t be played with, modified, updated or patched by others kind of defeats the purpose of open source programs. See, you can go from source code to an executable, but not the other way around. So let’s say you have the perfect tweak to an open source program, but all you have is the executable. You can’t turn that back into source code to modify the code and add that killer fix. So a programmer will release the source code and now everyone can play with it. When someone needs to run it on his particular distro, he simply compiles the final executable. Hey! We’re out of the quicksand! We’re finally back to the original question, what does it mean to “compile” from source code?
En fait, il y a un tas de raisons pour lesquelles un programmeur ne voudrait pas aller jusqu'au bout et créer un exécutable. D'abord, cela prend du temps. Plus long et plus complexe est le programme, plus ça prend du temps pour créer l'exécutable. Plus important encore, chaque distrib. étant légèrement différente, le programmeur devrait créer un exécutable légèrement différent pour chaque distrib. Ainsi, même avec de petits programmes, les quelques minutes nécessaires à chaque exécutable pour les différentes distrib. signifierait qu'un programmeur pourrait passer des heures sur rien d'autre que des exécutables. Cela fait beaucoup de temps qui pourrait être mieux utilisé à la création de nouveaux programmes ou à la consommation d'énormes quantités de bacon.
Qui plus est, un exécutable qu'on ne peut pas bidouiller, qui ne peut pas être modifié, mis à jour ou corrigé par d'autres personnes va à l'encontre de l'objectif des programmes Open Source. Parce vous pouvez transformer du code source en un exécutable, mais pas l'inverse. Supposons que vous ayez l'ajustement parfait pour un programme Open Source, mais tout ce que vous avez entre les mains, c'est l'exécutable. Vous ne pouvez pas le retransformer en code source pour pouvoir modifier le code et ajouter votre correctif génial.
Ainsi, un programmeur sortira le code source et tout le monde peut jouer avec. Quand quelqu'un a besoin de l'exécuter sur sa distrib. spécifique, il lui suffit de compiler l'exécutable final.
Ouah ! Nous sommes sortis du sable mouvant ! Nous sommes enfin revenus à la question originelle : qu'est-ce que ça veut dire, « compiler » à partir du code source ?
6
When you compile the source code, you’re using a program, known as a compiler, to take the program you created in one language, and turn it into a program in a second language. So it’s like either using a computer version of the Rosetta Stone, or mixing ground chicken parts into chicken feed; the recursiveness of it all has me a little confused. But you get the idea. Compiling is the process of taking those human-readable instructions (the source code) and turning it into machine-readable instructions (sometimes called the object code) that make up the executable. Let’s update that flowchart for writing a program. Now, it looks something like this: Case of Red Bull delivered by Amazon Prime > spark of caffeine-fueled creation > programmer fires up C++ > programmer writes source code > programmer compiles source code > end user runs the executable. Now here’s the exciting part: where it says “programmer compiles source code,” that can be you! No waiting around for a pesky programmer to do it for you. No begging your Ubuntu-hipster friend, the one who goes on about how he was totally into Ubuntu when it was just a little gleam in Mark Shuttleworth’s dreamy eyes. You can do it! Yes, you!
Pour compiler du code source, vous utilisez un programme, appelé compilateur, qui prend le programme que vous avez créé en un langage et le transforme en un programme en un autre langage. Ainsi, c'est similaire soit à l'utilisation d'une version informatique de la pierre de Rosette, soit au mélange de morceaux hachés de poulet avec de la pâtée pour volailles ; la récursivité de tout cela me rend assez perplexe.
Mais vous en comprenez les grandes lignes. La compilation c'est le processus qui reprend les instructions lisibles par des humains (le code source) et les transforme en instructions qui composent l'exécutable et qui sont lisibles par la machine.
Mettons à jour le diagramme représentant l'écriture d'un programme. Cela ressemblera à ceci : Amazon Prime livre une caisse de Red Bull > étincelle d'inspiration alimentée par la caféine > programmeur lance C++ > programmeur écrit le code source > programmeur compile le code source > l'utilisateur final lance l'exécutable.
Et voici la partie passionnante : là, où ça dit « programmeur compile le code source », ça peut très bien être vous ! Pas la peine de patienter en attendant qu'un programmeur enquiquinant le fasse pour vous. Pas besoin de mendier de l'aide de votre copain Ubuntu-cool, celui qui ne cesse de parler du fait qu'il était déjà totalement conquis par Ubuntu alors que ce n'était encore qu'une lueur dans les beaux yeux de Marc Shuttleworth.
Vous pouvez le faire ! Oui, vous !
7
If you’ve been using Ubuntu for a long time, and have never had the need to compile from source, I’m not surprised. Before Ubuntu was popular (so, for the ten minutes before anyone heard about it), not all programs were compiled for our distro. But as time went on, and more people used Ubuntu, fewer programs needed to be compiled because someone had already done it. So instead of downloading a file that contained the source code, and then compiling it for your operating system, you simply downloaded the executable. Better yet, you just went into the Software Center and installed it from there. But every now and again, there’s a program out there that you want or need, that’s written for Linux, and that hasn’t been made available through the Software Center. Do you just throw up your hands and pout? Maybe. And if your significant other is a power user, that might actually do the trick. But if not, you can handle it yourself. Here’s how. First, you need the source code, the instructions in C++ or other programming language that, when compiled, will become the executable program. These come in many flavors, but they usually look something like this: FILENAME.tar.gz
Si vous utilisez Ubuntu depuis longtemps et n'avez jamais eu besoin de faire une compilation à partir de la source, cela ne m'étonne pas. Avant qu'Ubuntu ne soit devenu populaire (c'est-à-dire pour la dizaine de minutes avant que les gens en aient entendu parler), tous les programmes n'étaient pas compilés pour notre distrib. Mais, au fur et à mesure que le temps passait et que plus de gens utilisaient Ubuntu, moins de programmes avaient besoin d'être compilés, car quelqu'un l'avait déjà fait. Donc, au lieu de télécharger un fichier contenant le code source, puis de le compiler pour votre système, vous téléchargiez l'exécutable. Mieux encore, vous vous rendiez à la Logithèque Ubuntu et l'installiez à partir de là.
Mais, de temps en temps, il existe un programme que vous désirez ou dont vous avez besoin, écrit pour Linux, et qui n'est pas disponible dans la Logithèque. Est-ce que, tout simplement, vous baissez les bras et boudez ? Peut-être. Et si votre tendre moitié est un utilisateur avancé, cela pourrait éventuellement fonctionner. Mais, sinon, vous pouvez vous en occuper vous-même. Voici comment.
Tout d'abord, il faut avoir le code source, les instructions en C++ ou d'autre langages de programmation qui, une fois compilées, deviendront le programme exécutable. Il y en a beaucoup de versions, mais, en général, les fichiers de code source ressemblent à ceci :
FILENAME.tar.gz
8
A tar file is the bundle of files that make up the source code. Because the tar bundle can get pretty big, you sometimes use gzip to compress them into a file ending in .gz. Once you download the tar file, it’s time to extract it. You can do that at the command line by typing: tar -xzf FILENAME.tar.gz You may have already guessed that to unpack a tar file, you use the tar command. You’ll see some letters after the dash (xzf). These are called switches, and they tell Ubuntu to do certain things to the file that follows. In this case, we ask the tar command to unzip (z) and then extract (x) the following tar file (f). Once the file is extracted, you need to configure it. Unlike compiling, configuring involves finding out what kind of computer you’re running, and then “configuring” the source code to work with it. Assuming you’re running as root administrator, here’s the command to configure the source code: ./configure Now that you have the source code, and you’ve configured it for your particular computer, you would think the last step of compiling the source code would use a command like, say, oh, I dunno, COMPILE!! Yeah, not so much.
Un fichier tar est l'ensemble de fichiers qui composent le code source. Parce que l'ensemble tar peut être très conséquent, vous utilisez gzip parfois pour les compresser en un fichier qui se termine par .gz.
Une fois le fichier tar téléchargé, le moment est venu de l'extraire. Vous pouvez faire cela en ligne de commande en tapant :
tar -xzf FILENAME.tar.gz
Vous avez peut-être déjà deviné que pour extraire un fichier tar, vous utilisez la commande tar. Vous verrez quelques lettres après le tiret (xzf). Elles s'appellent des commutateurs et elles disent à Ubuntu de faire certaines choses avec le fichier dont le nom suit. Dans ce cas, avec la commande tar, nous demandons qu'elle dézippe (z), puis qu'elle extraie (x) le fichier tar qui suit (f, comme « follow », c-à-d suit).
Une fois le fichier extrait, vous devez le configurer. Contrairement à la compilation, la configuration nécessite de savoir quelle sorte d'ordinateur vous utilisez, puis de « configurer » le code source pour qu'il fonctionne avec. En supposant que vous êtes en train de faire tout ceci en tant qu'administrateur root, voici la commande qui configure le code source :
./configure
Maintenant que vous avez le code source et qu'il est configuré pour votre ordinateur, vous pourriez penser que la dernière étape de la compilation du code source serait l'utilisation d'une commande telle que, disons, ben, j'sais pas, COMPILE !! Ouais, pas tant que ça.
9
Instead, you’ll use the Make command, like this: make Simple, right? This command looks at the configured source code and compiles it into an executable that will run on your computer. Technically, this is the compile step in the expression “compile from source.” Woohooo, you’ve compiled from source! Is that it? Maybe. If you’re one of those totally evolved beings who would climb to the top of Everest and not take any pictures, then I guess you are. The rest of us need something to remember this momentous occasion by. Like, maybe, by using the actual program we just compiled. Our last step, then, is to install the executable. To install the program you just compiled, we use the Make command again like this: make install This puts all the compiled files where they’re supposed to go. Think of it as a really good usher at the theater, who makes sure you’re not seated on top of someone else, which happens a lot more than most people realize. Now you can run the program! The program YOU compiled all by yourself! From the command line, no less!
À la place, vous allez utilisez la commande Make, comme ceci :
make
Facile, non ? Cette commande examine le code source configuré et le compile pour qu'il devienne un exécutable qui fonctionnera sur votre ordinateur. Techniquement parlant, c'est l'étape de compilation dans l'expression « compilation à partir des sources ».
Ouah, vous avez fait de la compilation à partir des sources ! C'est tout ? Peut-être. Si vous êtes l'un des êtres totalement évolués qui grimperaient jusqu'en haut de l'Everest sans prendre la moindre photo, alors, oui, vous avez terminé. Nous autres avons besoin de pouvoir nous souvenir de ce grand événement. Comme, peut-être, d'utiliser le programme que nous venons de compiler. La dernière étape devient donc l'installation de l'exécutable. Pour installer le programme que vous venez de compiler, nous utilisons la commande Make à nouveau, comme ceci :
make install.
Cela place tous les fichiers compilés à l'endroit où ils devraient être. Pensez-y comme d'une très bonne ouvreuse au théâtre, qui s'assure que vous ne vous asseyez pas sur quelqu'un d'autre, ce qui n'est pas aussi rare que les gens pensent.
Maintenant, vous pouvez lancer le programme ! Le programme que VOUS avez compilé tout seul ! Et à partir de la ligne de commande qui plus est !
10
Go, YOU! Now listen to me, LISTEN TO ME! I suggest you take a little break, have a cookie, and just relax for the rest of the day. I can’t count the number of times I’ve heard about a new user learning to compile from source, and then going out and signing up for MMA lessons because she thought she was Ronda Rousey! Like most things you can do in Ubuntu, compiling from source can get pretty complicated, pretty fast. Start with small programs, preferably ones with decent wikis or README files that explain any tricky bits. Besides allowing you to use programs that might not be easily available for your system, learning to compile gives you the freedom to work directly with the program. It’s like giving you the keys to a really cool car and letting you go under the hood to add a supercharger. There’s something about seeing the actual code used to create the executable that gives you a sense of power! I have, like, this overwhelming urge to run outside and toss the caber! HULK SMASH! I just compiled from source! Think I’ll join a Fight Club. Good luck, and happy Ubuntuing!
VOUS, pas si vite !
Écoutez-moi, ÉCOUTEZ-MOI ! Je vous conseille de faire une pause, manger un petit gâteau et tout simplement vous détendre pour le reste de la journée. Je ne peux pas compter le nombre de fois où j'ai entendu parler d'une nouvelle utilisatrice qui a appris à compiler à partir des sources, puis est partie s'inscrire à des leçons de MMA (Mixed Martial Arts), parce qu'elle s'imaginait être Ronda Rousey ! [Ndt : CF http://fr.wikipedia.org/wiki/Ronda_Rousey]
Comme la plupart des trucs que vous pouvez faire sous Ubuntu, la compilation à partir des sources peut se compliquer très, très vite. Commencez avec de petits programmes, de préférence avec des wikis décents ou des fichiers README qui expliquent les parties les plus délicates.
À part vous donner la possibilité d'utiliser des programmes qui ne sont peut-être pas facilement disponibles pour votre système, apprendre la compilation vous donne la liberté de travailler directement avec le programme. C'est comme si on vous donnait les clés d'une voiture géniale et vous permettait d'ouvrir le capot pour ajouter un turbocompresseur.
Voir le véritable code utilisé pour créer l'exécutable vous donne, en quelque sorte, une sensation de puissance ! J'ai un peu comme une tentation presque irrésistible de sortir et lancer un tronc d'arbre à l'écossaise !
HULK SMASH ! J'ai gagné ! Je viens de faire une compilation à partir des sources !
Je vais m'inscrire dans un Fight Club.
Bonne chance et amusez-vous bien avec Ubuntu !