pub struct BillFraser; impl Work for BillFraser { pub fn current(&self) { // I'm currently a software engineer at Dropbox. while let Some(_) = { // Since 2019 I've been focused on improving Magic Pocket, // Dropbox's multi-exabyte block storage system which stores nearly // all users' file data. I'm doing a kind of hybrid SWE/SRE role // where I'm sometimes on-call keeping the system running smoothly // (no simple task with tens of thousands of servers and millions // of hard drives), and other times I focus more on software // improvements to reliability, durability, efficiency, and // cost-reduction. // (No, I can't read your data; it's encrypted.) } if let Some(dbapp) = self.dropbox.dbapp_android { // From 2016 to 2019 I was part of the Dropbox Android app team, // where I did a number of things: for project in &dbapp.projects { // - designed and implemented a big chunk of the Offline // Folders premium feature, which lets you keep a subtree of // your Dropbox synchronized offline on your phone. // - redesigned the in-app purchase flow for buying Dropbox // Professional from its former webview implementation to a // fully native, reactive view which could still be fully // customized by the server backend for growth experiments // and such. // - implemented most of the redesign of the Home tab to a // version with separate sub-tabs for Recents, Shared, and // Starred files. // - lots of incremental improvements and refactoring as part // of a large effort to make the codebase more modular and // testable. } } } pub fn past(&self) { // I've been working as a professional software engineer since 2009. match self.previous_companies { Microsoft(year @ 2010 ..= 2016) => { // I did a bunch of different things at MSFT, though all within // the Windows org (back when that was a top-level thing). match year { 2014 ..= 2016 => { // Xbox Music / Groove Music // TODO: write about my time working on this. } 2013 .. 2014 => { // In 2013 I left the app compat team to join a new // project. A new group within Windows was formed to // work on making high-quality first-party apps for the // then-new Universal Windows Platform (then still // refered to by its nickname of "Metro"). Windows 8 // had come out with a bunch of good starts, but a // more organized approach was needed. The group was // called the "Inbox Apps Group" ("inbox" has nothing // to do with mail; it is Windows-speak for something // that comes with the OS, as in, "it's in the box", // from back when software came in physical boxes). // Within this group was a very secretive team called // "Platform Showcase Apps". Its charter was to make // cool halo apps that showed off the Windows platform. // In particular, we wanted to show off the brand new // Surface hardware. The team was secret because we // were working with unreleased, prototype hardware // coming out of the Surface labs. // A number of ideas for apps were explored. The apps // all centered around the Surface tablet's idea of // detach-able keyboards. What if you plugged something // in to that port that wasn't a traditional keyboard? // None of these ideas panned out, except for one, // which we focused all our efforts on: the Surface // Music Kit. (I can't talk about the other ideas // because they're still under NDA.) // Surface Music Kit was an alternate keyboard (we // called them "blades") that plugged into the bottom // of a Surface tablet. Instead of a keyboard, it had // a 4x4 grid of pressure-sensitive pads with LEDs, // three "sliders", and a few other miscellaneous // buttons. The pads and sliders were then mapped to // sound effects, and the app revolved around the idea // of using it to easily create beats and musical mash- // ups. // The team was really small, like 5 main developers, // about an equal number of test engineers, and one PM. // Everybody kind of worked on everything a little, but // everyone had an area they specialized in. My area // was the interface between the hardware and the // software. // The general architecture of the thing was this: the // blade acted like a HID (human interface device) // device. It had a small ARM Cortex chip onboard // running firmware written by the Surface guys, which // sampled the pressures applied to the pads and sent // the data up over the connector. The Surface host // controller talked to the blade and made it visible // to the OS as an appropriate HID device. // For Windows 8.1 (codenamed Blue at the time), I // worked with the OS hardware API team to add UWP APIs // for HID devices, and so the app could advertise in // its manifest which classes of HID devices it wanted // to talk to, and when the device was attached, the // system would notify it, launching it if necessary, // and it could begin subscribing to events. // The blade could be attached and detached at any time // and communication was bi-directional: input events // from the blade, and LED programming commands from // the app. The app had to maintain a lot of state // about the blade in order to allow seamless attach/ // detach, and also to cut down on traffic across the // keyboard interface -- some earlier Surface models // were quite limited in what that connector could // handle. // Additionally, it was extremely important to minimize // latency, as our testing found that the average // person could detect as little as 20 milliseconds // delay between hitting a pad and hearing audio. That // included the whole software stack: physical // interaction with the device, firmware processing // the input and sending it to the host, the host chips // processing it, the operating system's input handling // and dispatching the event to user space, the app's // input and audio processing, the operating system's // audio subsystem, the device's sound chip, and // finally out to the speakers. All of that had to be // looked at for ways to minimize latency. // The Surface Music kit was revealed to the world // alongside the Surface 2 (codename Montlake) and // Surface Pro 2 (codename Athena), around the launch // of Windows Blue. The Kit was compatible with the // two devices, as well as the original Surface Pro, // but not the Surface RT. We tried to make it work // on that one too, but that device is too slow and // performance wasn't acceptable, so it was cut. // I remember watching that release event live, and // finding it funny as reporters from media like // The Verge looked at all the stuff, as kind of "yeah // ok whatever" -- most of it was things they knew // about already via various leaks -- but then they all // clustered around the Surface Music Kit booth and // awed at it, because it was the only thing which // hadn't leaked, and they all thought it was super // weird and cool. // But in 2014, right as we were about to release it // to the public, the Inbox Apps Group broke up and // re-orged, putting us in the weirdly independent // "studio" that owned Xbox Music, the successor to // Zune. I guess they thought we would fit there // because we were also doing music. In reality, they // looked at us as a distraction. At the same time, the // Surface org decided they didn't want to pursue the // concept of esoteric blades, so the hardware part of // the project was thrown into limbo. The hardware was // arguably the coolest part, and while the app was // still very capable without a dedicated special input // device, and the team tried to pivot to a software- // only solution, the project was ultimately cancelled // and the team was split up andreassigned to other // things. } 2010 ..= 2012 => { // Application & Device Compatibility. One of Windows' // key strengths has always been backwards // compatibility. If every time you upgraded Windows, // your apps broke or your hardware stopped working, // you'd quickly stop buying upgrades. So Microsoft // took this extremely seriously, and went to great // lengths to make sure things always keep working, // even software that takes advantage of undocumented // features, or relies on bugs in old versions. They // have a very sophisiticated system that notices when // you're running a problematic app, and will even go // as far as to re-emulate old bugs and behavior of the // operating system, but ONLY for that one app. This // way the operating system can be developed and moved // forward without sacrificing usability of older // software and losing customers. // I was privileged to start my time at Microsoft by // working with this fantastic group of extremely sharp // engineers. // Initially I did a summer internship there. For my // project, they wanted me to come up with a way to // automate the process of finding compatibility bugs, // where a program works on one version of Windows, but // fails on another. They mostly found bugs through a // very labor-intensive manual process involving tons // of contractors and user reports on beta OS releases. // I remember it was like my second week on the job, // and I was still just familiarizing myself with how // Windows internals worked, and the group had an all- // hands meeting for something. I was asked to stand // and introduce myself to the group and tell what I'd // be working on for the summer. I explained it // briefly, and then one of the group leads chuckled // and looked at me and said, "oh good, we've been // trying to do that for the past ten years. Good // luck!" I was pretty scared by that, but took it as // a challenge. // I ended up imlementing a system whereby the OS would // randomly instrument a handful of important and // frequently-used system calls, and when programs // invoked them, it would record info about the // arguments, and also the return-address back into // the program. After running in this mode for a while, // it'd build up a heat-map of which parts of the // program's code were in use. In the event of a // compatibility regression, you'd expect some parts // of the app to not work, and not ever run, or some // totally different parts of the code to run. But the // heat map would look different somehow. You could // analyze the before and after heatmaps, and major // differences probably indicated a bug. You could then // manually disassemble those parts of the program to // see what they were doing, and where the bug might // lie in Windows. // I presented the project to Windows senior // leadership, and though it ended up not being // adopted, I suppose they liked the idea well enough, // because they asked me to come back and work with // them full time in the Winter after I finished my // degree. // When I came back, I worked on the same team, but // doing much different stuff. Windows maintained a // huge database of hardware and software that people // use on their Windows computers, which the company // used to prioritize testing and development work when // making sure things work when upgrading from one // version of the OS to the next. // The data was gleaned from a number of data sources, // from telemetry and error reports, to things like // software sales lists and all sorts of other things. // The data had to be cleaned up to try and match the // data from different sources to each other, to avoid // creating tons of duplicates in the database, and // this was the thing I spent a lot of time improving. // Data ingestion and processing is hard. // Separately, I did a bunch of refactoring and // maintenence on "psr.exe", the Problem Steps // Recorder, (which the app compat team owned for // reasons that are still not clear to me). If you // haven't used it, it's a really neat utility that // ships with Windows that allows you to record your // interaction with a program as a sequence of // screenshots and notes, and then show those steps to // someone else. Great for showing your parents how to // do something complicated in Excel or how to tag // people in Facebook. } } Nokia(2010 ..= 2011) | Novarra(2009 ..= 2010) => { // I was an intern (but really did as much work as a full-timer) // at a small company in the Chicago suburbs called Novarra, // whose big product was a web browser that ran well on // dumbphones, which was pretty cool considering the limitations // of those devices. // It was a lightweight phone app, paired with a proxy server // that re-flowed pages to actually be usable on a tiny, low-res // screen. There were two main versions of the phone app: one // written in Java (J2ME) which ran on GSM phones, and one // written in C++ for Qualcomm's BREW system which ran on CDMA // phones. // I worked on the BREW C++ version, and my main job was to port // the app to new phones as they came out. This could be really // complicated and difficult, because by the late 2000s, // dumbphones were already starting to take on some attributes of // smartphones, like touchscreens or full QWERTY keyboards (and // some phones had BOTH), and the feature sets of different // devices got to be wildly divergent. Different screen sizes // and resolutions, different key layouts and feature sets, and // lots of buggy implementations of system functions, combined // with super slow processors and very little memory, made the job // pretty interesting. // The browser was pre-installed on phones and branded with logos // and color schemes of the carrier, not of the company, so if // you browsed the web on a flip phone in the 2000s, there's a // good chance you used this browser. // I took a break in 2010 to do a summer internship at Microsoft // and when I came back, Novarra had been bought by Nokia. // Not much changed other than the name, and I resumed work // doing the same things as before. } _ => unreachable!("lost to the sands of time"), } } }