Recently, a reader wrote to me and asked about my writing process and burnout. They had an image in their head that I could sit down at a computer and type up a full post on a given topic, but were unsure if that's the right approach when they start blogging. And they were concerned about how to keep things sustainable for themselves, too. I started to write back to them, but decided to ship my answer for everyone else, as well. Now, to be clear: this is my writing process. There are many other very valid approaches, such as what Gabriella wrote. But I think outlining my process here will at least help break some of the mystique around writing, because I certainly do not just sit down and plunk out a post. Well, it often looks like that if you're an outside observer1. But that's only what's visible. How I write The very first piece of any blog post for me is an idea, some inspiration, something I want to share. These ideas come from a variety of places. Some of them are from conversations with friends or coworkers. Others come from problems I'm solving in my own code. Or they come from things I'm reading. Very rarely, they come from just thinking about things, but those are other sources with the connection hidden by the passage of time. After an idea comes to me, I try to capture it quickly. If I don't, it's probably gone! I store these ideas in a note in Obsidian, which currently has 162 ideas in it2. I format this file as a bulleted list, with minimal categorization so that the friction for adding something new is as low as possible. When I revisit this list to plan things to write (I do this every few weeks), I'll remove things which are either completed or which I'm confident I am not interested in anymore. Ideas which are promoted from "want to write" to "definitely going to write" then get moved into my primary task tracking system, LunaTask. When I start typing an article, I move it from "later" or "next" to "in progress". But in reality, I start writing an article far before I start typing it. See, the thing is, I'm almost always thinking about topics I'm going to write about. Maybe this is an element of having ADHD, or maybe it's from my obsessive interests and my deep diving into things I'm curious about. But it started happening more when I started writing on a schedule. By writing on a schedule, having to publish weekly, I've gotten in the habit of thinking about things so that I can hit the ground running when I sit down to type. Once I've picked out an idea, then it sits in the back of my head and some background processing happens. Usually I'm not crystal clear on what I want to say on a topic, so that background process churns through it. After figuring out what I want to say, I move onto a little more active thought on how I want to say it and structure it. This happens while I'm on a run or a walk, while I'm on coffee breaks, between exercises I'm working on for my music lessons. There's a lot of background processing between snatches of active effort. Piece by piece, it crystallizes in my mind and I figure out what I want to say and how to say it. Then, finally, I sit at the keyboard. And this is where it really looks like I just sit down and write posts in one quick sitting. That's because by then, the ideas are fully formed and it's a matter of writing the words out—and after a few years of that, it's something I got pretty quick at. Take this blog post for example. I received the initial email on January 1st, and it sat in my inbox for a few days before I could read it and digest it. I started to write a reply, but realized it would work as a blog post. So it ended up in background processing for a week, then I started actively thinking about what I wanted to write. At that point, I created a blog post file with section headings as an outline. This post ended up being delayed a bit, since I had to practice content-driven development for a project that has a self-imposed deadline. But the core writing (though not the typing) was done in the week after opening the original email. And then when I finally sat down to write it, it was two 20-minute sessions of typing out the words3. Editing and publishing After the first draft of a post is written, there's a lot of detail work remaining. This draft is usually in the approximate shape of the final post, but it may be missing sections or have too much in some. I'll take this time to do a quick read over it by myself. Here I'm not checking for spelling errors, but checking if the structure is good and if it needs major work, or just copy edits. If I'm unsure of some aspects of a post, I ask for feedback. I'll reach out to one or two friends who I think would have useful feedback and would enjoy reading it early, and ask them if they can read it. This request comes with specific feedback requests, since those are easier to fulfill then a broad "what do you think?" These are something along the lines of "was it clear? what parts stuck out to you positively or negatively? is there anything you found unclear or inaccurate?" Once people get me feedback, I add an acknowledgement for them (with explicit consent for if/how to share their name and where to link). After I'm more sure of the structure and content of a post, I'll go through and do copy edits. I read through it, with a spellchecker enabled4, and fix any misspellings and improve the wording of sentences. Then it's just the final details. I write up the blurb that goes in my newsletter and on social media (Mastodon, Bluesky, and LinkedIn, currently). I make sure the date is correct, the title is a decent one, and the slug mostly matches the title. And I make sure I did do things like acknowledgements and spellchecking. Here's the full checklist I use for every post before publishing. - [ ] Edited? - [ ] Newsletter blurb written? - [ ] Spellchecked? - [ ] Is the date correct? - [ ] Is the title updated? - [ ] Does the slug match the title? - [ ] Are tags set? - [ ] Draft setting removed? - [ ] Are acknowledgements added? Once that checklist is complete, it's ready to go! That means that on Monday morning, I just have to run make deploy and it'll build and push out the article. Making it sustainable I've been writing at least one post a week since September 2022—over two years at this point, and about 200,000 words. I've avoided burning out on it, so far. That's an interesting thing, since I've burned out on personal projects in the past. What makes this different? One aspect is that it's something that's very enjoyable for me. I like writing, and the process of it. I've always liked writing, and having an outlet for it is highly motivating for me. I thrive in structure, so the self-imposed structure of publishing every week is helpful. This structure makes me abandon perfection and find smaller pieces that I can publish in a shorter amount of time, instead of clinging to a big idea and shipping all of it at once, or never. This is where content-driven development comes in for me, and the consistent schedule also leads me to create inspiration. I also don't put pressure on myself besides the deadline. That's the only immovable thing. Everything else—length, content, even quality5—is flexible. Some of my earliest posts from 2022 are of the form "here's what I did this week!" which got me into a consistent rhythm. The most important thing for me is to keep it fun. If I'm not finding something fun, I just move on to a different post or a different topic. I have some posts that would be good but have sat in my backlog for over a year, waiting to be written. Whenever I sit down to write those, my brain decides to find a bunch of other, better, posts to write instead! So far, it's been fun and motivating to write weekly. If that ever stops, and it becomes a job and something I dread, I'll change the format to be something that works better for me instead! 1 If this is what it looks like then hey, stop peeking through my window. 2 I keep them in a bulleted list, each starting with -, so I can find the count via: grep "\s*-" 'Blog post ideas.md' | wc -l 3 Drafting documents is where I feel like my typing speed is actually a real benefit. On a typing test this evening, I got 99% accuracy at 120wpm. This lets me get through a lot of words quickly. This is a big plus for me both as a writer and as a principal engineer. 4 I leave my spellchecker disabled the vast majority of the time, since the squiggles are distracting! It's not a big deal to misspell things most of the time, and I'd rather be able to focus on getting words out than noticing each mistake as I make it—talk about discouraging! 5 That said, I think it's hard to judge your own quality in the moment. As writers, we can be very critical of ourselves. We think we wrote something boring but others find it interesting. Or something we think is quite clever, others find uninspiring. Sometimes, when I push out something I think is lazy and quick and low-quality, I'm surprised to find a very eager reception.

A project I'm working on (which is definitely not my SIGBOVIK submission for this year, and definitely not about computer ergonomics) requires me to use MIDI. And to do custom handling of it. So I need something that receives those MIDI events and handles them. But... I'm going to make mistakes along the way, and a terminal program isn't very interesting for a presentation. So of course, this program also needs a UI. This should be simple, right? Just a little UI to show things as they come in, should be easy, yeah? Hahahaha. Haha. Ha. Ha. Whoops. The initial plan Who am I kidding? There was no plan. I sat down with egui's docs open in a tab and started just writing a UI. After a few false starts with this—it turns out, sitting down without a plan is a recipe for not doing anything at all—I finally asked some friends to talk through it. I had two short meetings with two different friends. Talking it through with them forced me to figure out ahead of time what I wanted, which made the problems much clearer. Laying out requirements Our goal here is twofold: to provide a debug UI to show MIDI messages and connected devices, and to serve as scaffolding for future MIDI shenanigans. A few requirements fall out of this1: Display each incoming MIDI message in a list in the UI Display each connected MIDI device in a list in the UI Allow filtering of MIDI messages by type in the UI Provide a convenient hook to add subscribers, unrelated to the UI, which receive all MIDI messages Allow the subscribers to choose which device categories they receive messages from (these categories are things like "piano," "drums", or "wind synth") Dynamically detect MIDI devices, handling the attachment or removal of devices Minimize duplication of responsibility (cloning data is fine, but I want one source of truth for incoming data, not multiple) Now that we have some requirements, we can think about how this would be implemented. We'll need some sort of routing system. And the UI will need state, which I think should be separate from the state of the core application which handles the routing. That is, I want to make it so that the UI is a subscriber just like all the other subscribers are. Jumping ahead a bit, here's what it looks like when two of my MIDI devices are connected, after playing a few notes. Current architecture The architecture has three main components: the MIDI daemon, the message subscribers, and the GUI. The MIDI daemon is the core that handles detecting MIDI devices and sets up message routing. This daemon owns the connections for each port2, and periodically checks if devices are still connected or not. When it detects a new device, it maps it onto a type of device (is this a piano? a drum pad? a wind synth?) Each new device gets a listener, which will take every message and send it into the global routing. The message routing and device connection handling are done in the same loop, which is fine—originally I was separating them, but then I measured the timing and each refresh takes under 250 microseconds. That's more than fast enough for my purposes, and probably well within the latency requirements of most MIDI systems. The next piece is message subscribers. Each subscriber can specify which type of messages it wants to get, and then their logic is applied to all incoming messages. Right now there's just the GUI subscriber and some debug subscribers, but there'll eventually be a better debug subscriber and there'll be the core handlers that this whole project is written around. (Is this GUI part of a giant yak shave? Maaaaybeeeee.) The subscribers look pretty simple. Here's one that echoes every message it receives (where dbg_recv is its queue). You just receive from the queue, then do whatever you want with that information! std::thread::spawn(move || loop { match dbg_recv.recv() { Ok(m) => println!("debug: {m:?}"), Err(err) => println!("err: {err:?}"), } }); Finally we reach the GUI, which has its own receiver (marginally more complicated than the debug print one, but not much). The GUI has a background thread which handles message receiving, and stores these messages into state which the GUI uses. This is all separated out so we won't block a frame render if a message takes some time to handle. The GUI also contains state, in two pieces: the ports and MIDI messages are shared with the background thread, so they're in an Arc<Mutex>. And there is also the pure GUI state, like which fields are selected, which is not shared and is just used inside the GUI logic. I think there's a rule that you can't bandy around the word "architecture" without drawing at least one diagram, so here's one diagram. This is the flow of messages through the system. Messages come in from each device, go into the daemon, then get routed to where they belong. Ultimately, they end up stored in the GUI state for updates (by the daemon) and display (by the GUI). State of the code This one's not quite ready to be used, but the code is available. In particular, the full GUI code can be found in src/ui.rs. Here are the highlights! First let's look at some of the state handling. Here's the state for the daemon. CTM is a tuple of the connection id, timestamp, and message; I abbreviate it since it's just littered all over the place. pub struct State { midi: MidiInput, ports: Vec<MidiInputPort>, connections: HashMap<String, MidiInputConnection<(ConnectionId, Sender<CTM>)>>, conn_mapping: HashMap<ConnectionId, Category>, message_receive: Receiver<CTM>, message_send: Sender<CTM>, ports_receive: Receiver<Vec<MidiInputPort>>, ports_send: Sender<Vec<MidiInputPort>>, } And here's the state for the GUI. Data that's written once or only by the GUI is in the struct directly, and anything which is shared is inside an Arc<Mutex>. /// State used to display the UI. It's intended to be shared between the /// renderer and the daemon which updates the state. #[derive(Clone)] pub struct DisplayState { pub midi_input_ports: Arc<Mutex<Vec<MidiInputPort>>>, pub midi_messages: Arc<Mutex<VecDeque<CTM>>>, pub selected_ports: HashMap<String, bool>, pub max_messages: usize, pub only_note_on_off: Arc<AtomicBool>, } I'm using egui, which is an immediate-mode GUI library. That means we do things a little differently, and we build what is to be rendered on each frame instead of retaining it between frames. It's a model which is different from things like Qt and GTK, but feels pretty intuitive to me, since it's just imperative code! This comes through really clearly in the menu handling. Here's the code for the top menu bar. We show the top panel, and inside it we create a menu bar. Inside that menu bar, we create menu buttons, which have an if statement for the click hander. egui::TopBottomPanel::top("menu_bar_panel").show(ctx, |ui| { egui::menu::bar(ui, |ui| { ui.menu_button("File", |ui| { if ui.button("Quit").clicked() { ctx.send_viewport_cmd(egui::ViewportCommand::Close); } }); ui.menu_button("Help", |ui| { if ui.button("About").clicked() { // TODO: implement something } }); }); }); Notice how we handle clicks on buttons. We don't give it a callback—we just check if it's currently clicked and then take action from there. This is run each frame, and it just... works. After the top menu panel, we can add our left panel3. egui::SidePanel::left("instrument_panel").show(ctx, |ui| { ui.heading("Connections"); for port in ports.iter() { let port_name = // ...snip! let conn_id = port.id(); let selected = self.state.selected_ports.get(&conn_id).unwrap_or(&false); if ui .add(SelectableLabel::new(*selected, &port_name)) .clicked() { self.state.selected_ports.insert(conn_id, !selected); } } }); Once again, we see pretty readable code—though very unfamiliar, if you're not used to immediate mode. We add a heading inside the panel, then we iterate over the ports and for each one we render its label. If it's selected it'll show up in a different color, and if we click on it, the state should toggle4. The code for displaying the messages is largely the same, and you can check it out in the repo. It's longer, but only in tedious ways, so I'm omitting it here. What's next? Coming up, I'm going to focus on what I set out to in the first place and write the handlers. I have some fun logic to do for different MIDI messages! I'm also going to build another tab in this UI to show the state of those handlers. Their logic will be... interesting... and I want to have a visual representation of it. Both for presentation reasons, and also for debugging, so I can see what state they're in while I try to use those handlers. I think the next step is... encoding bytes in base 3 or base 45, then making my handlers interpret those. And also base 7 or 11. And then I'll be able to learn how to use this weird program I'm building. Sooo this has been fun, but back to work! 1 I really try to avoid bulleted lists when possible, but "list of requirements" is just about the perfect use case for them. 2 A MIDI port is essentially a physically connected, available device. It's attached to the system, but it's not one we're listening to yet. 3 The order you add panels matters for the final rendering result! This can feel a little different from what we're used to in a declarative model, but I really like it. 4 This is debounced by egui, I think! Otherwise it would result in lots of clicks, since we don't usually hold a button down for precisely the length of one frame render. 5 or in bass drum

Nearly every line of code I write for fun is in Rust. It's not because I need great performance, though that's a nice benefit. I write a lot of Rust because it's a joy to write code in. There is so much else to love about Rust beyond going fast without segfaults. Here are a few of my favorite things about it. Note that these are not unique to Rust by any stretch! Other languages have similar combinations of features. Expressive type safety There are two aspects of Rust's type system that I really enjoy: type safety and expressiveness. I got a taste of this expressiveness back when I learned Haskell, and had been seeking it. I found it in Rust. One of the other languages I use a fair amount at work1 is Go, and its type system is much harder for me to express ideas in. You can do it, but you're not getting the type system's help. Rust lets you put your design straight into types, with enums and structs and traits giving you a lot of room to maneuver. All the while, it's also giving you good type safety! I can express a lot in Python, but I don't trust the code as much without robust tests. You don't have a compiler checking your work! It's remarkably helpful having Rust's compiler by your side, making sure that you're using types correctly and satisfying constraints on things. To call back to data races, the type system is one of the reasons we can prevent those! There are traits that tell you whether or not data is safe to send to another thread or to share with another thread. If your language doesn't have the equivalent of these traits, then you're probably relying on the programmer to ensure those properties! That said, Rust's type system isn't an unmitigated good for me. It can take longer to get something up and running in Rust than in Python, for example, because of the rigidity of the type system: satisfy it or you don't run. And I find a lot of Rust that uses generics is very hard to read, feeling like it is a soup of traits. What we make generic is an implementation question, and a cultural question, so that isn't necessarily inherent to the language but does come strongly bundled to it. It doesn't crash out as much Okay, I have a beef with Go. They included Tony Hoare's "billion-dollar mistake": null pointers. Go gives you pointers, and they can be null2! This means that you can try to invoke methods on a null pointer, which can crash your program. In contrast, Rust tries very very hard to make you never crash. You can make null pointers, but you have to use unsafe and if you do that, well, you're taking on the risk. If you have something which is nullable, you'd use an Option of it and then the type system will make sure you handle both cases. The places you typically see crashes in Rust are when someone either intentionally panics, for an unrecoverable error, or when they unintentionally panic, if they use unwrap on an Option or Result. It's better to handle the other case explicitly. Fortunately, you can configure the linter, clippy, to deny code that uses unwrap (or expect)! If you add this to your Cargo.toml file, it will reject any code which uses unwrap. [lints.clippy] unwrap_used = "deny" Data race resistance It's so hard to write concurrent code that works correctly. Data races are one of the biggest factors contributing to this. Rust's data race prevention is an incredible help for writing concurrent code. Rust isn't immune to data races, but you have to work harder to make one happen. They're almost trivial to introduce in most languages, but in Rust, it's a lot harder! This happens because of the borrow checker, so it's harder to have multiple concurrent actors racing on the same data. You get more control, when you want With Rust, you know a lot more about what the CPU and memory will be doing than in many other languages. You can know this with C and C++, and newer systems programming languages like Zig. Rust is a little unique, to me, in being notably higher level than these languages while giving you ultimately the same amount of control (if you break glass enough, for some things). You're still subject to the operating system, most of the time, so you can't control the CPU and memory fully, but you get a lot more control than in Python. Or even than Go, another language used when you need good performance. This lets you predict what your code is going to do. You're not going to have surprise pauses for the garbage collector, and you're not going to have the runtime scheduler put some tasks off for a while. Instead, you know (or can determine) when memory will be deallocated. And you ultimately control when threads take tasks (though with async and the Tokio runtime, this gets much muddier and you do lose some of this control). This predictability is really nice. It's useful in production, but it's also just really pleasant and comforting. Mixing functional and imperative Rust lets you write in a functional programming style, and it also lets you write in an imperative programming style. Most idiomatic code tends toward functional style, but there's a lot of code that uses imperative style effectively as well! This is pretty unique in my experience, and I really like it. It means that I, the programmer, can pick the paradigm that best fits the problem at hand at any given moment. Code can be more expressive and clearer for the author and the team working on the code. One of the cool things here, too, is that the two paradigms effectively translate between each other! If you use iterators in Rust, they convert into the same compiled binary as the imperative code. You often don't lose any efficiency from using either approach, and you're truly free to express yourself! Helpful compiler errors A few other languages are renowned for their error message quality—Elm comes to mind. Rust is a standout here, as well. Earlier in my career, I was abused by C++. Besides all the production crashes and the associated stress of that, the compiler errors for it were absolutely inscrutable. If you messed up a template, you'd sometimes get thousands of lines of errors—from one missing semicolon. And those wouldn't tell you what the error was, but rather, what came after the mistake. In contrast, Rust's compiler error messages are usually pretty good at telling you exactly what the error is. They even provide suggestions for how to fix it, and where to read more about the error. Sometimes you get into a funny loop with these, where following the compiler's suggestions will lead to a loop of suggesting you change it another way and never get it to succeed, but that's fine. The fact that they're often useful is remarkable! It's fun! This is the big one for me. It's very subjective! I really like Rust for all the reasons listed above, and many more I've forgotten. There are certainly painful times, and learning to love the borrow checker is a process (but one made faster if you've been abused by C++ before). But on balance, using Rust has been great. It's fun having the ability to go ripping fast even when you don't need to. It's lovely having a type system that lets you express yourself (even if it lets you express yourself too much sometimes). The tooling is a joy. All around, there's so much to love about Rust. The performance and safety are great, but they're the tip of the iceberg, and it's a language worth considering even when you don't need top performance. 1 Go was introduced at work because I advocated for it! I'd probably use Go for fun sometimes if I were not getting enough of it at my day job. It's a remarkably useful language, just not my favorite type system. 2 They're expressed as nil in Go, which is the zero value, and is the equivalent of null elsewhere.

If you do things a few times, they're a tradition. This is the third time I'm writing one of these, so I guess it's an annual tradition now! This is where I reflect on the year that's been, and talk some about my hopes and goals for the next year. Reflecting on 2024 This year has been a lot, and there are a few months of it that just feel like a black hole to me. That's because I got sick in the middle of it. I'm really proud of how much I got done in spite of being the sickest I've ever been. And I'm excited to see what I can do next year, now that I'm nearly fully recovered. Professional I spoke at a conference! This year marked my first ever conference talk. Technically, my first one was at SIGBOVIK 2024, but I'm really talking about !!con. I've submitted talks to conferences before and this is the first one I've ever had accepted. You can watch the recording. That link takes you to the playlist of all !!con talks from this (final) year, so please enjoy them all! It was an incredible experience. The whole conference felt like I was with old friends who I just hadn't met yet. It made me remember the power of connecting with other nerds in physical space. And it reminded me of the joy of being on a stage. More on that in the personal section. I wrote even more than last year. My goal for this year was to continue my status quo: publish at least one blog post each week. I overshot this again, with 60 blog posts over 90,000 words. The most important thing for me has been consistency. By writing every week, I've been able to continue to use this momentum to stretch my creative practice. This even held during my illness this summer, and it was something for me to hold on to when I could do little else. I got paid for my writing. This is the first time I have been paid explicitly to write. I was sponsored to write a post about an open-source product (and the contract even requires that I misuse it, on purpose, since that's what I pitched). The overall experience was pretty good, and I'm also not sure I would do it again in the near future: while I'm working a day job, I don't want to spend my limited writing time on things I'm not already self-motivated to publish. But—I dearly want to find a way to get paid for my writing which isn't sponsored posts. This might look like a Patreon or similar, so let me know if you're interested, and you might be the nudge to get me over that finish line. I started coaching people. This year saw me take on my first three coaching clients. These were all pro bono, friends of mine who needed some help with career questions and technical leadership development. It's been an incredible experience, getting to directly help people grow and overcome their challenges. (If you're interested in being coached by me on technical leadership, reach out to me! You're a particularly good fit if you're a senior or staff software engineer aiming to level up, and members of marginalized groups are who I'm most hoping to help.) I grew as a leader. Most of my reflection here is private because it's so intertwined with specific leadership challenges at my day job, but it's been a really helpful year for me in my leadership development. I've learned a lot, and I've seen a lot of old decisions come around to their conclusion to complete my learning arc. Personal I got sick. It's hard to say when exactly I got sick, but my symptoms got to where I had to go to my doctor at the start of May, and my full recovery started in November. I am pretty sure I was sick before that, since I had started needing more and more sleep throughout the spring, but it's impossible to say at this point. At the peak of my illness, I was in near constant pain (about a 6 on the pain scale) and could not stand up for 5 minutes without having tachycardia. If that happened, I had to lie on my back until my heart rate came back down. Walking around the block was an impossibility, when months prior I was running 25 miles a week and hauling the kids around on my bicycle. I bounced through multiple doctors. We hit the end of my general practitioner's expertise, so she referred me to a GI practice since our core symptom was related to my liver and abdominal pain. (The liver was ultimately a red herring: what looked unusual on my ultrasound was, with further testing, not concerning.) The GI practice did a lot of tests, and I had a lot of waiting (GI docs are in such high demand, you can't see them), but ultimately... they also found nothing. Meanwhile I was still in pain, and could do very little. Around this point, I went on medical leave with my employer. Before that I had been working as much as I was able, and contributing something of value, but it had become clear that I was going to need to focus on my recovery if I wanted to actually get to the bottom of this. Going on medical leave was terrifying, because it meant I would be without income for months. But it was ultimately the right decision. Around this same time, I went to my third doctor. She got me a diagnosis. A friend sent me to her, since she's a specialist in conditions that present with ambiguous symptoms and chronic fatigue. This doctor ran a lot of tests—expensive tests, which insurance doesn't cover—and we ultimately got me a firm diagnosis six months into the whole ordeal. After starting treatment, it's been a very fast recovery: almost two months in, and I'm over 90% normal. How our definitions of "fast" shift. I may have relapses in the future, there's no way to know, but I'm relieved to know what is going on. I stopped running. The pain started in May when I was running, so I had to abruptly go from running 25 miles a week to not at all. Eventually it moved from pain while running to constant pain. And then eventually... it faded away entirely, as long as I keep up on one of my medications. Now I can run if I want to—but I've decided not to. For the last decade, I've identified as a runner. I did a few half marathons with reasonable times, and I did a marathon in 4:07, finishing in 75 F heat. For much of the decade before that, I identified as a cyclist. I was into cycling from the moment I could get on a bike, always wanting to go further and faster. In high school, I did a 100 mile bike ride. Now that I've been forced to take a break from it, I've realized I'm pretty content with not putting in the grueling schedule needed to get back to the high level of performance I thought I wanted to target next year. I might get back into this sooner or later, but right now, I'm working on functional strength and being healthy and having more balance in my life. I got back into music! When I was sick, I bought a wind synth and started playing music again. Then I started taking lessons with an incredible teacher who's an accomplished musician in his own right. And then I got a drum pad, another wind synth, a hand-me-down keyboard, and got my clarinet back out. I've fallen deep into this and I'm loving every single minute of it, frustration and all. This is replacing a lot of the dedication and discipline I used to get from endurance exercise. It has the added benefit of creating art in the process, which heals my soul. The deep breathing involved in playing wind instruments certainly helps me as well. I'm learning some music theory, and it's hard! I want to learn how to write songs and compose music, and I'm going to get there. If you have any favorite resources for this, please send them to me! The upshot of getting back into music is that it will, hopefully, give me a way to perform again. I've been a performer in some aspect for a lot of my life. In school, I was in our concert bands and in small wind ensembles. I was on the debate team, a shock to people who knew me as the shy kid who shook when forced to speak in front of the class. Since school, though, I've lost this opportunity. I got a taste of performance again with my conference talk, and I think music will be my route to performing regularly. I'm starting to use my voice. Advocacy and activism were always things I looked up to but didn't feel like I was able to do. But then I found I have a voice, and I realized I need to use it. I shared a few posts this year on things that are important and required me to speak up, like trans rights and the crisis that was happening in Asheville. Organized two rated chess tournaments. This year I organized two tournaments for our local chess club! They had about 12 players each, and went off smoothly. It was a good experience all around. I'm not sure I'll have the opportunity (or desire) to do this again this year. Kept my head up. Current events have been... a lot... and I've managed to keep my head up for most of it. I'm going to keep going, and keep trying. Upgraded the workshop for all-year use. Historically I've only been able to use my workshop for a few months of the year when the weather is right. This year, we got it insulated, replaced the windows, and added a heat pump, and all those combine to mean I can keep it temperate all year so I can go out there whenever I want. (Some wood finishes are inadvisable in cold or hot weather since they need good ventilation, but otherwise any time for anything.) It's changed my relationship with woodworking, since now I can pop out there and make something whenever I want. When I was rearranging my desk yesterday, I realized I really needed a headphone stand. And so I popped out to the workshop and put in a total of two hours of work (split across a few sessions for glue and finish to dry), and now I have one! Something similar happened when I needed an adapter to mount my drum pad: I just made it. Last year's goals This year was a lot! How does it stack up against what I wanted to do last year? ❓ I wanted to keep my rights, and I did—for now, in my own state. But it's really tenuous, and there are many states where I'd be punished for using a bathroom. The state I was born in, Ohio, has banned trans folks from using the bathrooms consistent with their gender, and the incoming administration is a dark cloud. I won't call this a miss yet, but I can't call it a win. ✅ No personal side projects went into production! I once again toyed with the idea and once again talked myself out of it. Good job, me! ✅ I am not sure I struck a better balance with calls and making, but I embraced that I love talking to my friends and just continued to make time for them. This is going to be even more important next year. ✅ I kept writing on the same schedule, and I did expand it! I did a creative writing class, and even wrote a poem as well. ❌ I did not do any comedy this year, so it's a miss. But it's a happy miss, because I found other things that I was drawn to. ✅ I stayed pretty active in my communities, given my health. ✅ I was a good parent and partner, given my health. ✅ I finished voice training! This was almost a gimme, since I was done in January this year. ✅ My ergonomic setup was definitely improved. I still want to work on using Talon more, but I have made improvements there as well. ❌ I did not do more technical projects this year. I've started a few, and I'm going along in the background, but health got in the way. ❌ I did not get back into competitive chess, and I probably won't. It simply doesn't feel as important right now. Music is filling the role that it filled in my life. ✅ I kept my mental health strong! I think I did really well on these goals, even if it were a normal year and not a year where I spent 6 months sick to various degrees and where I started to feel the crushing weight of our politics and its threat on my rights and my life. This year I did learn a bit about what is important to me, and where I want to spend my time. That's reflect in my hopes and goals for next year. Hopes and goals for 2025 These aren't predictions or concrete goals, but a reflection on what I'd like the next year to be. This is what I hope 2025 looks like for me. Keep my rights. A perennial goal at this point, it's the headliner since trans rights are near the top of the Republican's agenda for this new administration. I'm wary, and I'm going to do what I need to do to keep myself and my family safe. I think that can be done from where I am in a safe, supportive community, but we will keep ourselves safe while continuing to advocate for all those who need protection. In particular, I'm going to keep living my best life and being positive representation for other trans folks who are similarly under attack. No personal-time side projects into production. This one will probably be a forever anti-goal for me. I don't want to do ops-y things in my free time (despite feeling like shaving that yak occasionally), and I don't want to support a product in my free time. My free time is more about playful exploration. Maintain relationships with friends and family. This is the 2025 version of 2024's goal of "strike a better balance with calls and making." I'm positive I'll have time set aside for making things and for playing music. But this is going to be a challenging year, so my loved ones (given/chosen family and dear friends) will need my support and I will need theirs. So I'm going to put those relationships first and foremost. Explore ways to make this my living. I want to do more playful exploration, the kinds of things I do on my blog, and make that my living eventually! 2025 isn't when I'll get there, but I want to try out one or two things (like a Patreon? fund myself via consulting and coaching?) to start understanding what might work for both me and my readers. Keep my mental health strong. This is going to be a challenge, and I am in a good spot for it. I'll need to dedicate effort to it, though, what with the upcoming onslaught. Release some recorded music. I'm working on a lot of aspects of my music. Eventually, I want to write something and release it. This year might be releasing a recording of a cover, but it might also be an original piece. I'm not sure! Write some original music. I don't know if I'll release something of my own, but I know I need to work on it. We'll see how this goes! It's scary to me, and it's also something I'm confident I can do if I put in the effort to learn how. Do some ridiculous fun projects with code. There are a few things I really wanted to work on in 2024 that are just playful, fun, ridiculous things. I didn't get to do them since I was, uh, kinda sick (not sure if I mentioned that yet). So they're burning to get out of me this year. I want at least one to get out of me this year. * * * That's it! I've poured a lot of myself into this post. If you've made it this far: thank you, so much, for reading. 2024 had a lot in it, good and bad. I'm trying to hold both at the same time, to remember the good and remember the bad, as they are both important aspects of the year for different reasons. I hope that 2025 keeps much of the good, and that we can minimize the bad. I'm going to do everything I can to hold joy in this world. Please join me in that, and let's fill 2025 with joy, even in the face of all that's being thrown at us.