I’ve been meaning to read this book for a long time, and finally got the chance and finished it! It’s been a fantastic journey throughout the main important topics of modern software architecture.
Another year, another
FOSDEM edition. As always, since this conference grew so big (fact: if you tried to watch all
videos in a row, it’ll take you about 9 weeks!), chances are, every review you read from the conference will contain
something different, and therefore, complementary.
This is what I was able to experience. Let’s take a look.
Another year went by, and although I haven’t blogged that much this year, quite a few things did happen. Let’s take a quick review of them.
As you know, I attended FOSDEM 2019, back in February, and it was an exhilarating event.
I also took the opportunity to dive more into functional programming with Scala, by completing the online course in Coursera (which I highly recommend).
On the open source front, I started with some humble contributions to the grpc project, with the goal to add asynchronous support for the Python implementation.
I also read many interesting books. Among those about software engineering, I would also like to recommend Software Creativity 2.0 by Robert Glass.
What to look forward to for the 2020? I would like to repeat the
FOSDEM experience, and keep on contributing to open
source projects, as much as possible. There’s also the possibility (however I can’t promise anything), that I might
start a YouTube channel, with content similar to the one on this blog. But as always there will be more that I can’t
anticipate; the best is usually the unexpected!
Happy 2020 to everybody!
FOSDEM19 it’s just over, and here are my main highlights!
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.
It was a great pleasure to attend the Python San Sebastián conference. I’ve heard about this conference in a lightning talk in EuroPython, and I was curious about it. It was good to meet a group of friendly new people, and having the opportunity to present there (an enhanced version of the talk presented at the meetup in January). Besides, the city is amazing, so it’s certainly something to repeat!
Besides some improvements in my configuration files (vim and dot files), and to some of my other public repositories, there wasn’t that much room for open source contributions. On the other hand, there was a good deal of learning: I’ve read some fantastic books about software engineering (such as Facts and fallacies of software engineering, Object-oriented software construction, and more), which unfortunately I wasn’t able to cover in blog posts (but maybe in the future I will), and I successfully completed the machine learning course offered by Coursera, which was amazing. Again, maybe in a future post I will be able to properly review it, but for now I can just tell you that is highly recommendable, if you’re looking forward to learn a ton and at the same time have fun solving programming assignments.
All in all, it was a year with a lot of positive notes. Looking forward to an amazing 2019 for everyone!
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 disaster 1.
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.
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).