It was a great year, let's take a look at the main highlights.
Early in January, I presented a talk at a local meetup, which had a good reception amongst the audience. The fist part of the year was a great period for learning more about distributed systems, event sourcing, and event-driven architectures. The peak of which was attending the Kafka summit in London.
By late August/early September I finished my book Clean code in Python which was a quite challenging experience.
In our profession, attention to detail is of utmost importance. Any good software engineer understands that details matter a lot, as they make the difference between a working unit or a disaster1.
This is why clean code is not just about formatting or arranging the code. It's neither a foible. It is instead, paying attention exactly to those details that will make a big difference in production.
Let's see some examples of this in Python.
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.
FOSDEM 2019 | Demystifying Coroutines and Asynchronous
Programming in Python | 03 Feb
slidesPyCon San Sebastián 2018 | Demystifying Coroutines and
Asynchronous Programming in Python | 13 Oct
slidesPython BCN Meetup |
exploring-generators-and-coroutines{.interpreted-text role=“doc”}
| 17 Jan
slidesEuroPython 2017 | discovering-descriptors{.interpreted-text
role=“doc”} | 11 July video
slidesEuroPython 2017 | beyond-coverage{.interpreted-text role=“doc”}
(lightning talk) | 10 JulyPyCon CZ | Discovering Descriptors | 9 June
slidesPyCon CZ | Clean code in Python | 8 June
slidesSummary of the last days of talks at EuroPython 2017, and the two days for sprints.
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.
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.