fidzu : django

(One of my summaries of the 2026 one-day Pycon NL conference in Utrecht, NL).

An asyncio event loop is defined by asyncio.AbstractEventLoop. That's a large API with more than 50 public methods, but only three are fundamental. At the lowest useful leve, the loop manages callbacks, i/o and timers.

• We need a way to put events on a queue and a way to grab events from a queue and execute them. call_soon()
• We need timers too, for callbacks that must be run after some time. call_later()
• Sleep only knows about time. Often we want to sleep until the next time, unless a socket becomes ready first. So we need a "sleep" that can be interrupted by I/O readiness. add_reader(), add_writer()

His own example implementation of asyncio for educational purposes is at: https://github.com/tarasko/eduloop , it is only 250 lines. Handy if you want to understand asyncio.

He showed this simple example code, incrementally implementing the points above.

The nice thing about asyncio is coroutines. A coroutine is an extended kind of function that can be paused and resumed. The result is a "future". A future represents an eventual result of an async operation. So: a future is pending until somebody supplies either a result or an exception.

For network connection there's Transport and Protocol.

Unrelated photo from our Nelen&Schuurmans company trip to Cologne/Köln in Germany. St. Gereon church.

(One of my summaries of the 2026 one-day Pycon NL conference in Utrecht, NL).

Full title: fire, forget, regret: building resumable Python pipelines.

If you run a task in an async loop, there's often no reference to the task. So it can be garbage collected! You can solve that by keeping a reference in some list. But even then, the whole process can die. What happens with your task then?

Often you have to re-run the task. He himself is into LLMs, so failed tasks that you have to re-run can become expensive.

BackgroundTasks is part of FastAPI and it works great for spinning off longer running tasks. Real handy, but there is no retry mechanism and no recoverability in case of crashes. "Fire-and-forget".

You can use specific task queues. ARQ, Celery, Dramatiq. In this case, the job itself is safe and can be re-tried. But not the individual steps within the job.

What he wants is durable execution. Write down every step you finish; on restart, skip what is written. It can save you lots of time (and possibly money). It might be simpler to set up than you think.

His code + slides are at https://github.com/batman004/fire-forget-regret

Unrelated photo from our Nelen&Schuurmans company trip to Cologne/Köln in Germany. Model of the oldest parts of the St. Gereon church.

(One of my summaries of the 2026 one-day Pycon NL conference in Utrecht, NL).

This year is the first community-organized Pycon NL: hurray!

Most of us use open source as users. It is free! But all those open source projects only exist because someone started it and because someone maintains it.

"Care became contagious": she told the story about someone in Mumbay, India that started to clean up plastic waste that covered the whole beach. He and a 84 year old neighbor. Slowly other people joined in. Then a lot more. Care became contagious!

Python started when Guido van Rossum made a new language in his Christmas holiday.

But projects like this are fragile. The beach cleanup (almost?) stopped after 109 weeks: administrative lethargy, heckling, etc. (She said it stopped, but I guess it almost stopped, as later on she had photos of a clean beach with newly-hatched turtles). If you start a nice open source project, you're probably not thinking my dream is to answer Github issues for the next 20 years.

Sustainability is not endurance. Sustainability is regeneration. Joining a community, but also having the option to leave (just as an example).

Open source is safe. In open source project, code is public, knowledge is shared. A community. The community is the infrastructure. The community is the reason the code is trustworthy.

The Python software foundation holds the trademarks and licenses. Infrastructure like python.org, pypi, the documentation website. It hosts/helps conferences.

Pypi, the Python package index. 81.000 requests per second. And there are only two full-time security people working on it. Seth Larson and Mike Fiedler. We can call them heroes, but we might also look at Python's growth compared to the growth of its human infrastucture.

Our human infrastructure hasn't grown with Python's growth. And AI is making it more urgent. AI can consume whatever the community has to offer or has ever offered. Without giving something back. AI companies capture our value...

Public spaces are not self-maintaining. They need funding and public responsibility.

In 2025, the United Nations published the UN Open Source Principles. Countries are taking note. For example, Germany has the Sovereign Tech Fund, that invests directly in the people behind the code, supporting maintainers, community managers and technical writers.

She started Open community Leadership, helping communities create future contributors and leaders. The foundation is POPCOM: participation (how to join), ownership (how to gain responsibility), purpose (why people stay), connection (how relationships form), opportunity (how contributors grow), mentorship (how communities reproduce).

Regeneration takes people, time and money.

Open source is better together.

Unrelated photo from our Nelen&Schuurmans company trip to Cologne/Köln in Germany. Extreme low water in the Rhine: the 'beach' on the left should be fully submerged.