Upon undertaking the project that is iteration 1, I have discovered ways of doing things that work very well. I have also discovered things that do not work so well. First of all, it is always challenging to work and coordinate with another person. SVN was one thing that greatly helped in our team coordination. I have worked on teams that didn't use SVN before, and it sometimes got to be a mess. We would have to consistently send emails back and forth. In addition, we had troubles with merging our work together. SVN made it easy to transfer and merge our work together. Having some kind of repository is a must when working on any kind of group projects.
Also, we had great success when we broke up our code into small chunks that are easily handleable. More specifically, our code became more readable when we used small functions for certain sections of code. We put functions inside of function, which enabled us to see complex functions by looking at fewer lines of code, adding layers to the abstraction of the code. When we didn't create functions for sections of code, we had to spend a lot of time looking at the code to see where we had to change. Also, it was harder to test without the small functions. With these functions we could simply fix a bug in one function without having to worry about breaking the whole code.
It also helped us greatly to add comments as much as possible. We had problems with remembering what we were doing in certain chunks of code. Whenever we had comments, we able to quickly identify what the code was doing and were able to quickly assess what needed to be changed or added to fix the bug.
One thing we had trouble with, and was problematic, was scheduling time to work on the project together. When we worked on the project separately, we had to spend extra time explaining what we did and how we implemented it. If we would've spent more time working together, we would have spent less time explaining. We also had problems with head-butting code. This was when we would create implementations that did the same thing in different manners.
Additionally, lack of planning caused problems. When we mapped out exactly how we were to make the program, we had less problems. It was funny because we would have to end up planning out our code either way. This was because if we failed, we would end up getting so frustrated that we would just go back to the drawing board and plan it out anyways.
Procrastination was a major factor in the success, or lack thereof, of our program. Being diligent definitely would have helped. We could've done a better job at scheduling many small increments of time to work on the project. In the future we will have to do a better job at working on the project early.
Lastly, we needed to do a better job of assessing the goals of the project. We had to go through the rubric and the assignment page many times. This could have been prevented if we just would have had a clear outline of what we had to do before we started working on too much of the project.