Notes on FOSDEM19

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


After arri­ving to Brussel­s, and then to the ve­nue, I was­n’t on ti­me for the ­first ta­lk that in­te­res­ted me, and then I could­n’t make it in­to the HTTP/3 ta­lk be­cau­se the room wa­s ­fu­ll, so I de­ci­ded to get an in­tro­duc­tion to the con­fe­ren­ce by vi­si­ting the s­tan­d­s, and ne­two­rkin­g.

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 sa­me de­ve­lo­p­ment room fo­llo­wed a ta­lk in­tro­du­cing ONOS, a ­so­ftwa­re-­de­fi­ned ne­two­rking pla­tform (kind of like a “ker­ne­l” for ne­two­rking in an ar­chi­tec­tu­re) wri­tten in Ja­va, and wi­th a lar­ge co­m­mu­ni­ty, spon­so­red by bi­g ­com­pa­nie­s.

From the da­ta­ba­ses tra­ck, the ta­lk Pos­tgres goes to 11! was a rea­lly good in­tro­duc­tion to the his­to­ry of Pos­tgreS­Q­L, how the pro­ject starte­d, its roots, what has been going on la­te­l­y, ho­w’s the de­ve­lo­p­ment pro­ce­ss (the co­m­mi­t ­fes­ts, and its tra­cking sys­tem are a won­der­ful idea, that I wish othe­r ­pro­jec­ts adop­t!); and why it’s im­por­tant to alwa­ys up­da­te the en­gi­ne (e­ven ­mi­nor re­lea­ses con­tain im­por­tant chan­ges and bu­g-­fixes!). It al­so brie­fl­y ­co­ve­red the last new fea­tu­res that ha­ve been added to the da­ta­ba­se, and wha­t ­can be ex­pec­ted for the next re­lea­se, 12.

After that it was ti­me for a ta­lk about how Ne­tflix uses FreeBSD for its strea­min­g ­pla­tfor­m. It started wi­th a great in­tro­duc­tion to their pla­tform an­d ar­chi­tec­tu­re (im­pres­si­ve as you mi­ght ex­pec­t, for ins­tan­ce their CDN hand­le­s 100­Tb/s!), and what are the main dri­vers for their te­ch­ni­cal de­ci­sions (e.­g. s­peed vs. cos­ts, op­ti­mi­za­tion of the wo­rk­load­s, etc.). After that in­tro­duc­tio­n, it was ti­me to mo­ve to the co­re of the pre­sen­ta­tio­n, and ex­plain their so­ftwa­re en­gi­nee­ring appro­ach. The main takeaway was their aggres­si­ve stra­te­gy to­ in­cor­po­ra­te chan­ges from FreeBSD as fast as po­s­si­ble, by kee­ping tra­ck of the “hea­d” of the re­po­si­to­ry ra­ther than one of the sta­ble bran­che­s. Th­rou­gh ­de­ve­lo­p­ment cy­cles of ~5 weeks, it’s po­s­si­ble to in­te­gra­te wi­th the new ­fea­tu­res fas­te­r, pay the pri­ce of mer­ging ear­l­y, and achie­ve a fas­ter ve­lo­ci­ty of de­li­ve­r­y.

The next ta­lk was Pos­tgreS­QL vs. fs­ync an ama­zing ta­lk. It pro­vi­ded a dee­ply te­ch­ni­cal in­si­ght on the in­ter­nals of the da­ta­ba­se, and how it does to im­ple­ment the I/O sta­ck by re­l­ying on the fs­ync sys­ca­l, and why eve­r­y­body as­su­med it wo­rked in a way when in rea­li­ty it was doin­g ­so­me­thing di­ffe­rent (he­re the­re are mo­re in­for­ma­tion for the cu­rious).

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 da­y, pa­cked wi­th te­ch­ni­cal ta­lks, and a lot of kno­w­le­dge. ­But it was­n’t qui­te over ye­t: the­re was sti­ll a ni­ce din­ner or­ga­ni­zed by the ­P­y­thon de­ve­lo­p­ment room ahea­d.


The mor­ning was fo­cu­s­ed on the Py­thon de­ve­lo­p­ment room. The first ta­lk I wa­s a­ble to attend was about Gra­ph­QL, whi­ch is a re­la­ti­ve­ly new te­ch­no­lo­gy for web APIs de­ve­lo­p­men­t, that I ha­ve wo­rked in ­the past wi­th.

Then it fo­llo­wed a ta­lk about how to wri­te py­lint plu­gins. It ­makes me ha­ppy to see the­re are peo­ple who rea­li­se that the qua­li­ty, an­d s­tan­dar­d­s, in the co­de a­re so­me­thing that has to be en­for­ced by tool­s, and not le­ft out for peo­ple to­ ­the co­de re­view pha­se.

The next ta­lk was about a li­bra­ry for ma­na­ging con­fi­gu­ra­tion in ser­vi­ces, whi­ch was qui­te in­te­res­ting

After that one I pre­sen­ted my ta­lk about co­rou­ti­nes and as­yn­ch­ro­nous ­pro­gra­m­min­g:

Then, mo­re ta­lks, mo­re ne­two­rkin­g, and the last ta­lk was Breaking Pos­tgreS­Q­L at sca­le. A­no­ther so­lid ta­lk (this tra­ck is ac­tua­lly one of the bes­t). It ex­plo­re­d se­ve­ral pa­ra­me­ter­s, cons­tra­in­ts, and con­si­de­ra­tions to take in­to ac­count when ­dea­ling wi­th da­ta­ba­ses of di­ffe­rent sca­le­s, star­ting wi­th sma­ll ones (<=10­Gb), ­me­dium ones (~100­Gb - 1TB), or lar­ge ones (>1­TB). It’s in­te­res­ting to see ho­w at the be­gin­ning you can get away wi­th pre­tty mu­ch an­y­thin­g, but as the da­ta ­gro­ws, mo­re fi­ne tu­ning has to be do­ne, and di­ffe­rent stra­te­gies (e.­g. s­har­din­g, or chan­ging the ba­ckup po­li­c­y), co­me in­to pla­y.

And that was the end of the con­fe­ren­ce for me.

Final Remarks

The­re we­re lo­ts of ta­lks that I wis­hed to, but could­n’t atten­d, for a va­rie­ty of rea­sons (trans­por­ta­tio­n, lo­gis­ti­cs, so­me rooms we­re fu­ll and did­n’t allo­w ­mo­re peo­ple to get in, over­laps in the sche­du­le, etc.) I wi­ll try to wa­tch the ­vi­deos for the­se ta­lks as the­y’­re being re­lea­se­d, along wi­th fo­llo­wing up wi­th ­the sli­des.

Be­si­des this per­fec­tly un­ders­tan­da­ble mis­ha­p, I rea­lly en­jo­yed the con­fe­ren­ce, and lear­ned a lot, about many di­ffe­rent things (cloud com­pu­tin­g, da­ta­ba­ses, in­fras­truc­tu­re, pro­gra­m­ming lan­gua­ges, and ope­ra­ting sys­te­ms).

It was great to attend a con­fe­ren­ce pa­cked wi­th hi­gh­ly te­ch­ni­cal ta­lks (i­t’s ­rea­lly lo­ve­ly to spend a day lea­ning th­rou­gh so­lid pre­sen­ta­tions wi­th sli­des ­fu­ll of co­de sni­ppe­ts, and con­fi­gu­ra­tion fi­le­s), and I thi­nk tha­t’s a grea­t ­di­ffe­ren­tial com­pa­red to many other pre­vious con­fe­ren­ces I atten­ded in the pas­t (­pro­ba­bly the ex­cep­tion being the Ka­fka su­m­mit in Lon­don last year): the con­tent is hi­gh­l­y ­te­ch­ni­ca­l, and fo­cu­s­ed on te­ch­no­lo­g­y.

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