Last weekend an amazing edition of Python San Sebastián took place. Here are the main highlights of what the conference looked like to me.

Friday starting with a workshop on the morning that took place in the university of informatics of Basque Country. It was a workshop about machine learning, with Python.

The content was great, and enlightening. It's a very interesting topic, and presented with the main tools to work in Python: Jupyter, numpy, pandas, etc. Promising start.

These are some notes and takeaways on the recently celebrated Kafka Summit 2018 in London.

The conference was organized in three parallel tracks for sessions that were covering stream processing, pipelines, and internals. To get a good experience, I attended talks of the three types, but with a little preference towards internals and streams.

It was a two-day conference with lots of valuable technical content, awesome talks, speakers, and a lot more. Here are the highlights.

Let's revisit the idea of generators in Python, in order to understand how the support for coroutines was achieved in latest versions of Python (3.6, at the time of this writing).

By reviewing the milestones on generators, chronologically, we can get a better idea of the evolution that lead to asynchronous programming in Python.

We will review the main changes in Python that relate to generators and asynchronous programming, starting with PEP-255 (Simple Generators), PEP-342 (Coroutines via Enhanced Generators), PEP-380 (Syntax for delegating to a Sub-Generator), and finishing with PEP-525 (Asynchronous Generators).

A recap of the main events and posts throughout the year that is ending.

This year I attended some conferences overseas, where I presented talks. First, in June, I went to the beautiful city of Prague for PyCon CZ 2017. At first, I got only one talk approved, discovering-descriptors{.interpreted-text role=“doc”}, which was a new topic I was presenting. A few days before the conference started, another speaker had to step down, so I was asked to fill in the slot, to which I agreed by proposing my talk of clean code in Python. That meant I presented one the first two days of the conference, and then attended the workshop on the last day (Saturday).

This is an opinion I sometimes remember when seeing some code. Don't take it as a strong advice, or a rule, but instead as a general guideline that might help you to improve the code slightly.

On this post I will share a tiny and opinionated argument about why there are usually better things to do in the code instead of just pass.

Disclaimer: I am not saying that pass should be banned from the language, or that is an anti-pattern, or a bad idiom. Nothing like that. If that were the case, it wouldn't be a keyword (and we know how few keywords Python has, and how hard it is to introduce a new one, so it's there for a good reason).

Collection of talks presented at conferences.

Upcoming

2019

• FOSDEM 2019 | Demystifying Coroutines and Asynchronous Programming in Python | 03 Feb slides

2018

• PyCon San Sebastián 2018 | Demystifying Coroutines and Asynchronous Programming in Python | 13 Oct slides
• Python BCN Meetup | exploring-generators-and-coroutines{.interpreted-text role=“doc”} | 17 Jan slides

2017

• EuroPython 2017 | discovering-descriptors{.interpreted-text role=“doc”} | 11 July video slides
• EuroPython 2017 | beyond-coverage{.interpreted-text role=“doc”} (lightning talk) | 10 July
• PyCon CZ | Discovering Descriptors | 9 June slides
• PyCon CZ | Clean code in Python | 8 June slides

2016

• EuroPython | Clean code in Python | 20 July slides video

Summary of the last days of talks at EuroPython 2017, and the two days for sprints.

Thursday

The keynote for this day, titled The Different Roads We Take, made an interesting point by stating that the way we evaluate ourselves is non-linear, and coming from different backgrounds, gives everyone of us different a set of experiences and skills.

Afterwards, I moved to an advanced workshop called A Hands-on approach to tuning Python applications for performance, on which we covered several profiling tools for Python code, with pros and cons of each one (performance, overhead, simplicity of use), and some optimization techniques, running the profiling code after each improvement was made, in order to see the difference.

A summary of the first days (from day 0 --Sunday to day 3 --Wednesday), of EuroPython 2017.

Day 0: Beginners' day

Once again, like last year I volunteered for the beginners' day on Sunday, right at the dawn of the conference. It was another great opportunity to share knowledge and experience about Python.

In particular this time I was lucky enough to work with a group of mathematicians who used Python for data science, so I learnt about these concepts, and we worked a bit with Pandas for processing numbers.

It looks like there are a lot of opinions or assumptions about unit tests and code coverage, most of them confusing of biased in several ways. For example, I've heard or read things like "this is fine, it has X% coverage", or "checking for coverage on pull requests doesn't help", or "dropping the coverage level is not an issue", and many more of the like.

This article aims to shed some light on the issue of unit testing with and code coverage. Hopefully by the end of it, we'll get an idea of which of the previous statements are right and which are wrong (spoiler alert: they're all wrong, but for different reasons).

The third day of the conference was hosted on a different venue, the Czech Technical University of Prague.

The workshops

I signed up for two workshops: search for fun (and profit), and Effectively running python applications in Kubernetes / OpenShift.

They were both great, and left me with lots of interesting topics for research and do further work.

The first one walked through the workings of elasticsearch-dsl-py, which was great not only because the explanations were superb, but also because there is probably no better way to review this than from the author himself. I was already experienced with the library, since I've used, Elasticsearch with Python, but even though, this workshop gave me a deeper understanding of the concepts behind it (there was a lot about the internals of Elasticsearch, how it works, its configuration, concepts of information retrieval, etc.), so I got new ideas. On the practical side, I'll check this project.