Tech Blog Menu

Tech Blog

Coveo Blitz 2017

By

7th edition

After months of preparation, the seventh edition of Coveo Blitz was held on January 7th 2017. As was the case in the last few years, the contest was held in our Quebec City office. Participants like to see our offices and the work environment we offer - oh, and here’s a scoop: next year, it will be held in our brand new offices!

A total of 58 students from 6 universities and colleges participated this year. We opened the registration on October 18th and all the available places (15 teams of 4) were filled by November 3rd.

The Coveo Team

Again this year, a lot of people from Coveo participated to the event and I want to personally thank them for their involvement. I’m always amazed by people’s commitment to make this event better each year!

One interesting thing about this year’s contest is that participants from the very first Coveo Blitz held in 2011 were hired in 2016 and worked on the creation of this year’s challenge. Since the main goal of Coveo Blitz is to spread the word on Coveo and hire emerging talents, it’s great to see it’s working and people want to participate in the preparation of the contest.

The Challenge

Designing the challenge is never an easy task. We want something hard enough so the participants have to really work for it, and we can identify the ones that stand out of the pack - remember, hiring is the goal ;). At the same time, we don’t want this to be too challenging as this leads to an unrewarding experience for both the participants and the Coveo staff who worked on the challenge.

The 2016 edition was based on Vindinium, an AI contest platform, and was a huge success. We modified the original contest so that the costs were different and also added spike tiles that caused damage to heroes. This was enough to change the game and add complexity to the bots in the first edition.

We decided to reuse the same platform, but wanted to change the challenge enough to prevent people from recycling the algorithms or components from last year. The main reason for keeping the same basic challenge is cost; creating a contest like Coveo Blitz is a big investment and starting something new each year is a lot of work.

After hours (or was it days?) of throwing ideas, the team proposed to create a restaurant with burgers, fries, and customers. Each customer would have an order and the bot would need to gather the requested number of fries and burgers, and deliver them to the customer to make points. We also kept the concept of spike from last year, but changed it to utensils to be in line with the theme.

One thing that was challenging for participants in 2016 was the pathfinding algorithm. Several teams did not manage to have a proper pathfinding function by the end of the 8 hours last year. This year, we decided to create a pathfinding service that would help participants to quickly have a functional bot. However, the service was limited in several ways. For example, it did not consider the utensils or the other bots and it only returned the direction to go to, not the complete path.

Since we wanted the participants to use a service that behaves as in real life (yes, I mean a service containing bugs), we also introduced a little challenge in the pathfinding function. That is, random errors. The code looked like this:

/*
* Level 1 -> 5% of request error, 20% sleep for 150ms, 15% sleep for 300ms
* 
* Level 2 -> Level 1 + 10% of request sleep for 500ms, 5% of request sleep
* for 800ms + 3% increased error rate
* 
* Level 3 -> Level 1 + level 2 + 3% of request sleep for 1000ms + 3%
* increased error rate
*/

private void makeTheContestantsSuffer() {
    int i = (int) (Math.random() * 100);
    if (i < 5 && sufferingLevel >= 1) {
        boom();
    } else if (i >= 5 && i < 25 && sufferingLevel >= 1) {
        sleepNoThrow(150);
    } else if (i >= 25 && i < 40 && sufferingLevel >= 1) {
        sleepNoThrow(300);
    } else if (i >= 40 && i < 50 && sufferingLevel >= 2) {
        sleepNoThrow(500);
    } else if (i >= 50 && i < 55 && sufferingLevel >= 2) {
        sleepNoThrow(800);
    } else if (i >= 55 && i < 58 && sufferingLevel >= 2) {
        boom();
    } else if (i >= 58 && i < 61 && sufferingLevel >= 3) {
        // This might be too much of a dick move
        sleepNoThrow(1000);
    } else if (i >= 61 && i < 64 && sufferingLevel >= 3) {
        boom();
    } else {
        LOGGER.info("Lucky contestant, nothing happened...");
    }
}

We told the participants that there was a bug in the service and we were working hard to find it. With every fix we made, we actually increased the suffering level up to a point where we told the participants that we had finally found the bug in the function and had fixed it! The idea here was to give the teams a head start early in the day while they coded a better algorithm. As it turned out, several teams still used our service in the final rounds so we removed the suffering level after round 3.

Getting ready for D-Day

As always, there is a Blitz rush starting a bit before Christmas up until the last minute before the contest. Everyone puts the final touches for D-Day: order food and drinks, setup the contest area, install the projectors, speakers, and of course, finalize the code for the contest.

Each year, we gather volunteers to actually test the contest. This year, I decided to work with a team to create a bot and test it. Well, if you know me, you know I miss coding, so that was a little treat to actually do this!

Several employees created their bot and made them fight against each other to fine tune the rules we put in place. We also made sure the system could sustain several games going on at once by running performance tests.

These steps are important to ensure that everything works fine the day of the contest and we don’t get Coveo’s Grumpy Cat (sorry Guillaume ;)) during the event. This is where we decided to change the way customers were creating the orders. At first, it was all random, so each customer had potentially different order which could favor a bot over another based on their starting location. We changed it so that all customers would have an identical list of orders to be executed.

Even though this is the 7th edition, it seems that the rush is inevitable. At the same time, it comes with the adrenaline that, I think, we look forward to each year.

D-Day

This year, on top of the 15 teams, 2 Coveo teams also took part in the contest. They could not participate in the finals and, of course, could not win the prize. This is something we’ve done almost every year and Coveo people are looking forward to participate.

What was interesting this year is that most teams were able to have a bot that did something. Not just something random; they took logical decisions based on the information on the map. This led to interesting matches, but less fighting than last year because of the new concept (filling customer order). We managed to have the right level of difficulty; teams were able to actually accomplish something, but had to work hard to get a really good bot.

The presentation of the contest, early in the morning The presentation of the contest, early in the morning

Screenshot of the final match Screenshot of the final match

The winners and their prize The winners and their prize

Lesson learned

One thing we learned this year is to make sure the services we provide either have a constant output during the day, or that contestants know they might not get the same result each time they use them. Our idea of making the contestants suffer with the pathfinding service, that we initially thought would be funny, was, in hindsight, not as good as we thought it would be.

If we want to do something like that again, we’re going to make sure to let the contestants know the service may fail during the day. This way, they will know that writing their own service is the way to go. Or, like someone from Coveo did, start 10 threads to call the service to try to dodge the imposed suffering level.

Some tricks for next year

Again, I want to give advice I gave to participants so they get the most out of Coveo Blitz next year. These are similar tips I gave in a previous post.

Be prepared

Every year, we see the difference between the teams who spent time to prepare for the contest compared to the ones who did not. The ones who prepared already have the tools they want to use installed on their computer and pretty much know the role of each person on the team. On the other hand, some teams decide what language they will use the day of the contest! That makes a big difference when you have limited time to complete the challenge. You’ll have a lot more fun if you are prepared, trust me!

Set small, incremental goals during the day

This is crucial to achieving results. Use git (or whatever) to track modifications to the code. Use tags so that you can easily revert to working code. Get something basic working and take a snapshot (save the executable, tag in git, ). Improve from that point. For example, have a random bot working, then add intelligence to it.

Split the work and sync with your team

You’re a team and you need to sync often; make sure you’re all working in the same direction. One thing that seems to give good results here is to split the work and do pair programming.

Automate your builds and deployments

For Coveo Blitz, we leverage AWS for the contest. Participants code on their laptops and then have to deploy the code on AWS to run it. I highly suggest the deployment steps are automated so that you can deploy fast and revert fast in case the previous version was better than the new one - like this will happen. ;)

Wrap up

The 2017 edition was great and we look forward to next year’s edition in our brand new office! I hope to see you then!

One last note… I started a tradition a couple of years ago when I actually jumped and let the winners catch me (don’t try this at home, I’m a trained professional!). So, here’s the picture of this for 2017!