<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Victor Gallet on Medium]]></title>
        <description><![CDATA[Stories by Victor Gallet on Medium]]></description>
        <link>https://medium.com/@TheElkantor?source=rss-dd5928f4a1b8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*5uB3h7zp4HZNpL8ahc3I8A.jpeg</url>
            <title>Stories by Victor Gallet on Medium</title>
            <link>https://medium.com/@TheElkantor?source=rss-dd5928f4a1b8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 14:30:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@TheElkantor/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Miracle Morning (for entrepreneurs)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@TheElkantor/the-miracle-morning-for-entrepreneurs-ecc0d5e92792?source=rss-dd5928f4a1b8------2"><img src="https://cdn-images-1.medium.com/max/2600/0*XN7UZE2h4Fz6MCVL" width="2678"></a></p><p class="medium-feed-snippet">Nouvel article, nouvelle ann&#xE9;e (d&#xE9;j&#xE0; bien entam&#xE9;e par ailleurs). Il est temps de changer un petit peu la formule&#xA0;!</p><p class="medium-feed-link"><a href="https://medium.com/@TheElkantor/the-miracle-morning-for-entrepreneurs-ecc0d5e92792?source=rss-dd5928f4a1b8------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@TheElkantor/the-miracle-morning-for-entrepreneurs-ecc0d5e92792?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/ecc0d5e92792</guid>
            <category><![CDATA[miracle-morning]]></category>
            <category><![CDATA[développement-personnel]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Tue, 18 Feb 2020 12:16:03 GMT</pubDate>
            <atom:updated>2020-02-18T12:16:03.890Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How to add hot reload to your raylib proj(in C) ?]]></title>
            <link>https://medium.com/@TheElkantor/how-to-add-hot-reload-to-your-raylib-proj-in-c-698caa33eb74?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/698caa33eb74</guid>
            <category><![CDATA[hot-reload]]></category>
            <category><![CDATA[c]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[raylib]]></category>
            <category><![CDATA[c-programming]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Wed, 13 Feb 2019 06:54:51 GMT</pubDate>
            <atom:updated>2019-02-13T06:54:51.748Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to add hot reload to your raylib project (in C) ?</h3><p>In this article, I’m going to present you the real advantages of hot reloading when creating a game with raylib, and show you how you can do it yourself quite easily.</p><h3>First, what is raylib ?</h3><p><a href="https://www.raylib.com/">Raylib</a> is something I (really) always wanted. When I discovered it, back last year, it was a blast for me.</p><p>I always wanted to create games (or prototypes) easily, just by coding. <br>Without fancy editor in which you can spend hours. <br>Without extra “features that are so awesome you certainly need hours to learn how to use them, by watching deadly long tutorial videos” like in traditionnal game engines (Unity, Unreal Engine, Lumberyard…). Just to be clear, I used both Unity and Unreal, and they are great. You can do really good stuff with them, quickly, and they both have a great code design. <br>But you know, I’m a programmer, and what I really enjoy is actually writting code without beeing forced to search for hours in documentations how to use some components. I also like to have a total freedom regarding the architecture of the projects I work on, on my free time (if I want to experiment a full data-oriented and/or functional oriented design architecture, I can do it without any constraint). And precisely, because it’s on my free time, I think, the really first thing that matters is to enjoy doing it, no ? Otherwise it makes no sense (at least for me). And with that state of mind, raylib was just the framework I needed!</p><p>So raylib is an old plain C (C99) game framework, which works with opengl3.3 (or opengl ES). It has everything you need to create simple (or not so simple actually…) games including abstractions for dealing with sounds, images, meshes, shaders…</p><p>The best part is that it’s written in C, and you know that C is awesome when it comes to create bindings! So there are lots of bindings for lots of other programming languages like Go, Lua, Rust… In fact, it’s quite easy to create your own binding, because raylib depends on really few other external libraries. Actually, there is just GLFW to handle the window creation.</p><p>Raylib includes emscripter and the android headers + GLES, which signifies that you can build your game for the web, or for android if you want. Actually, there are a quite numbers of targets you can build to, including Windows (of course, you even can build your game as a W10 app), Linux, OSX, FreeBSD, and even Raspberry!</p><p>And the best part of raylib, is that the API is really tiny. There are no functions you don’t need. Everything is well named. You just need <a href="https://www.raylib.com/cheatsheet/cheatsheet.html">the cheatsheet</a>, and you are good to go! No need to look for documentation during hours! You actually can spend most of your time on writting the game instead of looking for how to use some components. Told you, it’s a blast!</p><p>With all of these reasons, I think you understand now why I love raylib! It’s tiny, in old plain C, open source, with a very permissive licence. That gives a really solid framework for beginners (and advanced programmers) to create games, or whatever other graphic application you want to create.</p><h3>So now, let’s dive into the main topic : hot reloading!</h3><p>First, some obvious questions you may be able to ask if you are developing your game, or whatever software, are : what is hot reload, and why should I ever want to add this feature to my program ?</p><p>So, hot reloading consists of reloading some parts (or even huge parts) of your code, at runtime. By default, raylib is written in C, and you know that C (like any other system language) is compiled into an executable file. So, traditionnaly, if you want to make even quick changes to your program, you always need to go through these steps :</p><ul><li>shut down the program</li><li>do your changes</li><li>recompile it (and make sure you don’t have any error)</li><li>relaunch your program</li><li>come back where you were before the changes</li><li>look if your changes are correct</li></ul><p>For short software, that probably not take a long time. But believe me, for more complicated programs, like games, or whatever other software with lots of UI included, for example, it actually can become a huge pain in the ass really quickly.</p><p>Why do you think developers came to love the web, with HTML/CSS and JS or even PHP ? The answer is quite simple : you make a change, you reload the page, and you see your change in realtime!</p><p>It’s a huge time savier when developing whatever kind of software, if you can iterate as fast as you can, without taking the cost of wasting time by recompiling and relaunching the project, every single time you modify some piece of code.</p><p>For this reason, lots of interpreted languages have emerged like Lua, Python, Ruby… Now, the most popular programming language out there is actually an interpreted language as well : JS (with the huge impact of NodeJS in the programming world).</p><p>In the game development industry, Lua was a classical choice until few years (and still is in some studios). But many choosed to build their own “visually scripting language”, which seem to be a norm now. Like the Blueprint system of Unreal Engine 4 for example (every huge game studio in the world has it’s own “Blueprint” system inside its game engine, from Guerilla Games with the Decima Engine, to Massive and its SnowDrop Engine…). These visual scripting languages give the possibility to non-programmers to make some quick changes to the code without having to ask to programmers to do it, and see in realtime their modifications. It’s a killer feature to prototype faster!</p><p>So, why don’t we use one of these language, make binding for it, or even create our own scripting language ?</p><p>The answer for me is quite simple : first, (personnaly), even if that sounds incredibly interesting, I’ve no time to build a scripting language. I don’t have enough free time, and all I want is to create some basics games with raylib, not languages. Then, a scripting language is, by it’s core nature, like I said, “interpreted”. Which means that, at runtime, the program needs to go through the scripting code, and “translate” it into instcructions, on the fly. It has a cost.</p><p>But you may answer, for us, with raylib, and if all we want is to create a simple game, this runtime cost is not a big deal. And you are right. But a scripting language brings an other problem, I think, which is more problematic. By using one of them, for specific part of your game (like IA for example) you will have two pieces of software to maintain : the core code of your program (in C/C++ in our case), and the scripting code.</p><p>And, if you screw up at some point on your bindings with the scripting language, you’ll have horrible bugs to resolve.</p><p>On the other hand, what we can do, to keep beeing as productive as we can, and iterate quickly, is to implement hot reload, with dll files (on windows, so files on Linux). And it’s a real chance that raylib is written in C (instead of C++ for example), because it’s much more easier to do with old plain C, where you have no classes, just a bunch of structures and functions.</p><h3>It’s time to show some code example!</h3><p>So, how to do it ? First, let’s create a really simple program using raylib and <a href="https://github.com/raysan5/raygui/blob/master/src/raygui.h">raygui</a> (which is an “addon” of raylib for creating GUI items quickly).</p><p>Here’s is our file named “main.c”, which contains the main function :</p><pre>#include &quot;raylib.h&quot;<br>#define RAYGUI_IMPLEMENTATION<br>#include &quot;raygui.h&quot;</pre><pre>int main(void){<br>    InitWindow(1280, 720, &quot;Test&quot;); // 1280x720 window named &quot;Test&quot;<br>    while(!WindowShouldClose()){<br>        BeginDrawing();<br>            ClearBackground(RED);<br>        EndDrawing();<br>    }<br>    CloseWindow();<br>    return 0;<br>}</pre><p>We can compile it with this command on Windows using mingw, assuming <em>raylib.h</em> and <em>raygui.h</em> are in the <em>include</em> folder, and that <em>raylib</em> + <em>glfw3</em> are available as static libraries inside the <em>libs</em> folder:</p><pre>gcc main.c -I./include -L./libs -lglfw3 -lraylib -lopengl32 -lgdi32 -o main.exe</pre><p>Finally, we got the <em>main.exe</em> executable file which just creates a window, and fill it with red, which we can launch with this command :</p><pre>./main.exe</pre><p>Really simple.</p><p>So now, let’s add some GUI. Let’s add a button, by using raygui, to this boring red window:</p><pre>#include &quot;raylib.h&quot;<br>#define RAYGUI_IMPLEMENTATION<br>#include &quot;raygui.h&quot;</pre><pre>int main(void){<br>    InitWindow(1280, 720, &quot;Test&quot;); // 1280x720 window named &quot;Test&quot;<br>    while(!WindowShouldClose()){<br>        BeginDrawing();<br>            ClearBackground(RED);<br>            if(GuiButton((Rectangle){ 500, 200, 250, 60 }, &quot;TEST BUTTON&quot;)) {<br>                puts(&quot;Button pressed\n&quot;);<br>            }<br>        EndDrawing();<br>    }<br>    CloseWindow();<br>    return 0;<br>}</pre><p>Again, it’s really simple, we are just adding a button with the text <em>TEST BUTTON</em> by using the <em>GuiButton</em> function from <em>raygui</em>. This button will be positioned at x=500, y=200, and it will be 250px long and 60px large.<br>If the button is pressed, we show on the console :<br><em>Button pressed</em></p><p>To be cleaner, I cutted the definitions part from the code of <em>raygui.h</em> (which contained by default declarations and definitions, it’s a header-only file), and I compiled it into a static library which I copied/pasted into the <em>libs</em> folder.</p><p>So now, we can compile the code with the same previous gcc command, just think about adding <em>-lraygui</em> statement as a parameter, before <em>-lglfw3</em>. And then execute the program to test our code, like before.</p><pre>gcc main.c -I./include -L./libs -lraygui -lglfw3 -lraylib -lopengl32 -lgdi32 -o main.exe</pre><p>So now, you agree that we have a simple program which just contained a window and a button. But if we want to modify everything related to this GUI, we need to recompile it every single time, and relaunch it. Yeah, boring stuff…</p><p>It’s time to dive into the fun part with hot reloading!</p><p>First, let’s split our code, by creating some abstraction here, with a new file simply called <em>core.c</em> in our case (which will be inside the <em>src</em> folder, and for clarity, we move <em>main.c</em> inside this folder too), associated with its <em>core.h</em> header file (which is inside the <em>include</em> folder).</p><pre>// inside core.h</pre><pre>#pragma once</pre><pre>void core_create_window(<br>    const unsigned short in_width,<br>    const unsigned short in_height,<br>    const char* in_title<br>);<br>void core_execute_loop();<br>bool core_window_should_close();<br>void core_close_window();</pre><pre>// inside core.c</pre><pre>#include &quot;core.h&quot;<br>#include &quot;raylib.h&quot; <br>#define RAYLIB_IMPLEMENTATION <br>#include &quot;raygui.h&quot;</pre><pre>void core_create_window(<br>    const unsigned short in_width,<br>    const unsigned short in_height,<br>    const char* in_title<br>){<br>    InitWindow(in_width, in_height, in_title);<br>}</pre><pre>void core_execute_loop(){<br>    BeginDrawing();<br>        ClearBackground(RED);<br>        if(GuiButton((Rectangle){ 500, 200, 250, 60 }, &quot;TEST BUTTON&quot;)) {<br>            puts(&quot;Button pressed\n&quot;);<br>        }<br>    EndDrawing();<br>}</pre><pre>bool core_window_should_close(){<br>    return WindowShouldClose();<br>}</pre><pre>void core_close_window(){<br>    CloseWindow();<br>}</pre><p>Which signify that our <em>main.c</em> file just includes <em>core.h</em> now, with no need of raylib header files. And it simply call functions from <em>core.c</em> (our abstraction layer).</p><pre>// inside main.c</pre><pre>#include &quot;core.h&quot;</pre><pre>int main(void){<br>    core_init_window(1280, 720, &quot;Test&quot;); // 1280x720 window named &quot;Test&quot;<br>    while(!core_window_should_close()){<br>        core_execute_loop();<br>    }<br>    core_close_window();<br>    return 0;<br>}</pre><p>So, if we compile our program with the following commands, it should do the exact same thing as before :</p><pre>// Compiling the core.c file into an object file<br>gcc -c ./src/core.c -I./include -o core.o</pre><pre>// Compiling the full project to get the executable file<br>gcc ./src/main.c core.o -I./include -L./libs -lraygui -lglfw3 -lraylib -lopengl32 -lgdi32 -o main.exe</pre><p>The result is a final <em>main.exe</em> executable file, which does the exact same thing as previously.</p><p>But until now, we can’t modify our program at runtime, without relaunching it. So it’s time to add the hot reload feature!</p><p>Hot reload on windows means dll files. So, in fact, with our example here, we need to transform our <em>core.o</em> file into a dll file, and get its functions by adress in our <em>main.c</em> file to be able to call them. Basically, it’s all we need.</p><p>But first, we need to add some definitions in our <em>core.h</em> header file, to tell the compiler to build <em>core.c</em> as a shared library (dll), when passing a specific option as parameter at the compiling step (in our case, that will be <em>BUILD_LIBTYPE_SHARED</em>).</p><pre>// inside core.h</pre><pre>#pragma once</pre><pre>#if defined(_WIN32) &amp;&amp; defined(BUILD_LIBTYPE_SHARED)<br>    #define CORE __declspec(dllexport) // We are building core as a Win32 shared library (.dll)<br>#elif defined(_WIN32) &amp;&amp; defined(USE_CORE_LIB_SHARED)<br>    #define CORE __declspec(dllimport) // We are using core as a Win32 shared library (.dll)<br>#else<br>    #define CORE // We are building or using core as a static library<br>#endif</pre><pre>void core_create_window(<br>    const unsigned short in_width,<br>    const unsigned short in_height,<br>    const char* in_title<br>);<br>void core_execute_loop();<br>bool core_window_should_close();<br>void core_close_window();</pre><p>Now these definitions are added, we can compile the <em>code.c</em> file as a dynamic library (dll).</p><p>To do so, with gcc, we just need to add one command : <em>gcc -shared file.o -o file.dll</em>, after creating the <em>core.o</em> file, to assemble it into a dll file :</p><pre>// Compiling the core.c file into an object file<br>// The option BUILD_LIBTYPE_SHARED indicates that we<br>// are building the core.c file to be used as a dll<br>gcc -c -DBUILD_LIBTYPE_SHARED core.c -I./include -o core.o</pre><pre>// Assembling the core.o object file into a dll file<br>gcc -shared core.o -o core.dll</pre><p>Finally, we have an independant piece of code in C, which can be used in our main program (inside <em>main.c</em>). <br>But how can we do that ?</p><p>The first thing to do, is to include the <em>libloaderapi.h</em> file in the <em>main.c</em> file, but to be as clean as possible, we will include it only if we are using <em>core.c</em> as a dll file. If we are using our <em>core.c</em> file traditionnaly, simply as an object file, we don’t want to include this <em>libloaderapi.h</em> file in our project. Remember, you always want to include the less dependencies you can (it’s really important for compilation speed).</p><p>You may probably ask why we are using this header file specifically, instead of just using the classic <em>windows.h</em>. In fact, there are two reasons:</p><ul><li>First, the obvious one, by including <em>windows.h</em>, you are actually including a lot of code in your project. Lot’s of code that you probably will never use. So again, I repeat myself but it’s important, keep in mind, whenever you can import as less as needed code in your project, do it! It’s really a time savier when compiling the entire project.</li><li>On the other hand, raylib defines some basic structures for its needs, and you can have terrible issues by importing <em>windows.h</em> due to the fact that there are some structures defined in <em>windows.h</em> which share the same name as the one from raylib. For example, raylib defines a structure named <em>Rectangle</em>, which is defined as an other structure inside <em>windows.h</em> (for gdi purpuses). So, except if you want to modify raylib, and rename some structures and functions by yourself, don’t use <em>windows.h</em>.</li></ul><p>Let’s come back to the topic.</p><p>The other problem we face, which let us choose between two choices, is whether we link to raylib (the static library) inside our dll, or inside the executable file.</p><p>Both decisions could be made, but they bring very different solutions to resolve the loading functions part. <br>In one case, we need to retrieve the state of the program from the dll, to the <em>main.c</em> file, to be able to restore it whenever we recompile the dll. <br>In the other case, we need to give to the dll pointers to raylib functions, to be able to use them from our <em>core.c</em> file.</p><p>The method I choose is the second one, because it’s less difficult to do (at least I think). If raylib was initialized on the heap instead of the stack, I probably had choose the first one. Because, when you initialize variables on the stack, whenever you recompile the program/dll, all of these variables are reset to their default values. But if it’s initialize on the heap, the variables don’t changes when recompiling the dll. They already are in memory, we just need to squizz the initialization step, which already has been done, and we are good to go!</p><p>So, keep in mind I choosed the second option, the one which consists of linking raylib in our main program, and making a <em>bridge</em> to give the functions pointers of raylib to our dll. <br>Now it’s said, let’s continue the code example!</p><p>The first thing to do, is to prepare a function in our <em>core.c</em>, only available when we are building this file as a dll, which will do the bridge between the raylib functions from our <em>main.c</em> file, to the dll.</p><p>So in order to be able to use these functions (from raylib and raygui), we also need to prepare some functions pointers variables, to store them in the dll file, to be able to use them later. Because remember, we don’t link raylib and raygui as static libraries in our dll file. We need <em>brige</em> functions.</p><p>I created a function called <em>core_load_raylib_functions</em> to achieve this goal inside <em>core.c</em>, and because it’s a function that will only be used when we are compiling <em>core.c</em> as a dll, there is no need to declare it inside the <em>core.h</em> header file.</p><p>Finally, I removed the includes of raylib and raygui inside <em>core.c</em> to place them in the main program, not in the dll (so inside <em>main.c</em>).</p><pre>// inside core.c</pre><pre>#include &quot;core.h&quot;</pre><pre>// Only for Hot Reload<br>#if defined(_WIN32) &amp;&amp; defined(BUILD_LIBTYPE_SHARED)<br>    /* Below are the functions pointers we need to make the bridge<br>    between the main.c (which contains raylib and raygui)<br>    and this core.c which will be converted to a dll.*/</pre><pre>    /* To be short, it&#39;s to be able to call raylib and raygui<br>    functions even if we are not linking them as static libraries<br>    into this dll. */</pre><pre>    // Raylib functions<br>    void (*raylib_init_window)(int width, int height, const char* title);<br>    void (*raylib_close_window)();<br>    bool (*raylib_window_should_close)();<br>    void (*raylib_begin_drawing)();<br>    void (*raylib_end_drawing)();<br>    void (*raylib_clear_background)(Color color);</pre><pre>    // Raygui functions<br>    bool (*raygui_gui_button)(Rectangle bounds, const char *text);<br>    void (*raygui_gui_set_style)(int control, int property, int value);</pre><pre>    // This function will be one of the first one to be load <br>    // from this dll in main.c. It&#39;s role is actually to initialize<br>    // our raylib and raygui functions pointers, to create the bridge.<br>    CORE void core_load_raylib_functions(<br>        void (*const in_init_window)(int width, int height, const char* title),<br>        void (*const in_close_window)(),<br>        bool (*const in_window_should_close)(),<br>        void (*const in_begin_drawing)(),<br>        void (*const in_end_drawing)(),<br>        void (*const in_clear_background)(Color color),<br>        bool (*const in_gui_button)(Rectangle bounds, const char *text),<br>        void (*const in_gui_set_style)(int control, int property, int value)<br>    ){<br>        // Raylib functions<br>        raylib_init_window = in_init_window;<br>        raylib_close_window = in_close_window;<br>        raylib_window_should_close = in_window_should_close;<br>        raylib_begin_drawing = in_begin_drawing;<br>        raylib_end_drawing = in_end_drawing;<br>        raylib_clear_background = in_clear_background;</pre><pre>        // Raygui functions<br>        raygui_gui_button = in_gui_button;<br>        raygui_gui_set_style = in_gui_set_style;<br>    }<br>#else<br>    // I redefine the raylib and raygui functions<br>    // I use here, because whenever we are using the dll<br>    // or not, I want to be able to have one single code,<br>    // without #if/#else in the functions below.<br>    <br>    // Raylib functions<br>    #define raylib_init_window InitWindow<br>    #define raylib_close_window CloseWindow<br>    #define raylib_window_should_close WindowShouldClose<br>    #define raylib_begin_drawing BeginDrawing<br>    #define raylib_end_drawing EndDrawing<br>    #define raylib_clear_background ClearBackground</pre><pre>    // Raygui functions<br>    #define raygui_gui_button GuiButton<br>    #define raygui_gui_set_style GuiSetStyle<br>#endif</pre><pre>void core_create_window(<br>    const unsigned short in_width,<br>    const unsigned short in_height,<br>    const char* in_title<br>){<br>    raylib_init_window(in_width, in_height, in_title);<br>}</pre><pre>void core_execute_loop(){<br>    raylib_begin_drawing();<br>        raylib_clear_background(RED);<br>        if(raygui_gui_button((Rectangle){ 500, 200, 250, 60 }, &quot;TEST BUTTON&quot;)) {<br>            puts(&quot;Button pressed\n&quot;);<br>        }<br>    raylib_end_drawing();<br>}</pre><pre>bool core_window_should_close(){<br>    return raylib_window_should_close();<br>}</pre><pre>void core_close_window(){<br>    raylib_close_window();<br>}</pre><pre>// inside main.c</pre><pre>#include &quot;core.h&quot;</pre><pre>// Whenever we will pass this option to the compiler, we will be able to use our core.c code as a dll<br>#if defined(CORE_USE_LIBTYPE_SHARED) <br>    #include &lt;libloaderapi.h&gt;<br>    #include &quot;raylib.h&quot;<br>    #include &quot;raygui.h&quot;<br>#endif</pre><pre>int main(){<br>    // This code is necessary only if we are using hot reload<br>    #if defined(CORE_USE_LIBTYPE_SHARED)<br>        HINSTANCE dll_handle = NULL; // Declare a pointer to the dll resource</pre><pre>        // We need to initialize some function pointers, because, <br>        // as mentioned before, by using a dll, we will load every functions<br>        // we need to use from raylib, to our dll, (think of it as a bridge), <br>        // because our dll is not aware of raylib. <br>        // We are not linking its static library in our dll file.<br>        void (*core_load_raylib_functions_func)(<br>            void (*const in_init_window)(int width, int height, const char* title),<br>            void (*const in_close_window)(),<br>            void (*const in_begin_drawing)(),<br>            void (*const in_end_drawing)(),<br>            void (*const in_clear_background)(Color color),<br>            int (*const in_get_key_pressed)(),<br>            bool (*const in_is_key_down)(int key),<br>            bool (*const in_gui_button)(Rectangle bounds, const char *text),<br>        );</pre><pre>        // Functions pointers to be able to store and call functions from <br>        // our dll file (the initialization of the window, the exec loop function...)<br>        void (*core_init_window_func)();<br>        void (*core_execute_loop_func)();<br>        void (*core_exit_func)();</pre><pre>        // Load our core.dll file as a dynamic library.<br>        // Regarding to the official windows documentation, the second parameter of &#39;LoadLibraryExA&#39;<br>        // is always NULL (just here for future need), and the last one corresponds to a flag<br>        // which determine the action to be taken when loading the module. In our case, we use the <br>        // default action (so the flag is 0)<br>        dll_handle = LoadLibraryExA(&quot;./core.dll&quot;, NULL, 0);<br>        if(dll_handle != NULL){<br>            // Load the &#39;core_load_raylib_functions&#39; function from the dll into the<br>            // &#39;core_load_raylib_functions_func&#39; function pointer<br>            core_load_raylib_functions_func = (void*) GetProcAddress(dll_handle, &quot;core_load_raylib_functions&quot;);<br>            if (NULL == core_load_raylib_functions_func){<br>                printf(&quot;Can&#39;t call core_load_raylib_functions dll function&quot;);<br>                exit(1);<br>            }else{<br>                // If the function is correclty loaded, then we call it, <br>                // and we pass the functions from raylib and raygui<br>                // we need.<br>                // It&#39;s the bridge between our main.c and our dll, to <br>                // retrieve the raylib and raygui functions.<br>                core_load_raylib_functions_func(<br>                    &amp;InitWindow,<br>                    &amp;CloseWindow,<br>                    &amp;BeginDrawing,<br>                    &amp;EndDrawing,<br>                    &amp;ClearBackground,<br>                    &amp;GuiButton,<br>                    &amp;GuiSetStyle<br>                );<br>            }<br>            core_init_window_func = (void*) GetProcAddress(dll_handle, &quot;core_init_window&quot;);<br>            if (NULL == core_init_window_func){<br>                printf(&quot;Can&#39;t call core_init_window dll function&quot;);<br>                exit(1);<br>            }else{<br>                // If the &#39;core_init_window&#39; function is correclty<br>                // loaded from the dll, we call it right now to<br>                // initialize the window.<br>                core_init_window_func();<br>            }<br>            core_execute_loop_func = (void*) GetProcAddress(dll_handle, &quot;core_execute_loop&quot;);<br>            if (NULL == core_execute_loop_func){<br>                printf(&quot;Can&#39;t call core_execute_loop dll function&quot;);<br>                exit(1);<br>            }<br>            core_exit_func = (void*) GetProcAddress(dll_handle, &quot;core_exit&quot;);<br>            if (NULL == core_exit_func){<br>                printf(&quot;Can&#39;t call core_execute_loop dll function&quot;);<br>                exit(1);<br>            }<br>        }else{<br>            // A problem occured when trying to load the dll file.<br>            // The most common mistake is a wrong given path to<br>            // the dll file.<br>            printf(&quot;Can&#39;t load the dll file.\n&quot;);<br>            exit(1);<br>        }<br>    #else<br>        // If we are not using the dll configuration, <br>        // then we just need to call the &#39;core_init_window&#39; function<br>        // from core.c<br>        core_init_window();<br>    #endif</pre><pre>    // Main loop<br>    while(1){<br>        #if defined(CORE_USE_LIBTYPE_SHARED)<br>            // We call the function loaded from the dll<br>            core_execute_loop_func();<br>        #else<br>            // If we are not using the dll configuration, <br>            // we direclty call the function from core.c <br>            core_exec_loop();<br>        #endif<br>    }<br>    #if defined(CORE_USE_LIBTYPE_SHARED)<br>        core_exit_func();<br>        // Important line here, we need to free the dll<br>        FreeLibrary(dll_handle);<br>    #else<br>        // If we are not using the dll configuration,<br>        // simply call the &#39;core_exit&#39; function from core.c<br>        core_exit();<br>    #endif<br>    return 0;<br>}</pre><p>Okay, now it’s done, we are able to compile it by using the dll file.</p><p>To do so, here are the commands we need :</p><pre>// Compiling the core.c file into an object file <br>// (the option USE_CORE_LIB_SHARED is passed to be able to have proper functions <br>// which can be called from a dll file)<br>gcc -c core.c -I./include -DUSE_CORE_LIB_SHARED -o core.o</pre><pre>// Assembling the core.o object file into a dll file<br>gcc -shared core.o -o core.dll</pre><p>Then, we can compile our <em>main.c</em> file, and create the executable:</p><pre>// Compiling the full project to get the executable file<br>gcc main.c -I./include -L./libs -lraygui -lglfw3 -lraylib -lopengl32 -lgdi32 -o main.exe</pre><p>As you probably noticed, we removed the <em>core.o</em> file from this command, because we are not using it anymore (we actually are loading and using at runtime the dll file which was assembled from this <em>core.o</em> file).</p><p>And now, if we run the application:</p><pre>./main.exe</pre><p>We got the exact same result as before. So our dll has correclty been loaded, and everything is properly working!</p><p>But, we are not able to load our code at runtime yet. We don’t have hot reload available so far.</p><p>I think you probably can figure out what we need to do to be able to do it now.<br>Personnaly, I like to be able to press on a key to pause the program, make some changes, recompile the dll file, and just press enter in the terminal to continue the program with my changes loaded on the fly.</p><p>To do so, we need to make an other bridge function between our <em>core.c</em> (dll) and <em>main.c</em> file (main program), to be able to know when the touch is pressed, and tell the main loop that we need to pause the program until we make our changes.</p><pre>// inside core.c</pre><pre>#include &quot;core.h&quot;</pre><pre>// Only for Hot Reload<br>#if defined(_WIN32) &amp;&amp; defined(BUILD_LIBTYPE_SHARED)<br>    /* Below are the functions pointers we need to make the bridge<br>    between the main.c (which contains raylib and raygui)<br>    and this core.c which will be converted to a dll.*/</pre><pre>    /* To be short, it&#39;s to be able to call raylib and raygui<br>    functions even if we are not linking them as static libraries<br>    into this dll. */</pre><pre>    // Raylib functions<br>    void (*raylib_init_window)(int width, int height, const char* title);<br>    void (*raylib_close_window)();<br>    bool (*raylib_window_should_close)();<br>    void (*raylib_begin_drawing)();<br>    void (*raylib_end_drawing)();<br>    void (*raylib_clear_background)(Color color);</pre><pre>    // Raygui functions<br>    bool (*raygui_gui_button)(Rectangle bounds, const char *text);<br>    void (*raygui_gui_set_style)(int control, int property, int value);</pre><pre>    // This function will be one of the first one to be load <br>    // from this dll in main.c. It&#39;s role is actually to initialize<br>    // our raylib and raygui functions pointers, to create the bridge.<br>    CORE void core_load_raylib_functions(<br>        void (*const in_init_window)(int width, int height, const char* title),<br>        void (*const in_close_window)(),<br>        bool (*const in_window_should_close)(),<br>        void (*const in_begin_drawing)(),<br>        void (*const in_end_drawing)(),<br>        void (*const in_clear_background)(Color color),<br>        bool (*const in_gui_button)(Rectangle bounds, const char *text),<br>        void (*const in_gui_set_style)(int control, int property, int value)<br>    ){<br>        // Raylib functions<br>        raylib_init_window = in_init_window;<br>        raylib_close_window = in_close_window;<br>        raylib_window_should_close = in_window_should_close;<br>        raylib_begin_drawing = in_begin_drawing;<br>        raylib_end_drawing = in_end_drawing;<br>        raylib_clear_background = in_clear_background;</pre><pre>        // Raygui functions<br>        raygui_gui_button = in_gui_button;<br>        raygui_gui_set_style = in_gui_set_style;<br>    }</pre><pre>    // This variable determines if we need to activate hot reload<br>    // function or not from the main loop, inside main.c<br>    // That could be a bool, of course, but I&#39;m not including<br>    // stdbool.h. So, 0 if false, 1 if true.<br>    char core_active_hot_reload = 0;<br>    CORE void core_get_value_hot_reload(char* out_index){<br>        *out_index = core_active_hot_reload;<br>    }<br>#else<br>    // I redefine the raylib and raygui functions<br>    // I use here, because whenever we are using the dll<br>    // or not, I want to be able to have one single code,<br>    // without #if/#else in the functions below.<br>    <br>    // Raylib functions<br>    #define raylib_init_window InitWindow<br>    #define raylib_close_window CloseWindow<br>    #define raylib_window_should_close WindowShouldClose<br>    #define raylib_begin_drawing BeginDrawing<br>    #define raylib_end_drawing EndDrawing<br>    #define raylib_clear_background ClearBackground</pre><pre>    // Raygui functions<br>    #define raygui_gui_button GuiButton<br>    #define raygui_gui_set_style GuiSetStyle<br>#endif</pre><pre>void core_create_window(<br>    const unsigned short in_width,<br>    const unsigned short in_height,<br>    const char* in_title<br>){<br>    raylib_init_window(in_width, in_height, in_title);<br>}</pre><pre>void core_execute_loop(){<br>    // Only for Hot Reload<br>    #if defined(_WIN32) &amp;&amp; defined(BUILD_LIBTYPE_SHARED)<br>        unsigned int key_pressed = raylib_get_key_pressed();<br>        // In my case, if the key pressed is the &#39;R&#39;, I perform<br>        // hot reload<br>        if(key_pressed == 114){<br>            core_active_hot_reload = 1;<br>        }<br>    #endif</pre><pre>    raylib_begin_drawing();<br>        raylib_clear_background(RED);<br>        if(raygui_gui_button((Rectangle){ 500, 200, 250, 60 }, &quot;TEST BUTTON&quot;)) {<br>            puts(&quot;Button pressed\n&quot;);<br>        }<br>    raylib_end_drawing();<br>}</pre><pre>bool core_window_should_close(){<br>    return raylib_window_should_close();<br>}</pre><pre>void core_close_window(){<br>    raylib_close_window();<br>}</pre><p>So now, in every single loop of the main loop, inside <em>main.c</em>, we just need to call this <strong><em>core_get_value_hot_reload</em></strong>, and if the value returned is 1 (= true), we need to write code to free the library, wait for enter key beeing pressed, reload the dll, and continue the loop!</p><p>Of course, to do so, we need to initialize a new function pointer to load this <strong><em>core_get_value_hot_reload</em></strong> at the begining of the program, or we won’t be able to call it from the main loop.</p><p>In fact, we don’t need to reload every single function from <em>core.c</em> when reloading the dll. For example, we don’t need our <strong><em>core_init_window</em></strong> function, because the window is already initialized. We just need functions that will be used during the main loop, or at the end of our program (<strong><em>core_exit</em></strong> for example).</p><pre>// inside main.c</pre><pre>#include &quot;core.h&quot;</pre><pre>// Whenever we will pass this option to the compiler, we will be able to use our core.c code as a dll<br>#if defined(CORE_USE_LIBTYPE_SHARED) <br>    #include &lt;libloaderapi.h&gt;<br>    #include &quot;raylib.h&quot;<br>    #include &quot;raygui.h&quot;<br>#endif</pre><pre>int main(){<br>    // This code is necessary only if we are using hot reload<br>    #if defined(CORE_USE_LIBTYPE_SHARED)<br>        HINSTANCE dll_handle = NULL; // Declare a pointer to the dll resource</pre><pre>        // We need to initialize some function pointers, because, <br>        // as mentioned before, by using a dll, we will load every functions<br>        // we need to use from raylib, to our dll, (think of it as a bridge), <br>        // because our dll is not aware of raylib. <br>        // We are not linking its static library in our dll file.<br>        void (*core_load_raylib_functions_func)(<br>            void (*const in_init_window)(int width, int height, const char* title),<br>            void (*const in_close_window)(),<br>            void (*const in_begin_drawing)(),<br>            void (*const in_end_drawing)(),<br>            void (*const in_clear_background)(Color color),<br>            int (*const in_get_key_pressed)(),<br>            bool (*const in_is_key_down)(int key),<br>            bool (*const in_gui_button)(Rectangle bounds, const char *text),<br>        );</pre><pre>        // Functions pointers to be able to store and call functions from <br>        // our dll file (the initialization of the window, the exec loop function...)<br>        void (*core_init_window_func)();<br>        void (*core_execute_loop_func)();<br>        void (*core_get_hot_reload_func)(char* out_index);<br>        void (*core_exit_func)();<br> <br>        // To be able to know if we need to perform hot reload<br>        // (0 = false, 1 = true)<br>        char activate_hot_reload = 0;</pre><pre>        // Load our core.dll file as a dynamic library.<br>        // Regarding to the official windows documentation, the second parameter of &#39;LoadLibraryExA&#39;<br>        // is always NULL (just here for future need), and the last one corresponds to a flag<br>        // which determine the action to be taken when loading the module. In our case, we use the <br>        // default action (so the flag is 0)<br>        dll_handle = LoadLibraryExA(&quot;./core.dll&quot;, NULL, 0);<br>        if(dll_handle != NULL){<br>            // Load the &#39;core_load_raylib_functions&#39; function from the dll into the<br>            // &#39;core_load_raylib_functions_func&#39; function pointer<br>            core_load_raylib_functions_func = (void*) GetProcAddress(dll_handle, &quot;core_load_raylib_functions&quot;);<br>            if (NULL == core_load_raylib_functions_func){<br>                printf(&quot;Can&#39;t call core_load_raylib_functions dll function&quot;);<br>                exit(1);<br>            }else{<br>                // If the function is correclty loaded, then we call it, <br>                // and we pass the functions from raylib and raygui<br>                // we need.<br>                // It&#39;s the bridge between our main.c and our dll, to <br>                // retrieve the raylib and raygui functions.<br>                core_load_raylib_functions_func(<br>                    &amp;InitWindow,<br>                    &amp;CloseWindow,<br>                    &amp;BeginDrawing,<br>                    &amp;EndDrawing,<br>                    &amp;ClearBackground,<br>                    &amp;GuiButton,<br>                    &amp;GuiSetStyle<br>                );<br>            }<br>            core_init_window_func = (void*) GetProcAddress(dll_handle, &quot;core_init_window&quot;);<br>            if (NULL == core_init_window_func){<br>                printf(&quot;Can&#39;t call core_init_window dll function&quot;);<br>                exit(1);<br>            }else{<br>                // If the &#39;core_init_window&#39; function is correclty<br>                // loaded from the dll, we call it right now to<br>                // initialize the window.<br>                core_init_window_func();<br>            }<br>            core_execute_loop_func = (void*) GetProcAddress(dll_handle, &quot;core_execute_loop&quot;);<br>            if (NULL == core_execute_loop_func){<br>                printf(&quot;Can&#39;t call core_execute_loop dll function&quot;);<br>                exit(1);<br>            }<br>            core_get_hot_reload_func = (void*) GetProcAddress(dll_handle, &quot;core_get_hot_reload&quot;);<br>            if(NULL == core_get_hot_reload_func){<br>                printf(&quot;Can&#39;t call core_get_hot_reload dll function&quot;);<br>                exit(1);<br>            }<br>            core_exit_func = (void*) GetProcAddress(dll_handle, &quot;core_exit&quot;);<br>            if (NULL == core_exit_func){<br>                printf(&quot;Can&#39;t call core_execute_loop dll function&quot;);<br>                exit(1);<br>            }<br>        }else{<br>            // A problem occured when trying to load the dll file.<br>            // The most common mistake is a wrong given path to<br>            // the dll file.<br>            printf(&quot;Can&#39;t load the dll file.\n&quot;);<br>            exit(1);<br>        }<br>    #else<br>        // If we are not using the dll configuration, <br>        // then we just need to call the &#39;core_init_window&#39; function<br>        // from core.c<br>        core_init_window();<br>    #endif</pre><pre>    // Main loop<br>    while(1){<br>        #if defined(CORE_USE_LIBTYPE_SHARED)<br>            // We call the function loaded from the dll<br>            core_execute_loop_func();<br>            core_get_hot_reload_func(&amp;activate_hot_reload);<br>            if(activate_hot_reload == 1){<br>                // First, we free the library<br>                FreeLibrary(dll_handle);<br>                // Then, we demand to the user to press a touch to continue <br>                // (enter key, on the terminal which runs the main program)<br>                char c;<br>                puts(&quot;[INFO] Press enter after rebuilding the functions dll file\n&quot;);<br>                // While the user doesn&#39;t pres any key, the scanf &quot;block&quot; the program<br>                scanf(&quot;%c&quot;, &amp;c);<br>                <br>                // If the user press enter, we need to reload the dll file, and the functions we need<br>                dll_handle = LoadLibraryExA(&quot;core.dll&quot;, NULL, 0);<br>                if (NULL != dll_handle){<br>                    core_load_raylib_functions_func = (void*) GetProcAddress(dll_handle, &quot;core_load_raylib_functions&quot;);<br>                    if (NULL == core_load_raylib_functions_func){<br>                        printf(&quot;Can&#39;t call core_load_raylib_functions dll function&quot;);<br>                        exit(1);<br>                    }else{<br>                        core_load_raylib_functions_func(<br>                            &amp;InitWindow,<br>                            &amp;CloseWindow,<br>                            &amp;BeginDrawing,<br>                            &amp;EndDrawing,<br>                            &amp;ClearBackground,<br>                            &amp;GuiButton,<br>                            &amp;GuiSetStyle<br>                        );<br>                    }<br>                    core_execute_loop_func = (void*) GetProcAddress(dll_handle, &quot;core_execute_loop&quot;);<br>                    if (NULL == core_execute_loop_func){<br>                        printf(&quot;Can&#39;t call core_execute_loop dll function&quot;);<br>                        exit(1);<br>                    }<br>                    core_get_hot_reload_func = (void*) GetProcAddress(dll_handle, &quot;core_get_hot_reload&quot;);<br>                    if(NULL == core_get_hot_reload_func){<br>                        printf(&quot;Can&#39;t call core_get_hot_reload dll function&quot;);<br>                        exit(1);<br>                    }<br>                    core_exit_func = (void*) GetProcAddress(dll_handle, &quot;core_exit&quot;);<br>                    if (NULL == core_exit_func){<br>                        printf(&quot;Can&#39;t call core_execute_loop dll function&quot;);<br>                        exit(1);<br>                    }<br>                }else{<br>                    printf(&quot;Can&#39;t load the dll file.\n&quot;);<br>                    exit(1);<br>                }<br>            }<br>        #else<br>            // If we are not using the dll configuration, <br>            // we direclty call the function from core.c <br>            core_exec_loop();<br>        #endif<br>    }<br>    #if defined(CORE_USE_LIBTYPE_SHARED)<br>        core_exit_func();<br>        // Important line here, we need to free the dll<br>        FreeLibrary(dll_handle);<br>    #else<br>        // If we are not using the dll configuration,<br>        // simply call the &#39;core_exit&#39; function from core.c<br>        core_exit();<br>    #endif<br>    return 0;<br>}</pre><p>And voilà!<br>Now, we are able to reload our code from <em>core.c</em> on the fly. We just need to press <strong>R</strong> inside the program window, make our changes, recompile our dll with the commands listed below, then press enter in the terminal which has launched the main program, and see our changes in realtime!</p><p>Before ending this long article, I just wanted to write this little warning: if you want to retrieve the exact same state of your program after hot reload, you need to create (an) other bridge(s) function(s) between the main program (<em>main.c</em>), and your dll (<em>core.c</em> in our case), to retrieve every single variable which you instanciated on the stack, on the dll part.</p><p>Because when you reload the dll file, the stack is reinitialized, so your variables will be reset to their default value.</p><p>But you don’t need to do so for variables you allocated on the heap. If you didn’t destroy them before hot reload, they always be available, until you close the main application.</p><p>If you want, in an other article, I could show you how to be even more productive by “automating” hot reload with your code editor (in my case : visual studio code). Don’t hesitate to tell me in the comments of this article if that could interest you!</p><p>Anyway, if you’ve understood and applyed what I shared with you in this article, you normally will end with something really cool like that (no need to relaunch the application anymore):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*u4Symh2QRU6Hke4f.gif" /></figure><h3>Conclusion</h3><p>I hope this article has been usefull to you, and you’ll be able to add hot reload to your program/game. It’s a really time savier feature to use while writing your application!</p><p>If you encounter any problem, feel free to ask for help in the comments below. I’ll be more than happy to help you!</p><p>In any case, thank you really much for your patience, and to have read this article until the end.</p><p>Have fun coding games, tools, or whatever you have in mind!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=698caa33eb74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tools of Titans : comment vivent les personnes « à succès »]]></title>
            <link>https://medium.com/@TheElkantor/tools-of-titans-comment-vivent-les-personnes-%C3%A0-succ%C3%A8s-aa60baf09bcd?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa60baf09bcd</guid>
            <category><![CDATA[développement-personnel]]></category>
            <category><![CDATA[résumé]]></category>
            <category><![CDATA[tools-of-titans]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Fri, 04 Jan 2019 00:00:00 GMT</pubDate>
            <atom:updated>2019-01-10T06:05:53.275Z</atom:updated>
            <content:encoded><![CDATA[<h3>Tools of Titans : comment vivent les personnes « à succès »</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EWSROzRevZhvvidaQVp88Q.jpeg" /></figure><p>Cela faisait un petit moment que je n’avais plus publié d’article pour résumer un des derniers livre que j’ai lu récemment. Pour faute ? Tout simplement car je n’ai plus pris la peine de terminer un livre depuis…</p><p>Il faut dire aussi qu’il y a eu pas mal de mouvements pour moi ces derniers temps. Et surtout, j’ai enfin eu la motivation de me remettre dans le développement d’un nouveau projet (un jeu) ! Cela faisait longtemps que je n’avais pas eu cette envie de « faire quelque chose », vous voyez ? Et comme j’expérimente pas mal de concepts de programmation au travers de ce projet (cela me fait une bonne excuse), j’y consacre la plupart de mon temps libre.</p><p>Mais vous n’êtes pas ici pour cela, pas vrai ? Si vous avez cliqué sur cet article, c’est que vous vouliez en savoir plus sur <a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a>, un des derniers livres du désormais très célèbre (du moins, dans le monde de l’entrepreneuriat disons) Tim Ferriss !<br>Alors trêve de blabla, sans plus attendre, rentrons dans le vif du sujet !</p><h3>Plus de 650 pages d’avis, de conseils, d’inspirations…</h3><p><a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a> n’est pas un livre comme les autres. Tout du moins, ce n’est pas un livre tel qu’on se l’imagine, classiquement. Il s’agit en fait d’un « recueil » des propos tenus par plusieurs dizaines (voire centaines même), de personnes « à succès », lors des épisodes du podcast de l’auteur. En effet, Tim Ferriss a lancé il y a quelques années un format audio, nommé sobrement <em>« The Tim Ferriss Show »</em>, dans lequel il a depuis interviewé un nombre vertigineux d’invités prestigieux (des cinéastes, écrivains, scientifiques, artistes, sportifs, entrepreneurs…).</p><p>Ce livre permet de découvrir les habitudes, les routines, et la manière avec laquelle toutes ces personnes « à succès » abordent la vie au quotidien. Le but affiché de <a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a> est d’amener une réflexion personnelle, et d’apporter la possibilité à tout à chacun d’entrevoir des schémas imitables. Cela dit, je préfère vous avertir tout de suite, bien que la plupart des femmes et hommes présents dans ce livre partagent effectivement certains points communs (une grande majorité d’entre eux, par exemple, pratiquent la méditation de façon quotidienne); il n’y a finalement pas autant de similarités frappantes qu’on aurait pu penser. Tout le monde semble bien différent, et c’est d’ailleurs sûrement de là que provient leur succès.</p><p>Au travers ces quelques 650 pages de cet ouvrage, on passe donc tout aussi bien des conseils de vie et de créativité de James Cameron (<em>Le Titanic</em>, <em>Avatar</em>), à la vie inspirante d’Arnold Schwarzenegger, en passant par les recommandations relatives à la santé de scientifiques comme Adam Gazzaley (PhD en neurosciences), ou aux discours d’entrepreneurs à succès tels qu’Alexis Ohanian (co-créateur de Reddit)… <br>Bref, vous l’avez compris, il y en a vraiment pour tous les goûts !</p><h3>La structure du livre</h3><p>D’un point de vue de sa structure, <a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a> est découpé en trois parties. Trois sections formant en fait les trois piliers que l’auteur, Tim Ferriss, a discerné de part ses entretiens avec toutes ces personnes, comme étant fondamentalement nécessaires à l’obtention du « succès » (dans un sens personnel, ou plus vaste).</p><p>Ces trois parties sont :</p><ul><li>La santé (Healthy)</li><li>La richesse (Wealthy), qui ne se limite pas qu’à l’argent</li><li>La sagesse (Wise)</li></ul><p>Encore une fois, <a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a> n’est pas véritablement un livre comme les autres. Il n’y a pas de début, pas de fin. L’auteur, Tim Ferriss, conseille d’ailleurs dès les premières pages de le « consommer » tel qu’on en a envie. Si on souhaite passer directement à la page 467, c’est possible. Il n’y a pas véritablement de liens direct entre les propos des personnes présentes dans ce livre.</p><p>En plus de ces propos, relativement souvent, l’auteur décide de partager également son expérience personnelle sur plusieurs points clés énoncés quelques pages auparavant.</p><p>Et je pense que c’est là que provient la véritable force de ce livre, qui, d’un premier abord, laisse à penser qu’il s’agit d’un livre impersonnel, bourré de citations d’un large panel de personnes plus ou moins connues (ce qu’il est aussi, il ne faut pas se le cacher)… Mais dans un second temps, on s’aperçoit rapidement que <a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a> est plus que ça.</p><p>Les « chapitres » d’interventions de Tim, par rapport à son expérience personnelle sur un large choix de sujets tels que le sport, les investissements, la méditation… apportent autant de valeur ajoutée que le reste.</p><h3>Conclusion</h3><p><a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a> est un livre vraiment intéressant, correspondant parfaitement à mes attentes. D’ailleurs, tout compte fait, il m’a même surpris en allant plus loin que ce que j’espérais.</p><p>Je m’attendais à un livre regroupant les moments « clés » des épisodes du podcast de l’auteur : « Tim Ferris Show », au cours desquels il a pu dialoguer avec toutes les personnes présentent dans <a href="https://www.amazon.fr/gp/product/1785041274/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1785041274&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=7da2e999a8c113e16f728393abd3e118">Tools of Titans</a>. Or cela va plus loin que ça. Les interventions personnelles de Tim apportent finalement autant de valeur ajoutée que le reste.</p><p>On y découvre les astuces, les façons de penser, les routines quotidiennes, ainsi que les conseils et retour d’expérience de plusieurs dizaines (voire centaines) de personnes « à succès », en plus de celles de l’auteur lui-même.</p><p>De plus, chacune d’entre elles cite constamment un (ou des) livres ayant eu le(s) plus d’impact(s) dans leur vie. Ce qui permet d’obtenir une liste considérable d’autres ouvrages à lire, afin de se renseigner plus spécifiquement sur des sujets précis.</p><p>Pour finir, voici quelques-unes des citations qui m’ont le plus marqués, issues de ce livre (et je vous laisse chercher son auteur pour chacune d’entre elles 🙂 ) :</p><ul><li>What you do is more important than how you do everything else, and doing something well does not make it important.</li><li>We are whatever we pretend to be.</li><li>Even when everything is going terribly, and I have no reason to be confident, I just decide to be.</li><li>The process matters more than the product.</li><li>I let gratitude fill my soul, because when you’re grateful, we all know there’s no anger. It’s impossible to be angry and grateful simultaneously. When you’re grateful, there is no fear. You can’t be fearful and grateful simultaneously.</li><li>Investing in yourself is the most important investment you’ll ever make in your life… There’s no financial investmentthat’ll ever match it, because if you develop more skill, more ability, more insight, more capacity, that’s what’s going to really provide economic freedom… It’s those skill sets that really make that happen.</li><li>What does the dog do if he catches the car he chasing ? He doesn’t have a plan for it. So I find it just as often on the entrepreneurial side. People don’t plan for success.</li><li>It’s always the hard part that creates value.</li><li>You are more powerful than you think you are. Act accordingly.</li><li>Be a meaningful specific instead of a wandering generality.</li><li>What you track determines your lens. Choose carefully.</li><li>Tell ten people, show ten people, share it with ten people; ten people who already trust you and already like you. If they don’t tell anybody else, it’s not that good and you should start over. If they do tell other people, you’re on your way.</li><li>To create something great (or eventually huge), start extremmely small.</li><li>Forget purpose. it’s okay to be happy without one. The quest for a single purpose has ruined many lives.</li><li>If you want something extraordinary, you have two paths: 1) Become the best at one specific thing. 2) Become very good (top 25%) at two or more things. The first strategy is difficult to the point of near impossibility. Few people will ever play in the NBA or make a platinum album. I don’t recommand anyone even try. The second strategy is fairly easy. Everyone has at least a few areas in which they could be in the top 25% with some effort. In my case, I can draw better than most people, but I’m harldy an artist. And I’m not any funnier than the average standup comedian who never makes it big, but I’m funnier than most people. The magic is that few people can draw well and writes jokes. it’s the combination of the two that makes what I do so rare.</li></ul><p><em>Originally published at </em><a href="https://www.developing-stuff.com/tools-of-titans-comment-vivent-les-personnes-a-succes/"><em>www.developing-stuff.com</em></a><em> on January 4, 2019.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa60baf09bcd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learn How to Learn : un cours pour améliorer sa capacité à apprendre (mooc en ligne gratuit)]]></title>
            <link>https://medium.com/@TheElkantor/learn-how-to-learn-un-cours-pour-am%C3%A9liorer-sa-capacit%C3%A9-%C3%A0-apprendre-mooc-en-ligne-gratuit-75e9bcba3ba2?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/75e9bcba3ba2</guid>
            <category><![CDATA[mooc]]></category>
            <category><![CDATA[cours-en-ligne]]></category>
            <category><![CDATA[apprendre]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Mon, 17 Dec 2018 06:05:20 GMT</pubDate>
            <atom:updated>2018-12-17T06:05:20.035Z</atom:updated>
            <content:encoded><![CDATA[<h3>Learn How to Learn : un cours pour améliorer sa capacité à apprendre (mooc en ligne gratuit)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KUvC-0zUae1P0FFh" /><figcaption>Photo by <a href="https://unsplash.com/@roadtripwithraj?utm_source=medium&amp;utm_medium=referral">Raj Eiamworakul</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Il y a quelques semaines, j’ai découvert que plus de 800 universités à travers le monde, partageaient gratuitement plus de 10.000 (<strong>dix milles !!!</strong>) cours en ligne sur la plateforme <a href="https://www.coursera.org/">coursera.org</a>.</p><p>Plusieurs centaines de domaines sont concernés par ces cours, que ce soit la médecine, la biologie, la programmation, les neurosciences, l’écriture, le marketing, et même (chose qui m’intéressait tout particulièrement), le jeu vidéo; avec des cours sur le game design, et sur la programmation. Il y en a vraiment pour tous les goûts, c’est une véritable mine d’or !</p><p><em>Petit aparté : </em><br><em>Très sincèrement, je ne sais pas si on se rend compte de la chance qu’on a aujourd’hui de disposer de ce genre de plateforme… Autant de sujets intéressant à voir/apprendre, traités par des professeurs expérimentés d’un peu partout dans le monde, et ce gratuitement, c’est assez fou ! Et comme la plupart sont de vrais cours dispensés dans le cadre de diplômes universitaires, on peut même payer une certification (oscillant entre 40 et 90 euros par cours) afin d’obtenir un diplôme, si on suit tous les cours nécessaires à l’obtention ce dernier en validant les connaissances à l’aide de questionnaires. De plus, il existe même des aides financières pour ceux qui n’auraient pas les moyens de payer les certifications !</em><br><em>Bref, je m’égare un peu, mais sérieusement, je vous invite à aller jeter un coup d’œil, au moins par curiosité !</em></p><p>Dans tous les cas, comme personnellement j’adore apprendre de nouvelles choses, j’ai rapidement dressé une liste de cours en vidéo à suivre. Dans un élan de motivation (des fois, ça arrive comme ça, sans vraiment savoir pourquoi haha), je me suis même lancé le défi de terminer un cours par mois ! Ces derniers sont la plupart du temps prévus pour être terminés en 3 semaines, avec un investissement d’une ou deux heures hebdomadaire. Cela me semblait donc être un défi tout à fait atteignable !</p><p>Et bien que j’éprouvais une énorme envie de commencer tout de suite par des cours tels que “<a href="https://www.class-central.com/course/edx-video-game-design-teamwork-collaboration-9191">Video Game Design: Teamwork &amp; Collaboration</a>” par exemple, en cherchant sur la plateforme, je suis tombé complètement par hasard, sur “<a href="https://www.coursera.org/learn/learning-how-to-learn/home/welcome">Learn How to Learn : Powerful mental tools to help you master tough subjects</a>” (créé conjointement par l’université de McMaster, à Hamilton dans l’Ontario, au Canada, et celle de San Diego, en Californie).</p><p>J’ai donc décidé de m’intéresser à ce dernier en priorité. Tout simplement car cela faisait plus de sens pour moi — avant de commencer à suivre d’autres cours, et donc d’apprendre de nouvelles choses — d’approfondir mes connaissances dans le fait même “d’apprendre”, dans le but de maximiser la quantité d’informations que je serai capable de retenir pour les prochains cours.</p><p>De plus, la plateforme coursera.org est assez bien faite. J’avais la quasi certitude que ce cours allait être suffisamment pertinent et intéressant à suivre, sans même l’avoir commencé, grâce à sa note globale. Et surtout, grâce aux avis des quelques 11.000 (à l’heure où j’écris cet article) personnes ayant suivis ces vidéos. C’est bête, mais ça me permettait d’être sûr de me lancer dans quelque chose de pertinent, et de ne pas “perdre mon temps” à suivre un cours peu intéressant, ou requérant certaines notions précises que je n’ai pas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/822/0*A9iPkdeHNE-h9Sl0.jpg" /></figure><p>Un point important à noter, comme vous l’aurez peut-être constaté grâce à l’image ci-dessus, est que les vidéos de ce cours sont en anglais. Par contre, il y a des sous-titres incluant un très grand panel d’autres langues (dont le français). Il est donc vraiment accessible à une très grande majorité de personnes !</p><h3>Globalement, quel est le contenu de ce cours ?</h3><p>Comme je l’ai écrit précédemment, le but de ce cours est de permettre d’obtenir des outils dans le but de maximiser sa capacité à retenir des choses. Pour résumer : à apprendre plus efficacement.</p><p>Barbara Oackley (<em>Professor of Engineering, Industrial &amp; Systems Engineering</em>, à l’Université d’Oackland), et Terrence Sejnowski (<em>Francis Crick Professor at the Salk Institute for Biological Studies</em>, à San Diego, en Californie) — les deux enseignants de ce cours — traitent autant de points précis concernant la mémoire et la concentration, en abordant par exemple les neurones, le rôle crucial des différentes parties du cerveau comme l’hippocampe… que de sujets plus <em>abstraits</em>, tels que les deux “modes” de fonctionnement du cerveau : <em>diffuse</em>, et <em>focus</em>.</p><p>Bien que parfois, je vous l’accorde, la forme (je parle ici du montage vidéo en général, puisque certains effets visuels sont un peu “chiches”, et l’incrustation du fond vert est également un poil trop “amateur”) ne soit pas idéale, les techniques enseignées sont elles, vraiment importantes et intéressantes.</p><p>Non seulement Barbara et Terrence expliquent pourquoi et comment l’utilisation de métaphores, ou du <a href="https://litemind.com/memory-palace/"><em>memory palace</em></a> par exemple, permettent de mieux retenir sur le long terme, mais ils utilisent les techniques enseignées également comme moyen pour inculquer leurs propos. Comme pour prouver concrètement que cela fonctionne.</p><p>Concernant la structure du cours, il est divisé en quatre grandes parties :</p><ul><li>What is Learning ?</li><li>Chunking</li><li>Procrastination and Memory</li><li>Renaissance learning and unlocking your potential</li></ul><p>La première partie est consacrée à définir ce que veut dire, concrètement le fait d’apprendre. Quels sont les parties de notre cerveau qui rentrent en jeu, et comment est-ce que ce processus se met en place, concrètement (comment est-ce que de nouvelles connexions se font entre nos neurones).</p><p>C’est dans cette partie, notamment, que Barbara et Terrence expliquent comment vaincre la procrastination (avec la technique du pomodoro par exemple), <strong>en se focalisant sur le “process” plutôt que le “product”</strong>. C’est à dire dans le cadre d’un pomodoro, se fixer comme objectif de travailler 25 minutes, sans penser à un résultat concret obtenu à la fin de cette durée, plutôt que de se donner comme impératif de terminer une tâche précise (donc favoriser l’<em>action de travailler</em> plutôt que le <em>résultat final).</em></p><p>Dans cette première partie, ils partagent aussi les conclusions de certaines études scientifiques mettant en avant l’importance de la pratique d’une activité physique, et du sommeil, dans le processus d’apprentissage.</p><p>La deuxième partie de ce cours est consacrée entièrement à la notion de <em>chunk.</em> Grosso-modo, il faut comprendre que lorsqu’on apprend quelque chose, des connexions neuronales se font dans notre cerveau. Ce que l’on peut représenter par une image : des <em>chunks</em>. C’est à dire des blocs.</p><p>Ces blocs sont donc constitués de plusieurs idées, plusieurs concepts, liés entre eux. Avec de la pratique, on peut renforcer ces <em>chunks</em> (encore une fois, il s’agit d’une image), et les utiliser par la suite pour en constituer d’autres.</p><p>Par exemple, si j’apprends aujourd’hui les fondamentaux de la création d’une entreprise, on peut représenter les nouvelles connexions neuronales qui vont s’effectuer dans mon hippocampe comme des blocs. Si je ne réutilise pas ces connaissances, alors ces connexions neuronales vont se briser : le <em>chunk (ou bloc) </em>créé est détruit petit à petit. Je ne serai donc pas capable de transformer cette mémoire à court terme, en mémoire à long terme. Cependant, si j’utilise régulièrement ces connaissances (par exemple, en montant véritablement une entreprise), alors au contraire, ces connexions neuronales vont se renforcer. Et peut-être que, plus tard, je serai amené à en créer de nouvelles (donc créer de nouveaux <em>chunks</em>) en utilisant mes connaissances déjà acquises précédemment.</p><p>Dans la troisième partie de ce cours, est abordée la notion de procrastination, qu’on connait déjà tous très bien. Cette partie partage également des méthodes permettant d’améliorer sa mémoire à long terme. Barbara Oackley et Terrence Sejnowski proposent des astuces, permettant de <em>hacker</em> notre cerveau pour passer à l’action, et améliorer l’acte même d’apprentissage. Pour faire simple, comprendre comment travailler <strong>plus intelligement</strong> pour maximiser le résultat.</p><p>Parmi ces techniques, on retrouve celle du <em>memory palace</em> par exemple, consistant à créer une image mentale d’un lieu (notre maison par exemple), tel qu’il existe actuellement, et d’y intégrer ce que l’on souhaite retenir. Par exemple, si je souhaite retenir qu’à la fin du mois, je dois emmener ma voiture chez le garagiste (je vous l’accorde, cet exemple n’est pas le meilleur possible…), alors il suffit d’imaginer ma voiture en plein milieu de mon appartement, dans une pièce précise. Le soir, en moins de deux minutes, je peux être capable de me remémorer cette image, et, en voyant la voiture mentalement dans mon appartement, alors je penserai automatiquement à ce rendez-vous chez le garagiste.</p><p>Encore une fois, cet exemple n’est pas forcément très pertinent, mais je pense que vous avez compris l’idée. Pour parvenir à retenir un grand nombre d’éléments divers, il faudra un peu de temps pour maîtriser parfaitement cette technique, mais dans tous les cas, elle semble fonctionner ! Pourquoi me direz-vous ? Car il semble que nous ayons des prédispositions (dues à l’évolution humaine), nous permettant de mémoriser facilement un lieu, une place. Il se pourrait, d’après les faibles recherches que j’ai effectué, que cela nous ait permis, par exemple, très loin dans le passé, à l’époque où nous étions encore des chasseurs-cueilleurs, de se souvenir rapidement d’un endroit comportant de la nourriture, pour y revenir plus tard. Cela serait donc un “don” qui aurait amélioré nos chances de survie à l’époque.</p><p>Pour finir, la partie quatre de ce cours résume un peu tout ce qui a été traité auparavant, et met vraiment en avant que le meilleur moyen d’apprendre, et de retenir le plus d’informations possible, c’est tout simplement d’apprendre constamment. <strong>La mémoire est un muscle, et comme tout muscle, plus on l’utilise, plus il se développe</strong>. Bien entendu, un quiz final est aussi mit en avant dans cette dernière section, pour tout simplement vérifier les acquis, ce qu’on a apprit durant ce cours. C’est également via ce quiz qu’on obtient un résultat nous permettant de valider le cours, si l’on décide de payer la certification.</p><h3>Conclusion</h3><p>Learn How to Learn est un cours vraiment intéressant, que je ne peux que vous conseiller de suivre.</p><p>Bien que la forme des vidéos pourra retenir l’envie de certains d’entre vous de suivre entièrement ce cours, il n’empêche que les propos formulés, les explications évoquées, et les techniques partagées, sont tous aussi pertinents les uns que les autres.</p><p>Je vous l’accorde, cela ne révolutionnera probablement pas votre vie (encore que…), mais avoir en tête ces notions, et en être pleinement conscience lorsque vous êtes sur le point d’apprendre quelque chose d’important ne peut que vous aider à améliorer de façon significative votre apprentissage, quelque soit le domaine étudié. Vous serez peut-être capable d’assimiler plus de contenu que vous ne le pensez, et surtout, de mettre en relation — sans doute — plus facilement certaines notions déjà acquises, avec vos nouvelles connaissances. Qui sait, cela pourrait vous amener à devenir plus créatif, et à inventer des produits révolutionnaires ! :)</p><p>Bref, si vous avez quelques heures de disponible chaque semaine, suivre ce cours est un excellent moyen de vaincre la procrastination. Cela vous donnera des outils utilisables dans n’importe quel domaine de votre vie.</p><blockquote><strong><em>On commence à vieillir quand on finit d’apprendre.</em></strong></blockquote><blockquote><em>Proverbe japonais</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=75e9bcba3ba2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[60–60–30 : une technique pour augmenter sa productivité !]]></title>
            <link>https://medium.com/@TheElkantor/60-60-30-une-technique-pour-augmenter-sa-productivit%C3%A9-2cb7d52a80f9?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cb7d52a80f9</guid>
            <category><![CDATA[60-60-30]]></category>
            <category><![CDATA[techniques]]></category>
            <category><![CDATA[productivité]]></category>
            <category><![CDATA[développement-personnel]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Tue, 20 Nov 2018 06:04:34 GMT</pubDate>
            <atom:updated>2018-11-20T06:04:34.677Z</atom:updated>
            <content:encoded><![CDATA[<h3>60–60–30 : une technique pour augmenter sa productivité !</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VQAtRAEX0umiUDpT" /><figcaption>Photo by <a href="https://unsplash.com/@carlheyerdahl?utm_source=medium&amp;utm_medium=referral">Carl Heyerdahl</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Cette semaine, j’avais envie d’écrire un article un peu particulier; du moins, différent de ce dont j’ai l’habitude d’écrire.</p><p>Ce ne sera donc pas un résumé d’un livre, comme je vous y ai habitué dans cette section “développement personnel” de ce blog, mais un article pour partager une technique permettant d’améliorer sa productivité, que j’utilise quotidiennement depuis plusieurs mois maintenant.</p><p>Effet placebo ou pas, il s’est avéré qu’en utilisant cette astuce du <strong>60–60–30</strong>, j’ai pu améliorer ma productivité, et plus généralement, je dirais même mon efficience (puisqu’on peut-être très productif à accomplir des tâches peu utiles comme passer plusieurs heures à réaliser un logo pour son site internet, plutôt que de créer du contenu par exemple).</p><p>Dans tous les cas, si cette technique m’a aidé, alors peut-être que cela fonctionnera aussi pour vous.</p><h3>Pourquoi utiliser des “techniques” dans le but d’améliorer sa productivité ?</h3><p>Il y a plusieurs mois (voire plus d’un an maintenant), je me suis retrouvé dans une situation qui me frustrait énormément : je voulais faire beaucoup de choses, mais j’avais l’impression de ne pas avoir assez de temps à consacrer à chacune des tâches que je m’étais fixé.</p><p>Bref, je n’avançais pas, et bien qu’à chaque fois, je pensais être gonflé à bloc, je me démotivais rapidement en voyant toutes ces semaines passées et le peu de résultat final obtenu.</p><p>J’ai constaté que lorsque je me lance dans des projets personnels, quels qu’ils soient, il y a plusieurs phases auxquelles je fais souvent face :</p><ul><li>L’idée, le moment où je me dis que ça serait ultra chouette de faire telle ou telle chose</li><li>Le commencement, où je suis généralement super motivé, et globalement, je sais où je veux aller plus ou moins précisément</li><li>Le doute, je me demande finalement si l’idée était si bonne que ça, et je réalise que cela va prendre un certains temps</li><li>Et enfin, l’abandon, car je n’arrête pas d’avoir d’autres idées (que forcément je juge meilleures, plus pertinentes), et je me dis que, finalement, il vaudrait mieux utiliser mon temps libre plus intelligemment à développer ces autres idées plutôt que celle que j’avais eu précédement</li><li>Hop, retour au premier point…</li></ul><p>Au final, je ne finissais donc que très rarement mes projets personnels, et je n’en étais que plus frustré. Frustré d’avoir passé autant de temps et de n’avoir aucun résultat concret. Frustré contre moi-même, pour ne pas être capable de me focaliser sur un seul projet à la fois. Et surtout frustré de ne pas arriver à rester concentré sur un seul projet à la fois, et/ou de ne pas avoir la motivation de le poursuivre jusqu’au bout.</p><p>Vous l’aurez compris, j’avais l’impression d’avoir tout simplement perdu mon temps (même si ce n’est pas totalement vrai, puisque j’apprends toujours quelque chose, quoi qu’il arrive). A force, cette frustration de ne jamais rien finir a tellement grandi, que j’ai fini par chercher s’il n’existait pas des techniques, des moyens pour “hacker” mon cerveau, et réussir à me motiver d’aller au bout de mes projets.</p><p>J’ai donc épluché plusieurs sites internet, plusieurs vidéos youtube (talks TED, interview d’experts en neurosciences…), et j’ai fini par trouver quelques astuces ! Encore une fois, sans essayer, on ne peut jamais savoir ce qui marche ! C’est donc après plusieurs semaines de “tests” intensifs, que j’ai enfin trouvé ma technique préférée (jusqu’à présent). Tout du moins, celle avec laquelle j’arrive à obtenir les meilleurs résultats. Mais aussi (et surtout, c’est le plus important) que j’aime utiliser : le <strong>60–60–30</strong>.</p><h3>Le principe</h3><p>La technique du <strong>60–60–30</strong> est au final extrêmement simple, et est basée sur ce cycle :</p><ul><li>50 minutes de travail</li><li>10 minutes de pause</li><li>50 minutes de travail</li><li>40 minutes de pause</li></ul><p>Vous vous demandez peut-être, comme moi la première fois que j’ai lu un article à son sujet, d’où vient alors le nom “60–60–30” ? Effectivement, c’est peu intuitif… Cependant, on peut résumer cette technique à deux cycles de 50 min de travail + 10 min de pause (donc 60 minutes), suivis de 30 min de pause.</p><p>Le plus important, pour tirer complètement avantage du temps de travail — et c’est d’ailleurs un point crucial, quelque soit la technique utilisée, comme celle du “Pomodoro”… — est de couper court à toute distraction éventuelle durant les phases de 50 minutes. L’objectif est en fait de se plonger pleinement dans les tâches, en focalisant 100% de son attention. Exit donc tout ce qui est smartphone (sms, réseaux sociaux, appels…), et en général, tout ce qui pourrait vous déranger, comme les notifications de mails ou encore d’extensions chrome/firefox à tout va !</p><p>Personnellement, j’aime mettre mon smartphone en mode avion, et couper absolument tout ce qui pourrait éventuellement me perturber durant cette phase de travail. Je ne garde que l’essentiel sur mon bureau, à savoir mon PC, mes deux écrans, mon clavier, ma souris, et de quoi écrire.</p><blockquote><strong><em>“That’s been one of my mantras — focus and simplicity.”</em></strong></blockquote><blockquote><strong><em>- Steve Jobs</em></strong></blockquote><p>Effectivement, j’aime rester le plus minimaliste possible pendant ces phases de 50 minutes de travail. Si vous êtes comme moi, alors vous avez vous aussi tendance à garder au minimum 8 à 10 onglets constamment ouverts dans votre navigateur internet. Au final, cela ne sert pas à grand chose, il faut bien l’avouer… Durant mes phases de travail, je m’assure donc de n’avoir qu’un seul onglet au maximum d’ouvert à chaque fois. Cela me permet de me focaliser complètement sur le travail en cours, sans perdre de temps à être tenté de naviguer sur internet, et à me perdre dans mes recherches (cela arrive très rapidement, et sans que je m’en rende compte, lorsque je code par exemple, et que je cherche de la documentation).</p><p>Enfin, pour terminer, le dernier point très important de cette technique est d’utiliser un minuteur pour chronométrer les phases (on peut utiliser un simple minuteur de cuisine, ou une extension chrome/firefox telle que <a href="https://addons.mozilla.org/en-US/firefox/addon/timer-webext/?src=search">Timer</a> par exemple). A la fin des 50 minutes de travail, dès qu’on entend le minuteur, il est très important de couper court à ce qu’on est en train de faire, et de prendre tout de suite 10 minutes de pause. Même si on est au milieu d’une tâche qu’on souhaite absolument finir avant de prendre ce <em>break </em>!</p><h3>Les explications scientifiques du 60–60–30</h3><p>Derrière cette technique de productivité, se cache quelques explications démontrées par plusieurs études scientifiques, ou par des tests “de terrain” (dans ce dernier cas, bien entendu, un effet placebo peut entrer en jeu, mais tant que le résultat est là…).</p><p>L’idée principale du 60–60–30, et en règle générale, de n’importe quelle méthode permettant d’améliorer sa productivité, est de tout mettre en place pour maximiser nos phases d’attention, de concentration intense. Plusieurs études scientifiques menées dans différents pays convergent toutes vers un même constat : le temps moyen de concentration des individus tend à diminuer. Les résultats sont assez “alarmant” d’ailleurs, puisque selon les résultats obtenus, nous ne serions capable, en moyenne, de rester pleinement concentré sur une unique tâche précise sur une durée maximale de 20 minutes. La faute, en partie, à l’essor des nouvelles technologies, tel que le smartphone, internet… Nous sommes de plus en plus sujets aux stimuli externes. Des stimuli qui brisent totalement notre concentration.</p><p><a href="https://www.journals.uchicago.edu/doi/10.1086/691462">Une étude de l’Université d’Austin</a>, au Texas, en juin 2017, a d’ailleurs prouvé qu’il suffit que son smartphone soit dans la même pièce pour que nos capacités cognitives soient réduites. Portant sur plus de 800 personnes, cette étude était représentée sous forme d’une série de tests sur ordinateur, demandant une concentration optimale pour obtenir le meilleur score possible. Ces tests étaient conçus pour mesurer la capacité cognitive disponible des participants, c’est à dire, la capacité du cerveau à traiter des informations à tout moment. Avant de commencer l’épreuve, chaque participant, devait de manière aléatoire placer son smartphone soit face en bas sur le bureau, dans leur poche ou leur sac, ou encore, dans une autre pièce. Quoi qu’il arrive, ils devaient également tous configurer leur smartphone en mode silencieux. Au final, les chercheurs ont constaté que les participants dont le téléphone se trouvait dans une autre pièce surpassaient considérablement ceux qui avaient leur téléphone sur le bureau sur cette série de tests; et étaient également légèrement plus performant que les participants qui avaient gardé leur téléphone dans leur poche ou leur sac.</p><blockquote><em>“Nous constatons une tendance linéaire qui suggère que, à mesure que le smartphone devient de plus en plus visible, la capacité cognitive disponible des participants diminue. Votre esprit conscient ne pense pas à votre smartphone, mais ce processus consistant à se forcer à “ne pas penser à quelque chose”, utilise en fait certaines de vos ressources cognitives limitées.”</em></blockquote><p>Cela n’explique toujours pas les cycles de 50 minutes, suivis de 10 minutes de pause de cette méthode du 60–60–30 cela dit… 50 minutes, c’est pourtant un nombre important ! C’est en effet la durée moyenne maximale pendant laquelle nous sommes capable de rester concentré sur une tâche précise. D’ailleurs, <a href="https://www.fastcompany.com/3035605/the-exact-amount-of-time-you-should-work-every-day">une étude interne récente</a> de la société Draugiem Group le prouve : les employés les plus productifs travaillent en suivant des cycles d’une moyenne de 52 minutes de travail, suivis de pauses d’environ 17 minutes.</p><p>Pour une grande majorité de personne, la durée moyenne de concentration n’excède pas 20 minutes. Cependant, en se forçant et en focalisant toute notre attention, nous pouvons globalement tous rester concentré pleinement sur une et une seule tâche durant un peu moins d’une heure (selon plusieurs études, cette durée tendrait d’ailleurs à augmenter avec l’âge). Passé ce délais, conserver cet état de concentration intense devient de plus en plus difficile. Finalement, à partir de cet instant, tout le temps en plus consacré à la tâche en cours est quasiment inutile, puisqu’on avance plus, nous ne sommes plus pleinement concentrés.<br>De plus, perdre cet état de concentration signifie obligatoirement devoir utiliser de l’énergie pour se focaliser à nouveau sur la tâche en cours. Or selon plusieurs études, incluant <a href="https://news.gallup.com/businessjournal/23146/too-many-interruptions-work.aspx">les recherches de Gloria Mark</a>, professeur à l’université d’Irvine, en Californie, le temps nécessaire pour retourner à un état de concentration maximal (également appelé <em>flow</em>) peut prendre jusqu’à 25 minutes !</p><p>Bref, le but des cycles de 50 minutes est donc de limiter autant que possible les éventuelles interruptions extérieures, afin de rester le plus longtemps possible focalisé sur l’unique tâche en cours Au delà des 50 minutes, puisque le risque de perdre cet état de concentration maximal devient vraiment important, il est alors temps de prendre une pause. Dans le cas contraire, on s’expose à perdre plusieurs précieuses minutes, à tenter de focaliser de nouveau toute notre attention sur le travail en cours.</p><p>Petite astuce personnelle : j’ai constaté que je perdais moins de temps à me concentrer de nouveau sur la tâche que j’ai laissé en suspens, une fois la pause terminée, lorsque durant cette dernière, je me lève, et que j’ai fais totalement autre chose. Par exemple, si je programme sur mon PC, assis à mon bureau pendant 50 minutes, ma pause consiste à me lever, aller faire ma vaisselle et/ou manger un fruit par exemple…</p><h3>Tout est une question d’aptitude à se concentrer</h3><p>Cette technique du <strong>60–60–30</strong> ne permet finalement que “d’initialiser” un environnement, fixant des règles strictes. Une fois ces règles définies, on a plus qu’à les suivre, sans y penser, pour se concentrer pleinement sur ce qui est vraiment important : les tâches à réaliser.</p><p>Le <em>nerf de la guerre</em> ne vient donc pas des techniques utilisées (le 60–60–30 n’en est qu’une parmi beaucoup d’autre…). Ce ne sont que des outils. L’essentiel réside dans notre capacité à rester concentré sur une tâche précise durant le plus de temps possible, sans interruptions. Pas de <em>multitasking</em>, mais bien un focus maximal sur UNE et UNE seule tâche à la fois. L’être humain est dans tous les cas très mauvais en multi-tâches. D’ailleurs, <a href="https://news.stanford.edu/news/2009/august24/multitask-research-study-082409.html">une étude réalisée par l’université de Standford</a>, en 2009, suggérait que les personnes adeptes du multi-tâches, accomplissaient beaucoup moins de travail sur une période donnée que celles qui se concentraient sur une et unique tâche à la fois.</p><p>Une des meilleurs preuves pour illustrer ce point, que vous avez peut-être tous déjà vécu, survient quand un de vos proches est dans une conversation téléphonique par exemple. S’il est vraiment totalement à l’écouter de l’autre personne, et donc pleinement concentré sur la conversation, alors vous pouvez lui tendre absolument n’importe quel objet (vraiment n’importe quoi). Il va alors s’en emparer automatiquement, sans s’en rendre compte. Il est tellement concentré sur la conversation, qu’il n’a plus conscience du reste qui l’entour. C’est d’ailleurs pour cela qu’il est strictement interdit de téléphoner au volant…</p><p>Finalement, bien que la durée moyenne maximale de pleine concentration des individus tende à diminuer de plus en plus — notamment à cause de l’essor technologique, permettant de constamment rester connecté et donc, de s’exposer à de nombreux stimuli — il faut garder en tête que la concentration est comme un muscle. C’est donc une bonne nouvelle puisque cela signifie qu’en s’entraînant, on peut augmenter notre faculté à rester focalisé plus longtemps sur une tâche donnée.</p><h3>Conclusion</h3><p>La méthode du <strong>60–60–30</strong> n’est qu’une technique parmi beaucoup d’autres, et elle ne sera peut-être pas adaptée pour vous. Vous lui préférerez peut-être celle du “Pomodoro”. Le plus important, c’est de trouver quelque chose qui vous convient le mieux, et que vous aimez utilisez surtout !</p><p>Comme cette technique m’a beaucoup aidé personnellement, je pense que vous devriez au moins l’essayer, si vous aussi, vous voulez améliorer votre productivité, et plus que ça même, votre efficience ! Mais gardez en tête que, quoi qu’il arrive, le nerf de la guerre ne réside pas dans l’utilisation d’une technique particulière. Ce ne sont que des outils qu’on utilise pour fixer un environnement avec des règles précises, qu’on a ensuite plus qu’à suivre à la lettre, bêtement, afin d’utiliser toute nos capacités cognitives disponibles sur l’essentiel.</p><p><strong>Le plus important réside dans la capacité de chacun à rester concentré le plus longtemps possible, sans interruptions sur une et une seule tâche précise à la fois.</strong></p><p>Merci beaucoup d’avoir pris la peine (et le temps) de lire cet article jusqu’au bout. Gardez en tête que je ne suis absolument pas un expert en neuroscience, ni, en règle générale, un gourou du fonctionnement du cerveau ou de la productivité. Je voulais simplement partager une astuce qui a fonctionné avec moi. Alors, si ça peut aider certains d’entre vous…<br>Dans tous les cas, si vous aussi, de votre côté, connaissez d’autres “techniques” de ce genre, je suis curieux de les découvrir. N’hésitez donc pas à m’en faire part via les commentaires de cet article sur mon blog, ou via twitter (@TheElkantor).</p><p><em>Cet article a été initialement publié sur mon blog </em><a href="http://www.developing-stuff.com./"><em>www.developing-stuff.com.</em></a><em><br>S’il vous a intéressé, peut-être souhaitez-vous vous abonner </em><a href="https://www.developing-stuff.com/newsletter/"><em>à ma newsletter</em></a><em>, afin de rester informé des nouveautés du blog, mais aussi pour obtenir par mail une liste d’articles, régulièrement, qui méritent le coup d’œil (que ce soit sur le développement personnel, la programmation…).</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cb7d52a80f9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Premiers Pas En Rust : Partie 7 — Extraction D’un Module Zip Téléchargé !]]></title>
            <link>https://medium.com/@TheElkantor/premiers-pas-en-rust-partie-7-extraction-dun-module-zip-t%C3%A9l%C3%A9charg%C3%A9-3ff68750dac9?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ff68750dac9</guid>
            <category><![CDATA[en-français]]></category>
            <category><![CDATA[rustlang]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[programmation]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Mon, 05 Nov 2018 06:03:48 GMT</pubDate>
            <atom:updated>2018-11-05T06:03:48.858Z</atom:updated>
            <content:encoded><![CDATA[<h3>Premiers Pas En Rust : Partie 7 — Extraction D’un Module Zip Téléchargé !</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2weqM4fST1pI7s0X" /><figcaption>“person wearing diving suit under water” by <a href="https://unsplash.com/@anuragvh?utm_source=medium&amp;utm_medium=referral">Anurag Harishchandrakar</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Dans l’article précédent, nous nous étions arrêté à la récupération d’un module au format zip, grâce à la sous-commande de bsc : <em>bsc add — zip [nom_module]</em>.</p><p>Aujourd’hui, on va voir comment procéder à la décompression de ce fichier zip, afin de récupérer les dossiers et fichiers sources du module.</p><p>Cet article est donc volontairement assez court. Je pense que c’est mieux comme cela, puisque les lecteurs voulant simplement voir comment extraire des fichiers <em>zip</em> en Rust, auront donc toute la procédure dédiée à ce sujet ici, et ne se perdrons pas avec le reste qui les intéresse sans doute moins.</p><h3>La décompression d’un module téléchargé au format zip</h3><p>Nous nous étions donc arrêtés sur cette ligne précise, dans <a href="https://www.developing-stuff.com/premiers-pas-en-rust-partie-6-recuperer-les-modules-distants/">l’article précédent</a> :</p><pre>common::set_content_file(&amp;format!(“{}bsc_modules/tmp/test.zip”, &amp;path), &amp;dst);</pre><p>Pour rappel, l’appel de la fonction <em>set_content_file</em>, dans mon fichier <em>common.rs</em>, a pour but de créer le fichier <em>test.zip</em>, dans le dossier <em>tmp</em> (temporaire) de <em>bsc_modules/</em>.</p><p>Elle permet de plus de remplir ce fichier <em>zip</em> d’archive avec les données présentes dans le vecteur <em>dst</em> (il s’agit simplement d’un copié/collé du contenu du fichier <em>zip</em> distant, au final).</p><p>Voyons maintenant comment extraire ces données.</p><p>L’option la plus simple consiste à utiliser un <em>crate</em> (puisqu’il s’agit d’une opération assez courante, il existe sans aucun doute un <em>crate</em> permettant de décompresser un fichier au format <em>zip</em>).</p><p>Après quelques minutes de recherche sur <a href="https://crates.io/">crates.io</a>, il s’avère que le <em>crate</em> “zip” (tout simplement !) possède exactement les fonctionnalités dont on a besoin.</p><p>Comme d’habitude lorsqu’on ajoute un nouveau <em>crate</em>, on commence donc par le renseigner dans le fichier <em>Cargo.toml</em>, situé à la racine du projet :</p><pre>[package]<br>name = “bsc”<br>“version = “0.1.0”<br>authors = [“Victor Gallet &lt;victor.gallet@developing-stuff.com”&gt;]</pre><pre>[dependencies]<br>indicatif = “0.9.0”<br>console = “0.6.1”<br>clap = “2.32.0”<br>git2 = “0.7.5”<br>fs_extra = “1.1.0”<br>curl = “0.4.15”<br>zip = “0.4”</pre><p>Voyons maintenant comment l’utiliser.</p><p>La première chose à faire, est d’ouvrir le fichier <em>zip</em> fraîchement créé (dans <em>bsc_modules/tmp/test.zip</em>), et de stocker son contenu dans une variable “file”, grâce à la fonction<em> fs::open</em> de la librairie standard (pour rappel, il faut ajouter la ligne “<em>use std::fs;</em>” en haut du fichier pour pouvoir l’utiliser :</p><pre>let file = fs::File::open(format!(“{}bsc_modules/tmp/test.zip”, &amp;path)).unwrap();</pre><p>Maintenant, en suivant la documentation du <em>crate zip</em>, on peut alors créer une instance de la structure <em>ZipArchive</em>, dont le constructeur prend en paramètre un fichier (dans notre cas, notre variable <em>file</em>).</p><p>Cette structure va nous permettre de récupérer tout le contenu compressé dans le fichier <em>zip</em> (dossiers et fichiers) :</p><pre>let mut archive = zip::ZipArchive::new(file).unwrap();</pre><p>On va également créer une variable de type <em>String</em> afin de stocker le chemin du dossier parent de cette archive.</p><pre>let mut folder_path = String::new();</pre><p>Il ne nous reste plus qu’à suivre à la lettre la documentation officielle du <em>crate</em> <em>zip</em>, en itérant pour chaque fichier/dossier trouvé dans l’archive, et en procédant à son extraction vers notre dossier temporaire <em>bsc_modules/tmp/ </em>:</p><pre>// Pour chaque dossier/fichier trouvé dans l’archive<br>for i in 0..archive.len(){<br>  // on récupère le fichier/dossier<br>  let mut file = archive.by_index(i).unwrap();<br>  if i == 0 {<br>    // Dans le cas où il s’agit du premier dossier, alors on stock son nom dans la variable “folder_path”.<br>    // Toutes les fonctions appelées à la suite (“sanitized_name, into_os_string…) permettent simplement de récupérer le nom du dossier seul (sans le chemin complet) au format string<br>    folder_path = file.sanitized_name().into_os_string().into_string().unwrap();<br>  }<br>  // On créé un buffer vers le chemin final du dossier après extraction<br>  let mut outpath = PathBuf::from(format!”{}{}”, &amp;path, “bsc_modules/tmp/”);<br>  outpath.push(file.sanitized_name());<br>  {<br>    // On affiche les commentaires liés au dossier/fichier en cours d’extraction,<br>    // s’il y en a de renseignés dans l’archive (ceci est complètement optionnel)<br>    let comment = file.comment();<br>    if !comment.is_empty(){<br>      printfln!(“File {} comment: {}”, i, comment);<br>    }<br>  }<br>  <br>  // Test s’il s’agit d’un dossier.<br>  // Si oui, alors on créé simplement un dossier du même nom dans le dossier temporaire parent bsc_modules/tmp/<br>  if(&amp;*file.name()).ends_with(‘/’){<br>    fs::create_dir_all(&amp;outpath).unwrap();<br>  }else{<br>    // Sinon, s’il s’agit d’un fichier, on l’extrait dans son dossier parent s’il existe.<br>    // Si jamais il n’existe pas (juste au cas où), alors on récupère le dossier parent et on le créé dans bsc_modules/tmp/<br>    if let Some(p) = outpath.paren(){<br>      if !p.exists(){<br>        fs::create_dir_all(&amp;p).unwrap();<br>      }<br>    }<br>    let mut outfile = fs::File::create(&amp;outpath).unwrap();<br>    io::copy(&amp;mut file, &amp;mut outfile).unwrap();<br>  }<br>}</pre><p>Maintenant que le dossier zip est correctement extrait dans notre dossier temporaire <em>bsc_modules/tmp/</em>, on peut alors supprimer le fichier <em>zip</em> téléchargé plus tôt, grâce à la fonction “<em>delete_file</em>” créée précédemment dans mon fichier “<em>common.rs”</em> :</p><p><em>Pour rappel, delete_file consiste simplement à appeler la fonction fs::remove_file de la librairie standard, et à gérer les éventuelles erreurs.</em></p><pre>common::delete_files(&amp;format!(“{}bsc_modules/tmp/test.zip”, &amp;path));</pre><p>On peut également déplacer le dossier du module extrait dans <em>bsc_modules/tmp/</em>, vers le dossier parent des modules bsc (<em>bsc_modules</em>), en appelant la fonction <em>move_folder_content_to_parent_folder</em> présente également dans le fichier <em>common.rs</em>.</p><p>Pour information, cette fonction permet, comme son nom l’indique, de déplacer un dossier (dont le chemin est donné en paramètre) vers le dossier parent, et ressemble tout simplement à ceci :</p><pre>pub fn move_folder_content_to_parent_folder(folder_path: &amp;str){<br>    let dir = path::Path::new(&amp;folder_path);<br>    if dir.is_dir(){<br>        for entry in fs::read_dir(dir).unwrap(){<br>            let entry = entry.unwrap();<br>            let path = entry.path;<br>            let mut parent_path = path.parent().unwrap();<br>            if path.is_dir(){<br>                // S’il s’agit d’un dossier, alors on le déplace vers le dossier parent de ce dossier<br>                move_folder(&amp;path.to_str().unwrap(), &amp;parent_path.parent.unwrap().to_str().unwrap());<br>            }else{<br>                // Pareil s’il s’agit d’un fichier, mais on appelle la fonction move_file, définie également dans common.rs (qui est au final un appel de la fonction move_items du crate fs_extra, car la librairie standard ne permet pas de directement gérer le déplacement de dossier/fichier. <br>                move_file(&amp;path.to_str().unwrap(), &amp;parent_path.parent().unwrap().to_str().unwrap());<br>            }<br>        }<br>    }<br>}</pre><p>Vous aurez remarqué, via les commentaires ci-dessus, que j’utilise le <em>crate</em> <em>fs_extra</em> pour déplacer les fichiers et les dossiers.</p><p>En effet, il n’y a pas de fonctions disponibles pour cela dans la librairie standard. Il faut donc itérer pour chaque fichiers/dossiers, les copier vers la destination, puis les supprimer de la source.</p><p>Cette étape est un peu longue, et j’ai préféré utiliser le <em>crate</em> <em>fs_extra</em> qui le fait à ma place — grâce à ses fonctions <em>move_dir</em>, et <em>move_items</em> — par simplicité (ou par flemme dira-t-on :) ).</p><p>Bref, dans tous les cas, revenons à nos moutons, voilà simplement l’appel à la fonction décrite ci-dessus, pour terminer l’opération d’extraction du module :</p><pre>common::move_folder_content_to_parent_folder(&amp;format!(“{}bsc_modules/tmp/{}”, &amp;path, folder_path));</pre><p>Au final, si notre module s’appelait <em>test_bsc0.1.1 </em>par exemple, on a donc téléchargé une archive au format <em>zip </em>nommée <em>test_bsc0.1.1.zip </em>qu’on a extrait dans <em>bsc_modules/tmp/test_bsc0.1.1</em>.</p><p>Puis, on l’a déplacé dans <em>bsc_modules/test_bsc0.1.1</em>.</p><h3>Pour conclure :</h3><p>Toute la partie de récupération des modules, quelque soit l’option choisie (via git, via la récupération d’un module local, ou, comme montré dans cet article, via la récupération d’un module distant au format <em>zip</em>), est dorénavant terminée !</p><p>Il ne nous reste plus qu’à vérifier l’intégrité du module téléchargé, et à ajouter ses fichiers sources dans la configuration de nos fichiers CMake (et effectuer un petit <em>twist</em> au niveau des fichiers <em>headers</em>, pour faciliter leur inclusion dans le projet), et nous aurons enfin terminé la partie dédiée à l’ajout d’un module !</p><p>J’espère que cette série continue de vous intéresser.</p><p>Pour finir, comme d’habitude, si jamais vous avez la moindre remarque ou question, que ce soit sur le fond, comme sur la forme de cet article (ou des précédents), n’hésitez surtout pas à m’en faire part via les commentaires ci-dessous !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ff68750dac9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sleep Smarter : comprendre le sommeil pour booster son énergie, sa santé, et sa productivité]]></title>
            <link>https://medium.com/@TheElkantor/sleep-smarter-comprendre-le-sommeil-pour-booster-son-%C3%A9nergie-sa-sant%C3%A9-et-sa-productivit%C3%A9-e11e94adb03a?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/e11e94adb03a</guid>
            <category><![CDATA[repos]]></category>
            <category><![CDATA[sommeil]]></category>
            <category><![CDATA[développement-personnel]]></category>
            <category><![CDATA[victor-gallet]]></category>
            <category><![CDATA[sleep-smarter]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Tue, 23 Oct 2018 05:07:23 GMT</pubDate>
            <atom:updated>2018-10-23T05:07:23.746Z</atom:updated>
            <content:encoded><![CDATA[<h3>Sleep Smarter : comprendre le sommeil pour booster son énergie, sa santé, et sa productivité</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P8ZP9ypFMNKX4_ykTxpjDQ.jpeg" /></figure><p>Ah, une nouvelle semaine qui commence (lorsque j’ai commencé à écrire cet article du moins), donc un nouveau livre lu dans la catégorie développement personnel ?</p><p>Et bien oui, ne changeons pas les bonnes habitudes !</p><p>Aujourd’hui, je vais partager avec vous ce que j’ai retenu de <a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a>, écrit par Shawn Stevenson.</p><p>Mais avant de commencer à rentrer dans le vif du sujet, quelques mots sur l’auteur.</p><h3>Pourquoi donner de l’attention à ce livre ?</h3><p><a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a> est donc un livre écrit par Shawn Stevenson, nutritionniste américain.</p><p>Ce qui est particulièrement intéressant ici, c’est que bien que ce dernier ne soit pas un expert reconnu (de manière officielle) du sommeil, que soit par un diplôme, par des recherches scientifiques… son histoire est suffisamment intrigante pour donner à son livre, et à ses conseils, un minimum de crédibilité.</p><p>Shawn a subi une maladie chronique dégénérative très jeune.</p><p>Comme une grande majorité d’américains de ces dernières décennies, il a vécu dans une famille sujette à la société de consommation — version outre-atlantique -, dans toute sa splendeur. Je vous laisse imaginer le tableau sur le plan alimentaire par exemple : l’eau remplacée par des sodas, des burgers ou des pizzas faisant office de nourriture de base…</p><p>Bref, rien de surprenant donc lorsqu’on apprend que Shawn était obèse très jeune.</p><p>Ajouté à cela le fait de ne pas exercer d’activité physique suffisante, et obtient l’apparition d’une maladie dégénérative osseuse, fragilisant son corps un peu plus chaque jour.</p><p>Si bien qu’une fois, alors qu’il courrait (chose qui n’arrivait globalement jamais), il est tombé, et il s’est cassé la hanche.</p><p>La chose assez dramatique dans sa situation, c’est que ce n’est pas le fait de tomber qui l’a amené à se fracturer l’os de la hanche (un des os les plus solides du corps humain au passage), mais plutôt qu’en courant, ce dernier s’est rompu. C’est cela, qui l’a fait chuter.</p><p>Vous voyez maintenant le tableau ? Ses os étaient purement et simplement devenus des allumettes.</p><p>Et alors qu’il n’avait aucun espoir de guérir — tous les médecins qu’il a consulté à l’époque lui certifiaient qu’il n’y avait rien à faire, hormis d’atténuer la douleur — il a décidé de changer drastiquement sa façon de vivre.</p><p>Puisque les médecins ne croyaient pas à sa guérison, il a pris lui-même les choses en main ! La première étape consista à se renseigner sur sa maladie, pour mieux la comprendre, en profondeur.</p><p>En dévorant des articles de recherches, et en allant jusqu’à s’intéresser aux différents éléments constituant le corps humains (gènes, protéines, hormones…), Shawn, doté d’une résilience et d’une aspiration à guérir gonflées à bloc, a radicalement changer son mode de vie : en commençant par son alimentation; et bien entendu (puisque c’est le sujet du livre), par la gestion de son sommeil.</p><p>Et sur le long terme, ça a commencé à payer !</p><p>En meilleur forme qu’auparavant, il a pu peu à peu recommencer à exercer une activité physique. Modérément dans un premier temps, afin de ne pas fragiliser encore plus son corps qui l’était déjà bien assez de par sa maladie.</p><p>Il a ainsi continué son programme “spécial guérison” jusqu’à ce qu’à un examen de contrôle de routine, les médecins lui annoncèrent que sa maladie dégénérative avait tout simplement disparue… Un fait tout simplement extraordinaire pour tout le personnel médical qui le suivaient à l’époque.</p><p>Bref, tout ça pour dire que bien que Shawn Stevenson ne soit pas un éminent chercheur, il n’en reste pas moins que les conseils qu’il partage dans ce livre peuvent tout de même être pris au sérieux.</p><p>Si améliorer son sommeil (en plus de sa nutrition) lui a permis d’arriver à être en meilleur forme physique et mentale, alors pourquoi ne pas lui donner crédit ? Pourquoi ne pas essayer d’appliquer ses conseils, au moins pour essayer ? Après tout, ça ne coûte pas grand chose…</p><h3>Le rythme circadien</h3><p>Pour mieux comprendre le fonctionnement du sommeil, l’auteur de <a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a> commence donc par expliquer la base, en évoquant le rythme circadien.</p><p>Le rythme circadien désigne en fait simplement chacun des processus biologiques cycliques, s’enchaînant durant les 24 heures d’une journée.</p><p>Grosso-modo, pour nous les humains, mais aussi pour la grande majorité des animaux, cela consiste en deux étapes : l’état de veille et l’état de repos/sommeil.</p><p>Contrairement à certaines espèces, nous ne sommes pas des êtres vivants nocturnes. Nous sommes programmés pour vivre durant la journée.</p><p>Notre rythme circadien est donc régi en grande partie par le Soleil.</p><p>Cela dit, plusieurs études montrent que même en l’absence de lumière, le corps humain continue d’être régit par ce rythme cyclique de 24 heures définissant des périodes de veille et de repos.</p><p>Parmi les principales études sur le sujet, on retrouve par exemple <a href="https://www.sitemed.fr/rythmes/rythme_3.htm">l’expérience de Michel Siffre</a>, un géologue qui a vécu durant presque deux mois sous un glacier, à 130 mètres de profondeur, en l’absence totale de lumière (et de plus, avec des conditions climatiques extrêmes).</p><p>Bref, tout ça pour dire que cette notion de rythme circadien est extrêmement importante à comprendre.</p><p>Nous sommes le résultat de plusieurs millions d’années d’évolution, et bien que l’être humain soit “<em>l’ultime machine d’adaptation</em>”, pour citer <strong>Tom Bilyeu</strong>, nous ne pouvons pas modifier drastiquement, du jour au lendemain, certains des principes qui régissent notre vie depuis toujours.</p><h3>La mélatonine, l’hormone du sommeil</h3><p>Avant de vouloir améliorer la qualité de son sommeil, encore faut-il comprendre comment l’organisme fonctionne. Pour faire simple, comment sur le plan biologique, arrive-t-on à l’état de fatigue ? Quels processus entrent en jeu dans les étapes amenant au sommeil ?</p><p>Il s’avère que, durant la journée, des capteurs situés sur notre peau et dans nos yeux, amassent la lumière du soleil, riche en vitamine D, une vitamine nécessaire à la synthèse de la sérotonine.</p><p>La sérotonine est un neurotransmetteur, notamment impliqué dans la gestion des humeurs, et à l’état de bonheur, lorsqu’il est présent à un taux équilibré dans l’organisme.</p><p>Une chose intéressante, c’est que lorsque l’exposition à la lumière du jour est diminuée, voire complètement inexistante, la sérotonine se transforme en mélatonine : l’hormone du sommeil.</p><p>La fabrication de mélatonine est essentielle pour entrer dans un état de fatigue, et donc pour garantir un endormissement rapide, et une nuit optimale.</p><p>De plus, il semblerait que, généralement — j’écris “généralement” car puisque la quantité de mélatonine est corollaire de la quantité de sérotonine dans l’organisme, elle-même dépendante de la quantité de lumière du soleil reçue durant la journée, les saisons, ainsi que la géolocalisation sont à prendre en compte — la fabrication de mélatonine atteint un pic entre minuit et 4 heures du matin.</p><p>Encore une fois, cela dépend également de notre mode de vie (les travailleurs du soir ont un cycle circadien décalé par exemple, ce qui peut d’ailleurs entraîner des soucis de santé, à terme).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*J5irI-ou3g89ER8D.jpg" /></figure><blockquote><em>Production de mélatonine en fonction des heures de la journée</em></blockquote><p>Selon Shawn Stevenson, capter la lumière du jour, le matin, pendant 45 minutes, quotidiennement, suffirait à améliorer de manière significative notre sommeil (en plus de notre humeur et de notre sensation de bonheur), en nous permettant de dormir plus rapidement le soir.</p><p>Même par temps nuageux, ou pluvieux, la quantité de lux émise par le soleil est tout de même assez importante pour booster la production de sérotonine, et donc, de mélatonine dans la soirée.</p><p>Il conseille aussi d’éviter de se contenter de “prendre le soleil” derrière une fenêtre, puisque ces dernières bloquent une partie des rayons UV du soleil.</p><p>Mais dans tous les cas, s’exposer aux rayons UV au travers de fenêtres est tout de même mieux que rien. La preuve en est avec <a href="https://www.cass.city.ac.uk/__data/assets/pdf_file/0004/363217/lighting-work-performance-cass.pdf">les nombreuses études</a> montrant que travailler dans des conditions de faible (voire carrément d’absence de) luminosité naturelle, entraîne une diminution drastique de l’état de bonheur, et de productivité.</p><h3>Le cortisol, l’hormone du stress à réguler absolument</h3><p>L’hormone ayant les effets inverse de la mélatonine s’appelle le cortisol. Il s’agit d’une hormone stéroïde produite à partir du cholestérol.</p><p>Elle a un rôle majeur dans la régulation du cycle circadien (cycle jour-nuit ou lumière-obscurité, comme vu précédemment).</p><p>Le cortisol stimule l’augmentation du glucose sanguin; plus simplement dit, il permet donc de libérer de l’énergie à partir des réserves de l’organisme.</p><p>On l’appelle “hormone du stress”, car son but principal consiste à aider l’organisme à faire face à des situations de danger, en mobilisant l’énergie nécessaire pour nourrir les muscles, le cerveau mais aussi le cœur.</p><p>Il fonctionne de concert avec l’adrénaline.</p><p>L’adrénaline entraîne une réponse immédiate de l’organisme aux situation de danger, et le cortisol vient à la rescousse, quelques secondes, plus tard avec pour but de “mobiliser toute l’énergie contenue dans les sucres pour l’expédier à certains endroits précis”. Dans les muscles des bras, par exemple, pour soulever un poids important; ou dans ceux des jambes, afin de prendre la fuite le plus rapidement possible.</p><p>Dans cette optique de “réponse immédiate au danger”, le cortisol pousse à une efficacité maximale. Dans ce but, il peut alors entraîner l’arrêt du fonctionnement de certains organes, comme ceux de l’appareil digestif. Il peut même aller jusqu’à mettre en veille le système immunitaire pour faciliter son action !</p><p>Il faut constamment garder en tête que l’Homme est le fruit d’une évolution lente, qui s’est déroulée sur les deux derniers millions d’années.</p><p>Durant plus de 99% du temps qu’on a passé sur Terre, nous étions des chasseurs-cueilleurs. Des prédateurs, mais aussi des proies !</p><p>Le cortisol a donc eu un rôle essentiel à notre survie à cette époque, puisqu’en augmentant favorablement nos réactions face au stress (face au danger), via l’inhibition de certaines réponses du système immunitaire, cette hormone permettait, en cas d’attaque d’un prédateur, d’améliorer ses chances de survie en mettant tous nos sens en alerte pour prendre la fuite par exemple.</p><p>Cela dit, dans notre monde moderne, l’Homme n’a plus véritablement de prédateurs mortels.</p><p>Du moins, il ne s’agit plus des mêmes “prédateurs” qu’il y a plusieurs dizaines de milliers d’années en arrière.</p><p>Aujourd’hui, les “dangers” auxquels nous faisons face tiennent plus de l’ordre de notre santé, de notre nutrition, ou de notre vie professionnelle et sociale par exemple.</p><p>Et bien que le cortisol soit un outil essentiel à la survie, il peut aussi devenir extrêmement pénalisant.</p><p>Le principal soucis, c’est qu’aucune différence d’importance n’est faite entre “il y a un tremblement de terre”, et “je vais rater mon train”.</p><p>Dans chacune de ses situations, le cortisol va agir avec la même efficacité.</p><p>En vivant des tensions de manières répétées, tout au long de la journée, nous perdons d’une part énormément d’énergie, mais d’autre part, cela a des répercussions dramatiques sur l’organisme :</p><ul><li>rythme cardiaque constamment élevé</li><li>pression artérielle très haute</li><li>taux de sucre sanguin qui augmente</li><li>…</li></ul><p>De plus, notre société de consommation actuelle promeut tout ce qui touche à une alimentation sucrée à l’excès. C’est simple, je vous mets au défi de trouver aujourd’hui ne serait-ce qu’une dizaines de produits non sucrés dans vos provisions alimentaires.</p><p>En sachant que la quantité de sucre dans l’organisme est bien souvent corollaire avec le taux de cholestérol, cela ne fait qu’amplifier l’action du cortisol.</p><p>Et plus la réponse au stress est forte, tout en étant répétée, plus à terme, cela affaibli notre organisme.</p><p>Bref, le cortisol est une hormone essentielle, mais comme souvent, si elle n’est pas régulée, elle nuit plus à l’organisme qu’elle ne le sert.</p><p>Quel est son rapport concret avec le sommeil cela dit ?</p><p>Et bien chez l’adulte, la sécrétion de la mélatonine augmente quand celle de cortisol diminue.</p><p>Le risque encourut par une trop grande concentration de cortisol durant la journée, réside donc dans le décalage du cycle circadien, et donc un état de fatigue qui n’arrive que plus tard dans la nuit.</p><p>Réguler son taux de cortisol durant la journée est crucial pour limiter ce décalage du rythme circadien, afin de s’endormir rapidement le soir.</p><h3>L’exposition à la lumière bleue, et l’importance de dormir dans le noir absolu</h3><p>Comme écrit précédemment, nous avons sur notre corps et dans nos yeux, des capteurs à lumière bleue (UV).</p><p>La captation de la lumière bleue entraîne la fabrication de sérotonine, le neurotransmetteur essentiel à la production de la mélatonine (l’hormone du sommeil). Pour rappel, c’est en l’absence de lumière bleue que la sérotonine se transforme en mélatonine, et nous pousse à l’état de fatigue.</p><p>Ce qui arrive généralement le soir, lorsque le Soleil s’est couché.</p><p>En partant de ce constat purement scientifique, si je vous dit maintenant que la plupart des écrans que nous regardons quotidiennement (PC, smartphones, TV…) émettent de la lumière bleue en grande quantité, je pense que vous saisissez le problème que cela suscite sur le sommeil…</p><p>Même si cette lumière bleue émise par nos écrans est proportionnellement bien moins importante que celle reçu par les rayons du soleil, il n’en reste pas moins qu’elle bloque la transformation de la sérotonine en mélatonine, puisque nos capteurs sur notre corps et dans nos yeux considèrent qu’il fait encore jour : le cycle circadien est décalé.</p><p>Ainsi, Shawn Stevenson conseille dans <a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a><strong><em> </em></strong>de ne pas regarder d’écrans le soir, deux heures avant de se coucher.</p><p>Et, dans le cas où cela n’est pas possible, il conseille alors d’utiliser des applications permettant de réduire la lumière bleue émise par nos écrans. Sur PC, il y a <a href="https://justgetflux.com/"><em>f.lux</em></a> par exemple, et <em>Twilight</em> sur smartphone.</p><p>Personnellement, j’utilise ces deux applications depuis plus d’un an. Je les utilisais déjà avant la lecture de ce livre.</p><p>Et au delà de mieux dormir, j’ai également constaté que je suis moins sujet à des migraines depuis… Est-ce lié ou pas (peut-être qu’il s’agit simplement d’un effet placebo) ? Dans tous les cas, puisque le résultat est là, je continue de les utiliser.</p><p>Shawn conseille également de dormir dans le noir total.</p><p>En effet, selon plusieurs études scientifiques, ne serait-ce qu’une très faible lumière émise dans la pièce dans laquelle on dort pourrait perturber notre sommeil.</p><p>De plus, dormir dans le noir total consisterait également à réduire l’apparition d’apnée du sommeil.</p><h3>La pratique d’une activité physique le matin</h3><p>Un autre conseil donné dans <a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a><strong><em> </em></strong>est de favoriser la pratique d’une activité physique plutôt le matin, entre 6 et 10 heures, que le soir.</p><p>Dans tous les cas, l’exercice physique est important pour améliorer notre globale énergie quotidienne, comme le prouvait Tony Schwartz dans <a href="https://www.developing-stuff.com/the-power-of-full-engagement-lenergie-et-non-le-temps-est-notre-ressource-la-plus-precieuse/"><strong><em>The Power of Full Engagement</em></strong></a>.</p><p>Et bien que cela soit compliqué à mettre en place, dans le cas de sports en club (dont les séances d’entraînement sont principalement le soir), il est crucial de garder cela en tête, si vous avez des problèmes d’insomnies.</p><p>Une des raisons de ne pas pratiquer une activité physique le soir, quelques heures avant de se coucher concerne notre température corporelle.</p><p>En effet, celle-ci fluctue tout au long du cycle circadien. Le moment où notre corps est le plus froid se situe durant la nuit.</p><p>L’état de fatigue arrive lorsque notre corps commence à réguler sa température, en la diminuant petit à petit.</p><p>Il est d’ailleurs conseillé, dans <a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a><em>, </em>de prêter attention à garder une température de la chambre aux alentours de 18 degrés, afin de favoriser au maximum les conditions permettant de s’endormir rapidement.</p><p>Mais via le sport, et la dépense intense d’énergie physique, notre température corporelle augmente.</p><p>Le résultat est donc simple, plus nous pratiquons une activité sportive tard, plus la régulation de la température corporelle est décalée, entraînant par conséquent un déphasage du sommeil.</p><p>De plus, plusieurs études, dont <a href="https://www.scopus.com/record/display.uri?eid=2-s2.0-65849282657&amp;origin=inward&amp;txGid=0242e9b944bee912f83c6d920f9ea237">une de l’université de Loughborough, en 2009</a>, ont prouvé que les résultats procurés par la pratique d’un sport, sur le plan de la prise de muscle, l’endurance, et par rapport à l’augmentation de sa force en général, sont plus important après des séances le matin que le soir.</p><h3>La méditation, la pratique “couteau-suisse” pour améliorer sa santé et son sommeil</h3><p>Je pourrais vous lister un grand nombre d’études scientifiques prouvant que pratiquer ne serait-ce que dix minutes de méditations quotidiennement, peut drastiquement changer votre vie.</p><p>Autant concernant votre santé — en permettant une meilleur régulation de la pression sanguine, du rythme cardiaque… — que votre énergie physique (en améliorant la récupération après effort), mentale (en diminuant le stress par exemple) et spirituelle (en prenant conscience de soi, des autres, et de ce qui nous entoure).</p><p>Bref, la méditation est un outil extrêmement utile, qui n’attend qu’à être utilisé pour améliorer nos vies.</p><p>Dans <a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a>, Shawn Stevenson affirme que pratiquer ne serait-ce que dix minutes de méditation le matin, a un réel impact sur la qualité du sommeil.</p><p>Selon lui, plus nous méditons, plus l’impact est important.</p><p>Si vous souhaitez commencer la méditation, mais que vous ne savez vraiment pas comment vous lancer, je ne peux que vous conseiller d’utiliser un “guide” audio, avec l’application <a href="https://www.headspace.com/"><strong><em>Head Space</em></strong></a> par exemple (en anglais), ou son équivalent francophone : <a href="https://www.petitbambou.com/"><strong><em>Petit Bambou</em></strong></a>.</p><h3>Conclusion</h3><p><a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a><strong><em> </em></strong>est un livre vraiment intéressant, bourré d’astuces pour améliorer la qualité de son sommeil.</p><p>Dormir plus, c’est effectivement une chose à ne pas négliger, surtout si vos nuits durent moins de 6 heures. Mais dormir mieux, c’est encore plus important !</p><p>Shawn Stevenson partage dans ce livre tout ce qu’il connaît, à propos du sommeil : du niveau biologique, concernant le comportement des différentes hormones du cycle circadien, jusqu’à un niveau bien plus haut, permettant de comprendre comment mettre en place certaines “bonnes pratiques” ayant fait leurs preuves.</p><p>Certaines des astuces qu’il met en avant peuvent paraître logique, mais d’autres, — comme le fait de placer une “plante dépolluante” dans sa chambre telle que la <em>Sanseviera Trifasciata</em>, pour oxygéner et purifier l’air (cette plante a la particularité de produire de l’oxygène, même de nuit, et <a href="https://en.wikipedia.org/wiki/NASA_Clean_Air_Study">une étude de la NASA</a> prouve même son efficacité) — ; sont totalement fortuites.</p><p>Bref, <a href="https://www.amazon.fr/gp/product/1781808368/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=1781808368&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=03975f1c5e551f26c39cfaa915bdb36d"><strong><em>Sleep Smarter</em></strong></a><strong><em> </em></strong>nous en apprend beaucoup sur le sommeil, et surtout, sur son importance réelle, dans notre vie de tous les jours, et je ne pourrais que vous conseiller sa lecture.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e11e94adb03a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Premiers pas en Rust : Partie 6 — Récupérer les modules distants !]]></title>
            <link>https://medium.com/@TheElkantor/premiers-pas-en-rust-partie-6-r%C3%A9cup%C3%A9rer-les-modules-distants-b6fe21541a79?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6fe21541a79</guid>
            <category><![CDATA[rustlang]]></category>
            <category><![CDATA[développement]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[programmation]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Fri, 12 Oct 2018 05:09:11 GMT</pubDate>
            <atom:updated>2018-10-12T05:09:11.229Z</atom:updated>
            <content:encoded><![CDATA[<h3>Premiers pas en Rust : Partie 6 — Récupérer les modules distants !</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CufPMI4AMI2oyvljiwPALw.jpeg" /></figure><p>Cela fait maintenant deux semaines que je n’ai pas écrit d’article concernant bsc, en Rust…</p><p>Il est plus que temps de remédier à cette inactivité (non voulue) !</p><p>Aujourd’hui, on va donc voir ensemble la suite de la partie précédente, à savoir la toute première étape de la sous-commande <em>add</em> : récupérer un module (distant ou non).</p><h3>Quelques rappels et explications rapides</h3><p>Dans l’épisode précédent, nous nous étions arrêtés à la création de la sous-commande en elle-même, grâce au crate <em>clap</em>, avec toutes les options dont nous avions besoin pour l’instant :</p><ul><li>−−local : pour récupérer un module stocké sur le pc</li><li>−−zip : pour récupérer un module stocké sur un serveur distant (en ligne sur github par exemple), et compressé au format <em>zip</em></li><li>−−git : pour directement cloner un module disponible via un dépôt <em>git</em> distant</li></ul><p>On avait donc vu que ces options étaient ensuite transformées en <em>enum</em>, et passées à la fonction d’entrée de l’ajout d’un module : <em>add_dependency</em>, dans le fichier <em>add.rs </em>:</p><pre>// Cette fonction est située dans le fichier main.rs principal, et est appelée dans<br> // le cas où l&#39;utilisateur a tapé la sous-commande bcs add ...<br>fn add_dependency(path: &amp;str, module_url: &amp;str, git_repository: bool, local_repository: bool, zip_repository: bool){<br>    // on passe le chemin courant, l&#39;url du module à ajouter, et son type (git, local ou zip)<br>    // à la fonction add_dependency, présente dans le fichier add.rs<br>    // qui est le point d&#39;entrée pour la fonctionnalité d&#39;ajout d&#39;un module<br>    if git_repository {<br>        add::add_dependency(&amp;path, &amp;module_url, add::ModuleType::Git);<br>    } else if local_repository {<br>        add::add_dependency(&amp;path, &amp;module_url, add::ModuleType::Local);<br>    } else if zip_repository {<br>        add::add_dependency(&amp;path, &amp;module_url, add::ModuleType::Zip);<br>    } else {<br>        println!(&quot;Error: the module is neither a local, a git, or a zip url.&quot;);<br>    }<br>}</pre><p>Aujourd’hui, on va donc s’intéresser au premières instructions de cette fameuse fonction “point d’entrée” de la fonctionnalité d’ajout d’un module.</p><p>La première étape consiste à créer (s’il n’existe pas déjà) le dossier <em>bsc_modules</em>, qui contiendra tous les modules dont le projet va dépendre.</p><p>Pour ce faire, je fais appel à la fonction <em>create_folder</em>, précédemment définie dans le fichier <em>common.rs</em>.</p><pre>pub fn add_dependency(path: &amp;str, module_url: &amp;str, module_type: ModuleType){<br>    // Création du dossier bsc_modules, à la racine du projet<br>    // si celui-ci n&#39;existe pas déjà<br>    common::create_folder(&amp;format!(&quot;{}/bsc_modules&quot;, &amp;path));<br>}</pre><p>Il faut aussi penser que les modules importés peuvent être contenus dans des dossiers avec des noms particuliers. Ou encore, que ces derniers sont déjà inclus dans le projet en cours (il faut donc vérifier les modules déjà existant afin d’éviter des doublons…).</p><p>Pour vérifier tout cela, je commence donc par les importer dans un dossier <em>tmp</em> (dossier temporaire), situé dans <em>bsc_modules</em>. Cela permet également de pouvoir télécharger les éventuels modules au format zip dedans, avant de les <em>déziper</em> dans <em>bsc_modules </em>(le dossier parent de <em>tmp</em>).</p><p><em>Vous l’aurez compris, aucun module ne pourra donc être nommé “tmp” au risque d’être considéré comme le dossier temporaire, et donc d’être détruit une fois la commande terminée.</em></p><p>Mais avant de créer ce dossier, et pour que toute cette opération reste “propre”, on va détruire tout dossier éventuel <em>tmp</em> dans <em>bsc_modules, </em>juste au cas où.</p><p>Puis, on va appeler la fonction <em>copy_module_to_tmp </em>qui se chargera de récupérer le module grâce à l’url renseigné dans la sous-commande.</p><pre>pub fn add_dependency(path: &amp;str, module_url: &amp;str, module_type: ModuleType){<br>    common::create_folder(&amp;format!(&quot;{}/bsc_modules&quot;, &amp;path));<br>    // Suppression d&#39;un éventuel dossier tmp existant dans bsc_modules/<br>    common::destroy_folder(&amp;format!(&quot;{}/bsc_modules/tmp&quot;, &amp;path));<br>    // Fonction qui gère la récupèration du module, en fonction de son type (zip, local, git)<br>    copy_module_to_tmp(&amp;path, &amp;module_url, module_type);<br>}</pre><p>Tout semble prêt pour passer à l’étape suivante !</p><h3>L’ajout d’un module local</h3><p>Le principe d’ajout d’un module local est vraiment simple.</p><p>On va simplement copier/coller le dossier situé à l’url renseigné dans la sous-commande.</p><p>Dans la fonction <em>copy_module_to_tmp</em>, on appelle donc la fonction <em>copy_folder</em> (précédemment créée dans le fichier <em>common.rs</em>).</p><pre>pub fn copy_module_to_tmp(path: &amp;str, module_url: &amp;str, module_type: ModuleType){<br>    // switch en fonction du type du module qu&#39;on souhaite ajouter<br>    match module_type {<br>        // s&#39;il s&#39;agit d&#39;un module de type git<br>        ModuleType::Git =&gt; {<br>        },<br>        // s&#39;il s&#39;agit d&#39;un module de type local<br>        ModuleType::Local =&gt; {<br>            // on copie/colle simplement le module dans notre dossier tmp<br>            common::copy_folder(&amp;module_url, &amp;format!(&quot;{}/bsc_modules/tmp&quot;, &amp;path));<br>        },<br>        // s&#39;il s&#39;agit d&#39;un module de type zip<br>        ModuleType::Zip =&gt; {<br>        },<br>        _ =&gt; unreachable!(),<br>    }<br>}</pre><p>Bref, c’est simple et efficace.</p><p>Voyons maintenant le cas d’un module qui se trouverait sur un dépôt git distant.</p><h3>L’ajout d’un module git</h3><p>Vous vous souvenez du crate <em>git2</em> utilisé précédemment, lors de la création d’un nouveau projet (avec la sous-commande <em>bsc create</em>), pour initialiser un dépôt git ?</p><p>Et bien nous allons le réutiliser ici, mais cette fois, pour cloner un dépôt git, depuis une adresse url donnée.</p><p>On va donc utiliser la fonction <em>clone</em> présente dans le namespace <em>Repository</em> de ce crate, qui prend en arguments deux chaînes de caractères (l’url du dépôt git distant, et le dossier de destination du clonage), comme indiqué dans la <a href="https://docs.rs/git2/0.7.5/git2/">documentation</a> :</p><pre>pub fn copy_module_to_tmp(path: &amp;str, module_url: &amp;str, module_type: ModuleType){<br>    match module_type {<br>        ModuleType::Git =&gt; {<br>            // on clone le dépôt git disponible à l&#39;adresse url &quot;module_url&quot;, passée en paramètre<br>            // dans le dossier tmp, tout en gérant le cas d&#39;une éventuelle erreur<br>            // lors de cette opération<br>            match git2::Repository::clone(&amp;module_url.to_string(), format!(&quot;{}/bsc_modules/tmp/&quot;, &amp;path)){<br>                Err(why) =&gt; panic!(&quot;Error: failed to clone {}.&quot;, why.description()),<br>                Ok(_) =&gt; (),<br>            };<br>        },<br>        ModuleType::Local =&gt; {<br>            common::copy_folder(&amp;module_url, &amp;format!(&quot;{}/bsc_modules/tmp&quot;, &amp;path));<br>        },<br>        ModuleType::Zip =&gt; {<br>        },<br>        _ =&gt; unreachable!(),<br>    }<br>}</pre><p>Encore une fois, rien de très compliqué. Surtout via l’utilisation du crate <em>git2</em> qui nous facilite énormément le travail !</p><p>Passons maintenant au dernier cas de figure.</p><h3>L’ajout d’un module zip</h3><p>Pour commencer, on va s’intéresser au téléchargement du fichier zip, disponible, encore une fois, à l’adresse url renseignée dans la sous-commande <em>bsc add</em>.</p><p>Pour télécharger un fichier, on va utiliser le crate <em>curl</em>, qui n’est rien d’autre qu’un <em>wrapper</em> de la libcurl, écrite en C (vous connaissez d’ailleurs probablement l’utilitaire curl, utilisable en ligne de commande, qui s’appuie sur la libcurl).</p><p>Cette librairie permet de télécharger des fichiers disponibles depuis un serveur distant.</p><p>Comme d’habitude lorsqu’on ajoute un nouveau crate au projet, on va donc commencer par ajouter une ligne dans le fichier <em>Cargo.toml</em> pour spécifier à <em>Cargo</em> qu’on souhaite utiliser le crate <em>curl</em> :</p><pre>[package]<br>name = &quot;bsc&quot;<br>version = &quot;0.1.0&quot;<br>authors = [&quot;Victor Gallet&lt;victor.gallet@developing-stuff.com&gt;&quot;]</pre><pre>[dependencies]<br>indicatif = &quot;0.9.0&quot;<br>clap = &quot;2.32.0&quot;<br>git2 = &quot;0.7.5&quot;<br>// Ajout du crate curl dans sa version 0.4.15 <br>// (dernière version en date, lors de l&#39;écriture de cet article)<br>curl = &quot;0.4.15&quot;</pre><pre>[profile.release]<br>lto = true</pre><p>Au prochain appel de la commande <em>cargo build</em>, ou <em>cargo run…</em>, Cargo récupérera le crate, et le compilera pour qu’il soit utilisable dans notre projet.</p><p>Nous n’avons plus qu’à rajouter l’instruction pré-processeur suivante, tout en haut de notre fichier <em>add.rs</em>, pour pouvoir l’utiliser :</p><pre>extern crate curl;</pre><p>Regardons maintenant plus en détails l’utilisation de ce crate :</p><pre>pub fn copy_module_to_tmp(path: &amp;str, module_url: &amp;str, module_type: ModuleType){<br>    match module_type {<br>        ModuleType::Git =&gt; {<br>            match git2::Repository::clone(&amp;module_url.to_string(), format!(&quot;{}bsc_modules/tmp/&quot;, &amp;path)){<br>                Err(why) =&gt; panic!(&quot;Error: failed to clone {}.&quot;, why.description()),<br>                Ok(_) =&gt; (),<br>            };<br>        },<br>        ModuleType::Local =&gt; {<br>            common::copy_folder(&amp;module_url, &amp;format!(&quot;{}bsc_modules/tmp&quot;, &amp;path));<br>        },<br>        ModuleType::Zip =&gt; {<br>            // Création du dossier tmp pour stocker le module téléchargé, et l&#39;unzip<br>            common::create_folder(&amp;format!(&quot;{}bsc_modules/tmp&quot;, &amp;path));<br>            // Utilisation du crate curl pour télécharger le fichier zip<br>            let mut easy = curl::easy::Easy::new();<br>            let mut dst = Vec::new();<br>            easy.url(https://medium.com/&amp;module_url).unwrap();<br>            {<br>                let mut transfer = easy.transfer();<br>                transfer.write_function(|data| {<br>                    dst.extend_from_slice(data);<br>                    Ok(data.len())<br>                }).unwrap();<br>                transfer.perform().unwrap();<br>            }<br>            common::set_content_file(&amp;format!(&quot;{}bsc_modules/tmp/test.zip&quot;, &amp;path), &amp;dst);<br>        },<br>        _ =&gt; unreachable!(),<br>    }<br>}</pre><p>D’après la <a href="https://docs.rs/curl/0.5.0/curl/">documentation officielle</a> du crate, on commence donc par créer une structure de type <em>Easy</em>, permettant d’effectuer le binding entre le crate <em>curl </em>et la lib C <em>libcurl</em>.</p><p>Ensuite, on créé un vecteur (nommé <em>dst</em> ici), pour stocker le contenu du fichier qu’on souhaite télécharger.</p><pre>let mut easy = curl::easy::Easy::new();<br>let mut dst = Vec::new();</pre><p>Puis on donne l’url où se trouve le fichier au champ <em>url</em> de la structure <em>easy</em> (<em>unwrap</em> permet d’automatiquement gérer une éventuelle erreur en effectuant un appel à <em>panic!</em>, comme vu dans les articles précédents) :</p><pre>easy.url(https://medium.com/&amp;module_url).unwrap();</pre><p>Maintenant que tout est prêt, il ne reste plus qu’à traiter la structure <em>easy.</em></p><p>Pour cela, on va s’en tenir à la documentation officielle du crate : on ouvre donc un nouveau scope. Ce qui veut dire que toute variable déclarée sur le tas dans ce scope n’est plus accessible passé le “}” (en l’occurrence ici, les variables <em>transfer </em>et <em>data</em>).</p><pre>{<br>    let mut transfer = easy.transfer();<br>    transfer.write_function(|data| {<br>        dst.extend_from_slice(data);<br>        Ok(data.len())<br>    }).unwrap();<br>    transfer.perform().unwrap();<br>}</pre><blockquote><em>Pourquoi déclarer un nouveau scope ?</em></blockquote><p>En fait, c’est lié à une des particularités de Rust, dont je ne vous ai pas encore parlé : le borrow checker.</p><p>Je pense que cette notion propre à ce langage nécessite un article complet (qui arrivera sûrement d’ici quelques jours / semaines) pour bien comprendre et expliquer ce concept.</p><p>Pour faire simple Rust est un langage safe. Qu’est-ce que cela veut dire ?</p><p>Tout simplement qu’il n’est pas possible de passer et modifier des variables par référence ou par adresse (la plupart du temps instanciées sur la pile), au risque de se retrouver avec une variable détruite (<em>free </em>en mémoire), et qui n’est donc plus disponible.</p><p>Dans l’éventualité où ce cas arriverait, les traitements suivants sont complètement biaisés puisqu’ils vont essayer de chercher une variable dans une zone mémoire qui n’en contient plus. Cela produit des erreurs assez compliquées à résoudre puisqu’elles ne sont pas levées lors de la compilation, mais lorsque le programme est lancé (donc il faut effectuer une grande quantité de tests pour rencontrer un bug de ce genre).</p><p>Cela implique donc une grande vigilance de la part des programmeurs, en étant certain de traiter absolument tous les cas de figures.</p><p>Sauf qu’on le sait tous, l’erreur est humaine, et un oubli est vite arrivé, surtout sur des projets conséquents incluant plusieurs dizaines de développeurs.</p><p>Imaginez simplement le cas d’un jeu où une IA (personnage A) suit une autre IA (personnage B).</p><p>On peut donc spéculer que le personnage A possède une référence sur le personnage B, et qu’à chaque itération de la boucle principale du jeu, il va aller regarder la position du personnage B, pour le suivre.</p><p>Maintenant, supposons que le personnage B meurt, ou est détruit, et ne soit plus dans le jeu. La mémoire allouée pour ce personnage est donc libérée.</p><p>Si un tel cas de figure n’est pas traité correctement, alors le personnage A contient maintenant une référence sur une zone mémoire vide (dans le meilleur des cas), ou pire, qui contient carrément autre chose dorénavant (dans le cas où des allocations ont été faites entre la destruction du personnage B = libération de la zone mémoire, et l’appel à la fonction permettant au personnage A de suivre B).</p><p>Dans le cas d’un petit jeu, avec peu de NPC (IA), cela sera un problème vite repéré.</p><p>Mais dans le cas d’une grosse production, constituée de plusieurs centaines de NPC interagissant constamment entre eux et avec le joueur, je vous laisse entrevoir les problèmes que cela peut poser, si le bug n’est détecté très vite…</p><p>Bref, Rust a donc notamment été pensé pour sécuriser cette notion de “passage par référence ou par adresse”. Et pour y parvenir, plusieurs règles ont été créées, dont le <em>borrow checker.</em></p><p>Pour faire simple, lorsqu’on déclare une variable <em>mutable</em>, on ne peut la modifier par référence qu’une seule fois par scope; scope qui ne peut pas être plus grand que celui qui contient la déclaration de la variable.</p><p>En attendant d’écrire un article entièrement dédié à ce sujet (en français), je vous invite vivement à lire <a href="https://doc.rust-lang.org/1.8.0/book/references-and-borrowing.html">la documentation officielle</a> (en anglais), très claire, avec plusieurs exemples.</p><p>Bref, cet aparté étant terminé, revenons à nos moutons !</p><p>Une fois les actions effectuées dans ce nouveau scope terminées, nous nous retrouvons donc avec le contenu du fichier zip téléchargé dans le vecteur <em>dst</em> (qui n’est rien d’autre qu’un tableau d’int sur 8 bits non signés).</p><p>On peut donc maintenant créer et remplir un fichier d’extension .zip avec ces données, en passant ce vecteur <em>dst</em> à la fonction <em>set_content_file</em>, présente dans le fichier <em>common.rs</em> :</p><pre>// Création d&#39;un fichier dans bsc_modules/tmp/ nommé test.zip<br> // qui contient le contenu du fichier zip téléchargé <br>common::set_content_file(&amp;format!(&quot;{}bsc_modules/tmp/test.zip&quot;, &amp;path), &amp;dst);</pre><p>Il ne nous reste plus qu’à <em>unzip </em>ce fichier pour récupérer le code du module !</p><p>Comme cet article commence à devenir plutôt conséquent, nous verrons cela dans la partie 7.</p><h3>Conclusion</h3><p>L’ajout d’un nouveau module commence à prendre forme !</p><p>Jusqu’ici, on a donc récupéré le code du module qu’on souhaite ajouter dans le dossier <em>bsc_module/tmp</em>, sauf concernant le cas d’un module récupéré par archive zip, où nous n’avons pour l’instant que le fichier .zip téléchargé.</p><p>Dans l’article suivant, nous verrons donc comment <em>unzip</em> ce fichier, et les étapes restantes nécessaires à l’ajout d’un module bsc :</p><ul><li>vérification des fichiers (pour savoir s’il s’agit bien d’un module bsc)</li><li>vérification des dépendances, pour savoir si le module ajouté est déjà une dépendance du projet</li><li>ajout des fichiers <em>headers</em> et<em> sources</em> aux fichiers CMakeLists.txt, de configuration du méta build <em>cmake</em></li><li>modification des instructions pré-processeurs <em>#include</em> écrites dans les fichiers du module ajouté, afin d’obtenir des chemins finaux plus simples et logiques.</li><li>…</li></ul><p>Encore une fois, je vous remercie vraiment d’avoir pris le temps de lire cet article jusqu’au bout !</p><p>J’espère que cela vous intéresse toujours autant, et je suis bien évidemment encore à l’écoute de vos commentaires sur le sujet (que ce soit sur le fonctionnement intrinsèque de <em>bsc</em>, ou sur le code Rust).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6fe21541a79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Power of Full Engagement : L’énergie, et non le temps, est notre ressource la plus précieuse]]></title>
            <link>https://medium.com/@TheElkantor/the-power-of-full-engagement-l%C3%A9nergie-et-non-le-temps-est-notre-ressource-la-plus-pr%C3%A9cieuse-9652ff2f548c?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/9652ff2f548c</guid>
            <category><![CDATA[travail]]></category>
            <category><![CDATA[power-of-full-engagement]]></category>
            <category><![CDATA[productivité]]></category>
            <category><![CDATA[développement-personnel]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Mon, 08 Oct 2018 04:49:32 GMT</pubDate>
            <atom:updated>2018-10-08T04:49:32.035Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Power of Full Engagement : L’énergie, et non le temps, est notre ressource la plus précieuse</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*brmAkB0KTl3ZCGpBJtYoig.jpeg" /></figure><p>Une nouvelle semaine se termine, et avec elle, la lecture d’un nouveau livre sur le développement personnel.</p><p>Aujourd’hui, je vais donc vous résumer <a href="https://www.amazon.fr/gp/product/0743226755/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=0743226755&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=4af24479d383c91deecf654626f3afce"><em>The Power of Full Engagement</em></a>, de Jim Loehr et Tony Schwartz.</p><p>Ce livre essaye de répondre à une question incroyablement simple, mais dont la réponse (si tenté qu’il en existe une) est terriblement complexe : <strong>comment faire en sorte d’être plus productif, plus conscient et plus concentré dans tous les domaines de notre vie ?</strong></p><h3>Le plein engagement, ou le secret de la performance optimale</h3><p>Tony Shwartz et Jim Loehr sont deux amis, ayant chacun leur propre société de <em>consulting </em>dans le domaine du développement personnel. Leur but commun est d’accroître les performances et la productivité de leurs clients.</p><p>Tony se focalise principalement sur les capacités physiques. Ses clients sont des athlètes de haut niveau (joueurs de tennis, golfeurs…) dont l’unique objectif est de tout mettre en oeuvre pour devenir le numéro un dans leur domaine.</p><p>Jim quant à lui s’est spécialisé dans les performances intellectuelles. Il aide donc des cadres, voire même des chefs d’entreprises, à devenir plus efficient dans leur travail.</p><p>L’idée principale de <a href="https://www.amazon.fr/gp/product/0743226755/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=0743226755&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=4af24479d383c91deecf654626f3afce"><em>The Power of Full</em> Engagement</a>, qui découle de ce mantra :</p><blockquote><em>“L’énergie, et non le temps, est la ressource fondamentale d’une grande performance.”</em></blockquote><p>provient d’une conséquence du travail des deux auteurs.</p><p>Particulièrement de Tony Schwartz, qui, lorsqu’il travaillait avec des joueurs de tennis de renom, s’est aperçu que ce qui séparait les dix meilleurs joueurs mondiaux des autres, n’était pas uniquement lié aux compétences physiques et mentales.</p><p>Non, ce qui permet aux meilleurs joueurs du monde de se démarquer remarquablement de leurs concurrents, réside fondamentalement dans leurs habitudes vis à vis de la récupération après effort.</p><p>Ainsi, que ce soit Pete Sampras, Jim Courier ou encore Arantxa Sanchez-Vicario, chacun de ces athlètes a mis en place un rituel après chaque point, afin de récupérer (en baissant leur fréquence cardiaque par exemple).</p><p>Entre chaque point, vous allez me dire, ils n’ont pas le temps de récupérer complètement !</p><p>Vous avez parfaitement raison, mais ces quelques secondes, mises bout à bout, procèdent à la fin d’un match de plusieurs heures, en un résultat qui fait toute la différence.</p><p>Rappelez-vous du livre <a href="https://amzn.to/2w3LygF"><em>The Coumped Effect</em></a> de Darren Hardy : rien n’est plus puissant que l’effet cumulé croissant.</p><p>Aujourd’hui, nous vivons dans un monde connecté, où tout va vite. Très vite même !</p><p>Nous n’avons même plus le temps de prendre conscience de la plupart de nos actions. C’est la course à la productivité.</p><p>Nous travaillons plusieurs heures par jour, et certains, comme au Japon ou aux États-Unis, vont même à travailler jusqu’à plus de 80 heures par semaine. La vie de l’homme moderne est calibrée comme du papier à musique : métro, boulot, dodo…</p><p>Dans <a href="https://www.amazon.fr/gp/product/0743226755/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=0743226755&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=4af24479d383c91deecf654626f3afce"><em>The Power of Full</em> Engagement</a>, Jim Loehr et Tony Schwartz démystifient la croyance populaire qui nous fait croire que plus nous travaillons, plus les résultats à la clef sont importants.</p><p>Pour atteindre le plein engagement et réaliser de grandes choses dans tous les domaines de notre vie, que ce soit professionnel, familial… l’important n’est pas la quantité d’heures consacrée, mais l’énergie que nous sommes capable d’attribuer aux tâches quotidiennement.</p><h3>Les quatre piliers du plein engagement</h3><p>Le plein engagement — c’est à dire notre capacité a rester concentrer sur des taches précises, durant de longues périodes -, qui est donc notre ultime outil de productivité selon ce livre, repose sur la somme de quatre énergies :</p><ul><li>physique</li><li>mentale</li><li>émotionnelle</li><li>et spirituelle</li></ul><p>Un des aspects fondamental du pouvoir du plein engagement, est de comprendre qu’il s’appuie véritablement sur chacune de ses quatre énergies.</p><p>Le but est donc de maximiser chacun de ces piliers pour garantir une concentration et des performances optimales durant la journée.</p><p>Et bien qu’elles soient disponibles en quantité limitée, contrairement au temps, qui lui est figé — nous disposons tous de 24 heures dans une journée -, ces énergies sont des ressources amplifiables.</p><p>Comme des muscles, nous pouvons les entraîner, les renforcer, dans le but d’accroître notre quota d’énergie globale quotidienne, et donc notre productivité.</p><p>Lésiner ne serait-ce qu’un seul de ces piliers déséquilibre la balance générale, et entraîne une perte d’énergie globale.</p><h3>L’énergie physique</h3><p>Le pilier fondateur du plein engagement, l’énergie physique, est sans doute celui dont la prise de conscience est la plus facile.</p><p>Cela inclut à la fois les activités physiques, l’alimentation, mais également tout ce que nous pouvons mettre en oeuvre afin d’améliorer le bien être de notre corps — en pratiquant la méditation par exemple, dans le but de réguler notre respiration et notre rythme cardiaque…</p><p>On oublie aussi trop souvent l’importance de s’hydrater.</p><p>Pourtant, l’eau est peut-être une des principales source d’énergie physique et mentale.</p><p>Notre corps est constitué à plus de 70% d’eau. Notre système lymphatique, servant à drainer les tissus et à transporter les lipides issus de l’alimentation, requiert de grandes quantité d’eau pour continuer de fonctionner de manière optimale. Ce dernier joue par ailleurs un rôle crucial dans l’immunité de l’organisme.</p><p>En plus du système lymphatique de notre corps, <a href="https://blognutritionsante.com/2017/10/04/vaisseaux-lymphatiques-cerveau/">des études récentes</a> ont également prouvé que notre cerveau dispose lui aussi d’un système de drainage des déchets nécessitant également une grande quantité d’eau pour continuer de fonctionner de façon optimale.</p><p>Pour finir, les bénéfices de l’énergie physique sont facilement compréhensibles puisque, de par notre culture, et grâce aux différentes études de ces dernières décennies, nous savons tous que pratiquer une activité physique régulière, couplée à une alimentation saine et équilibrée, nous est extrêmement favorable, et décuple notre énergie globale.</p><p>Cependant, c’est véritablement la qualité de l’exercice physique qui est le facteur le plus important. Les muscles se renforcent et grossissent grâce à <strong>l’oscillation</strong> : l’alternance entre période de stress, et de récupération.</p><p>Une activité physique sans récupération conduit simplement à une augmentation de stress (accroissement du taux de cortisol, une des hormones du stress).</p><p>Mais à l’inverse, ne pratiquer aucune activité physique (et donc de très longues périodes de récupération continues), conduit à une atrophie.</p><h3>L’énergie mentale</h3><p>Le deuxième pilier du plein engagement, l’énergie mentale, est également facilement identifiable.</p><p>Notre cerveau est un muscle.</p><p>Comme écrit précédemment, plus nous le stimulons, — tout en prêtant attention à garantir des périodes de repos (via le sommeil) -, plus nous le renforçons; conduisant par la suite des performances plus élevées que ce soit sur la durée de concentration sur des tâches intellectuelles précises, sur la mémoire…</p><p>Dans notre société moderne, le travail intellectuel joue une place majeure.</p><p>Socialement, les attentes (surtout professionnelles) sont très importantes.</p><p>Or on oublie souvent que le travail intellectuel intense conduit plus rapidement à un état de fatigue que le fait de pratiquer une activité physique.</p><p>Encore une fois, l’importance de l’<strong>oscillation</strong> est capitale pour assurer une efficience optimale.</p><p>Bien que le fait de prendre des pauses n’est pas vraiment encouragé (voire même, est vu de façon très négative) dans notre société occidentale moderne, Jim Loehr indique qu’il est essentiel d’avoir des courtes périodes de récupération, toutes les 90 à 120 minutes, afin de rester au meilleur de ses capacités.</p><p>Enfin, le plus important concernant le travail intellectuel, mentionné dans <a href="https://www.amazon.fr/gp/product/0743226755/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=0743226755&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=4af24479d383c91deecf654626f3afce"><em>The Power of Full</em> Engagement</a>, est de se fixer des limites horaires.</p><p>Travailler durant de longues périodes sans repos est contre productif.</p><p>Au Japon, les salariés travaillent en moyenne entre 10 et 12 heures par jour, soit plus de 60 heures par semaine.</p><p>Résultat ? Environ 10.000 japonais décèdent chaque année d’AVC, de crise cardiaques… Autant de conséquences directes du stress emmagasiné durant ces longues périodes de travail sans repos.</p><p>Un terme est même apparu dans les années 1980 pour désigner ces décès : “<a href="https://fr.wikipedia.org/wiki/Kar%C5%8Dshi"><em>karochi</em></a>” (mort par sur-travail).</p><h3>L’énergie émotionnelle</h3><p>Le pilier émotionnel, peut-être moins évidant à prendre conscience, n’en reste pas moins crucial que les précédents selon Jim Loehr et Tony Schwartz, pour garantir un haut niveau d’énergie globale au fil de la journée.</p><p><a href="https://www.amazon.fr/gp/product/0743226755/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=0743226755&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=4af24479d383c91deecf654626f3afce"><em>The Power of Full Engagement</em></a> décrit l’énergie émotionnelle comme étant l’énergie utilisée — ou émanant — via l’expression de nos émotions.</p><p>Le but est de réduire la quantité d’énergie dépensée par nos mauvaises émotions, comme la colère, la peur, l’anxiété, etc; en essayant de rester le principal maître à bord. En essayant au final de penser, avant de laisser nos émotions s’exprimer.</p><p>Finalement, cette approche qui consiste à vouloir absolument contrôler notre ressenti à chaque instant, afin de relativiser et de transformer nos émotions négatives en quelque chose de plus positif (par exemple l’arrogance en humilité, l’indifférence pour autrui en empathie…) est un des fondements de la philosophie stoïcienne.</p><p>Sombrer dans l’expression de nos émotions négatives nécessite une grande quantité d’énergie. Une quantité d’énergie qui ne pourra alors pas être utilisée pour se focaliser sur quelque chose de plus productif, de plus efficient…</p><p>Par ailleurs, être incapable de contrôler nos émotions négatives peut, par effet boule de neige, entraîner vers des conséquences dramatiques.</p><p>Marc-Aurèle, empereur romain du 2ème siècle après J.C, une des figures les plus emblématiques du stoïcisme, disait à ce propos :</p><blockquote><em>“Les effets de la colère sont beaucoup plus graves que les causes.”</em></blockquote><p>L’énergie émotionnelle réside donc finalement en la capacité de chacun à penser avant de ressentir. Une des manières d’y arriver, repose sur la méditation par exemple, en prenant le temps de se concentrer sur soi-même.</p><p>Bien que cela ne soit pas facile, Tony Schwartz affirme que nombre de joueurs de tennis talentueux ont atteint les premières places du classement mondial en maîtrisant leurs émotions pour ne pas céder à la colère en plein match, afin de toujours focaliser toute leur énergie sur le moment présent.</p><p>John McEnroe, célèbre joueur de tennis des années 1980–1990, connu pour ses excès de colère, reconnaît dans son autobiographie que la seule différence fondamentale entre lui et Jimmy Connors, son principal rival de l’époque, était que ce dernier réussissait mieux à contrôler ses émotions pour utiliser pleinement son énergie sur chaque point.</p><p>Le résultat parle de lui-même : Jimmy Connors est resté 268 semaines consécutives à la tête du classement mondial de tennis, tandis que McEnroe, malgré un talent indéniable, ne l’a été que durant 170 semaines.</p><h3>L’énergie spirituelle</h3><p>Le dernier pilier pour assurer le plein engagement, d’après Jim Loehr et Tony Schwartz, est l’énergie spirituelle.</p><p>L’énergie spirituelle réside dans le fait de prendre conscience de quelque chose de plus grand que soi.</p><p>Bien souvent, elle est exprimée au travers de la religion. Croire en un (ou plusieurs) dieu(s) aide à passer outre sa propre personne, en pensant aux autres, à l’environnement qui nous entour, au monde en général.</p><p>Cependant, il n’est pas nécessaire d’être croyant pour accroître notre quantité d’énergie spirituelle. Encore une fois, la méditation est citée comme un excellent outil dans <a href="https://www.amazon.fr/gp/product/0743226755/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=0743226755&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=4af24479d383c91deecf654626f3afce"><em>The Power of Full Engagement</em></a>, pour renforcer ce “muscle”.</p><p>Selon les auteurs, nous ne pouvons atteindre un état de concentration et d’engagement ultime que si nous sommes alignés avec un objectif dépassant notre intérêt personnel immédiat.</p><p>Plus les réponses aux questions :</p><ul><li>Quelle est l’état de votre motivation actuel ?</li><li>Est-ce que vous avez un objectif précis dans la vie ?</li><li>Quelle valeur voulez-vous apportez au monde ?</li></ul><p>sont claires, et précises, plus il y a de chance d’être concentré sur les tâches à réaliser pour satisfaire nos objectifs.</p><h3>En conclusion</h3><p><a href="https://www.amazon.fr/gp/product/0743226755/ref=as_li_tl?ie=UTF8&amp;camp=1642&amp;creative=6746&amp;creativeASIN=0743226755&amp;linkCode=as2&amp;tag=victorgallet-21&amp;linkId=4af24479d383c91deecf654626f3afce"><em>The Power of Full Engagement</em></a><em> </em>est un livre extrêmement intéressant que je vous recommande vraiment de lire.</p><p>Ce dernier est bourré d’études de cas (issues des accompagnements au changement des clients des deux auteurs, Jim Loehr et Tony Schwartz).</p><p>On parle ici de rapport détaillés de plusieurs dizaines de personnes ayant décidées de prendre leur vie en main, en transformant leurs “mauvaises” habitudes en “bonnes” habitudes.</p><p>De plus, il y a des fiches en annexe à remplir, nous permettant de définir concrètement quelles sont nos forces, nos faiblesses, qu’est-ce qui est le plus important à nos yeux, et ce qu’on souhaite améliorer… Bref, un véritable appel à l’action pour planifier le changement.</p><p>Et réfléchir à un plan est sans doute l’étape la plus primordiale pour engranger le changement, avoir une vision claire, et avancer !</p><p>Car comme l’écrivait Sun Tzu dans <em>L’Art de la guerre </em>:</p><blockquote><em>“Celui qui n’a pas d’objectifs ne risque pas de les atteindre.”</em></blockquote><p>Pour conclure, la principale leçon que souhaitent partager les auteurs, est que l’énergie que nous sommes capables de dépenser quotidiennement, dans le but d’atteindre nos objectifs (quels qu’ils soient : professionnel, familial…) est notre ressources la plus précieuse nécessaire pour atteindre une haute performance, pour améliorer notre productivité et, plus généralement, notre bien être.</p><p>A contrario du temps qui lui est figé, l’énergie globale quotidienne est un muscle. Et comme tout muscle, cette dernière peut croître (et inversement, s’atrophier si elle est négligée).</p><p>Finalement, l’essentiel est de ne jamais oublier le concept d’<strong>oscillation</strong>.</p><p>Pour rester performant, nous devons intelligemment alterner les périodes de stress et de récupération, tout en prêtant attention à la nécessité d’équilibrer nos quatre types d’énergie : physique, mentale, émotionnelle et spirituelle.</p><blockquote><em>“Pour être pleinement impliqué, nous devons être physiquement motivés, liés émotionnellement, focalisés mentalement et spirituellement alignés avec un objectif dépassant notre intérêt personnel immédiat.”</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9652ff2f548c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Premiers Pas En Rust : Partie 3 — La Génération Des Fichiers De Méta Build Cmake]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@TheElkantor/dans-cet-article-on-va-enfin-voir-ensemble-les-derni%C3%A8res-%C3%A9tapes-de-la-g%C3%A9n%C3%A9ration-du-projet-c-qui-d4213d8c812e?source=rss-dd5928f4a1b8------2"><img src="https://cdn-images-1.medium.com/max/2056/1*AEFXw6LZvNxAwYZvZbxCPQ.jpeg" width="2056"></a></p><p class="medium-feed-snippet">Dans cet article, on va enfin voir ensemble les derni&#xE8;res &#xE9;tapes de la g&#xE9;n&#xE9;ration du projet C, qui, pour rappel, est ce qui se cache&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@TheElkantor/dans-cet-article-on-va-enfin-voir-ensemble-les-derni%C3%A8res-%C3%A9tapes-de-la-g%C3%A9n%C3%A9ration-du-projet-c-qui-d4213d8c812e?source=rss-dd5928f4a1b8------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@TheElkantor/dans-cet-article-on-va-enfin-voir-ensemble-les-derni%C3%A8res-%C3%A9tapes-de-la-g%C3%A9n%C3%A9ration-du-projet-c-qui-d4213d8c812e?source=rss-dd5928f4a1b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4213d8c812e</guid>
            <category><![CDATA[rustlang]]></category>
            <category><![CDATA[développement]]></category>
            <category><![CDATA[programmation]]></category>
            <category><![CDATA[rust]]></category>
            <dc:creator><![CDATA[Victor Gallet]]></dc:creator>
            <pubDate>Sat, 29 Sep 2018 09:49:00 GMT</pubDate>
            <atom:updated>2018-09-29T17:27:10.769Z</atom:updated>
        </item>
    </channel>
</rss>