SEEKING FREELANCE | REMOTE | Hybride on Brussels (Belgium/EU)

Willing to relocate: No

Hi, I’m Laurent, a senior Python developer with a lot of different experiences from full stack (django, flask, sanic…), backend, asyncio, open source contributions (18k contributions on github), tools building, framework development, automated refactoring and more.

In addition I’ve develop side skills like application oriented sysadmin (deploying python projects and all), config management basics (salt), monitoring (prometheus stack), observability, CI/CD pipelines (a lot of gitlab but I know github too) and team coordination/organisation.

My skills: python, django, flask/sanic/quart/asyncio, jupyter, SQL (postgres), peewee/sqlalchemy, javascript, vue (basic), git/jj/mercurial, debian/ubuntu/linux, nginx/caddy, docker/docker-compose, prometheus/grafana/influxdb, kanban, DevOps (gitlab/github CI, salt), doing conferences and many more

I love building software while ensuring we focus on what really matters. I’m always happy to learn new things and would gladly jump on new technologies.

My github: https://github.com/psycojoker

My résumé/CV: https://worlddomination.be/cv.pdf

Email: on the CV

Funny, I actually did the same thing for python years ago and also talked about "Lossless Syntax Tree" then start calling it a Full Syntax Tree since CST doesn't really fit; I wasn't aware of the existence of lib2to3 at that time.

My goal was different than your: I wanted make writing custom refactoring code (that's it: code that modify source code) and code that works on source code a do-able task.

I end up doing some design decisions that I haven't found elsewhere (but this field is hard to explore):

- producing json, because datastructure doesn't lie to you and potential interoperability

- nodes are responsible for the formatting within itself, in opposition with lib2to3 where a node is responsible for the formatting before itself (or after, I'm not sure anymore)

- the tree is design for the human brain instead of an interpreter/compiler (for example having list instead of recursive structures)

The project is called Baron https://github.com/pycqa/baron and was actually a mean for me to work on what really interest me: the abstraction that attempt to make writing custom refactoring a doable task https://github.com/pycqa/redbaron

Good luck with your project :)

Cool, I didn't know about those projects. I have been using sed for a long time to refactor Python!

I think the goals are actually similar -- refactoring is a style-preserving transformation that is similar to changing the language. At Google there is a bunch of work on converting C++ 03 to 11 to 14 to 17, etc. and they're using similar techniques with Clang. That's an example of a refactoring that's also changing the language.

I think it would be nice to make a "LST-aware sed". Once you have the parsers, I don't think it's that hard to add something like that on top. The parsers are of course a lot of labor!

I've used RedBaron before when building some toy languages.

Thanks for a great project!

Oh, can you give more details/links please? I'm really curious about that!

The code never became public, but I can give some details.

The idea was to create an easier C, using Python as an intermediary language.

RedBaron provided the AST and AST->Python layers.

Unfortunately, the project had to pivot, because optimising Python to be fast enough was overly difficult/unpredictable.

Adding a comment as a reminder to look up your project. Which sounds really interesting!

Never did this before but after reading your comment, I thought there must be a better way. Click the "n units ago" timestamp next to the commentors user name, there's a "favorite" option you can then access through your profile page "favorite stories / comments".

It's not perfect, but YunoHost is a very big step forward in that direction and it's making progress https://yunohost.org

And to fix the "ISP sucks" we have started to package an "just work out of the box" solution in the FFDN, a federation of local associative ISPs https://internetcu.be/

The trick is to use a "internet cleaning" VPN that gave you a static ip address and that this VPN is handled by an association in which you are a member and that you can trust.

I'm exactly in the same boat than you. Worst, I do believe that, even if the API is nice, asyncio belongs to the old past way of doing concurrency, I want actor models and/or STM with feature like the ones found in clojure.

Python core devs really miss the point that if you want people to move from one solution to another with a cost (here: breaking backward compatibility) you have to provide an high value reason to move (see the network effect). Here we only got minor (but cool) improvements, moving to python3 is just not worth it. It's like having to do a plain old boring homework imposed by a teacher with the only reason "because I told you to" (and the situation is even worst if you have to do compatible code for libs).

I'm not at all against breaking backward compatibility, you have to have a good reason and to make it worth it and, of all the (minor) improvements I see, none of them was a justification for this. Tell me things like "oh, we break backward compatibility because we want to drop the GIL and implement the erlang actors model natively in python" and I'm with you the day it's released (even if you don't provide automatic CPU balancing at the beginning).

I confirm about the pain. They should be transparent and you shouldn't need to care about them but that's absolutely not the case. Also, it's the responsibility of the pypi maintener to push wheels on it, but none do this, so you end up building your own wheels while this should have already been done on pypi and it's stupid. And one last thing: https://twitter.com/mitsuhiko/status/426700148409135104 "It turns out, Python binary wheels on Python 2 are rejected by PyPI, I suppose because of the lack of UCS tag in the filename."

Apart from all of this pain, I'm very happy to be able to use them.

I'm really waiting for someone to build a "wheel on demand" website that would be a proxy to pypi. Or to turn pypi into a wheel farm (I don't know how realist this idea is).

<- PyPI Administrator.

I have plans for either turning PyPI into a build farm, or making a secondary service that acts as a build farm for PyPI. We've just been more focused on cleaning up other issues.

A good part of DIY ISP don't have customers, they have users, it's a major difference, they are made by the people for the people.

It really depends on the country where you want to do that, but, generally, it's hard and expensive to setup a traditional (think *DSL, FTTH) ISP.

From a quick overview I really like your approach: you start by a hello world directly (then template, then models) instead of doing this strange approach of the django official tutorial that starts with model then admin interface then show an hello world at part 3. I also really like the presence of exercices.

Quick comment: here, you are teaching render_to_response http://www.tangowithdjango.com/book/chapters/templates_stati... while you should be using render instead https://docs.djangoproject.com/en/1.5/topics/http/shortcuts/... which is simplier than render_to_reponse (where you have to use the horrible context_instance=RequestContext(request) to be able to do certain things in the template which confuse a lot people).

Thanks for this contribution to the django community!

Maybe you should give a try at pentadactyl (vimish behavior of firefox) http://5digits.org/pentadactyl/

Just take a look at Eben Moglen[0], he is a very brilliant speaker and a brilliant man in general. Or Jérémie Zimmermann[1] for the European side. Or Benjamin Bayart for the French side.

[0] http://youtu.be/sKOk4Y4inVY [1] http://youtu.be/qRiY9tkdkV8 [2] http://youtu.be/i7JVzN3dM34 (in french)

"The greatest group of political scientists to ever congregate in one place and time" were probably the Athenians that, out of the same conclusions on human nature, concluded that if you want political equality for all, your political system must only allow small, non-renewable and other controlled mandates taken by randomly chosen citizens (yes, they have considered elected but have rejected it). The key point being that those randomly chosen people don't have the power, it the assembly of all the citizens that have the power.

And it's based on that that they have created the first (and only, for some people) democratic system ever. Ironically, the person that have created our current democratic system knew exactly this Athenian system but explicitly rejected it because it was ... democracy, and that is was a system were the people really has the power. It's only since Tocqueville has started to call it democracy that we think about it has democratic, Tocqueville who explicitly said that he wasn't afraid of election because people would vote what we told them to vote, something impossible in the Athenian system.