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 di­d­n’t do ve­­ry we­­ll on ba­­ckwa­r­­ds co­m­­pa­­ti­­bi­­li­­ty,
­­be­­­cau­­se the­­re has been eno­r­­mous effo­r­­ts in or­­der to pre­­se­r­­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 di­d­n’t take it ve­­ry we­­ll. Py­­thon de­­ve­­lo­­­pers should be mo­­­re re­­ce­p­­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.

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.

Another of the key points of the day was Debugging in Python 3.6: Better,
Faster, Stronger. This talk was really interesting beause it explained how new
additions proposed on PE­P-5231 applied in Python 3.6, make it much
easier to debug and inspect in frames. It also compared several tracing
strategies used by loggers, showing their differences on performance.

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!

Well, not just yet. First I listened to the keynote, How to create inspiring
data visualizations?. After that I listened to Solid Snakes, a talk I knew
it was presented at PyCon US (like the one about debugging in Python
3.6). It was really good, one of the best points of the day.

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 morning was spent on the training for optimizing code with
Cython. I will cover this topic as part of performance improvements and
analysis in the future.

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 basically half-way through EuroPython 2017. So far, it’s being an
amazing experience. Looking forward for another half like this! (or better :-).