This weekend BSDCan 2015 was held at the University of Ottawa. I was told it was the biggest, bestest BSDCan ever. Certainly, there were a lot of talks, giving rise to a four track split. Personally, I think that may be too many. Some of the best conferences I’ve attended have been two or even one track. To the credit of the organizers though, they did a great job of splitting up talks such that I was rarely in the position of having to choose between two talks I really wanted to attend. Some talks were about new developments, which I’m interested in, some talks were about system administration issues I’d really rather not know anything about. One of the consequences of multi-tracking though is that the OpenBSD people go to the OpenBSD talks and the FreeBSD people go to the FreeBSD talks, etc., making it less of a BSD conference and more like an OpenBSD conference and a FreeBSD conference running side by side. Fewer tracks would mean more forcible cross attendance. But it’s a minor quibble. BSDCan has become a victim of its own success.
The opening keynote was by Stephen Bourne. I was in the overflow room and didn’t see the slides, but the talk was still good. If I recall correctly, he said it took about six months to understand how signals really worked, and that’s sitting in the room with the people who invented them. I feel better about not understanding signals now. Generally speaking, be wary of complexity.
I have only a passing interest in RDMA over ethernet but it was a good talk, covering Infiniband and then working forward to ethernet networks. I don’t have many plans to work with RDMA anything, but it’s interesting tech.
The Secure Virtual Architecure talk was very interesting. Currently, a kernel exploit results in a complete game over situation for all application code. There’s nothing they can do. SVA reduces the size of the trusted kernel component to a bare minimum, and then extends some new capabilities to applications. So, for example, a userland program can keep an encryption key in memory without worry that even with a kernel exploit, another program would be able to steal it. At least that’s the theory. Although the mechanism is quite different, the end result reminded me of the exokernel approach. The traditional kernel, outside the trusted core, essentially becomes an extension of libc. Functionality is shared between applications, but vulnerabilities in one do not affect each other.
Per Teaching Advanced Operating Systems there are two undergraduate class styles: have students build a scheduler, file system, virtual memory, etc. for a toy operating system (I did this) or have them randomly poke at some small component of a larger, real world system. Graduate classes generally consist of paper reading and no coding (I did this too). None of the three approaches does a good job of combining understanding with practical experience. Using FreeBSD and DTrace, students run sample programs not to develop new code, but to probe and understand a working system. Sounds like a good way to gain an appreciation for the complexities of real systems, without the effort of having to build one.
It’s really hard to fit An Introduction to ZFS in a single 45 minute talk, especially when it’s interrupted by a fire alarm, but Kirk made a valiant effort. One of the main points of interest was how blocks are freed. With unlimited copy on write snapshots that may still contain references, it’s a hard problem. An entire lecture could have been devoted to this topic alone.
There were four other OpenBSD talks, but I managed to miss all of them. It ended up being all FreeBSD all conference for me. I also talked to people in the hallway, and Michael Lucas gave me a pen.