Atomic Games 2015 – Othello Challenge!

On October 24, we held our first Atomic Games — a one-day programming competition for college students. Many of Atomic’s employees are graduates of regional colleges and universities, and we believed the Atomic Games would be valuable for students by:

• Bringing students together from multiple schools and introducing them to the technology community.
• Having students work in Atomic’s office so they get a better idea of what a creative office environment is like.
• Challenging students with a more open-ended programming assignment than they likely get in their classes so they could get an idea of what professional work would be like.
• Pairing students with developers from Atomic so students could get perspective on the skills and experience they will gain in their professional careers.
• Opening up potential job opportunities through relationships built at the event.

Of course, it wasn’t just one-sided. The Atomic Games also helped Atomic:

• Get energized by living our teach and learn value mantra and connect with students who are passionate about programming.
• Hone our training and on-boarding approach based on our observations of the skills students are building in school.
• Directly connect us with students who might be interested in working at Atomic in the future.

How it Worked

The Atomic Games was open to college juniors or seniors pursuing a bachelor’s degree in computer science, computer engineering, or a related program.

Students competed as two-person teams to create a winning Othello implementation. Atomic created a broker application that provided a playing field for competing Othello artificial intelligence (AI) implementations. The broker could run two AIs against each other, or allow a user to play against an AI in an interactive mode.

Our broker application invokes an AI with command line arguments indicating the current state of the game board, the color the AI needs play as, and a time limit for returning a valid move. The AI needs to return a valid move as an exit code within the given time limit. The CLI between the broker and AIs allowed student to use their language of choice.

We paired Atomic developers with students to help coach students throughout the day on games rules, programming, and strategic approach.

Our general, recommended approach to students was to:

• Get the command line argument of the board state processed into a data structure you can use to detect valid moves.
• Create an algorithm to detect valid moves.
• Develop scoring heuristics for valid moves that help select the best valid move.
• Develop a look-ahead approach that helps inform the best, next move based on potential future plays from an opponent.

What We Noticed

It was interesting to observe what challenged some of the teams:

• Parsing command line input was tough for some teams. A few teams wrote custom code, while others took advantage of options parsing libraries.
• Some teams had difficulty understanding how our tooling and wrapper scripts were used. Our infrastructure used leiningen to invoke the broker app with two arguments for scripts wrapping AI implementations. Some teams struggled to figure out how their implementation would be invoked or where/how to set environment variables like Java’s CLASSPATH. A few teams had issues getting Java code to work from the command line as they were more familiar with working directly in and IDE.
• Many team relied on logging or printing to STDOUT to debug instead of building automated tests.
• Some teams struggled more than others to create a valid move detection algorithm.

I’m not completely surprised by the challenges teams encountered. I suspect most school assignments are more closed-ended, have few dependencies, and code is directly invokable in a more controlled environment.

I was impressed with several teams that:

• Wrote a significant amount of automated unit tests for valid move detection.
• Used whiteboard diagrams and tools like Excel to visualize game states and support algorithm design.
• Got beyond random, valid move selection and developed heuristics for selecting more valuable moves.
• Used languages like Python instead of Java or C#.

I was very impressed with the winning team of Daniel Harold and Tyler VanZanten (The Corduroys) from Calvin. Dan and Tyler were able to develop an AI that had valid move selection optimized for the move, resulting in the most of their pieces on the board. They created look-ahead logic to help them select the next move that would likely get them to the best board state several moves in the future.

Dan and Tyler also created a solution architecture that allowed them to keep a Java process running without incurring the JVM startup-time hit for every move invocation from the broker. By reducing startup time, Dan and Tyler were able to use more time for look-ahead logic.

The Tournament

At the end of the day, we held a single-elimination tournament. I could feel the excitement in the air and enjoyed watching the AIs play against each other.

We projected the broker-app’s board GUI so everyone could see the matches play out.

One of the best games was in the semi-finals where The Hoagies (Curt Brink and Eldon Hoolsema from GVSU) played The Corduroys. The Hoagies were playing as black and had developed advanced, move-selection heuristics that took corners and stable discs into account but didn’t have any look-ahead logic. The Corduroys didn’t have advanced, move-selection heuristics but developed look-ahead logic.

The match was captured via mobile-phone video and you can check it out below:

Atomic Games 2015 Grand Rapids – Hoagies vs. The Corduroys from Atomic Object on Vimeo.