Technically Personal - tech

What Lemm.ee's shutdown means (and doesn't) for the Fediverse

2025-07-01T00:00:00+00:00

On 3rd June 2025, the Lemm.ee team announced</a> they were shutting down the instance, and yesterday, the website went dark. Some people seem to be a bit alarmist about this shutdown. I think it’s a completely normal part of the Fediverse. Let’s dive in.

tl;dr: It’s not that big of a deal that an instance went offline. It’s a natural part of the ecosystem.

Fedi-what?</h2>
Fediverse. It’s the name given to a collection of platforms that are able to interoperate between one another without actually being affiliated. What does that mean in English? Imagine if you could “follow” a subreddit from Twitter. Imagine if you could follow your favourite quotes publisher on Tumblr from Instagram. Or maybe you’d rather follow a high-school friend on Flickr from your MySpace?
Okay, that last one is a bit far-fetched, but the principle remains. Or almost. There’s a few platforms in the Fediverse that use ActivityPub</a>, a protocol that allows different platforms to communicate between each other. There’s for example Lemmy</a>, Mastodon</a>, Vernissage</a>, and many, many others.
Lemmy is closest to Reddit, whereas Mastodon is closer to Twitter. Vernissage is a cross between Flickr and Instagram. I’ve never tried either Friendica or Diaspora, but I hear they’re closer to Facebook (which I’ve also never used).
What’s an instance?</h2>
The concept of federation might sound bizarre to most people, until they realise it is exactly like email. For example, you can create an email account with Hotmail or Gmail or Fastmail, and you can then send and receive email from every corner of the internet (for better or for worse). You don’t need to have an account with Hotmail to exchange emails with other Hotmailers.
The same concept applies for Fediverse platforms. Say you want to join Mastodon, and toot at the world. Which instance do you choose? Well, there’s a bunch to pick from. You can pick an instance that has a focus on security</a>, or maybe you just want one that is more focused on writing and poetry</a>. You can explore all the Masto servers here</a>.
But maybe you want to pick an instance that has specific rules. Maybe you want a moderation that actively removes Nazi bullshit, or maybe you want an instance that doesn’t moderate anything (don’t—you’re going to have a really bad time).
The main point is that choosing an instance isn’t that big of a deal for most people. Just like when you created your first email inbox, you probably created that now-cringeworthy address with the same provider as the person who was helping you setting up said email address.
But here’s a bonus feature: many platforms allow you to easily migrate your account to a new instance. For example, I was able to migrate my account from Pixelfed to Vernissage, and my followers (all 6 of them or something) came with me, and didn’t lose me as the amazing content producer I am. And that’s not even the same platform!
Is it bad that lemm.ee shut down?</h2>
Well, some people</a> seem to think so. Lemm.ee was the second largest Lemmy instance</a>, by user count. Sadly FediDB doesn’t show any data about it anymore, probably because it can’t be scraped anymore, but that appears to put it in the 5-10k monthly active users scale.
But, I disagree with people who seem to think this is a doomsday moment for Lemmy or the Fediverse. Instances going up and down is exactly the point of the Fediverse. That’s why they are federated in the first place! While I won’t go as far as to cheer for lemm.ee’s disappearance, this underlines the importance of federation. For example, you can still browse a Lemmy Community (think subreddit) about sous-vide cooking, and read posts from over two years ago</a>. While the source server is gone, the content isn’t.
I’m not going to pretend the data is safe—it will disappear eventually. But, it’s not like we lost everything that was produced in that community overnight, even with the server going offline.
Parting words</h2>
I’m not very active on Lemmy; I’ve been thoroughly enjoying Mastodon instead. And the shut down came in quite an unexpected and sudden way (at least for bystanders). Reading their post, I fully understand why they decided to shutter the service. The amount of abuse and spam that the admins have to wade through so that the rest of us can enjoy things in peace must be stupendous. I couldn’t be more grateful to the admins of lemm.ee, and those of every other fedi server.
Thank you.

Rust and WASM for form validation

2025-04-24T00:00:00+00:00

In recent years, Rust and WebAssembly have become much more usable for pure backend-style engineers. When I say “pure backend-style”, I mean people who never wrapped their heads around React, SPAs, and all that stuff. This, unsurprisingly, includes me.
For a very long time, in order to use WASM you were strongly guided towards using Webpack and a whole array of Node-related tools in order to just get started. These days, luckily, the story has become much more streamlined. In today’s tutorial, we’re going to create a quick project which includes both a web server in Rust which renders HTML templates, and a small WASM component (served by the same web server) that does form validation.
Why?</h2>
Well, I want to keep a reference handy about how this can be done. But I also want to hear if I’m doing something wrong or suboptimally.
As to why Rust/WASM instead of standard JS or TS? For one, I like to see how far we’ve come with WASM, and there is something very appealing about having the same code shared across the frontend and the backend, especially if it means potentially having the same data structures when serialising/deserialising data from one end to the other.
I’m using form validation as a placeholder. It shows all the crucial aspects to use WASM instead of JS, like wiring up DOM events to Rust functions, and then reacting to those events.
Stack</h2>
This post is being written in early-to-mid 2025. And the stack I currently jive with is as follows:

wasm-bindgen 0.2</li>
wasm-pack 0.13</li>
web-sys 0.3</li>
rocket 0.5</li> </ul>
I’m not going to do any database-related things or anything, which allows us to keep the dependencies pretty short and sweet. Most of these are library dependencies, however wasm-pack</code> is a binary that actually modifies files and prepares them for distribution. This needs to be installed locally:
# binstall can also be used here cargo install wasm-pack</code></pre>
Project structure</h2>
Let’s create a directory structure that allows this whole setup to work. One typical approach for this is to have separate crates for the server part, and the actual wasm component. Something like this:
tutorial ├── server └── wasm</code></pre> If you want to create things quickly:
mkdir tutorial && cd tutorial cargo new --lib wasm cargo new server</code></pre> If you prefer to see the entire repo instead of creating all the files yourself, there is full repository available here</a>. WASM setup</h2> Installing wasm as a target</h3> One thing that you might have to do is to get the compiler support to actually produce wasm binaries. Provided you use rustup</a> (and you really ought to be using it), this is as simple as: rustup target add wasm32-unknown-unknown</code></pre> You can check which targets you currently have installed with rustup target list --installed</code>. Configuring the wasm crate</h3> Edit Cargo.toml</code> and add the following section. This tells the compiler to produce a dynamic library that has a relatively stable ABI. This is similar to building a library for C/C++ interop. [lib] crate-type = ["cdylib"]</code></pre> Let’s also pull in some dependencies while we’re editing that file: [dependencies] wasm-bindgen = "0.2" [dependencies.web-sys] version = "0.3" features = [ "Document", "HtmlFormElement", "HtmlInputElement", "Window", "console", "Event", ]</code></pre> At this point, you should be able to build the library in wasm form using the following command: wasm-pack build --target web</code></pre> This will produce a few files in pkg/</code>: $ ls pkg/ package.json wasm_bg.wasm wasm_bg.wasm.d.ts wasm.d.ts wasm.js</code></pre> Great, now that we’re producing a WASM library that can be loaded from a browser, it’s time to build the server. Server side implementation</h2> Let’s add a few libraries to our server’s Cargo.toml</code>: [dependencies] rocket = "0.5" [dependencies.rocket_dyn_templates] version = "0.2" features = ["tera"]</code></pre> Rocket is our main server framework. It provides both sync and async support, has a strong database integration, but also is easy enough to use that it won’t get in the way. In our src/main.rs</code>, let’s add a some code to handle our fictional login. Anyone with the password “hunter2” will be allowed in. fn verify_password(password: &str) -> bool { password == "hunter2" } #[get("/login")] fn render_login() -> Template { Template::render("login", context! {}) } #[derive(Debug, FromForm)] struct LoginInformation<'a> { email: &'a str, password: &'a str, } #[post("/login", data = "<login>")] fn handle_login(login: Form<LoginInformation<'_>>) -> Template { if verify_password(login.password) { Template::render( "success", context! { username: login.email, }, ) } else { render_login() } }</code></pre> If you’ve worked with things like FastAPI the above most likely doesn’t shock you too much. We define a verify_password</code> function that validates anyone who knows the secret handshake, and we render a form where users can submit their credentials when they access /login</code>. We then define the shape of the form data that we expect (&'a str</code> is effectively a pointer to a string, if you come from Golang or the Cs) in our LoginInformation struct, and we define a handler when people submit a POST request to the same path /login</code>. Rocket handles the form parsing for us, and will balk at the client if they submit unexpected data. When our function is called, we know the data is at least UTF-8 which should be reasonably safe to process. Note: handle_login</code> could be declared as an async function (async fn handle_login(...)</code>), and absolutely nothing else in our code would change. Rocket automatically handles the future that an async function produces. We need a tiny bit more glue to start the rocket server, so let’s replace our main function with something that actually starts the server: #[launch] fn rocket() -> _ { rocket::build() .mount("/", routes![render_login, handle_login]) .mount("/wasm", FileServer::from(relative!("../wasm/pkg"))) .attach(Template::fairing()) }</code></pre> There’s some cool stuff happening here. We tell Rocket that we want the /login</code> handlers to be mounted on /</code>, and we start a file server handler on /wasm</code>, and we tell it to serve the files created by our wasm library. Finally, we give Rocket a way to actually render our templates. We do need to create a couple of templates for Rocket to render our pages (both the login form and the success page). I’m keeping things very simple and therefore ugly. I would advise young children to close their eyes. Here is our beautiful login.html.tera</code>: <!DOCTYPE html> <html> <head> <meta content="text/html;charset=utf-8" http-equiv="Content-Type"/> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>Login</title> </head> <body> <form id="login" action="/login" method="POST"> <div> <label for="email-field">Email</label> <input id="email-field" name="email" type="email" autocapitalize="false" placeholder="johndoe@example.com" autocomplete="email" required> </div> <div> <label for="password-field">Password</label> <input id="password-field" name="password" type="password" placeholder="*******" autocomplete="password" required> </div> <input type="submit" value="Login"> </form> <script type="module"> import init from './wasm/wasm.js'; init(); </script> </body> </html></code></pre> And now for our success.html.tera</code>: <!DOCTYPE html> <html> <head> <meta content="text/html;charset=utf-8" http-equiv="Content-Type"/> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>Login successful</title> </head> <body> <h2>Welcome {{ username }}</h2> <p>You've successfully logged in! </body> </html></code></pre> Shove both of these templates in a directory called templates</code> in your server</code> project, and Rocket should be able to start when you launch it: $ cargo run ... 📬 Routes: >> (render_login) GET /login >> (handle_login) POST /login >> (FileServer: ../wasm/pkg) GET /wasm/<path..> [10] ... 📐 Templating: >> directory: templates >> engines: ["tera"] 🚀 Rocket has launched from http://127.0.0.1:8000</code></pre> Note: I’ve skipped a few lines of output from Rocket for brevity. What does this tell us? For one, Rocket properly picked up our route handlers and allows us to load the wasm, the template engine is registered. With the server running, you should be able to access the login form</a>. And with that, our server is done! Adding more features to the WASM</h2> Now, form validation is pretty boring in and of itself; I just decided on that concept as a way to demonstrate the usefulness of Rust. The first thing I’d like to do is make the WASM print something in the console to show it did indeed correctly load. I think it’s quite poor practice to just randomly leave messages in the browser console.log for no reason, but for this tutorial I think it’s fine. In our wasm/src/lib.rs</code>, let’s replace the existing code with the following snippet: #[wasm_bindgen(start)] pub fn run() { web_sys::console::log_1(&"Rust-based form validation starting up".into()); }</code></pre> After rebuilding the wasm library and ensuring the server is started, we can see the nice greeting in our browser’s console. Success! Now, our HTML already does a lot of heavy lifting when it comes to form validation. If you just try to login with “foo” as the email, your browser should prevent you from submitting the form and ask for a valid email address. In my browser, the requirement is barely more than having an ‘@’ in the value (so for example my browser will happilly accept .@e</code> as a valid email address). So what can we do to improve it? Well, modern browsers allow you to piggyback on top of their internal form validation. You don’t need to add a whole bunch of extra HTML to display error messages and stuff. You just need to tell the browser what to do. The first thing in that process is that we need to start doing some good ol’ getElementById stuff, but oxidised. We need a handle on the form to be able to cancel its default behaviour, and submit it later on once validation is complete. let doc = window().unwrap().document().unwrap(); let form = doc .get_element_by_id("login") .unwrap() .dyn_into::<HtmlFormElement>() .unwrap(); let form_ref = form.clone();</code></pre> The form_ref</code> is something we need because HtmlFormElement</code> is a refcounted object that can’t be copied willy-nilly. And in the next section, we’ll move form</code> into a different context, but we still need to keep a handle on it later. Next, we need to define the function that will be called by the onsubmit</code> event. let closure = Closure::<dyn Fn(Event)>::new(move |event: Event| { event.prevent_default(); let input = doc .get_element_by_id("email-field") .unwrap() .dyn_into::<HtmlInputElement>() .unwrap(); if !input.check_validity() { input.report_validity(); return; } if Some("example.com") != input.value().split('@').nth(1) { input.set_custom_validity("Email domain must be @example.com"); input.report_validity(); input.set_custom_validity(""); return; } form_ref.submit().unwrap(); });</code></pre> Okay, there’s quite a bit going on here. Let’s break it down. The first line creates a new Closure (a function that can be called JS/DOM). This closure must be 'static</code>, which is why we have that move</code> keyword in there. Any outside variable we reference will be moved into it. Next, we do another get_element_by_id</code> to find our email input field, nothing surprising there. We then use the constraints validation API</a> to, again, do the heavy lifting for us. We start by checking whether the native checks pass, and report the error/refuse to submit if it didn’t. The next chunk is bit more interesting, but still very basic. We know that the email at least contains a ‘@’ because the native checks have passed, so we can just split the string on that. We can then check if the user comes from the correct domain. If there is no domain to speak of (the None</code> case), or if the domain is not example.com</code>, then we bail and show an error message. The slightly awkward call to set_custom_validity</code> with an empty string is sadly how this browser API is expected to work. As a last step in this closure, if everything validated fine, we can submit the form. The final piece of the puzzle is to attach the closure to the form’s event listener. This can be achieved with: form.add_event_listener_with_callback("submit", closure.as_ref().unchecked_ref())?; closure.forget();</code></pre> This is why we had to create that form_ref</code> value that was used in the closure. We need both the closure and the form, but the closure uses the form to submit, and then we need the form to attach the closure. It’s a chicken and egg problem, so we get around it by cloning the egg. Or maybe we cloned the chicken? Closing thoughts</h2> I think that WASM story in Rust is really strong now. With just a handful lines of code we can get access to an incredibly powerful language embedded in our otherwise extremely simple web page. WASM is still relatively heavy1</a>, compared to the equivalent JS that would’ve accomplished the same (20KB or so vs a few hundred bytes), but this is also an extremely contrived example case. We’re paying a heavy penalty to get started with WASM, because we are using a few libraries that hide a lot of the ugly details from us. If we were to add a few hundred more validation functions, the code size would barely increase, whereas it would increase linearly with JS, so there are economies of scale to be had. Obviously, the sample code above unwrap</code>s to high heaven, and that’s nothing something I would condone in actual production code—please do use proper error handling. That about wraps up our exercise for today. We’ve built a simple web app that uses Rust for both backend and frontend logic, all powered by Rocket and WebAssembly. As a reminder, a full example of the above tutorial is available on Codeberg</a>. If you try something similar, I’d love to hear about it—and if there’s something deeply flawed in my approach, I’d be happy to be corrected. Thanks for reading! It is possible to reduce the size of WASM binaries by using LTO, specific opt-levels, or even using post-processing tools such as wasm-opt. Another trick is to get rid of the default allocator if possible, or swap it out for a more lightweight one. These techniques are very nicely documented in the Rust WASM book</a>, but even more so in the min-sized-rust</a> repo. Thanks to Mendy for letting me know</a> about this more up-to-date source. ↩</a> </li> </ol> </section>
Email notifications with Migadu on iOS 2025-04-19T00:00:00+00:00 One of the email providers I use is Migadu</a>. I will talk more about them in a future post, but for now, suffice it to say that they are an amazing provider when you have many domains and want to manage many different users or mailboxes. It’s raw email at its purest form, and I couldn’t be happier with them. They’re also European</a>, which makes my Europhile heart glow with pride. Up until recently, there was one annoyance I had with my Migadu accounts, though. With my other main provider, FastMail, I was able to have push notifications enabled and be happy. But for some reason, with Migadu, I would never get notifications on my phone, which would cause me to miss emails completely. I decided to dig into the problem once more, and finally found a (partial) solution. Push and poll</h2> Let’s jump back for a second and talk about terminology for a little bit. Whenever there is some kind of client/server architecture, the architects building the protocols need to decide on either push or polling. Push means that the server can initiate a message and inform a client that there is some kind of update. Polling means that every once in a while, the client will connect to the server and ask if there’s anything new. This may seem like a minor detail—and it sort of is—however it can have massive impacts on system load, mobile device battery life, etc. You see, creating network connections is expensive for mobile devices. Expensive in a power consumption kind of way. In modern mobile operating systems, when we talk about “push”, we effectively mean “we’re using the OS’ push capabilities”. On iOS, this is commonly called APNs, or Apple Push Notification service. This allows, for example, one of Netflix’ servers to send a notification to your phone about a new episode of Love Island, without your phone needing to ask Netflix “hey, got anything new?” every 5 minutes like a junkie. Try to imagine the scale of that, though—millions or billions of devices checking in every few minutes or hours to get an update. There is no good way to design a server architecture to handle this efficiently. The bandwidth cost alone would be significant. Email is old. It’s properly ancient at this point. It was already properly ancient when Steve Jobs demoed sending an email from the first iPhone. And because it is so old, the original architects didn’t have to worry about battery life or mobile data usage. They only considered a desktop computer being turned on once a day with a user clicking “fetch new e-mails” and waiting for the missives to be downloaded while enjoying a cup of coffee or reading the paper. Or both. Therefore, the original, standard email was only poll. The email client establishes a connection to the email server, asks “anything new?”, and then disconnects. Because we’ve become addicted to the instantaneity of everything, we now also want our mobile devices to get emails right away. Sometimes, that might even be essential—like when you’re waiting for a 2FA that is only valid for five minutes but your email client only fetches email once an hour, that’s going to be a problem. It’s to counteract this issue that most email clients (Thunderbird, Outlook, Apple Mail) still have a “fetch email” button. Enter XAPPLEPUSHSERVICE</h2> Obviously, this concept of polling was terrible for iPhones. Well, it was terrible for all mobile devices, but most phone manufacturers are not also email server providers—but Apple is, or was. Apple used to maintain a “server” edition</a> of macOS which contained an email server. Apple could’ve decided to adopt IMAP IDLE/P-IMAP—these are dated respectively from 1997 and 2006,1</a> but they decided to do things their own way. In all fairness, I don’t believe this is a case of the NIH syndrome</a>. There were very solid concerns regarding the scalability of IMAP IDLE (the original document recommends clients check in with the server every 29 minutes, an active TCP connection must be kept between the client and the server, etc), and the timing of P-IMAP was not exactly aligning with Apple’s timeline. Apple having their own APNs probably also wanted to dogfood it, to try and prove its capabilities. Thus, Apple built a proprietary extension to IMAP in their macOS Server Mail server with the XAPPLEPUSHSERVICE command which registers the device for push notifications without needing to have an active IMAP connection. This system worked quite well as long as you had an inbox hosted by either iCloud or an Apple email server. In 2015, FastMail became</a> the first external provider to officially support XAPPLEPUSHSERVICE, apparently with Apple’s blessing. Over the next few years, Apple slowly retired macOS server, and doing so, the only reference implementation of XAPPLEPUSHSERVICE—save maybe for the FastMail one. There have been</a> some efforts to try and implement</a> the extension in other MTAs</a>2</a> with varying degrees of success. Some email providers have refused to implement it</a> due to alleged privacy issues (Apple could potentially track phone/email associations and the contents of the emails). All in all, what it means is that iPhones are slightly stunted when it comes to less popular email providers and the native Mail app. Practical implications</h2> What does this mean, in practice? Well, if you’re using iOS and the Mail app with some providers, you might have noticed that you don’t get emails delivered immediately. They probably arrive instantly on macOS (whose Mail app implements IMAP IDLE—confused yet?), but only show up on your iPhone when you open the Mail app, or when your phone is on WiFi and charging. If you navigate to Settings > Apps > Mail > Mail Accounts > Fetch New Data, you’ll find the settings that control this. The top part of the screen shows the accounts you have configured and whether they are capable of using Fetch or Push. The bottom part shows how Fetch accounts are managed. By default, your phone is most likely configured to use the “automatic” fetch schedule. There’s a little piece of grey text at the bottom that I’d like to highlight: Your iPhone will fetch new data in the background only when on power and Wi-Fi. </blockquote> Considering how many people these days don’t even have WiFi at home, this effectively means that for a good and growing chunk of users, some emails will never be downloaded unless they manually open the Mail app and watch the messages stream in. I also know many people who exclusively charge their phone in the car on their way to and fro’ work. Switching this to “Hourly” has been working pretty decently for me, although I decided to go down to every half hour for now and try that out. Note: It might be worthwhile reducing the number of accounts listed here that are configured as “Fetch”, since each of those accounts now refreshes at a fixed interval, potentially draining battery faster. I will definitely be pruning some of the calendars from that list, but that’s a problem for future me. Okay, so our phone is now finally capable of fetching the emails in the background. Why am I still not getting any notifications? Well, there’s another setting, buried deep within the maze that is iOS settings. Full disclosure: I don’t know if I did something wrong and misconfigured something, or if there is another reason why the following setting was set as it was, however I’m just documenting it here for myself, and hopefully to help someone else out. After probably two years of not getting notifications, it suddenly clicked that maybe the lack of notifications I was seeing was due to my phone not downloading my emails, but simply not notifying me about them. Navigate to Settings > Apps > Mail > Notifications > Customise Notifications and you’ll be greeted with a screen similar to this: The one thing you might notice is that the first account, hosted by Migadu, only has the “Badges” notification permission, whereas the second one, hosted by FastMail, has access to all notification types. Enabling “Alerts” solves the entire problem. I now get notifications for all emails exactly as I’d like. Closing thoughts</h2> There’s a few avenues I might explore. First, I might reach out to the Migadu team to see what their position is on the topic. Maybe they’re already working on something, or maybe they’re entirely opposed to giving Apple the time of day. It could also be fun to try and implement my own MTA-proxy that provides XAPPLEPUSHSERVICE on top of an existing mailbox that provides IMAP IDLE. Email is that weird protocol that I can’t stop messing with, for decades now. It’s a shame that Apple is making this so difficult. I really wish they would at least publish some kind of either reference implementation (that they clearly still have in some Python source code format) or documentation about the command and its implementation. Alternatively, it would be fantastic if Apple properly implemented IMAP IDLE on iOS just like it has on macOS, or whatever better alternative there is today. I’m convinced Apple throwing its weight behind a specific implementation (JMAP?) would piss some people off, but it would also bring alignments to many MTAs. In the current state, Apple has created a weird void in the Push-Email capabilities that might cause people to stop using the Mail app and make them over-reliant on third-party apps to handle email, just to provide real-time notifications. Email, for all its faults, is remarkably one of the last systems where using independent clients, servers and services is still entirely possible, and I’d hate to lose that. The original P-IMAP RFC</a> was drafted in 2006 and subsequently abandoned, but the Lemonade RFC</a> was only published in 2009. ↩</a> </li> Mail Transfer Agent, aka an email server. ↩</a> </li> </ol> </section> Getting started with Scala on macOS in 2025 2025-03-12T00:00:00+00:00 Scala</a> is a functional programming language that I’ve come across in the past, but it never stuck in my tool belt. One of my clients has asked me to help them with a billing project, and as this is a Scala shop, I figured it would make sense to get a head start and setup my workstation to be ready to work with Scala again. The best way to get started with Scala is by using Coursier</a>; an application and artifact manager for Scala. The official docs for both Scala</a> and Coursier</a> seem to provide incorrect</del>suboptimal information for installation. Both sources recommend installing coursier/formulas/coursier</code> using brew</code>, however that formula seems to install an Intel binary, which obviously doesn’t run on Apple silicon. Instead, the following workaround</a> appears to work quite well: brew install coursier coursier setup</code></pre> Once you have coursier installed and setup, you should have a fully functional Scala build environment. Here’s the usual sanity check: @main def hello() = println("Hello, World!")</code></pre> Which you can run with scala run hello.scala</code>. The output should look something like: Compiling project (Scala 3.6.4, JVM (23)) Compiled project (Scala 3.6.4, JVM (23)) Hello, World!</code></pre> Fantastic. Now what’s left to do is to enable code completion for Scala in nvim. :LazyExtras</code> should offer scala as a suggested language if you’re editing the hello.scala</code> file above, after which a :MetalsInstall</code> should install everything needed to get up and running. Once Metals is installed, you should be able to see proper code completion. Sadly, type hints in the form of inlays doesn’t seem to be supported. This is an extremely useful feature that I’ve come to absolute love when writing Rust, and I don’t understand that it’s not a priority for most LSPs. I find it almost universally useful, regardless of the language. Switching to a split keyboard 2025-02-13T00:00:00+00:00 I’m not going to lie: I’m typing this at an excruciatingly low speed. For the past twenty years I’ve been used to typing nearly as fast as I could think, or at the very least, talk. This previous sentence, however, took me well over a minute to write down. As I mentioned a few days ago, I have decided to switch to a new keyboard layout. While the layout itself is still QWERTY, I am now using what is commonly referred to as a custom split ortholinear staggered-column mechanical keyboard. As you can probably tell, this keyboard has significantly fewer keys than a typical one, and that’s sort of the point. This kind of keyboard layout is designed to try and reduce the amount of movements your hand is making in order to reach all the keys on your keyboard. The learning curve has been absolutely brutal. I was able to get a single time over 50 wpm, and that was definitely a fluke. After a couple days of use, I am now consistently getting 30-40 wpm. I’m not convinced attempting to write a lot during this transition phase is the greatest of ideas, but it seems to me like the only way out is to practice. Interestingly enough, one of the keys I struggle with the most is the c letter, which is tucked below the d key. This means that I should in theory use my middle finger in order to hit it, but on regular keyboards I seem to have taken the habit of using my index finger. The result is that nearly every time I try to type c, I end up typing v. Even now, when I was consciously thinking through the process and explaining it. The next section will be a bit more technical as I document things that were not immediately clear to me. Homerow mods</h2> Beyond the key layout difference, the biggest change is the use of homerow mods in order to access the keys most people have around their boards. Most keyboards tend to come with a couple shift keys, some control, alt and even super (Windows/Mac) keys. These don’t exist on a 36 key keyboard, so you have to get creative. One way the community has solved this is by inventing homerow mods. What it means is that the keys on your homerow (e.g.: asdf-hjkl) have double duty. If I just tap ‘j’, I obviously get ‘j’. However if I hold ‘j’ for just a short while, it turns into a shift key. F does the same thing, just on the other side of the keyboard, in case there are collisions. The same is true for my control keys (d and k), alt (s and l) and super (a and ’). This is a major shift (pun intended) in how I type, and have to think about typing. Firmware customisation</h2> This keyboard is based on the nice!nano v2 microcontrollers. These provide wireless connectivity, so I am using the ZMK</a> firmware (ZMK appears to be more geared towards wireless keyboards whereas QMK</a> seems to be mostly wired). I decided to start with a layout based on the reasonably popular Miryoku</a> layout. I talk about a layout, however I have decided to stick with QWERTY for now. The layout, therefore, only refers to the different layers I have on the keyboard, and where keys are positioned within those. The first thing I wanted to do was adding combos, or chords I’ve grown quite used to over the past few months. Here are the chords I want to achieve; all for Danish: ‘o’ and ‘e’ to produce ‘ø’,</li> ‘a’ and ‘e’ to produce ‘æ’,</li> ‘a’ and ‘o’ to produce ‘å’.</li> </ul> In order to achieve this, I had to define some macros and combos in the firmware: / { macros { oe: oe { compatible = "zmk,behavior-macro"; #binding-cells = <0>; wait-ms = <MACRO_TIMEOUT>; bindings = <&macro_tap &kp RA(O)>; }; }; combos { compatible = "zmk,combos"; combo_oe { timeout-ms = <COMBO_TIMEOUT_SLOW>; key-positions = <3 9>; bindings = <&oe>; }; }; };</code></pre> The full customisation can be found here</a> (remember to include this file otherwise it will have no effect). The most confusing thing in this was actually that the key numbers did not line up with the physical keyboard I had in front of me. Because this chocofi</a> keyboard is quite similar to a corne</a> keyboard, that’s the layout that is used. Miryoku doesn’t use the extra keys on a corne anyway. The big difference is that the corne has 42 keys whereas the chocofi only has 36. So instead of just being able to count the keys on the physical object in front of me, I had to mentally remove some imaginary key numbers. So what does this actually do? The combo says that if keys 3 and 9 are pressed simultaneously within certain timeout, the macro should be invoked. The macro says that when it is invoked, it will generate a single key press of RA(O)</code>, which means right alt + O</code>, which on my Mac, produces an ø. I suppose that this might be done without the use of a macro, just by using a combo alone, however I need to add support for the uppercase form of these letters as well. I don’t expect that will be doable without a macro. For future reference, here is what the key mapping looks like on a chocofi for ZMK: ------------------------------------------- │ 1 2 3 4 5 │ 6 7 8 9 10 │ │ 13 14 15 16 17 │ 18 19 20 21 22 │ │ 25 26 27 28 29 │ 30 31 32 33 34 │ --------- 36 37 38 │ 39 40 41 --------- -----------------------</code></pre> At the moment, I am focusing my attention on getting this keyboard to play nicely with my Mac only, and will add the complexity of other OS’ later on. On my current TODO list is fixing the layout as I don’t currently have access to a tilde key, which is kind of important for me. I also need to improve the 3D-printed case of the keyboard so that it sits in a more stable way on my desk. At the moment it’s slightly janky and tends to tilt when I press some keys which is not entirely comfortable. I might also need to work on the timing of some chording/tapping behaviour; I sometimes generate unwanted key presses when I start typing a bit faster, especially with some rolls such as ‘st’. Another comfort I’d like to get back somehow would be some form of caps lock. The main reason for this is that with the homerow mods it can get a bit tiresome to switch from one hand to the other to maintain shift when typing longer uppercase things (constants in Rust or other programming languages come to mind). I know there’s support for this in ZMK, but I haven’t been able to figure out whether it’s already available in Miryoku. Edit: This turned out to be a non-issue. Miryoku has this built-in, and the reason I couldn’t find it is because I use the vi-shifted navigation layout. ZMK has a feature called caps words</a> which, when turned on, capitalises all letters until a non-alphanumerical character is pressed. This luckily also includes underscores, so it’s a perfect fit for programming. On Miryoku this is activated by pressing nav + /</code>. Freebox automatic ruTorrent download 2016-04-26T00:00:00+00:00 I love Free. I think it is one of the best ISPs in the world, and even more so in France. If I’m not mistaken, they invented the ISP-provided set top box that seems so common place these days. Their Wikipedia entry</a> explains some of the reasons I like them so much, but to list a few: unmetered bandwidth,</li> fixed IPv4 address, /60 IPv6 block,</li> they allowed and encouraged people to run their own servers (reverse-IP customisation, every port available, etc),</li> their router doesn’t suck,</li> fixed price policy: ~30 euros, all inclusive,</li> the IPTV streams are viewable on your PCs through VLC,</li> the list could go on for a long time.</li> </ul> All this being said, one of the major reason I loved their product so much was because of their modem, the Freebox</a>. I’ve been a long fan of all their hardware (since the V4), but the Freebox Revolution takes the cake. Anyway, back on topic. The Freebox Revolution Server allows you to set an RSS feed, and all items in this RSS feed will be automatically downloaded by the newsgroup/torrent/direct download client that is built into the router (yeah, they have that built in). I used to use a seedbox, but because I had a really bad DSL connection (4 Mbits), I preferred for my downloads to happen during the day—when nobody was home—rather than having to painstakingly wait for the bits to transfer when I was home. The other reason was also that downloading anything would immediately saturate the link, and ruin browsing/YouTubing for anyone home at that point. The other main point that should be stressed is that the Freebox Player (the part connected to the TV) could stream any file stored on the Server’s hard drive (it acted as a NAS, out of the box). This meant that we were able to watch the new GoT episode faster than most of my colleagues who had FTTH connections, simply because we just had to turn the telly on, and click “Play”. I came up with the following script to generate an RSS feed of downloaded files that my Freebox would then automatically pick up. #!/usr/bin/python import cPickle as pickle import xml.etree.cElementTree as et # You can find PyRSS2Gen at: # https://pypi.python.org/pypi/PyRSS2Gen import PyRSS2Gen as RSS2 import urllib, mimetypes from os import path, walk from datetime import datetime DIRECTORY = '/home/rtorrent/downloaded' DATABASE = '/home/rtorrent/.rssdb' EXTENSIONS = ['.avi', '.mkv', '.mp4', '.mpeg', '.mpg'] HOSTNAME = 'myseedbox.example.com' PATH = 'downloads' HTTPS = True RSS_FILENAME = '/home/rtorrent/downloads.rss' class FileList: def __init__(self, database): self.database = database self.load() def append(self, file, size, type): if file not in self.files: self.files[file] = { 'date': datetime.now(), 'size': size, 'mimetype': type } def store(self): with open(self.database, 'w') as fp: pickle.dump(self.files, fp) def load(self): if path.exists(self.database): with open(self.database, 'r') as fp: self.files = pickle.load(fp) else: self.files = {} def get(self): """ Return the files in reverse order in which we stored them. """ return self.files class DirectoryParser: def __init__(self, directory, extensions = []): self.directory = directory self.extensions = extensions mimetypes.init() def parse(self, store): for _path, directories, files in walk(self.directory): for file in files: if self.filter(file): type = self.get_filetype(file) full_path = path.join(_path, file) size = path.getsize(full_path) storeable_path = full_path[len(self.directory) + 1:] store.append(storeable_path, size, type) def filter(self, file): if len(self.extensions) is 0: return True elif path.splitext(file)[1] in self.extensions: return True else: return False def get_filetype(self, file): return mimetypes.types_map[path.splitext(file)[1]] class RSSGenerator: def __init__(self): if HTTPS: self.url = 'https://' else: self.url = 'http://' self.url += '%s/%s/%%s' % (HOSTNAME, PATH) def generate(self, files): items = [] for file in files: url = self.url % urllib.quote(file) item = RSS2.RSSItem( title = file, link = url, guid = RSS2.Guid(url), pubDate = files[file]['date'], enclosure = RSS2.Enclosure(url, files[file]['size'], files[file]['mimetype']) ) items.append(item) self.rss = RSS2.RSS2( title = '%s downloads RSS feed' % HOSTNAME, description = 'The latest finished downloads at %s\'s ruTorrent' % HOSTNAME, link = self.url % '', items = items ) def store(self, filename): with open(filename, 'w') as fp: self.rss.write_xml(fp) if __name__ == '__main__': file_list = FileList(DATABASE) parser = DirectoryParser(DIRECTORY, extensions = EXTENSIONS) parser.parse(file_list) file_list.store() rss_generator = RSSGenerator() rss_generator.generate(file_list.get()) rss_generator.store(RSS_FILENAME)</code></pre> This was called by a cron job every 5 minutes: # Generate the downloads.rss, every 5 minutes */5 * * * * /usr/local/bin/rssdirectory.py && /bin/sed -i 's!></enclosure!/!g' /home/rtorrent/downloads.rss</code></pre> The reason that sed command is there is because the Freebox doesn’t understand the enclosure tag that is generated by PyRss2Gen. Yeah, that one took a while to debug and figure out. While this setup worked very nicely, every couple of months, the Freebox would simply stop downloading new items. In the router’s WebOS, I’d force updates to the RSS feed, but nothing would show up. The feed would be empty. After some time, I figured out that it was due to the Freebox not being able to cope with the size of the RSS file. So here’s the hack-ish remedy for that, you’ve guessed it, another cron job: # Remove the .rssdb once a week (garbage collection) @weekly /bin/rm /home/rtorrent/.rssdb</code></pre> This setup worked very nicely for the better part of 5 years, while we lived in France. So thank you Free, and all the engineers behind the amazing ISP that you are, and all the engineers who make the Freebox possible. It’s an amazing piece of kit, and the hacker spirit that you guys show all over the place is awe-inspiring, to say the least. My FreeBSD setup 2016-04-23T00:00:00+00:00 Update in 2025: After using FreeBSD for a few years, the little netbook gave up the ghost. I no longer use FreeBSD as a daily driver. I’m leaving the information below in case I ever pick FreeBSD up again. Over the past few years, I’ve been feeling more and more ill at ease with my Linux systems. The main reason for this is systemd. I won’t go into a full-on anti-systemd rant in this post; there has been enough ink spilled on that topic. Initially, I tried out OpenBSD, but had a bit of trouble getting going started (mainly, I couldn’t get neovim to build), and the system performance on my netbook was pretty bad. I switched to FreeBSD, assuming that some of these things would be better, and indeed, they were. Neovim is just a pkg</code> command away (even though it’s version 0.1.2), and the whole system feels incredibly responsive. I also decided to drop KDE and switch to i3, the window manager</a>. I never used KDE on my netbook, on that one I always kept OpenBox. I’m absolutely in love with i3. It’s very lightweight, though requires a pretty fair amount of configuration in order to be usable (or at the very minimum, fit my needs). After a few days of mucking about, this is what my setup looks like: And this is what my lock screen looks like: I’ll keep this article updated with my configuration, mostly as a way to help myself set up new systems. Some of this stuff might end up in my dotfiles repository, though. Base system</h2> /etc/sysctl.conf</code>: # Enchance shared memory X11 interface kern.ipc.shmmax=67108864 kern.ipc.shmall=32768 # Enhance desktop responsiveness under high CPU use (200/224) kern.sched.preempt_thresh=224 # Bump up maximum number of open files kern.maxfiles=200000 # Disable PC speaker hw.syscons.bell=0 # Shared memory for Chromium kern.ipc.shm_allow_removed=1 # Allow users to mount disks vfs.usermount=1 # Synaptics configuration hw.psm.synaptics.min_pressure=40 # Suspend on lid close hw.acpi.lid_switch_state=S3</code></pre> /boot/loader.conf</code>: # Load intel graphics driver i915kms_load="YES" # Reduce GPU power consumption (SandyBridge/IvyVridge) drm.i915.enable_rc6=7 # Allow loading of the realtek firmware (wifi dongle) legal.realtek.license_ack=1 # Use new graphical console driver kern.vty=vt # Devil worship in loader logo loader_logo="beastie" # Boot-time kernel tuning kern.ipc.shmseg=1024 kern.ipc.shmmni=1024 kern.maxproc=10000 # Load MMC/SD card-reader support mmc_load="YES" mmcsd_load="YES" sdhci_load="YES" # Access ATAPI devices through the CAM subsystem atapicam_load="YES" # Filesystems in Userspace fuse_load="YES" # Intel Core thermal sensors coretemp_load="YES" # In-memory filesystems tmpfs_load="YES" # Asynchronous I/O aio_load="YES" # Handle unicode on removable media libiconv_load="YES" libmchain_load="YES" cd9660_iconv_load="YES" msdosfs_iconv_load="YES" # Load sound subsystem snd_driver_load="YES" # Enable better trackpad support hw.psm.synaptics_support=1</code></pre> /etc/rc.conf</code>: hostname="somemachine.home.wedrop.it" # Enable DHCP but don't let it block the boot process background_dhclient="YES" # Try to configure re0 (wired) on boot ifconfig_re0="DHCP" # Clone urtwn0 to a device called wlan0 wlans_urtwn0="wlan0" # Configure wlan0 to connect through WPA and use DHCP ifconfig_wlan0="WPA SYNCDHCP" keymap="uk.iso.kdb" # Remote logins sshd_enable="YES" # Set dumpdev to "AUTO" to enable crash dumps, "NO" to disable dumpdev="AUTO" moused_enable="YES" # powerd: hiadaptive speed while on AC power, adaptive while on battery powerd_enable="YES" powerd_flags="-a hiadaptive -b adaptive" # Reduce power consumption by using higher C-states than the default of C1 performance_cx_lowest="Cmax" economy_cx_lowest="Cmax" # Enable bluetooth hcsecd_enable="YES" spdp_enable="YES" # Synchronize system time ntpd_enable="YES" # Let ntpd make time jumps larger than 1000sec ntpd_flags="-g" # Enable dbus (IPC) dbus_enable="YES" # Enable hald (hardware detection), should not be required. # hald_enable="YES" # Enable graphical login slim_enable="YES"</code></pre>User configuration</h2> I haven’t documented or stored all of this to my dotfiles repositories yet. Come back later? :) Installed ports</h2> Following is a list of packages that I usually install pretty quickly after setting up a new system: Terminal and shell stuff</h3> pv (pipe viewer)</li> rxvt-unicode (terminal)</li> scrot (screen capture)</li> sudo</li> the_silver_searcher (grep replacement for vim)</li> zsh (shell)</li> </ul> Development</h3> neovim (from source)</li> autotools</li> clang38</li> cmake</li> git</li> gmake (BSD-make is sadly not very supported)</li> </ul> Desktop environment</h3> dmenu (app launcher for i3)</li> feh (background manager)</li> firefox</li> git-gui</li> i3-gaps (from source)</li> keepass (password manager)</li> slim (graphical login)</li> </ul> I’m an absolute FreeBSD noob, so some of the stuff listed here is probably suboptimal. Feel free to tell me on Twitter or drop me an email if there’s anything I should change. Building GCC 2015-08-24T00:00:00+00:00 There’s a nasty bug</a> that plagues GCC 5.1 (the current version of GCC in Fedora 22), which blocks the unit tests for Realm. Instead of going to the very bleeding edge, I’ve decided to compile version 4.9.3 and keep that as a backup to run tests and whatnot. The bug has been fixed and should be part of the GCC 5.3 release, so we’ll just have to be patient until then. Sometimes, Fedora’s race-to-the-new can bite you a tiny bit. There are a couple of dependencies needed other than the usual build tools: sudo dnf install -y gmp-devel mpfr-devel libmpc-devel</code></pre> It’s fairly simple to build GCC. I wouldn’t expect otherwise, frankly: cd src/foss && \ wget http://mirror1.babylon.network/gcc/releases/gcc-4.9.3/gcc-4.9.3.tar.bz2 tar xf gcc-4.9.3.tar.bz2 && cd gcc-4.9.3 ./configure \ --prefix=$HOME/bin/gcc-4.9.3 --program-suffix=-4.9.3 make -j4 && make install</code></pre> The $HOME/bin</code> directory is already in my PATH</code>, so I’m just going to create a small symlink that will allow me to call gcc-4.9.3</code> from anywhere. cd $HOME/bin ln -s gcc-4.9.3/bin/gcc-4.9.3 gcc-4.9 ln -s gcc-4.9.3/bin/g++-4.9.3 g++-4.9</code></pre> Be aware that compiled, GCC does take a fair amount of space: du -sh $HOME/bin/gcc-4.9.3 1.1G /home/slau/bin/gcc-4.9.3 du -sh $HOME/src/foss/gcc-4.9.3 5.5G /home/slau/src/foss/gcc-4.9.3</code></pre> So yeah, there’s that to keep in mind. Fedora 22 WiFi problems 2015-06-17T00:00:00+00:00 I went to the office today (well, technically, yesterday) to take care of the final paperwork, get my final paycheck and stuff (more on that in another post, hopefully). I wanted to do some cleaning in order to get a nice break after this gig, so I decided to update my computers to Fedora 22. The process ran perfectly on most computers, but on my netbook I had a small kink: WiFi didn’t work anymore. I didn’t have much to go on, as the logs didn’t indicate a lot. I noticed that a number of packages from F21 had been carried over to F22, so I did a bit of cleaning in that regard: sudo dnf remove kernel-modules-4.0.4-202.fc21.x86_64 \ kernel-modules-3.19.5-200.fc21.x86_64 \ kernel-modules-extra-3.19.5-200.fc21.x86_64</code></pre> I noticed that I didn’t have any wl</code> kernel module, so figured that akmod</code> or kmod</code> was not working as expected. I forced the reinstallation of the latest kernel: sudo dnf reinstall kernel kernel-devel</code></pre> Take note of the version being installed. For me, it was 4.0.4-303.fc22.x86_64</code>. Reboot, and make sure you select the right kernel when Grub prompts the list of kernels. akmod</code> is very difficult to debug, mainly because of the clusterfuck that is systemd. The best way is by forcing the modules to rebuild manually, and seeing what the errors are. As a non-privileged user, run akmodsbuild</code> to see if your system has everything it needs to actually build the modules. Be warned that this checks the running kernel, so if you didn’t reboot, you may not have the necessary directories and files. Lastly, simply run the following commands to get WiFi up and running again: sudo akmods --force sudo modprobe wl</code></pre> NetworkManager should pick up on the new network interface and connect you automagically. Happy surfing! Fedora 21 VPN problems 2015-02-03T00:00:00+00:00 At the office, a few us use Fedora. The main reasons are that it’s a fairly good desktop distribution, and the software is nice and bleeding edge; perfect for developers. But sometimes, it breaks. I’m still on Fedora 20, but a handful of coworkers have either upgraded to Fedora 21 or installed the latest version because they recently got new computers (and crunchbang doesn’t play well with newer Haswell setups). All the new setups had one problem: they couldn’t connect to one of our VPNs. We’re in the process of migrating to SoftEther</a>, but this particular VPN still uses PPTP while we validate that SoftEther can handle our load. So what happened? The short answer is that the VPN wouldn’t connect. It would take ages for the connection attempt to fail, and in the logs</a>, we’d see something along the lines of: LCP: timeout sending Config-Requests</code></pre> After a bit of digging</a>, it turns out that there are a few packets that are being blocked by the firewall since the 3.18 kernel</a>: As expected, with the 3.2.x kernel : if neither nf_conntrack_proto_gre nor nf_conntrack_pptp are loaded, the first GRE packet of a plain GRE tunnel (as set by ip tunnel) or a PPTP connection is NEW ; […] What has changed with the 3.18.x kernel : if neither nf_conntrack_pptp nor nf_conntrack_proto_gre are loaded, any GRE packet is INVALID. </blockquote> The solution, thus, both on Ubuntu and Fedora (and I expect others as well) is to always load the nf_conntrack_pptp</code> module. # Fedora echo nf_conntrack_pptp | sudo tee /etc/modules-load.d/pptp-firewall.conf sudo modprobe nf_conntrack_pptp # Ubuntu and friends echo nf_conntrack_pptp | sudo tee /etc/modules/pptp-firewall.conf sudo modprobe nf_conntrack_pptp</code></pre> Happy connecting! Hash anagram challenge, part 2 2015-02-03T00:00:00+00:00 This is part two of my attempt to solve the Hash Anagram challenge offered by TrustPilot. Full disclosure: These articles are not written in chronological order; I finished the challenge a few weeks ago. I’m merely documenting my mental process, and trying to get back into proper writing. In this part, we’ll start writing a small script that crunches the words, and do some rough benchmarking on it, to see whether our approach actually makes sense or not. In part 1</a>, we saw that we have a couple thousand words to work with. We also saw that working from the letters in the seed anagram alone, there were a few quintillion possible permutations. So what kind of algorithms could we apply to this problem, to try and solve it? Let’s try to restate the problem in order to see things more clearly: Given a list of 1758 words, find a permutation of n words whose md5 hash computes to 4624d200580677270a54ccff86b9610e</code>. </blockquote> First, let’s lay down some observations: There are 18 letters in the seed anagram, hence the number of letters in the target anagram will be 18 as well;</li> We don’t know how many words the target anagram contains;</li> We don’t know how many permutations of the words list are actual anagrams.</li> </ol> Technically, we could assume that the target anagram contains nothing more than three words, but I don’t want to make that assumption. I see two main algorithmic paths: Generate all possible word permutations, and filter it down;</li> Recursively append words to one another until an anagram is found.</li> </ul> So how do you check whether a string is an anagram of another string? I’ve found the following algorithm in Python: def isAnagram(first, second): # If the strings are identical, they are anagrams if first == second: return True # Remove spaces, and convert `first` into a list first = first.translate({ord(' '): None}) second = second.translate({ord(' '): None}) # If they don't have the same length, they can't be anagrams if len(first) != len(second): return False else: first = list(first) try: # Remove all characters found in second map(first.remove, second) except ValueError: return False else: return True</code></pre> And an equivalent implementation in C: // Return a copy of the letters a string (without spaces) char * lttrdup(char const * str) { // Technically, we're wasting a few bytes here, but that's OK. char * copy = malloc(strlen(str) + 1); char * tmp = copy; do { if (*str != ' ') *tmp++ = *str; } while (*str++ != '\0'); return copy; } bool is_anagram(char const * first, char const * second) { // If the strings are equivalent, they are anagrams if (strcmp(first, second) == 0) return true; else { // Remove the spaces from our strings char * cpy_first = lttrdup(first); char * cpy_second = lttrdup(second); // tmp_second is an iterator over cpy_second char * tmp_second = cpy_second; // If both strings don't have the same length, they can't be anagrams if (strlen(cpy_first) == strlen(cpy_second)) { // Iterate over cpy_second until the end is reached while (*tmp_second != '\0') { // find the character pointed by tmp_second in cpy_first char * match = strchr(cpy_first, *tmp_second); // if a match is found, overwrite it, and move on the to the // next character if (match != NULL) { *match = '.'; tmp_second++; } // no match found, skip to cleanup else break; } } // if tmp_second doesn't point to the end of the string, we found a // character that doesn't exist in first, hence, no anagram bool result = *tmp_second == '\0'; // cleanup free(cpy_first); free(cpy_second); return result; } }</code></pre> The main issue I see with both implementations is that we actually need to do allocations in order to verify that two strings are anagrams of each other. Granted, the allocations in C are way smaller and more manageable than the Python ones, but still, not great. If you know of an algorithm that doesn’t require allocations, I’d be happy to hear about it. Talking about allocations, what could we do to reduce their numbers? At the moment, the only check we do before undergoing any allocation, both in Python and C, is checking whether both strings are the same. How could we cut that down? This is my train of thought: Characters are encoded into their ASCII value, and for lowercase letters in the alphabet, their value will range between 97 and 122. What happens if we add the values of our seed anagram (letters only, no spaces)? anagram = "poultry outwits ants".translate(None, ' ') sum(map(ord, anagram)) => 2036</code></pre> Regardless of the order of the letters, an anagram of “poultry outwits ants” will always have the same order point sum. The reverse, however, isn’t true: a string that has an order point sum value of 2036 isn’t necessarily an anagram of “poultry outwits ants”. Let’s throw that into our code: def letterCount(word): return sum(map(lambda x: 1 if x != ' ' else 0, word)) def sumLetters(word): return sum(map(lambda x: ord(x) if x != ' ' else 0, word)) def isPlausibleAnagram(first, second): return letterCount(first) == letterCount(second) and \ sumLetters(first) == sumLetters(second)</code></pre> Excellent. Let’s try to do the same in C: bool is_plausible_anagram(char const * first, char const * second) { unsigned int first_length = 0; unsigned int second_length = 0; unsigned int first_ord = 0; unsigned int second_ord = 0; do { if (*first != ' ') { first_ord += *first; first_length++; } } while (*first++ != '\0'); do { if (*second != ' ') { second_ord += *second; second_length++; } } while (*second++ != '\0'); return first_length == second_length && first_ord == second_ord; }</code></pre> I decided to write the C version as a single function, so as to only have to loop over the two strings once. The Python version uses a more functional approach. Great, so we now have a way to approximate whether a string might be an anagram without doing any allocations, and a way to know whether a string really is an anagram of another string. Let’s put together a quick script that gives us all the permutations and starts pumping out anagrams, but first, let’s use our newfound quicktester to spare some CPU cycles: def isAnagram(first, second): if not isPlausibleAnagram(first, second): return False # If the strings are identical, they are anagrams if first == second: return True first = first.translate({ord(' '): None}) second = second.translate({ord(' '): None}) # If they don't have the same length, they can't be anagrams if len(first) != len(second): return False else: first = list(first) try: # Remove all characters found in second map(first.remove, second) except ValueError: return False else: return True</code></pre> And now for the main function: def main(): words_url = 'http://followthewhiterabbit.trustpilot.com/cs/wordlist' anagram = 'poultryoutwitsants' words = getEnglishWords(words_url) words = filterWords(words, anagram) length = 0 while True: length += 1 print("Testing permutations of %d words" % length) generator = itertools.permutations(words, length) for permutation in generator: permutation = ' '.join(permutation) if isAnagram(permutation, anagram): print("--> Found anagram:", permutation)</code></pre> I let this run for a few minutes, and as luck would have it, it actually spat out the answer: python permutations.py Splitting file into list() Removing words that contain letters not found in anagram Original set of words length: 99174 Filtered set of words length: 1658 Testing permutations of 1 words Testing permutations of 2 words Testing permutations of 3 words --> Found anagram: want spit tortuously --> Found anagram: want pursuit tolstoy --> Found anagram: want tortuously spit --> Found anagram: want tortuously pits --> Found anagram: want tortuously tips --> Found anagram: want pits tortuously --> Found anagram: want tolstoy pursuit --> Found anagram: want lousy outstript --> Found anagram: want yous trustpilot --> Found anagram: want trustpilot yous</code></pre> Wait, trustpilot</code>? Would the answer just be “trustpilot wants you”? Nevermind, I haven’t tested any md5 hashes or anything, so I won’t cheat. The major issue with using itertools.permutations</code> is that it’s pretty difficult to run on a cluster, and looking at the speed, it’s not going to complete quickly. What I mean by speed is that a quick benchmark shows that the Python script running on my netbook is capable of rougly 50k permutations per second. Going back to the number crunching we did in part 1, how many different permutations are there for n ranging from 1 to 5? 1658! / (1658-1)! + 1658! / (1658-2)! + 1658! / (1658-3)! + \ 1658! / (1658-4)! + 1658! / (1658-5)! => 12 461 304 888 660 100</code></pre> I don’t even need to calculate how long that would take to know it would be a very, very long time (hint: they should’ve started back in the Copper Age</a>). Now obviously, I wouldn’t need to test every single permutation; especially if I check the md5 hash every time I find an anagram. So how can we split the work across multiple cores? I know just the library for the job: ZeroMQ</a>. ZeroMQ (also written ØMQ) is a great tool to have on your belt. It doesn’t require much, other than a good ol’ paradigm shift (POP!). ZeroMQ makes multithreading and multiprocessing easy. Well, it doesn’t, it just makes communicating between multiple threads, processes or servers a piece of cake. The PyZMQ bindings</a> are excellent, and they make everything an absolute pleasure to work with. ZeroMQ takes care of managing the sockets, establishing or receiving connections, polling and whatnot. Instead of working with dumb sockets, ZeroMQ offers pre-defined socket types that behave in certain ways (request/response, router, publish/subscribe, etc.). Here’s the architecture we’ll deploy, simple and concise: The server will take care of downloading and reducing the wordlist;</li> When a client asks for a word, the server will sequentially go through its words list, and send the next word to a client;</li> Upon exhausting all possibilities for a given word, the client will send back all the anagrams it found, and request a new word.</li> </ul> Later on, we’ll teach clients to also switch to md5 computing tasks if there are any. This will allow us to not spend the next 8000 years computing, but also completing the challenge. ZeroMQ gives us a socket we can talk on between the clients and the server, but what dialect should we employ? These days, I usually default to JSON; it’s very well supported and can encode nearly all the types of data one usually needs. It compresses fairly well, and isn’t too verbose, yet remains human-readable. And hey look! PyZMQ offers convenience functions to read/write in JSON directly! The other question we should probably answer is “What kind of sockets are we going to use?” For the sake of simplicity, we’re going to use one of ZeroMQ’s simplest socket types: the Request-Response combo. Let’s take a moment to define the grammar of our dialect: --> {'type': 'initialise'} <-- {'seed': 'poultryoutwitsants', 'words': ['a', 'abaci', 'aback', ... ]} --> {'type': 'next_word'} <-- {'word': 'truants'} --> {'type': 'found_anagrams', 'result': ['truants outwit slopy', ...]} <-- {}</code></pre> Let’s start by creating our server. Most of the stuff will remain the same, we’re just going to add a small class that keeps track of the current word, and stuff like that: class WordsList(object): """I download a list of words, clean it up and iterate through it.""" def __init__(self, filter, url): self._words = getEnglishWords(url) self._words = filterWords(self._words, filter) # A copy for future reference self._all_words = list(self._words) def nextWord(self): """I give the next word in the words list, or None if the end has been reached""" try: return self._words.pop() except IndexError: return None def getWords(self): """I give access to the whole words list.""" return self._all_words def endReached(self): """I'm a helper function that tells you whether the end of the list has been reached or not""" return len(self._words) == 0</code></pre> And this is again where I’m going to call it a night ;) I’ll finish writing this article tomorrow or something. Thanks for reading, anyway. Hash anagram challenge, part 1 2015-02-02T00:00:00+00:00 As I mentioned previously, I’ve been working on a technical challenge I found a few days ago. Just to be clear: this is a low-priority challenge for me. I don’t expect anything out of this, and I don’t consider it to be anything more than yet another toy-project to keep my mind busy whenever I have a moment to spare. The challenge</a> is as follows: What is the anagram of “poultry outwits ants” whose md5 hash computes down to 4624d200580677270a54ccff86b9610e</code>? </blockquote> Sounds simple enough, right? That’s what I thought as well. Let’s start by doing some math: There are 18 letters in the seed anagram, not including spaces. Let’s leave the spaces aside for the moment and just focus on those 18 letters. How many permutations of letters are there? Well, that’s fairly easy, let’s head up to WolframAlpha</a> and calculate some factorials</a>: 18! => 6 402 373 705 728 000</code></pre> Just shy of 6.5 quadrillion</a> possibilities? Not bad. Now, let’s see what throwing in those spaces changes… 21! => 51 090 942 171 709 440 000 23! => 25 852 016 738 884 976 640 000</code></pre> Between 51 quintillion</a> possibilities and 25 sixtillion possibilities</a>, assuming there are respectively 3 to 5 words in the actual anagram. Wow. We now know how many possible permutations there are. These are purely permutations (e.g.: theoretical anagrams), and not actually matched to real, existing words. That’s another step. Let’s just go with these numbers and see how long it would take to calculate all of these. How fast is my computer? I’m writing this on a small, cheap netbook that runs off battery power. I’m not expecting much out of it. Let’s see what John the ripper</a> thinks of my CPU. $ john -test | grep -A md5 Benchmarking: md5crypt [MD5 32/64 X2]... DONE Raw: 5383 c/s real, 5427 c/s virtual</code></pre> I’m taking md5crypt as a low baseline, as I’m guesstimating it to be more computationally intensive than just calculating the md5 sum of small strings. Let’s assume I get a thousand boxes like mine, slightly more powerful (four cores instead of two): 5000 hashes/s * 1 000 000 * 4 cores => 20 000 000 000</code></pre> 20 billion hashes per second, that’s pretty good, and in our era of cloud computing, surely not that impossible to achieve. How long would it take me to crack the challenge, by simple, honest to goodness bruteforce? 21! / (5000 * 4 * 1 000 000 per second) => 709 596 hours => 29 567 days</code></pre> So, assuming perfect workload distribution, and assuming no overhead from the software, it would take around 80 years</a> to calculate the md5 hash of every single possible anagram. Now, I realise those are very, very low values; maybe more worthy of vapour that cloud computing. According to Andrew Dunham</a>, it is possible to get up to 2.3 billion md5 hashes per second per Amazon EC2 GPU cluster. So assuming an hourly rate of USD 0.7, it would only cost under USD 5 million</a> to calculate everything, but it would still take nearly as long</a> as to put a human on this planet. Note that those numbers are for 1000 GPU clusters; The reason I didn’t go for the million-figure in this estimate is because I somehow strongly doubt the fact that Amazon has a spare million GPU clusters lying around. I love a good challenge as much as the next guy, but I don’t have that kind of time or money to throw at just something to keep my brain idling. So where do we go from now? Let’s look at the challenge again. Hey, they gave us a list of words</a>! That must be useful, right? Of course it is! How many words did they give us? $ wc -l wordlist 99174 wordlist</code></pre> Wait, how many unique words did they give us? $ sort -u wordlist | wc -l 96316</code></pre> OK, so let’s remove any word that contains a letter that doesn’t exist in our seed anagram: poultry outwits ants. Time to let go of bash and friends, and call in the big guns: Python. #!/usr/bin/env python from __future__ import (absolute_import, print_function, unicode_literals) import os.path import urllib2 """ Unoptimised file downloader with minimal cache management. It expects a newline-delimited file and removes any line that contains letters not found in an arbritrary string """ def fileFromHTTP(url, filename): """I download a file and save it to the provided filename""" print("Downloading file:", url) file = urllib2.urlopen(url).read() with open(filename, 'wb') as fp: fp.write(file) def fileToList(file): """I know how split a file into a list(). Yay me.""" print("Splitting file into list()") lines = [x.decode('utf-8') for x in file.splitlines()] return lines def getEnglishWords(url): """I check if the cache is warm, and download the file if it can't be found locally""" filename = os.path.basename(url) if not os.path.isfile(filename): fileFromHTTP(url, filename) with open(filename, 'rb') as fp: file = fp.read() return fileToList(file) def filterWords(haystack, needles): """I take a a list of words, and remove any that can't be found in the needles string""" print("Removing words that contain letters not found in anagram") print("Original set of words length:", len(haystack)) # The list(set()) operation is done to remove dupes haystack = list(set(haystack)) for word in list(haystack): if not existsInPool(needles, word): haystack.remove(word) print("Filtered set of words length:", len(haystack)) return haystack def existsInPool(pool, word): """I check whether `word` could possibly exist in `pool`""" pool = list(pool) try: for c in word: pool.remove(c) except ValueError: return False return True def main(): words_url = 'http://followthewhiterabbit.trustpilot.com/cs/wordlist' anagram = 'poultryoutwitsants' words = getEnglishWords(words_url) words = filterWords(words, anagram) if __name__ == '__main__': main()</code></pre> Let’s give it a run and see how many words we managed to squash out: $ python foo.py Splitting file into list() Removing words that contain letters not found in anagram Original set of words length: 99174 Filtered set of words length: 1658</code></pre> OK, we managed to remove 98.32% of the words list provided by Trustpilot. This definitely reduces the amount of calculations we’re going to have to perform, but it doesn’t really make things that much easier. Let’s look at why. The usual way to calculate the number of permutations will again be based around factorials, as we used previously. As before, let’s assume the target anagram is made of 3 words, just like the seed anagram. What would be the formula to calculate that? Well actually, the Python documentation</a> gives it right to us: # for n the pool length, and r the number of permutations: n! / (n-r)!</code></pre> So applied to our problem: 1658! / (1658 - 3)! => 4 549 538 736 # 18 bytes per anagram, 3 bytes for spaces, 32 bytes for the md5 hash 4549538736 * (18 bytes + 3 bytes + 32 bytes) => 241 125 553 008</code></pre> I guess it would be possible to load up a Cassandra cluster with 240GB of data and use Apache Spark to carve through it, but it doesn’t really seem like the right way to do it. In the next article (part 2</a>), we’ll write a quick python script that starts crunching through the list of words and find a way to discard impossible permutations. RPM versioning with Jenkins 2014-02-01T00:00:00+00:00 I’m currently deploying Jenkins at work, in order to simplify the build process. At the moment, we have a fairly complicated process that involves a couple dozen steps, which, even though each step is fairly braindead, does require a good amount of focus and planning in order to get everything just right. Jenkins</a> provides a build number for all the different projects you might configure. Each build number is unique in a given project; this ensures that you can refer to specific builds without too much of a hassle. That’s great, but knowing that I’m trying to achieve fully automated RPM packaging, it doesn’t help me much. The versioning system in our company (defined by moi, pretty much), is heavily inspired by the usual RPM rules: release numbers are reset to 1 whenever the version number changes. There’s no real way, as far as I know, to use Jenkins’ build number for this, as there is no programmatic way to reset the build number in Jenkins. Multi-instance exclusive lock in Python</h1> The first issue I tried to tackle was the fact that the Jenkins server will run multiple builds at the same time, possibly for the same project. What this means is that simply having stuff in a file isn’t really sensible due to concurrency issues. I know that portalocker</a> roughly does the same as what I tried to do, but not completely. portalocker provides a lock to a file; my implementation provides a transaction-kinda lock, regardless of whether you want to access files or databases or whatever. Without further ado, here’s the class: import os, time class Lock(object): """ Manage a system-wide lock used to inform other processes they should wait. The lockfile argument is the token that should be shared amongst all the processes wanting to acquire exclusive locks to the same resource. """ polling = 0.1 def __init__(self, lockfile): self._lockfile = '%s.lock' % lockfile # I only target linux systems... Sorry. self._path = os.path.join('/tmp', self._lockfile) self.locked = False def __enter__(self): self.acquire() return self def __exit__(self, _, __, ___): self.release() def acquire(self): """ Try to acquire a lock. This is a blocking call, until the lock is acquired. If you want a non-blocking call, try nb_acquire(). """ if self.locked: """ TODO: Raise """ pass while not self._acquire(): time.sleep(self.polling) self.locked = True def nb_acquire(self): if self.locked: """ TODO: Raise """ pass self.locked = self._acquire() return self.locked def _acquire(self): try: os.mkdir(self._path) except OSError: return False return True def release(self): if not self.locked: """ TODO: Raise """ pass os.rmdir(self._path) self.locked = False</code></pre> There’s a couple of TODOs, and I might push this stuff to my github account at some point or another, but it gives a general idea on what I tried to do. The jist of it is that I use mkdir as an atomic locking operation. What you lock against is basically just an identifier, which means that whether you want to read/write to files, access a database, fiddle your toes doesn’t realy matter. If the lock acquisition fails, the acquire()</code> method will block until it is able to acquire the lock. If you don’t want it to block, there’s always nb_acquire()</code> which will just return a boolean indicating the lock status. How to use it</h2> Here’s how it could be used: lock_name = 'my-lock' # Primary usage with Lock(lock_name): print "We should be locked!"</code></pre> And that’s really just it. The locking magic happens in the with</code> statement. As soon you enter the with</code> statement, you are guaranteed to be the sole executor of whatever code you have running. As soon as you leave the scope of the with</code> statement, the lock is released. Below are a few other scenarios of how you could use the above class: lock_name = 'my-lock' # Another kind of usage lock = Lock(lock_name) lock.acquire() print "We should be locked!" # If you do not call the following function, you're going to have bugs. lock.release() # Yet another kind of usage (non-blocking, this time) if lock.nb_acquire(): print "We should be locked!" lock.release() else: print "We're most definitely not locked!"</code></pre> So, now we can execute a block of code without having to worry about other instances of the script mucking about our stuff. Let’s work on the RPM versioning now. Efficient RPM release numbers</h1> RPM versioning works like this: 1.2.3-4</code> where 1.2.3</code> is the version number, and 4</code> is the release. For a more in-depth overview of RPM versioning, check out Fedora’s wiki, or something. I usually put the version number of my software in a file somewhere, so getting that isn’t usually a problem. However, the release part of the RPM version is a bit more tricky. The way we use it is that every time we release something to the QA team (or directly to production if it’s a very urgent bugfix), we increment the release number if the version number hasn’t changed. This is the case, for example, if you have to fix something in the packaging process, or if you are applying successive fixes to the release branch (according to nvie’s branching model</a>). This also means that as soon as the version number changes, the release number should be reset to 1. I wrote the following tool, which uses the Lock</code> class above, to keep track of all the different releases that have been built so far, based on the package name and version number: import argparse, json from lock import Lock from os.path import expanduser, join class RPMReleases(object): def __init__(self): self._path = join(expanduser('~'), 'iv-rpm-releases') self._releases = {} def __enter__(self): self.load() return self def __exit__(self, _, __, ___): self.dump() def load(self): try: with open(self._path, 'r') as f: self._releases = json.load(f) except IOError: pass def dump(self): with open(self._path, 'w+') as f: json.dump(self._releases, f) def get_next_release(self, package, version, increment = True): if package not in self._releases: self._releases[package] = {} if version not in self._releases[package]: self._releases[package][version] = 0 if increment: self._releases[package][version] += 1 return self._releases[package][version] def set_release(self, package, version, release): if package not in self._releases: self._releases[package] = {} self._releases[package][version] = release if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument("package", help = "The software package for which you want a release number") parser.add_argument("version", help = "The version of the package for which you want a release number") parser.add_argument("--current", action = "store_true", help = "Don't increment any counters, just print the current value") parser.add_argument("--full", action = "store_true", help = "Print the full package name") args = parser.parse_args() with Lock('iv-rpm-releases'): with RPMReleases() as releases: inc = not args.current release = releases.get_next_release(args.package, args.version, increment = inc) if not args.full: print release else: print '%s-%s-%s' % (args.package, args.version, release)</code></pre>How to use it</h2> The tool is used as follows: $ python rpm-release-number.py -h usage: rpm-release-number.py [-h] [--current] [--full] package version positional arguments: package The software package for which you want a release number version The version of the package for which you want a release number optional arguments: -h, --help show this help message and exit --current Don't increment any counters, just print the current value --full Print the full package name</code></pre> For example: $ python rpm-release-number.py foo 1.1 1 $ python rpm-release-number.py foo 1.1 2 $ python rpm-release-number.py foo 1.1 3 $ python rpm-release-number.py foo 1.1 --current 3 $ python rpm-release-number.py foo 1.1 --current 3 $ python rpm-release-number.py foo 1.1 --current --full foo-1.1-3</code></pre> So, there we have it. A quick tool that keeps track of what release every package is supposed to have, and stores it in an easy-to-maintain location (a JSON file in the user’s home directory). This tool is easily usable in Jenkins scripts, but that’ll be for a different blog entry. Routing YouTube traffic through a server 2013-10-17T00:00:00+00:00 My ISP, Free, is in a bit of a conflict with Google, on a number of subjects. Advertising, bandwidth prices, the list is fairly long. If this were a purely commercial war, end-users wouldn’t be hit. But, neither Google nor Free wanting to back down, it stopped being a purely commercial war, and for the past year or so, the pipe connecting Free users to YouTube’s servers has shrunk to become tiny. I don’t mind, I think Free</a> is an excellent ISP, and even though I could switch to another ISP and bypass these issues, their stance on protecting my rights and privacy is unequalled. I value my privacy and their company more than I value my YouTube bandwidth. I own a couple of dedicated servers with unlimited bandwidth (courtesy of OVH</a>), so I decided to try and use one of those as a proxy to YouTube. Here are the things you’ll need: A DNS server on your local network (I’ll be using dnsmasq</code> on my raspberrypi).</li> A server with squid3 on it.</li> </ul> My router is a Freebox Revolution, and by default the DHCP will give the router’s IP as DNS server. I changed the primary DNS to point to my raspberrypi, and kept the freebox’s IP as a secondary DNS, as backup, in case the raspberry is down. On the raspberrypi, install dnsmasq: sudo apt-get install dnsmasq</code></pre> Next, configure dnsmasq to hijack all YouTube related traffic to your server: server="123.123.123.123" echo "address=/youtube.com/$server" | sudo tee -a /etc/dnsmasq.conf</code></pre> On my server, I already host quite a few websites, so port 80 is already assigned to lighttpd</code>. I could use iptables</code> to send the traffic from my home network to squid</code> (on port 3128), but then I couldn’t access sites hosted by lighty. Instead, I opted to use lighty as a reverse proxy onto squid, and added the following rule to /etc/lighttpd/lighttpd.conf</code>: else $HTTP["host"] =~ "youtube.com$" { $HTTP["remoteip"] == "88.88.88.88" { proxy.server = ("" => (( "host" => "127.0.0.1", "port" => 3128 )) ) } }</code></pre> Also, don’t forget to add mod_proxy</code> to the server.modules</code> directive. Now, install squid: sudo apt-get install squid3</code></pre> Lastly, /etc/squid3/squid.conf</code> needs a couple of lines for everything to work properly: http_access allow localhost http_port 127.0.0.1:3128 transparent vhost allow-direct</code></pre> And that’s it! Now, obviously, this completely and utterly breaks every SSL aspect on YouTube, but I don’t care about those. Another side-effect is that when logging-in to another Google service such as GMail, one of the redirects that happens during the login process will fail. I imagine this is Google ensuring all the cookies are set properly. The workaround to this is to simply refresh the page you were trying to get at initially; the cookies will have been set, and you will be logged in.

User configuration</h2>
I haven’t documented or stored all of this to my dotfiles repositories yet. Come back later? :)</p>

Installed ports</h2>
Following is a list of packages that I usually install pretty quickly after setting up a new system:</p>

Technically Personal - tech

What Lemm.ee's shutdown means (and doesn't) for the Fediverse

Rust and WASM for form validation

Email notifications with Migadu on iOS

Getting started with Scala on macOS in 2025

Switching to a split keyboard

Freebox automatic ruTorrent download

My FreeBSD setup

Building GCC

Fedora 22 WiFi problems

Fedora 21 VPN problems

Hash anagram challenge, part 2

Hash anagram challenge, part 1

RPM versioning with Jenkins

Routing YouTube traffic through a server

Technically Personal - tech

What Lemm.ee's shutdown means (and doesn't) for the Fediverse

Rust and WASM for form validation

Stack</h2> This post is being written in early-to-mid 2025. And the stack I currently jive with is as follows:</p>

Project structure</h2> Let’s create a directory structure that allows this whole setup to work. One typical approach for this is to have separate crates for the server part, and the actual wasm component. Something like this:</p>

Server side implementation</h2> Let’s add a few libraries to our server’s Cargo.toml</code>:</p>

Email notifications with Migadu on iOS

Getting started with Scala on macOS in 2025

Switching to a split keyboard

Freebox automatic ruTorrent download

My FreeBSD setup

User configuration</h2> I haven’t documented or stored all of this to my dotfiles repositories yet. Come back later? :)</p>

Installed ports</h2> Following is a list of packages that I usually install pretty quickly after setting up a new system:</p>

Building GCC

Fedora 22 WiFi problems

Fedora 21 VPN problems

Hash anagram challenge, part 2

Hash anagram challenge, part 1

RPM versioning with Jenkins

Routing YouTube traffic through a server

User configuration</h2>
I haven’t documented or stored all of this to my dotfiles repositories yet. Come back later? :)</p>

Installed ports</h2>
Following is a list of packages that I usually install pretty quickly after setting up a new system:</p>