Notes on FOSDEM19

FOS­DEM19 it’s just over, and here are my main high­light­s!

Saturday

Af­ter ar­riv­ing to Brus­sel­s, and then to the venue, I was­n’t on time for the ­first talk that in­ter­est­ed me, and then I could­n’t make it in­to the HTTP/3 talk be­cause the room was ­ful­l, so I de­cid­ed to get an in­tro­duc­tion to the con­fer­ence by vis­it­ing the ­s­tand­s, and net­work­ing.

The first talk I at­tend­ed was VNF de­vel­op­ment made easy with netmap, which was very good. Even though it’s a top­ic dif­fer­ent than what I usu­al­ly work with, it was a re­al­ly in­ter­est­ing talk with snip­pets of C code and low-lev­el op­er­a­tions in the slides, deep tech­ni­cal in­sights in­to the de­tails of net­work­ing, and quite en­joy­able.

In the same de­vel­op­ment room fol­lowed a talk in­tro­duc­ing ONOS, a ­soft­ware-de­fined net­work­ing plat­form (kind of like a “k­er­nel” for net­work­ing in­ an ar­chi­tec­ture) writ­ten in Java, and with a large com­mu­ni­ty, spon­sored by big ­com­pa­nies.

From the data­bases track, the talk Post­gres goes to 11! was a re­al­ly good in­tro­duc­tion to the his­to­ry of Post­greSQL, how the project start­ed, its root­s, what has been go­ing on late­ly, how’s the de­vel­op­ment process (the com­mit fests, and its track­ing sys­tem are a won­der­ful idea, that I wish oth­er pro­jects adop­t!); and why it’s im­por­tant to al­ways up­date the en­gine (even mi­nor re­leas­es con­tain im­por­tant changes and bug-­fix­es!). It al­so briefly­ ­cov­ered the last new fea­tures that have been added to the database, and what ­can be ex­pect­ed for the next re­lease, 12.

Af­ter that it was time for a talk about how Net­flix us­es Free­BSD for its stream­ing ­plat­for­m. It start­ed with a great in­tro­duc­tion to their plat­form and ar­chi­tec­ture (im­pres­sive as you might ex­pec­t, for in­stance their CDN han­dles 100T­b/s!), and what are the main driv­ers for their tech­ni­cal de­ci­sions (e.g. speed vs. cost­s, op­ti­miza­tion of the work­load­s, etc.). Af­ter that in­tro­duc­tion, it was time to move to the core of the pre­sen­ta­tion, and ex­plain their soft­ware engi­neer­ing ap­proach. The main take­away was their ag­gres­sive strat­e­gy to in­cor­po­rate changes from Free­BSD as fast as pos­si­ble, by keep­ing track of the “­head” of the repos­i­to­ry rather than one of the sta­ble branch­es. Through de­vel­op­ment cy­cles of ~5 week­s, it’s pos­si­ble to in­te­grate with the new fea­tures faster, pay the price of merg­ing ear­ly, and achieve a faster ve­loc­i­ty of de­liv­ery.

The next talk was Post­greSQL vs. fsync an amaz­ing talk. It pro­vid­ed a deeply tech­ni­cal in­sight on the in­ter­nals of the database, and how it does to im­ple­ment the I/O stack by re­ly­ing on the fsync syscal, and why ev­ery­body as­sumed it worked in a way when in re­al­i­ty it was do­ing ­some­thing dif­fer­ent (here there are more in­for­ma­tion for the cu­ri­ous).

The last talk of the day, was Walk­ing through walls Post­greSQL ♥ Free­BSD. An­oth­er ­su­perb talk. One of the ones I en­joyed the most, ac­tu­al­ly. Again, su­per tech­ni­cal, in this case it all start­ed by an anal­y­sis of how does Post­greSQL per­form on BSD sys­tems (spoil­er alert: no so well by around ~2014). Af­ter that, there were sev­er­al changes be­ing made, both in FreeBDS and in Post­greSQL in­ order to make it faster. It was a good tech­ni­cal re­view of op­er­at­ing sys­tem­s in­ter­nals (for in­stance, the com­po­nent of Post­greSQL that sets the process name as the query that’s cur­rent­ly run­ning, was slow be­cause in BS­D, it re­lied on a ­func­tion of the stan­dard li­brary that used two sys­tem call­s, there­fore a new ­func­tion — set­proc­ti­tle_­fast(3)— was cre­at­ed to ac­com­plish the same with­out sys­tem calls at al­l, achiev­ing a 10% of per­for­mance gain). There were ­mul­ti­ple oth­er ex­am­ples like this one that made the pre­sen­ta­tion very en­light­en­ing. Ac­tu­al­ly it was close­ly re­lat­ed to the pre­vi­ous one in the sense that the “fsync­gate” was men­tioned, and the dilem­ma of re­ly­ing on the ­op­er­at­ing sys­tems ca­pa­bil­i­ties vs. im­ple­ment­ing di­rect I/O reap­peared.

That was the first day, packed with tech­ni­cal talk­s, and a lot of knowl­edge. But it was­n’t quite over yet: there was still a nice din­ner or­ga­nized by the Python de­vel­op­ment room ahead.

Sunday

The morn­ing was fo­cused on the Python de­vel­op­ment room. The first talk I was able to at­tend was about GraphQL, which is a rel­a­tive­ly new tech­nol­o­gy for web APIs de­vel­op­men­t, that I have worked in­ the past with.

Then it fol­lowed a talk about how to write pylint plug­ins. It ­makes me hap­py to see there are peo­ple who re­alise that the qual­i­ty, and ­s­tan­dard­s, in the code are some­thing that has to be en­forced by tool­s, and not left out for peo­ple to the code re­view phase.

The next talk was about a li­brary for man­ag­ing con­fig­u­ra­tion in ser­vices, which was quite in­ter­est­ing

Af­ter that one I pre­sent­ed my talk about corou­tines and asyn­chronous pro­gram­ming:

Then, more talk­s, more net­work­ing, and the last talk was Break­ing Post­greSQL at scale. An­oth­er sol­id talk (this track is ac­tu­al­ly one of the best). It ex­plored ­sev­er­al pa­ram­e­ter­s, con­straints, and con­sid­er­a­tions to take in­to ac­count when deal­ing with data­bases of dif­fer­ent scales, start­ing with small ones (<=10G­b), medi­um ones (~100Gb - 1T­B), or large ones (>1T­B). It’s in­ter­est­ing to see how at the be­gin­ning you can get away with pret­ty much any­thing, but as the data ­grows, more fine tun­ing has to be done, and dif­fer­ent strate­gies (e.g. shard­ing, or chang­ing the back­up pol­i­cy), come in­to play.

And that was the end of the con­fer­ence for me.

Final Remarks

There were lots of talks that I wished to, but could­n’t at­tend, for a va­ri­ety of rea­sons (trans­porta­tion, lo­gis­tic­s, some rooms were full and did­n’t al­low ­more peo­ple to get in, over­laps in the sched­ule, etc.) I will try to watch the videos for these talks as they’re be­ing re­leased, along with fol­low­ing up with­ the slides.

Be­sides this per­fect­ly un­der­stand­able mishap, I re­al­ly en­joyed the con­fer­ence, and learned a lot, about many dif­fer­ent things (cloud com­put­ing, databas­es, in­fras­truc­ture, pro­gram­ming lan­guages, and op­er­at­ing sys­tem­s).

It was great to at­tend a con­fer­ence packed with high­ly tech­ni­cal talks (it’s re­al­ly love­ly to spend a day lean­ing through sol­id pre­sen­ta­tions with slides ­full of code snip­pet­s, and con­fig­u­ra­tion files), and I think that’s a great d­if­fer­en­tial com­pared to many oth­er pre­vi­ous con­fer­ences I at­tend­ed in the past (prob­a­bly the ex­cep­tion be­ing the Kaf­ka sum­mit in Lon­don last year): the con­tent is high­ly tech­ni­cal, and fo­cused on tech­nol­o­gy.

FOS­DEM is great for ex­pand­ing the tech­ni­cal port­fo­lio be­cause the ­con­fer­ence of­fers mul­ti­ple tracks in par­al­lel and with dif­fer­ent tech­nolo­gies.