A View on FOSDEM 2020

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 ex­pe­ri­ence. Let’s take a look.

Read more…

2019 in Review

An­oth­er year went by, and al­though I haven’t blogged that much this year, quite a few things did hap­pen. Let’s take a quick re­view of them.

As you know, I at­tend­ed FOS­DEM 2019, back in Febru­ary, and it was an ex­hil­a­rat­ing even­t.

I al­so took the op­por­tu­ni­ty to dive more in­to func­tion­al pro­gram­ming with Scala, by com­plet­ing the on­line course in Cours­era (which I high­ly rec­om­mend).

On the open source fron­t, I start­ed with some hum­ble con­tri­bu­tions to the gr­pc pro­jec­t, with the goal to add asyn­chro­nous sup­port for the Python im­ple­men­ta­tion.

I al­so read many in­ter­est­ing book­s. Among those about soft­ware en­gi­neer­ing, I would al­so like to rec­om­mend Soft­ware Cre­ativ­i­ty 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!

Hap­py 2020 to ev­ery­body!

2018 in review

It was a great year, let’s take a look at the main high­light­s.

Ear­ly in Jan­uary, I pre­sent­ed a talk at a lo­cal mee­tup, which had a good re­cep­tion amongst the au­di­ence. The fist part of the year was a great pe­ri­od for learn­ing more about dis­trib­uted sys­tem­s, event sourcing, and even­t-­driv­en ar­chi­tec­tures. The peak of which was at­tend­ing the Kaf­ka sum­mit in Lon­don.

By late Au­gust/ear­ly Sep­tem­ber I fin­ished my book Clean code in Python which was a quite chal­leng­ing ex­pe­ri­ence.

It was a great plea­sure to at­tend the Python San Se­bastián con­fer­ence. I’ve heard about this con­fer­ence in a light­ning talk in Eu­roPy­thon, and I was cu­ri­ous about it. It was good to meet a group of friend­ly new peo­ple, and hav­ing the op­por­tu­ni­ty to present there (an en­hanced ver­sion of the talk pre­sent­ed at the meet­up in Jan­uary). Be­sides, the city is amaz­ing, so it’s cer­tain­ly some­thing to re­peat!

Be­sides some im­prove­ments in my con­fig­u­ra­tion files (vim and dot files), and to some of my oth­er pub­lic repos­i­to­ries, there was­n’t that much room for open source con­tri­bu­tion­s. On the oth­er hand, there was a good deal of learn­ing: I’ve read some fan­tas­tic books about soft­ware en­gi­neer­ing (such as Facts and fal­la­cies of soft­ware en­gi­neer­ing, Ob­jec­t-ori­ent­ed soft­ware con­struc­tion, and more), which un­for­tu­nate­ly I was­n’t able to cov­er in blog posts (but maybe in the fu­ture I will), and I suc­cess­ful­ly com­plet­ed the ma­chine learn­ing course of­fered by Cours­era, which was amaz­ing. Again, maybe in a fu­ture post I will be able to prop­er­ly re­view it, but for now I can just tell you that is high­ly rec­om­mend­able, if you’re look­ing for­ward to learn a ton and at the same time have fun solv­ing pro­gram­ming as­sign­ments.

All in al­l, it was a year with a lot of pos­i­tive notes. Look­ing for­ward to an amaz­ing 2019 for ev­ery­one!

Subtleties of Python

In our pro­fes­sion, at­ten­tion to de­tail is of ut­most im­por­tance. Any good soft­ware en­gi­neer un­der­stands that de­tails mat­ter a lot, as they make the dif­fer­ence be­tween a work­ing unit or a dis­as­ter 1.

This is why clean code is not just about for­mat­ting or ar­rang­ing the code. It’s nei­ther a foible. It is in­stead, pay­ing at­ten­tion ex­act­ly to those de­tails that will make a big dif­fer­ence in pro­duc­tion.

Let’s see some ex­am­ples of this in Python.

Read more…

Notes on the Kafka Summit London 2018

These are some notes and take­aways on the re­cent­ly cel­e­brat­ed Kaf­ka Sum­mit 2018 in Lon­don.

The con­fer­ence was or­ga­nized in three par­al­lel tracks for ses­sions that were cov­er­ing stream pro­cess­ing, pipeli­nes, and in­ter­nal­s. To get a good ex­pe­ri­ence, I at­tend­ed talks of the three type­s, but with a lit­tle pref­er­ence to­wards in­ter­nals and stream­s.

It was a two-­day con­fer­ence with lots of valu­able tech­ni­cal con­tent, awe­some talk­s, speak­er­s, and a lot more. Here are the high­light­s.

Read more…

Exploring Generators and Coroutines

Let’s re­vis­it the idea of gen­er­a­tors in Python, in or­der to un­der­stand how the sup­port for corou­tines was achieved in lat­est ver­sions of Python (3.6, at the time of this writ­ing).

By re­view­ing the mile­stones on gen­er­a­tors, chrono­log­i­cal­ly, we can get a bet­ter idea of the evo­lu­tion that lead to asyn­chro­nous pro­gram­ming in Python.

We will re­view the main changes in Python that re­late to gen­er­a­tors and asyn­chro­nous pro­gram­ming, start­ing with PEP-255 (Sim­ple Gen­er­a­tors), PEP-342 (Corou­tines via En­hanced Gen­er­a­tors), PEP-380 (Syn­tax for del­e­gat­ing to a Sub­-­Gen­er­a­tor), and fin­ish­ing with PEP-525 (Asyn­chronous Gen­er­a­tors).

Read more…