EuroPython 2017 days 0 to 3

A su­m­ma­ry of the first da­ys (from day 0 —­Sun­day to day 3 —Wed­nes­da­y), of Eu­ro­P­y­thon 2017.

Day 0: Beginners’ day

On­ce agai­n, like last year I vo­lun­tee­red for the be­gin­ner­s’ day on Sun­da­y, ­ri­ght at the dawn of the con­fe­ren­ce. It was ano­ther great oppor­tu­ni­ty to sha­re k­no­w­le­dge and ex­pe­rien­ce about Py­tho­n.

In par­ti­cu­lar this ti­me I was lu­cky enou­gh to wo­rk wi­th a group of ­ma­the­ma­ti­cians who us­ed Py­thon for da­ta scien­ce, so I learnt about the­s­e ­con­cep­ts, and we wo­rked a bit wi­th Pan­das for pro­ce­s­sing num­ber­s.

Day 1: Monday

The day the con­fe­ren­ce offi­cia­lly started wi­th the first an­noun­ce­men­ts. Afte­r ­tha­t, the first ke­y­no­te was de­li­ve­re­d: A Py­thon for fu­tu­re ge­ne­ra­tions. I ­per­so­na­lly rea­lly en­jo­yed this ta­lk be­cau­se it co­ve­red many im­por­tant as­pec­ts of Py­tho­n, main­ly tho­se areas whe­re the lan­gua­ge sti­ll has to evol­ve (­pa­cka­gin­g, de­fi­ning de­pen­den­cies and re­qui­re­men­ts for lar­ge pro­jec­ts, and so­ o­n).

I found this ke­y­no­te to be ab­so­lu­te ama­zin­g. The speake­r, a we­ll-k­no­wn ex­per­t in the co­m­mu­ni­ty, pointed out rea­lly im­por­tant poin­ts on the pre­sent of Py­tho­n, ­that wi­ll ha­ve a sig­ni­fi­cant im­pact on its fu­tu­re. The main poin­ts as I re­ca­ll ­them (a­gain the ta­lk is tho­rou­gh­ly grea­t, so it’s to­ta­lly wor­th it to wa­tch it en­ti­re­l­y), are:

  • Pa­cka­ging has im­pro­ved but it sti­ll nee­ds po­lis­hing (many tools like pi­p, se­tup­tools, wheel­s, and mo­re, they all pa­tch in­ter­nals of Py­thon in or­der to­ wo­rk). The­re should be so­me­thing like the pa­cka­ge.­j­son fo­r Ja­vaS­crip­t/­No­de­JS appli­ca­tion­s.
  • CFFI is the way to go. De­ve­lo­ping C ex­ten­sions is not a good idea.
  • The most rea­lis­tic way of ge­tting rid of the GIL is by breaking ba­ckwar­d­s ­com­pa­ti­bi­li­ty on C ex­ten­sion­s. And we shoul­d.
  • … Speaking of whi­ch Py­thon did­n’t do ve­ry we­ll on ba­ckwar­ds com­pa­ti­bi­li­ty, ­be­cau­se the­re has been enor­mous effor­ts in or­der to pre­ser­ve the­m, when ma­y­be­ ­the­re should ha­ve not been. And the one ti­me it was (for Py­thon 3), the ­co­m­mu­ni­ty did­n’t take it ve­ry we­ll. Py­thon de­ve­lo­pers should be mo­re re­cep­ti­ve ­to new chan­ges, and ac­cept that things chan­ge and the­y’­re going to brea­ck, as it ha­ppens on many other lan­gua­ges.
  • The Uni­co­de im­ple­men­ta­tion on CP­y­thon is not ve­ry good. Fi­xing this mi­gh­t ­mean breaking so­me ba­ckwar­ds com­pa­ti­bi­li­ty (for exam­ple, re­mo­ving sli­cing on s­trings).
  • Other im­ple­men­ta­tions of Py­thon (py­py, for ins­tan­ce), try to mi­mic the ­be­ha­viour of CP­y­thon, lea­ding to is­sues or ha­cks that could be avoi­de­d ­that could be avoi­ded just by ac­cep­ting that they are not 100% com­pa­ti­ble (and making clear so­).
  • The sour­ce co­de of CP­y­thon is ve­ry rea­da­ble, whi­ch makes it ve­ry clear to­ ­get an idea of what is going on pro­duc­tio­n.

The next ta­lk I atten­ded to was Pro­to­cols and Prac­ti­ces en­for­cing in Py­tho­n ­th­rou­gh byte­co­de and ins­pec­tion. It was fi­ne, and I got the idea of usin­g ins­pec­tion in or­der to co­de de­fen­si­ve­l­y, and make your li­bra­ry mo­re ro­bus­t, ­fai­ling qui­ck­ly when users try to use the API in unex­pec­ted wa­ys.

On the sa­me room fo­llo­wed “2 + 2 = 5: Mo­nke­y-­pa­tching CP­y­thon wi­th cty­pes to­ ­con­form to Par­ty doc­tri­ne“. The va­lue of this ta­lk was rea­lly good in the sen­se that the pa­th it took le­ft lo­ts of lear­ning poin­ts along the wa­y. It wa­s a te­ch­ni­cal ta­lk ex­plo­ring so­me in­ter­nals of CP­y­tho­n, how it loads va­ria­ble­s, op­ti­mi­za­tions of the in­ter­pre­ter­s, con­tex­t, and mo­re.

Next ta­lk, ti­tled “But how do you know your mo­ck is va­li­d? Ve­ri­fied fakes of web ser­vi­ces“, pre­sen­ted good exam­ples of mo­cking and tes­tin­g, wi­th tips good ­prac­ti­ces and re­co­m­men­da­tion­s.

Ano­ther of the key poin­ts of the day was De­bu­gging in Py­thon 3.6: Be­tte­r, ­Fas­te­r, Stron­ger. This ta­lk was rea­lly in­te­res­ting beau­se it ex­plai­ned how new a­ddi­tions pro­po­sed on PE­­P-523 [1] applied in Py­thon 3.6, make it mu­ch ea­sier to de­bug and ins­pect in fra­me­s. It al­so com­pa­red se­ve­ral tra­cin­g s­tra­te­gies us­ed by lo­gger­s, sho­wing their di­ffe­ren­ces on per­for­man­ce.

The last ta­lk of the day was As­ync Web Apps wi­th Sanic, that sho­wn exam­ple­s of this appli­ca­tion ser­ve­r.

Then the­re was ti­me for the li­gh­tning ta­lks. I pre­sen­ted one about co­de ­co­ve­ra­ge ti­tled Be­yond co­ve­ra­ge.

Du­ring this ti­me it was an­noun­ced that the­re we­re two free slo­ts for ta­lks, so­ I vo­lun­tee­red to fi­ll in one of the gap­s, for Tues­day at 15:45, on a 30’ slo­t.

That meant next da­y, was a ta­lk da­y.

Day 2: Tuesday

Ta­lk da­y!

We­ll, not just ye­t. First I lis­te­ned to the ke­y­no­te, How to crea­te ins­pi­rin­g ­da­ta vi­sua­li­za­tion­s?. After that I lis­te­ned to So­lid Snakes, a ta­lk I knew it was pre­sen­ted at Py­Con US (like the one about de­bu­gging in Py­tho­n 3.6). It was rea­lly good, one of the best poin­ts of the da­y.

Then, on the after­noon, it was ti­me for my ta­lk ca­lle­d Dis­co­ve­ring Des­crip­tors. I liked the way it pan­ned ou­t, and I was aske­d in­te­res­ting ques­tions by the au­dien­ce, who al­so ga­ve me good fee­dba­ck. It’s an in­te­res­ting to­pi­c, that I’m glad I pre­sen­te­d.

I fi­nis­hed the day by lis­teing to the ta­lk about Djan­go and Gra­ph­Q­L, whi­ch is an in­te­res­ting and trendy te­ch­no­lo­g­y. Afte­rwar­d­s, it was ti­me for li­gh­tnin­g ­ta­lks, whi­ch are alwa­ys grea­t.

Day 3: Wednesday

This day al­so started wi­th ano­ther ama­zing ke­y­no­te, this ti­me it was If Ethi­cs is not No­ne. I alwa­ys en­joy ta­lks that re­cap the his­to­ry of com­pu­tin­g, hi­gh­li­gh­ting the mi­les­to­nes, but this one in par­ti­cu­lar al­so le­ft me wi­th lo­ts of ite­ms to in­ves­ti­ga­te, so I rea­lly en­jo­yed it.

The rest of the mor­ning was spent on the tra­i­ning for op­ti­mi­zing co­de wi­th Cy­thon. I wi­ll co­ver this to­pic as part of per­for­man­ce im­pro­ve­men­ts an­d a­na­l­y­sis in the fu­tu­re.

On the after­noon, the­re we­re two great ta­lks Green th­rea­ds in Py­thon (whi­ch was about a su­per in­te­res­ting to­pi­c, pre­sen­ted in a rea­lly good wa­y), an­d Sus­tai­na­ble Scien­ti­fic So­ftwa­re De­ve­lo­p­ment, whi­ch was ab­so­lu­te­ly awe­so­me. ­The la­tte­r, ma­de the da­y, be­cau­se it was an ana­l­y­sis of so­ftwa­re en­gi­nee­rin­g ­prin­ci­ples (tes­ts, con­ti­nuous in­te­gra­tion­s, good prac­ti­ce­s), applied to­ s­cien­ce, in a way of “en­for­cin­g” the­se prac­ti­ces on scien­ti­fic re­sear­ch.

That was ba­si­ca­lly hal­f-way th­rou­gh Eu­ro­P­y­thon 2017. So fa­r, it’s being an a­ma­zing ex­pe­rien­ce. Looking fo­rward for ano­ther half like this! (or be­tter :-).

[1] https://www.python.org/dev/peps/pep-0523/