EuroPython 2017 days 0 to 3

A sum­ma­ry of the first days (from day 0 —­Sun­day to day 3 —Wednes­day), of Eu­roPy­thon 2017.

Day 0: Beginners’ day

Once again, like last year I vol­un­teered for the be­gin­ner­s’ day on Sun­day, right at the dawn of the con­fer­ence. It was an­oth­er great op­por­tu­ni­ty to share ­knowl­edge and ex­pe­ri­ence about Python.

In par­tic­u­lar this time I was lucky enough to work with a group of ­math­e­mati­cians who used Python for da­ta sci­ence, so I learnt about the­se ­con­cept­s, and we worked a bit with Pan­das for pro­cess­ing num­ber­s.

Day 1: Monday

The day the con­fer­ence of­fi­cial­ly start­ed with the first an­nounce­ments. Af­ter that, the first key­note was de­liv­ered: A Python for fu­ture gen­er­a­tions. I per­son­al­ly re­al­ly en­joyed this talk be­cause it cov­ered many im­por­tant as­pect­s of Python, main­ly those ar­eas where the lan­guage still has to evolve (­pack­ag­ing, defin­ing de­pen­den­cies and re­quire­ments for large pro­ject­s, and so on).

I found this key­note to be ab­so­lute amaz­ing. The speak­er, a well-­known ex­pert in the com­mu­ni­ty, point­ed out re­al­ly im­por­tant points on the present of Python, that will have a sig­nif­i­cant im­pact on its fu­ture. The main points as I re­cal­l them (a­gain the talk is thor­ough­ly great, so it’s to­tal­ly worth it to watch it en­tire­ly), are:

  • Pack­ag­ing has im­proved but it still needs pol­ish­ing (many tools like pip, se­tup­tools, wheel­s, and more, they all patch in­ter­nals of Python in or­der to ­work). There should be some­thing like the pack­age.j­son for JavaScrip­t/N­ode­JS ap­pli­ca­tion­s.
  • CF­FI is the way to go. De­vel­op­ing C ex­ten­sions is not a good idea.
  • The most re­al­is­tic way of get­ting rid of the GIL is by break­ing back­ward­s ­com­pat­i­bil­i­ty on C ex­ten­sion­s. And we should.
  • … Speak­ing of which Python did­n’t do very well on back­wards com­pat­i­bil­i­ty, be­cause there has been enor­mous ef­forts in or­der to pre­serve them, when may­be there should have not been. And the one time it was (for Python 3), the ­com­mu­ni­ty did­n’t take it very well. Python de­vel­op­ers should be more re­cep­tive ­to new changes, and ac­cept that things change and they’re go­ing to breack, as it hap­pens on many oth­er lan­guages.
  • The Uni­code im­ple­men­ta­tion on CPython is not very good. Fix­ing this might mean break­ing some back­wards com­pat­i­bil­i­ty (for ex­am­ple, re­mov­ing slic­ing on strings).
  • Oth­er im­ple­men­ta­tions of Python (pypy, for in­stance), try to mim­ic the be­haviour of CPython, lead­ing to is­sues or hacks that could be avoid­ed that could be avoid­ed just by ac­cept­ing that they are not 100% com­pat­i­ble (and mak­ing clear so).
  • The source code of CPython is very read­able, which makes it very clear to get an idea of what is go­ing on pro­duc­tion.

The next talk I at­tend­ed to was Pro­to­cols and Prac­tices en­forc­ing in Python through byte­code and in­spec­tion. It was fine, and I got the idea of us­ing in­spec­tion in or­der to code de­fen­sive­ly, and make your li­brary more ro­bust, ­fail­ing quick­ly when users try to use the API in un­ex­pect­ed ways.

On the same room fol­lowed “2 + 2 = 5: Mon­key-­patch­ing CPython with ctypes to ­con­form to Par­ty doc­trine“. The val­ue of this talk was re­al­ly good in the sense that the path it took left lots of learn­ing points along the way. It was a tech­ni­cal talk ex­plor­ing some in­ter­nals of CPython, how it loads vari­ables, op­ti­miza­tions of the in­ter­preter­s, con­tex­t, and more.

Next talk, ti­tled “But how do you know your mock is valid? Ver­i­fied fakes of web ser­vices“, pre­sent­ed good ex­am­ples of mock­ing and test­ing, with tips good prac­tices and rec­om­men­da­tion­s.

An­oth­er of the key points of the day was De­bug­ging in Python 3.6: Bet­ter, ­Faster, Stronger. This talk was re­al­ly in­ter­est­ing beause it ex­plained how new ad­di­tions pro­posed on PEP-523 [1] ap­plied in Python 3.6, make it much easi­er to de­bug and in­spect in frames. It al­so com­pared sev­er­al trac­ing s­trate­gies used by log­ger­s, show­ing their dif­fer­ences on per­for­mance.

The last talk of the day was Async Web Apps with San­ic, that shown ex­am­ples of this ap­pli­ca­tion serv­er.

Then there was time for the light­ning talk­s. I pre­sent­ed one about code ­cov­er­age ti­tled Be­yond cov­er­age.

Dur­ing this time it was an­nounced that there were two free slots for talk­s, so I vol­un­teered to fill in one of the gap­s, for Tues­day at 15:45, on a 30’ slot.

That meant next day, was a talk day.

Day 2: Tuesday

Talk day!

Well, not just yet. First I lis­tened to the keynote, How to cre­ate in­spir­ing ­da­ta vi­su­al­iza­tion­s?. Af­ter that I lis­tened to Sol­id Snakes, a talk I knew it was pre­sent­ed at Py­Con US (like the one about de­bug­ging in Python 3.6). It was re­al­ly good, one of the best points of the day.

Then, on the af­ter­noon, it was time for my talk called Dis­cov­er­ing De­scrip­tors. I liked the way it panned out, and I was asked in­ter­est­ing ques­tions by the au­di­ence, who al­so gave me good feed­back. It’s an in­ter­est­ing top­ic, that I’m glad I pre­sent­ed.

I fin­ished the day by lis­te­ing to the talk about Djan­go and GraphQL, which is an in­ter­est­ing and trendy tech­nol­o­gy. Af­ter­ward­s, it was time for light­ning talk­s, which are al­ways great.

Day 3: Wednesday

This day al­so start­ed with an­oth­er amaz­ing keynote, this time it was If Ethic­s is not None. I al­ways en­joy talks that re­cap the his­to­ry of com­put­ing, high­light­ing the mile­stones, but this one in par­tic­u­lar al­so left me with lot­s of items to in­ves­ti­gate, so I re­al­ly en­joyed it.

The rest of the morn­ing was spent on the train­ing for op­ti­miz­ing code with Cython. I will cov­er this top­ic as part of per­for­mance im­prove­ments and ­anal­y­sis in the fu­ture.

On the af­ter­noon, there were two great talks Green threads in Python (which was about a su­per in­ter­est­ing top­ic, pre­sent­ed in a re­al­ly good way), and Sus­tain­able Sci­en­tif­ic Soft­ware De­vel­op­ment, which was ab­so­lute­ly awe­some. The lat­ter, made the day, be­cause it was an anal­y­sis of soft­ware en­gi­neer­ing prin­ci­ples (test­s, con­tin­u­ous in­te­gra­tions, good prac­tices), ap­plied to ­science, in a way of “en­forc­ing” these prac­tices on sci­en­tif­ic re­search.

That was ba­si­cal­ly half-way through Eu­roPy­thon 2017. So far, it’s be­ing an a­maz­ing ex­pe­ri­ence. Look­ing for­ward for an­oth­er half like this! (or bet­ter :-).

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