July 21, 2026

I’m really grateful to the FreeBSD Foundation for sponsoring my trip to BSDCan 2026 in Ottawa. The conference ran for four days — two days of DevSummit, then two days of the main conference, with many interesting talks throughout. For me, it’s mainly a chance to talk with developers I don’t otherwise get to reach in day-to-day work. This was my third time attending, and I was happy to be back again. 

This year’s DevSummit felt a little different from previous years. A number of sessions touched on how AI is influencing project maintainability. Some of that influence is positive — vulnerability research came up as one example — but it’s also adding real burden on the reviewer side. Hearing different opinions from different people gave me a much broader view of the issue than I had going in. 

This was also my first DevSummit as a src committer, so on day two, I got to take part in “Have Need Want” — the usual BSDCan session for this — and present my own work for review along with my plans for the next release. That covered updates to our USB stack, LLVM, CPU power throttling, and bhyve. I also got some feedback privately afterward, which drew a bit of welcome attention from other developers. 

On the first day of the main conference, the talk I found most interesting was “Heterogeneous Scheduling on FreeBSD” by Minsoo Choo. It wasn’t really about the scheduler itself, but it got into something just as important: how heterogeneous core information should feed into the scheduler, and where and how that should happen.  It reminded me that my CPU throttling work needs the same kind of information.  Right now, the idea is to raise performance parameters as fast as possible under load, and back off while idle to save power. On a non-heterogeneous system, that only means tracking idle time. But on a heterogeneous system, cores differ in performance, which changes how we translate an abstract performance instruction into something a given core can act on — and that in turn affects how the cpufreq interface makes its decisions. I was glad to hear that there are already interfaces that provide heterogeneous-core hints for throttling, and I’m hoping to fold that into my future work. 

On day two, I went to “Return of the Segment: Thread Local Storage” by jhb@. Since I also work on LLVM ELF internals, it was great to finally get a clear picture of how Thread Local Storage actually works under our libc++ ABI. jhb@ walked through it well — starting from thread-local errno and building up to a compiler-guided ELF TLS design. Afterward, we talked about whether we should move errno over to compiler-based TLS. 

All in all, it was a great trip, with many good conversations with other developers.  Thanks again to the Foundation for making it possible for me to be there. 

Respectfully, 

ShengYi Hung