CS360: Othello Program Partner Evaluation

My contribution to the success of our team was virtually nil. This is not, however, entirely an issue of laziness on my part. There was a bad decision made relatively early in the process where Morgan divided the responsibilities in a particular way and I didn't properly consider the ramifications before agreeing to them.

Specifically, the program was divided into the search code (a translation of the PVS search algorithm into LISP) and the board evaluation (a more creative process whose success is highly dependent on the efficiency of the implementation).

Morgan wrote a version of the search code that worked passably as I was researching Othello boards and LISP. During the time period that I was working on my evaluation implementation he also implemented a board evaluation function that was significantly more complex than mine. He did so without consulting with me and I only learned about it when he checked it into the source repository. Since his evaluation function was more complex and more effective, it was his that was used in the competition.

This is where a difference in values on mine and Morgan's part was a crucial issue. I made the distinct decision to limit the complexity of my evaluation function and focus on understanding the metaphor of LISP. This decision was based out of an analysis of what exactly a win in the competition would mean:

• The winner defeats his classmates in direct competition. This is one of the reasons I think the Othello program is a good choice for senior undergraduate students. They have generally formed a peer group and invested part of their identity in their relative prowess within the group. The Othello program competition can give a sense of meaning to their activities that might otherwise be lacking.
• The winner understands the game of Othello better than the other teams.
• The winner is better able to translate their understanding of Othello into an algorithm better than the other teams.
• The winner is able to write more concise LISP code than the other teams. Particularly in a domain like this where the evaluation function is called thousands of times, the efficiency is paramount.

The main difference, I think, between Morgan and I, was the influence of the first point. I don't know anyone in this program and so far as my identity as a programmer, I draw that from having been doing it professionally for several years now rather than being able to beat random grad students. This is particularly true because of the LISP requirement. I speak some French. If you asked me to write a position paper on the influence of religiosity on cognitive development in French, it would probably be nearly incomprehensible. This does not mean that I do not understand the topic or that I am unintelligent. It means I don't speak French well. Likewise, if someone with LISP experience could not write a better program than me it would be an indictment of their skills — I already know that I'm not a LISP programmer.

There was also an issue on the Othello front. I will leave this class have learned a variety of new things. Given that I have a limited amount of time and mental capacity, the choice to learn one thing in depth is an active decision to not learn another. Leaving this class with an in-depth understanding of Othello and its nuances was not of interest to me. I would much prefer to devote that time to understanding the homework or the literature survey which actually develop my understanding of the field of AI.

I actively chose to attempt a relatively simple evaluation metric and focused on expressing the concept using LISP's metaphors. LISP, as a language, has a following that is notorious for claiming to understand something escoteric that other programmers simply don't comprehend. I figured that of the useful things I might gain from this class, perhaps one could be a beginning understanding of LISP.

I would say I devoted 3-4 hours to reading Othello books to pick stability as a minimum reasonable criteria for an evaluation function. I then spent an additional 10-15 hours reading LISP books and attempting to not simply write C using LISP syntax. Specifically I focused quite a bit on list comprehensions and recursion (which are patterns I've used in more pure functional languages).

Ultimately this work had no effect on our program because Morgan implemented a more complex algorithm.

There were obvious communication issues. I still don't really know why Morgan implemented the evaluation function. I assume that he was frustrated with my progress. I had a timetable laid out, but hadn't communicated it to him and I'm assuming he had a different one and didn't communicate it to me.