<?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 Alan Justino on Medium]]></title>
        <description><![CDATA[Stories by Alan Justino on Medium]]></description>
        <link>https://medium.com/@alanjds?source=rss-58e5cf56f30b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*L4kspt-UymdtydqJ4C1sww.jpeg</url>
            <title>Stories by Alan Justino on Medium</title>
            <link>https://medium.com/@alanjds?source=rss-58e5cf56f30b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:49:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alanjds/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[How to use virtualenvwrapper.sh with Python 3.13 (that have  JIT and no GIL!) in Ubuntu 22.04]]></title>
            <link>https://medium.com/@alanjds/how-to-use-virtualenvwrapper-sh-with-python-3-13-that-have-jit-and-no-gil-in-ubuntu-22-04-10efdb86d75f?source=rss-58e5cf56f30b------2</link>
            <guid isPermaLink="false">https://medium.com/p/10efdb86d75f</guid>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[parallel-computing]]></category>
            <category><![CDATA[ubuntu]]></category>
            <dc:creator><![CDATA[Alan Justino]]></dc:creator>
            <pubDate>Fri, 13 Dec 2024 03:25:59 GMT</pubDate>
            <atom:updated>2024-12-13T03:33:50.476Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h3>How to use virtualenvwrapper.sh with Python 3.13 (that have JIT and no GIL) in Ubuntu 22.04 LTS</h3><blockquote><strong>tl;dr: Ubuntu 22.04 have no Python3.13 in default repo. Python3.13 have no `virtualenv` module by default. Virtualenvwrapper needs that. You need to install them all otherwise it does not work. And yes, it still have a disabled Global Interpreter Lock that you can turn back on if you want for some reason.</strong></blockquote><p>Some may remember that <a href="https://medium.com/getninjas/go-vs-cpython-visual-comparison-of-concurrency-and-parallelism-d29a1ebec20a">Python <em>had</em> a Global Interpreter Lock</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*wd0z1C75VsxD42QdKqCjpA.gif" /><figcaption>Python pre-3.13 Global Interpreter Lock: only one OS Thread can run at a time.</figcaption></figure><p>HAD. Because <a href="https://docs.python.org/3.13/whatsnew/3.13.html#free-threaded-cpython">now you can disable it</a>. Finally. On CPython. Lets see how:</p><p>0. add the `deadsnakes` repo:</p><pre># apt-get install software-properties-common<br># add-apt-repository ppa:deadsnakes/ppa</pre><p>1. install Python3.13t:</p><pre># apt-get install python3.13-{nogil,venv,dev}</pre><p>2. install `pip` and `virtualenv` modules on Py3.13:</p><pre># python3.13 -m ensurepip<br># python3.13 -m pip install virtualenv</pre><p>3. install virtualenwrapper: # apt install virtualenvwrapper</p><p>4. activate virtualenvwrapper: $ source /usr/share/virtualenvwrapper/virtualenvwrapper.sh</p><p>5. Call `mkvirtualenv` targeting Python3.13t: <strong>attention to the </strong><strong>t because it is the NOGIT binary. </strong>The one without t have GIL still enabled.</p><pre>$ mkvirtualenv &lt;envname&gt; -p`which python3.13t`<br>created virtual environment CPython3.13.1.final.0-64 in 208ms<br>  creator CPython3Posix(dest=/root/.virtualenvs/envname, clear=False, no_vcs_ignore=False, global=False)<br>  seeder FromAppData(download=False, pip=bundle, via=copy, app_data_dir=/root/.local/share/virtualenv)<br>    added seed packages: pip==24.3.1                                                                   <br>  activators BashActivator,CShellActivator,FishActivator,NushellActivator,PowerShellActivator,PythonActivator<br>$</pre><p>Is done. It works now.</p><h3>Epilogue: Does it really have no GIL activated?</h3><p>Well, lets try:</p><pre>$ workon &lt;envname&gt;<br>$ python --version<br>Python 3.13.1<br>$ python -c &#39;import sys; print(sys._is_gil_enabled())&#39;<br>False</pre><p>Yeah. It says that it have no GIL :)</p><p>Was a long ride, <a href="https://medium.com/getninjas/go-vs-cpython-visual-comparison-of-concurrency-and-parallelism-d29a1ebec20a#d177">but we got it, Batman.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10efdb86d75f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Released grumpy-runtime v0.3.0]]></title>
            <link>https://medium.com/getninjas/released-grumpy-runtime-v0-3-0-a05f1cf8e111?source=rss-58e5cf56f30b------2</link>
            <guid isPermaLink="false">https://medium.com/p/a05f1cf8e111</guid>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[parallel-computing]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Alan Justino]]></dc:creator>
            <pubDate>Tue, 24 Jul 2018 19:11:19 GMT</pubDate>
            <atom:updated>2018-07-25T16:31:17.331Z</atom:updated>
            <content:encoded><![CDATA[<h4>The Golang-made Python &quot;interpreter&quot; is now installable via pip on Linux, macOS and Android. Featuring a more near-<em>drop-in replacement of CPython </em>than before.</h4><blockquote><strong>tl;dr:</strong> Install the Golang version 1.10+. Then <em>pip2 install grumpy-runtime</em>. Try the new toy with <em>grumpy -c &quot;print &#39;Hello World’&quot;</em>.</blockquote><p>About a year and a half ago, Reddit was stormed by surprisingly <a href="https://opensource.googleblog.com/2017/01/grumpy-go-running-python.html">good news</a> from Google: the Youtube dudes published an experimental Python &quot;interpreter&quot; written in Golang. In a matter of days, its <a href="https://github.com/google/grumpy">github repo</a> reached 4-figure numbers stars and hundreds of forks. This is big.</p><p>Why is this big? Because Go language have a sophisticated machinery that allows better parallelism than CPython one and Grumpy can take advantage of it. You can read more on this article: <a href="https://labs.getninjas.com.br/go-vs-cpython-visual-comparison-of-concurrency-and-parallelism-d29a1ebec20a">https://labs.getninjas.com.br/go-vs-cpython-visual-comparison-of-concurrency-and-parallelism-d29a1ebec20a</a></p><p>Right now, I just published the version 0.3.0 of grumpy-runtime package on the official <a href="https://pypi.org/project/grumpy-runtime/">Python Package Index</a>. It is not production-ready, but is a lot easier to install, try, develop and test. And was not pushed by Google.</p><h4>Not pushed by Google.</h4><p>Because the official Google repo stalled, <a href="https://github.com/google/grumpy/pull/399#issuecomment-379921295"><strong><em>I forked away</em></strong></a>. Right now (2018 JUL) their last commit is dated of 2017 NOV 22. <a href="https://github.com/google/grumpy/issues/406#issuecomment-402454063">A new <em>organization</em></a> to push Grumpy is emerging, but this is a subject for another article.</p><h4>And now for the good news</h4><p>After 229 new commits, the just-published Grumpy Runtime v0.3.0 is pip-installable, respects the PEP-3147 and features a new command line API closer of CPython one. It is in continuous integration on Linux and macOS and being manually tested on Android via Termux. Details ahead.</p><h3>Newbies welcome</h3><p>The main point of this release is getting easier to start and test Grumpy. Having the Golang installed along with make and Python 2, get Grumpy using pip (preferably on a virtualenv):</p><pre>$ pip2 install grumpy-runtime<br>Collecting grumpy-runtime<br>Collecting grumpy-tools&gt;=0.3.0 (from grumpy-runtime)<br>...</pre><p>It installed the grumpy CLI tool along with its runtime. You can now test simple line scripts or elaborate Python files</p><pre>$ grumpy -c &#39;print (&quot;Hello World&quot;)&#39;<br>Hello World<br>$ grumpy myscript.py<br>...</pre><p>Curious about internal nuts and bolts? Peek at the logs setting the verbosity level to -v debug:</p><pre>$ grumpy -v debug myscript.py<br>info: GOPATH: /Users/alanjds/.virtualenvs/py27/lib/python2.7/site-p…<br>info: __main__ pycache folder: /var/folders/50/nxn5kg1125g6mfml3sa3…<br>debug: Should transpile &#39;__main__&#39;<br>...</pre><p>Modern CPython versions keeps a “compiled” cache of scripts on __pycache__ folders, but not for the main script, just for its imports. On Grumpy you can see the transpilation result of main script by keeping the __main__ temporary folder: pass a --keep-main flag. No harm, as it should disappear automatically when OS reboots.</p><pre>$ grumpy -v warning --keep-main myscript.py<br>...<br>warning: not cleaning the temporary pycache folder: /var/folders/50…</pre><h3>Featuring on v0.3.0</h3><h4>Installable via pip2</h4><p>A big effort was made to make Grumpy accessible to new testers and contributors. When you run pip install grumpy-runtime, the transpiler is installed and the whole Grumpy is compiled on your machine. I did not find a way to provide wheel binaries yet. The installation took ~3 minutes on a Macbook and ~26 minutes on my Android.</p><p>Two packages are installed: grumpy-tools and grumpy-runtime. The Tools contains the CLI and the transpiler. The Runtime includes a reimplementation of the CPython standard library. Or most of it ;)</p><h4>Better command line API</h4><p>Pip installs the new grumpy CLI tool. It is evolving to be a superset of CPython’s python command line interface.</p><p>For example, the -c and -m options already have similar behaviors. The command lines python -c &quot;print (&#39;Hello World&#39;)&quot; and grumpy -c &quot;print (&#39;Hello World&#39;)&quot; behaves identically.</p><h4>PEP-3147 a.k.a __pycache__ folder</h4><p>Internal import machinery have a lot to evolve, but it does already cache the Golang results of transpilation of each <em>.py</em> file, resulting in faster 2nd+ execution.</p><p>They are stored on a folder inside of __pycache__ sibling to the original script. Technically, the PEP-3147 demands a file inside the __pycache__ folder instead, but the way Golang works pushed a bit of flexibility here.</p><p>It may be possible to use Golang <em>.a file packs </em>in the future, even to store binary <em>pkg/</em> caches. It can deliver substantial warmup speed gains: the Go code compilation accounts for ~90% of the <em>Hello World</em> current run time.</p><h4>Works on Android Termux</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PueR-u-fcL6q9g27JTNuFw.jpeg" /><figcaption>Grumpy running on Android Termux over Moto G4 Plus. Subway line “2-Green” on São Paulo/SP/Brazil</figcaption></figure><p>Since this is the “computer” I have available for 2 hours during my daily commuting, I need Grumpy working on Android. Is not a warrant nor a promise of support, but my daily development of Grumpy happens on vim over Android Termux in a 32bit ARM hard-float. Yikes!</p><h3>Next steps</h3><p>Something I do know is that I cannot push this big project just by myself. It needs to become useful for someone and help will come naturally. Then the project needs to welcome the new helpers, in my humble opinion.</p><h4>embrace help; become useful</h4><p>With this batch of features shipped, my new priorities on this project will be: 1) Merge or feedback the existing Google’s repo PRs; 2) Have <em>something</em> useful working.</p><p>People who provided me feedback repeatedly asked to run some Flask toy “just to see”. Let&#39;s try it. Or maybe provide a more accurate httpie binary? Is there a lower hanging fruit around?</p><p>Please point me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a05f1cf8e111" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getninjas/released-grumpy-runtime-v0-3-0-a05f1cf8e111">Released grumpy-runtime v0.3.0</a> was originally published in <a href="https://medium.com/getninjas">GetNinjas</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Go vs CPython: Visual comparison of concurrency and parallelism options]]></title>
            <link>https://medium.com/getninjas/go-vs-cpython-visual-comparison-of-concurrency-and-parallelism-d29a1ebec20a?source=rss-58e5cf56f30b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d29a1ebec20a</guid>
            <category><![CDATA[parallel-computing]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Alan Justino]]></dc:creator>
            <pubDate>Tue, 03 Oct 2017 21:30:15 GMT</pubDate>
            <atom:updated>2018-08-27T17:02:20.431Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>Using MPG diagrams to see the differences between Threading, Multiprocessing and Asyncio, the 3 official CPython options, and Go Runtime.</h4><blockquote>This article will assume that your tasks are CPU-intensive. For IO-intensive tasks every option will perform comparable good, with large deviation on RAM usage and minor deviation on CPU usage and performance, given a reasonable concurrency level.</blockquote><p><strong><em>Update: This article turned into a Python Brasil 2017 talk </em></strong><a href="http://bit.ly/grumpy2017video"><strong><em>now on Youtube</em></strong></a><strong><em> (audio in Portuguese). Slides </em></strong><a href="http://bit.ly/grumpy2017slides"><strong><em>available on slides.io</em></strong></a><strong><em>.</em></strong></p><p><strong><em>Update2: Is released the grumpy-runtime v0.3.0, now pip-installable. Details on </em></strong><a href="https://labs.getninjas.com.br/released-grumpy-runtime-v0-3-0-a05f1cf8e111"><strong><em>https://labs.getninjas.com.br/released-grumpy-runtime-v0-3-0-a05f1cf8e111</em></strong></a></p><p>After <a href="http://morsmachine.dk/go-scheduler">reading</a> <a href="https://www.goinggo.net/2015/02/scheduler-tracing-in-go.html">about</a> the way Golang Runtime schedules OS threads and Green threads &quot;<em>Goroutines</em>&quot; over the hardware CPUs, I found myself comparing it with the Python current concurrency options <a href="https://pymotw.com/2/threading/index.html#module-threading">Threading</a>, <a href="https://pymotw.com/2/multiprocessing/index.html#module-multiprocessing">Multiprocessing</a>, <a href="https://pymotw.com/3/asyncio/coroutines.html">Asyncio</a> and Green Threads (<a href="http://sdiehl.github.io/gevent-tutorial/">greenlet &amp; gevent</a> <a href="https://github.com/twisted/twisted">and</a> <a href="https://github.com/eventlet/eventlet">others</a>).</p><p>The <strong>MPG</strong> diagrams used in <a href="https://morsmachine.dk/go-scheduler">Mr. Daniel Morsing&#39; article</a> seems a good tool to visually model the concepts around <strong>M</strong>achine threads, <strong>P</strong>rocessing contexts and <strong>G</strong>reen threads (called Goroutines in the original, but lets [ab]use the concept…)</p><h3>MPGwhat??</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/391/1*L1xu8ygn-0_GPGD09TFGEA.jpeg" /><figcaption>See: <a href="https://morsmachine.dk/go-scheduler">https://morsmachine.dk/go-scheduler</a></figcaption></figure><p><strong>Machines</strong> are the OS Threads the runtime spawns/forks to run its work. No news here: OS schedules it and switches over at own will. Even in the middle of some operation.</p><p><strong>Processing</strong> contexts (originally called Processors) are the info that Green threads <strong>&quot;G&quot;</strong> needs loaded before run. Resembles an user-space CPU.</p><p><strong>Green</strong> threads (or Goroutines in Golang world) are user-space threads, scheduled by the application. Usually, there is an infinite loop controlled by the language runtime.</p><h3>Keep it simple.</h3><p>CPython code have a very strong stance in favor of simplicity. There is no Processing contexts and was no native Green threads until Python 3. It is made this way to be simple to maintain on the long run.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/223/1*g2w7Cp5lxxy5SjiYst5AaA.png" /><figcaption>By default, CPython is as simple as an OS thread :)</figcaption></figure><p>Is very efficient <a href="https://wiki.python.org/moin/GlobalInterpreterLock#line-21">for single-threaded</a> apps and very <a href="https://wiki.python.org/moin/GlobalInterpreterLock#line-18">simple</a> to explain and maintain, mostly because of the infamous <a href="https://wiki.python.org/moin/GlobalInterpreterLock">Global Interpreter Lock</a> (GIL). If you need some concurrency the standard library offers 3 official options: <a href="https://docs.python.org/3/library/threading.html">threading</a>, <a href="https://docs.python.org/3/library/multiprocessing.html">multiprocessing</a> and <a href="https://docs.python.org/3/library/asyncio.html">asyncio</a>/coroutines. Asyncio is the native Green threads of Python 3, but you can get similar results via Gevent and others on Python 2.</p><p><strong>The threading module</strong> allows to spawn OS Threads (M on MPG), that are cheap on CPU and RAM. But the GIL locks to only one thread to use any CPU at a time. Plus, you have the burden of putting locks over your critical code yourself because the OS can switch the running thread and mess non-atomic operations. And you got <a href="https://brianchan.us/2017/05/27/concurrency-vs-parallelism/">concurrency but no parallelism</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*wd0z1C75VsxD42QdKqCjpA.gif" /><figcaption>CPython Threading: only one OS Thread can run at a time. The one that got the GIL.</figcaption></figure><p>To solve the &quot;no parallelism&quot; emerged <strong>the multiprocessing module</strong>, forking a new OS Process (M of MPG). This can truly run in parallel on computers with multiple CPUs, but the objects on both forked OS Process (M) cannot see each other and needs to communicate by other ways. Only OS ways. Personally, I see it as an elegant hack that works for most cases, but cannot share <a href="https://docs.python.org/3.1/library/multiprocessing.html#all-platforms">unpicklable stuff</a> like generators, for example. And is very costly on RAM, delay time to spawn and on CPU for context switching, compared to the threading option.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/1*IFspDwQQkqGQ5PHz4qrxbw.gif" /><figcaption>Multiprocessing: One GIL per CPython process. But different processes cannot share unpicklable stuff eg. generators</figcaption></figure><p><strong>AsyncIO and Gevent-ish options</strong> creates Green threads (G of MPG) into the only running OS Thread (M). It is the cheapest concurrency option over RAM, CPU and code burden. No OS preemption allows user code with almost no explicit locks, as the concurrency is cooperative. Application controls the green thread switching. However, only one Green thread can get a CPU at time, like OS Threading. Again, this is CPU concurrency, not CPU parallelism.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/402/1*oXn8dxkPPXaxHHNQ9mpc5A.gif" /><figcaption>AsyncIO &amp; Gevent: The main CPython thread schedules the internal Green thread to be ran. One at a time.</figcaption></figure><h3>Introducing the P of MPG</h3><p>Processing context (P of MPG) is, in my humble opinion, THE largest difference of <strong>Go Runtime</strong> over the CPython options. Green threads (G) can move between Processing contexts (P) to rebalance the workload.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*Gzgk8JSHSxfwfAJ4vW6R_A.png" /><figcaption>See: <a href="https://morsmachine.dk/go-scheduler">https://morsmachine.dk/go-scheduler</a>. On Go Runtime, Green threads can move between Processing context queues to run early and in parallel.</figcaption></figure><p>Processing contexts (P) are movable around OS Threads (M), if the actual thread needs to stop by any reason. And, by having no GIL, a number of Processing contexts on the same number of hardware CPUs can have each one a running Green thread (G). This is true parallelism made cheap!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/530/1*eqgfFci1fXZVbWsem1oFTA.gif" /><figcaption>Go Runtime: Processing context (P) can switch to another OS thread (M) if the actual one is stopped, eg. to do a syscall.</figcaption></figure><h3><strong>Here be dragons</strong></h3><blockquote>See: <a href="https://en.wikipedia.org/w/index.php?title=Hic_sunt_dracones">HC SVNT DRACONES</a></blockquote><p>How could Go Runtime run stuff in parallel having no GIL and still be fast? Many <a href="https://jeffknupp.com/blog/2013/06/30/pythons-hardest-problem-revisited/">tried</a> to have a GIL-less Python, many <a href="http://pypy.org/tmdonate2.html">failed</a>. Indeed <a href="https://youtu.be/P3AyI_u66Bw?t=4m55s">some</a> <a href="https://youtu.be/P3AyI_u66Bw?t=22m42s">succeed</a> but end up with a <a href="https://youtu.be/P3AyI_u66Bw?t=25m24s">very slow</a> result.</p><p>Go Runtime have some parts very different than CPython internally. The garbage collector is <a href="https://pusher.com/sessions/meetup/the-realtime-guild/golangs-realtime-garbage-collector">a lot more complex </a>than CPython one. Is designed to <a href="https://blog.plan99.net/modern-garbage-collection-911ef4f8bd8e#ada5">run in parallel</a> with the user code. And there is no internal interpreter.</p><p>Do this all in CPython would be very difficult to be achieved without breaking the internal C-APIs, and would be <a href="http://www.artima.com/weblogs/viewpost.jsp?thread=214235">very hard to be accepted</a> on the upstream official.</p><h3>Is there Python hope?</h3><p>What about reimplement just the Python <em>language </em>over the Go Runtime? Sounds weird, but the Go complex concurrent and parallel GIL-less thing is done already and being maintained &amp; improved, right?</p><p>Oh, Batman, there is the <a href="https://opensource.googleblog.com/2017/01/grumpy-go-running-python.html">Grumpy</a> runtime born by Youtube dudes! They even published a benchmark!! And suddenly this whole blogpost seems a disguised propaganda to get help on the opensource project <a href="https://github.com/grumpyhome/grumpy/">https://github.com/grumpyhome/grumpy/</a>. Is too late, Robin, we had read the whole thing already!</p><p>:trollface:</p><p>Please help us. All of us. Unless there is a better way.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d29a1ebec20a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/getninjas/go-vs-cpython-visual-comparison-of-concurrency-and-parallelism-d29a1ebec20a">Go vs CPython: Visual comparison of concurrency and parallelism options</a> was originally published in <a href="https://medium.com/getninjas">GetNinjas</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>