Notes on FOSDEM19

FOSDEM19 it’s just over, and here are my main highlights!


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 stand­s, and net­work­ing.

The first talk I attended was VNF development made easy with netmap, which was very good. Even though it’s a topic different than what I usually work with, it was a really interesting talk with snippets of C code and low-level operations in the slides, deep technical insights into the details of networking, and quite enjoyable.

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 projects 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 en­gi­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 Walking through walls PostgreSQL ♥ FreeBSD. Another superb talk. One of the ones I enjoyed the most, actually. Again, super technical, in this case it all started by an analysis of how does PostgreSQL perform on BSD systems (spoiler alert: no so well by around ~2014). After that, there were several changes being made, both in FreeBDS and in PostgreSQL in order to make it faster. It was a good technical review of operating systems internals (for instance, the component of PostgreSQL that sets the process name as the query that’s currently running, was slow because in BSD, it relied on a function of the standard library that used two system calls, therefore a new function — setproctitle_fast(3)— was created to accomplish the same without system calls at all, achieving a 10% of performance gain). There were multiple other examples like this one that made the presentation very enlightening. Actually it was closely related to the previous one in the sense that the “fsyncgate” was mentioned, and the dilemma of relying on the operating systems capabilities vs. implementing direct I/O reappeared.

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.


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 stan­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­chro­nous 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 da­ta 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 dif­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.

FOSDEM is great for expanding the technical portfolio because the conference offers multiple tracks in parallel and with different technologies.