About Me

Name’s Vadim Borodin. I’m a professional programmer and software enthusiast currently based in Seattle, WA. I’ve been programming since 2008, working mostly for startup companies. In 2015 I’ve accepted a position at Microsoft to work on Bing geocoding services. Before that I’ve mostly been doing web programming and system integration stuff on a daily basis but on my spare time I’ve been exploring other areas (like game development), learning different programming languages and experimenting with modern (and old-school) technologies. Below is a list of some interesting things I worked on over the years.

Contact me via email, follow me on github and twitter or check out my writings on this site. My professional profile is available on linkedin.

As a Microsoft employee I need to say that all opinions, comments etc on this site are my own and I do not speak on behalf of my employer.

Archive: Neural Network from Scratch in Rust

I wanted to retry getting into Rust for a while since it’s 1.0. I also wanted to obtain some hands-on experience with neural networks. So I joined-in with @lennytmp and later @freevoid to build a neural net from scratch (e.g. no dependencies) in Rust. We ended up with some dependencies (e.g. serde) at some point, but actual NN stuff was very fun to implement from the ground up. It learns MNIST dataset pretty well and we also attempted to make it learn how to play Snake video game just from looking at map data. That didn’t go that well, but was a lot of fun.

Rust programming language turned out to be very easy to use once you overcame initial frustration with borrow checker. We used a bit of unsafe code e.g. to speed up matrix multiplications and to implement some graph operations (borrows are not the easiest thing to work with when you have graphs). We also used more advanced concepts from the standard library like channels, Arc and Mutex to distribute processing across CPUs. Again after some initial frustration when you don’t know what you are doing they become a blast to integrate with the rest of the code. I am definitely using Rust for my next project :D

Demo: Tankoids — a Real-time Multiplayer Artillery Game in Go+JS

In late 2016 me and @lennytmp had an idea to make what’s basically a real-time multiplayer Worms-clone where each player controls one worm. I was also looking for an opportunity to play with Go language so we used Go for server and JS for client (usual suspects: websockets, canvas etc). The game in it’s simplest form is complete (which is not usual for us, took about a month lazy pair-programming some evenings), you can try it here. We were going to continue building on top of it and even asked for feedback from actual indie gamedevs on TIGSource forums (haven’t gotten any :P). We also tried buying some Google ads to play with real people and see if they get it. It is quite fun and maybe we’ll get back to it on some point. Please let me know if you have any suggestions.

Archive: Handmade Language

In early 2016 I built a (toy) programming language compiler on top of LLVM. I called it Handmade Language as a tribute to the Casey Muratori’s show and because I didn’t want the language to have any runtime at all or talk to the operating system directly. You can’t even build an exectutable in this, you have to write a “platform layer” in C which will call into the language and provide function pointers to talk back if needed. The end-goal was to make it possible to rewrite Handmade Hero game part in it, but that’s of course a bit too ambitious for a first-time compiler author.

By itself hmlang is quite complete — it is a medium-rare programming language like C with user-defined data structures, nested function definitions, local structs, type inference, function overloading and a lot more. I started to work on compile-time code execution, but that was about time to leave it as abandonware as I normally do. Learned a lot though :)

Archive: LLVM IR Hello World for OS X

While I was playing with LLVM I ended up with three ways to integrate with OS: using C standard library, using my own library written in assembly or using my own library implemented in LLVM Language itself. Only the first option is more or less documented on the web so I made a github project demonstrating all the approaches I know. If you are also hacking LLVM please take a look and email me with your thoughts. I have a plan to extend this project to Linux and Windows in the future so pull-request me if you are using this platforms.

Archive: Handmade Hero Platform Layer Implementation for OS X

Handmade Hero is a very interesting project by Casey Muratori where he is creating a complete, professional-quality game entirely from scratch: no libraries, no engine etc. Project is accompanied by videos that explain every single line of source code. I am very excited and enthusiastic about this project and following along in my spare time on OS X platform. I’ve even made a pretty decent OS X platform layer by myself and very proud of it =). Check out the source code here and if you are interested in things like Cocoa, Core Audio, IOKit and such it would be nice to have a code review =). Since then I didn’t have time to follow Handmade Hero anymore since I joined Microsoft and had to spend it learning completely different things (at that period mostly big-data stuff).

Archive: Building a Multiplayer Game with Node.js and Node-webkit

An (unfinished) series of articles where I am describing a process of creating a desktop multiplayer game in Node.js using node-webkit, WebGL, Web Audio API and UDP. The source code of the game is available here. Most of technology specific things are outdated now, but I believe some ideas are still valid.

List of articles:

  • Toolset
    Where we are setting up node-webkit and implementing a “low-level” platform layer (basically just convenient access from Node.js to DOM, sound, WebGL etc).
  • Tiles and Sprites
    Where we are thinking about game coordinate system, tiles and sprites rendering implementation and such.
  • Networking in General
    Where I am talking about ways to make our game multiplayer, implementing a game server and client/server messaging protocol.
  • Next part will be about actual game-specific networking and I am still in the process of writing it =)