Usually the one(s) I’m working on right at the moment.
But if I were to look back and decide which ones I still remember enjoying, a few come to mind.
For my day job, I’ve written two different (more or less) ORMs in my career. (For two different companies and in two different languages.) Pretty interesting stuff, that. The kind of project that you can sink your teeth into.
Neither one was a “I think I’ll write an ORM” kind of situation. They were more like “oh, given these requirements, I think probably I’ll need something that will work like X, Y, Z… oh, that’s an ORM. Ok then, let’s do this.”
Side-projects-wise, most of the side projects I’d talk about are here. (Yes, AntiMS is me even though different username.) “hydrogen_proxy” got way less fun when I got stuck for like a year on how to make HTTPS work. But aside from that it was a lot of fun to work on. “codecomic” is quite interesting to work on as well.
And the project I’ve been working on most recently is a very configurable framework written in a combination of Go and OpenSCAD for creating bespoke, 3d-printable mechanical keyboards including keycaps.
Here’s a preview of kindof roughly where I am with that mechanical keyboard project at the moment:
Lol! Yes! I’d never made the connection, but yes “AntiMS” was a name I chose originally to mean “anti-Microsoft.” And I used Github until the day I heard that Microsoft was buying Github. (Actually, my Github is still out there. I just force-pushed to overwrite all the history of all my Github repos with a single readme file that says “I moved to Gitlab.”)
I started using that username back before I realized all corporations were evil. I thought it was just Microsoft back then. Simpler times.
I like the basic premise of GoVTT, that you trust the players to not cheat. I’ve got a project on the back burner to allow people to play online games the same way they play in person: rules are agreed upon and enforced collectively instead of imposed and enforced programmatically. I figure to start with ordinary playing cards, then build up from there.
I built a ruobo workbench for hand tool and other general woodworking tasks. Was made with all mortise and tenon joints and no fasteners, so I got to learn and practice lots of techniques (hand saw and chisel cuts, router flattening, lamination, etc).
Work related project was a library for curves representation (polynomial, bezier, and a lot of other types) in C++. I liked working on it for several reasons. First one is that I could finally start something from scratch after years of working on legacy code. No dependency on strange old library from the team, only mainstream libraries.
But mostly it was because I learned a lot on this project. I had to mix template programming, heavy use of polymorphism, python bindings of the c++ and serialization together. I had experience in all of this stuff already, but mixing everything together bring a lot of new troubles and you have to understand how it works more in deep to be able to solve them.
I’m not making “famous” open source package with thousands of download and used everywhere, but seeing this package still in use in several other projects (and not only in my initial team) even after I left the initial team feels good. One day someone from my new company recommended to use “my” library as dependency to solve one of our problem, without knowing that I was the author, saying that it was a good well written lib. That’s a nice ego boost!
Automatic differentiation in C++17, had to do it from scratch as they weren’t open to 3rd-party libraries and it had to integrate with many symbolic calculations that are also done in the library (so even if you used a 3rd-party library you’d still have to rewrite parts of it to deal with the symbolic stuff). Succeeded in doing it and basically the performance was on par with what people in the industry would expect (all derivatives at once in around 3 times the evaluation time, sometimes much less if the calculation code has no dynamic parts and is differentiated entirely at compile-time).
It was pretty cool because it was a fun opportunity to really abuse template meta-programming and especially expression templates (you’re basically sort of building expression trees at compile-time), compile-time lazy evaluation, static polymorphism and lots of SFINAE dark magic and play around with custom memory allocators.
Then you get scolded by the CI guys because your template nightmare makes the build times 3x slower, so the project then also becomes an occasion to try out a bunch of tricks to speed up compilation.
That’s insane. You’re basically talking about a custom implementation of pytorch autograd right? How long did it take?
Roughly one year. No GPU code however for that project as the target library is CPU-only anyway so not really comparable to PyTorch (and PyTorch is more than just the autodiff), but there was lots of SIMD vectorization. Yeah you could train a neural network on CPU with it if you want, and the expression template stuff I talked about would be somewhat equivalent to PyTorch’s operator fusion, but the target use is more quant finance code.
My favorite was this project because it really shouldn’t be possible, it requires some unusual problem solving (kinda like code golf), but the best part is seeing people’s horrified expression when they realize
- The monstrosity works
- There’s no real alternative
(I’m working on a video that explains it, but until then the readme and stack overflow post will have to do.)
