2018 in review

It was a great yea­r, le­t’s take a look at the main hi­gh­li­gh­ts.

Ear­ly in Ja­nua­r­y, I pre­sen­ted a ta­lk at a lo­cal mee­tu­p, whi­ch had a good re­cep­tion amongst the au­dien­ce. The fist part of the year was a ­great pe­riod for lear­ning mo­re about dis­tri­buted sys­te­ms, event sour­cin­g, an­d e­ven­t-­dri­ven ar­chi­tec­tu­res. The peak of whi­ch was atten­ding the Ka­fka su­m­mi­t in Lon­don.

By la­te Au­gus­t/ear­ly Sep­tem­ber I fi­nis­hed my book Clean co­de in Py­thon whi­ch was a qui­te cha­llen­ging ex­pe­rien­ce.

It was a great plea­su­re to attend the Py­thon San Se­bas­tián con­fe­ren­ce. I’­ve heard about this con­fe­ren­ce in a li­gh­tning ta­lk in Eu­ro­P­y­tho­n, and I was cu­rious about it. It was good to­ ­meet a group of friend­ly new peo­ple, and ha­ving the oppor­tu­ni­ty to pre­sen­t ­the­re (an enhan­ced ver­sion of the ta­lk pre­sen­ted at the mee­tup in Ja­nua­r­y). ­Be­si­des, the ci­ty is ama­zin­g, so it’s cer­tain­ly so­me­thing to re­pea­t!

Be­si­des so­me im­pro­ve­men­ts in my con­fi­gu­ra­tion fi­les (vim and dot fi­le­s), and to­ ­so­me of my other pu­blic re­po­si­to­rie­s, the­re was­n’t that mu­ch room for open ­sour­ce con­tri­bu­tion­s. On the other han­d, the­re was a good deal of lear­nin­g: I’­ve read so­me fan­tas­tic books about so­ftwa­re en­gi­nee­ring (su­ch as Fac­ts an­d ­fa­lla­cies of so­ftwa­re en­gi­nee­ring, Ob­jec­t-o­rien­ted so­ftwa­re cons­truc­tion, and mo­re), whi­ch un­for­tu­na­te­ly I was­n’t able to co­ver in blog pos­ts (but ma­y­be­ in the fu­tu­re I wi­ll), and I suc­ce­ss­fu­lly com­ple­ted the ma­chi­ne lear­nin­g ­cour­se offe­red by Cour­se­ra, whi­ch was ama­zing. A­gai­n, ma­y­be in a fu­tu­re post I wi­ll be able to pro­per­ly re­view it, but for no­w I can just te­ll you that is hi­gh­ly re­co­m­men­da­ble, if you’­re looking fo­rward to­ ­learn a ton and at the sa­me ti­me ha­ve fun sol­ving pro­gra­m­ming as­sig­n­men­ts.

All in all, it was a year wi­th a lot of po­si­ti­ve no­tes. Looking fo­rward to an a­ma­zing 2019 for eve­r­yo­ne!

Subtleties of Python

In our pro­fe­s­sio­n, atten­tion to de­tail is of ut­most im­por­tan­ce. Any good ­so­ftwa­re en­gi­neer un­ders­tan­ds that de­tails ma­tter a lo­t, as they make the ­di­ffe­ren­ce be­tween a wo­rking unit or a di­sas­ter [1].

This is why clean co­de is not just about for­ma­tting or arran­ging the co­de. It’s ­nei­ther a foi­ble. It is ins­tea­d, pa­ying atten­tion exac­tly to tho­se de­tails tha­t wi­ll make a big di­ffe­ren­ce in pro­duc­tio­n.

Le­t’s see so­me exam­ples of this in Py­tho­n.

Leer más…

Notes on the Kafka Summit London 2018

The­se are so­me no­tes and takeawa­ys on the re­cen­tly ce­le­bra­ted Ka­fka Su­m­mi­t 2018 in Lon­don.

The con­fe­ren­ce was or­ga­ni­zed in th­ree pa­ra­llel tra­cks for ses­sions that we­re ­co­ve­ring stream pro­ce­s­sin­g, pi­pe­li­nes, and in­ter­nal­s. To get a good ex­pe­rien­ce, I atten­ded ta­lks of the th­ree ty­pes, but wi­th a li­ttle pre­fe­ren­ce to­war­d­s in­ter­nals and strea­ms.

It was a two­-­day con­fe­ren­ce wi­th lo­ts of va­lua­ble te­ch­ni­cal con­ten­t, awe­so­me ­ta­lks, speaker­s, and a lot mo­re. He­re are the hi­gh­li­gh­ts.

Leer más…

Exploring Generators and Coroutines

Le­t’s re­vi­sit the idea of ge­ne­ra­tors in Py­tho­n, in or­der to un­ders­tan­d how the su­pport for co­rou­ti­nes was achie­ved in la­test ver­sions of Py­thon (3.6, at the ti­me of this wri­tin­g).

By re­viewing the mi­les­to­nes on ge­ne­ra­tor­s, ch­ro­no­lo­gi­ca­ll­y, we can get a be­tte­r i­dea of the evo­lu­tion that lead to as­yn­ch­ro­nous pro­gra­m­ming in Py­tho­n.

We wi­ll re­view the main chan­ges in Py­thon that re­la­te to ge­ne­ra­tors an­d a­s­yn­ch­ro­nous pro­gra­m­min­g, star­ting wi­th PE­P-255 (Sim­ple Ge­ne­ra­tor­s), PE­P-342 (­Co­rou­ti­nes via Enhan­ced Ge­ne­ra­tor­s), PE­P-380 (S­yn­tax for de­le­ga­ting to a ­Su­b-­Ge­ne­ra­to­r), and fi­nis­hing wi­th PE­P-525 (A­s­yn­ch­ro­nous Ge­ne­ra­tor­s).

Leer más…

2017 in Review

A re­cap of the main even­ts and pos­ts th­rou­ghout the year that is en­din­g.

This year I atten­ded so­me con­fe­ren­ces over­sea­s, whe­re I pre­sen­ted ta­lks. Firs­t, in Ju­ne, I went to the beau­ti­ful ci­ty of Pra­gue for Py­Con CZ 2017. At firs­t, I ­got on­ly one ta­lk appro­ve­d, Dis­co­ve­ring Des­crip­tors, whi­ch was a new ­to­pic I was pre­sen­tin­g. A few da­ys be­fo­re the con­fe­ren­ce starte­d, ano­the­r s­peaker had to step do­wn, so I was asked to fi­ll in the slo­t, to whi­ch I agree­d by pro­po­sing my ta­lk of clean co­de in Py­tho­n. That meant I pre­sen­ted one the ­first two da­ys of the con­fe­ren­ce, and then atten­ded the wo­rks­hop on the las­t ­day (S­atur­da­y).

The con­fe­ren­ce was ni­ce, and as alwa­ys, a great oppor­tu­ni­ty for ne­two­rking an­d ­lear­nin­g.

Ju­ly was the mon­th for Eu­ro­P­y­tho­n, a con­fe­ren­ce that is alwa­ys awe­so­me. This ­yea­r, I did not ha­ve a ta­lk sche­du­led be­fo­re­han­d, as I did last yea­r, bu­t ­sur­pri­sin­gly enou­gh, on the li­gh­tning ta­lk ses­sions of Mon­day they an­noun­ced a ­free slot for the Tues­da­y, to whi­ch I vo­lun­teer by su­bmi­tting my new ta­lk, “­Dis­co­ve­ring Des­crip­tor­s”. So, on­ce agai­n, ano­ther unex­pec­ted (but gla­d), o­ppor­tu­ni­ty that I had to pre­sent a ta­lk at a good con­fe­ren­ce.

On other to­pi­cs, I atten­ded se­ve­ral mee­tups of Py­thon and Go, and be­ca­me mo­re in­vol­ved in dis­tri­buted sys­te­ms.

It was al­so a good year to wo­rk mo­re wi­th Do­cke­r, and started to learn mo­re a­bout Ku­ber­ne­tes.

Re­gar­ding con­tri­bu­tions to open sour­ce, I re­lea­sed new ver­sions of most of the ­pro­jec­ts I ha­ve on Gi­tHu­b, but the­re is mo­re. I sent the first suc­ce­ss­fu­l ­pa­tch to CP­y­thon in Gi­tHub (im­por­tant no­te: at the be­gin­ning of this yea­r, the ­CP­y­thon pro­ject mo­ved to Gi­tHu­b). It was a sim­ple chan­ge on the do­cu­men­ta­tio­n, a­bout des­crip­tor­s, that got qui­ck­ly mer­ge­d, but a good head star­t.

Ano­ther ni­ce con­tri­bu­tion is tha­t, du­ring the sprin­ts at Eu­ro­P­y­tho­n, I wo­rke­d a­long the py­py tea­m, and sent so­me co­m­mi­ts fi­xing chan­ges for Py­thon 3.6. It was an ama­zing ex­pe­rien­ce to learn mo­re about the pro­jec­t, and about CP­y­tho­n i­tsel­f. Cer­tain­ly so­me­thing I look fo­rward to con­ti­nue doin­g.

For the new yea­r, I ex­pect mo­re con­tri­bu­tions to open sour­ce, main­ly on the sa­me pro­jec­ts (CP­y­thon and py­py), and re­lea­se mo­re open sour­ce li­bra­rie­s. Al­so mo­re con­fe­ren­ce­s, and as alwa­ys, room for the best whi­ch is usua­lly the u­nex­pec­te­d.

Refuse the temptation to pass

This is an opi­nion I so­me­ti­mes re­mem­ber when seeing so­me co­de. Do­n’t take it as a strong ad­vi­ce, or a ru­le, but ins­tead as a ge­ne­ral gui­de­li­ne that mi­ght hel­p ­you to im­pro­ve the co­de sli­gh­tl­y.

On this post I wi­ll sha­re a tiny and opi­nio­nated ar­gu­ment about why the­re are u­sua­lly be­tter things to do in the co­de ins­tead of just pa­ss.

Leer más…