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­ma­ti­cians who used Python for da­ta sci­ence, so I learnt about these 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­pects 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­call 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­wards 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 maybe 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­hav­iour 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.

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 PEP-523 1 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 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 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 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 Ethics 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 lots of items to in­ves­ti­gate, so I re­al­ly en­joyed 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 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 sci­ence, in a way of “en­forc­ing” these prac­tices on sci­en­tif­ic re­search.

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 :-).