I've been really diving into my C++ recently. I haven't done too much of it, starting off in the Java world, and then moving onto lots of Python development. But so far, I've been enjoying myself quite a bit, mostly because of my Distributed Systems course at SFU. We are currently working on a robot simulation across multiple computers, simulating 1,000,000 robots pucking up 1,000,000 pucks.

Its been a challenge, not only from a programming perspective, but much more so from a Software Engineering perspective. Richard Vaughan, the professor, decided to have teams of 10 people, meaning that not only do you solve a distributed system over a network of computers, but you also solve it across a team of individuals. The interesting thing about starting with 10 people is how to appropriately divvy up the work amongst ourselves (other groups solutions - let one guy beast out the entire thing, not cool! They skipped out on half the fun). Usually in a project or startup, you would start with two people working passionatly on a project, and highering more and more people comes out of necessity, where as starting a project with a group of 10 people can get extremely hecktick. Especially when more then half the group are some pretty close friends. We have had some big problems along the way - heads butting for architectural decisions, people not pulling there weight, bad communication, etc. But there is a lot to learn out of a project like this, and I won't talk about those things right now because it's 3:20am and I'm tired, but I will definitely have a post mortem on this project. Going good right now though, this last week is going to be intense!

Oh, and unordered_map in the STL is awesome. Previously, we were using the map datatype from the STL, for what we needed to do, we needed an insane amount of lookup, and because a lookup in a map is O(nlogn), things were slowing down big time. A certain function we had for doing bounding boxes was taking ~5 minutes, as we had to sort a list using insertion sort. The reason we used insertion sort is because while it is O(n^2) for the initial sort, it is ~O(n) for any sort with a list that is almost sorted, and because each time step of a robot resulted in positions that were not changed too much, insertion sort was perfect. We also had to maintain a hash for our objects mapping to the index of that object in our sorted array, which is why we needed O(1) access. I simply switched out std::map for std::unordered_map, and everything worked like a charm. Went from ~5 minutes on initial sort of 50,000 robots down to ~1.5 minutes for the initial sort using the unordered_map. Fun times :)