What We Learned ~ One Semester Later

There's a relatively steep learning curve when trying to organize and coordinate a project and while our first semester has come to an end and our initial ambitious goals have not been realized we did take away a lot of information.

1. Large groups may initially appear to be more productive since you have more minds tackling the same problem, however, with more people the communication and organization necessary increases drastically. It takes a lot of time just to get everyone up to date, most of your time ends up getting lost in this communication. It can also be challenging to break up the work in a way where everyone can be productive. Smaller groups (2-3) are more effective.

2. New to group coding projects means new to source code management. While this seems to often be ignored by people who have been involved in projects for a while, choosing the best SCM (git) and getting everyone in the group up to speed in learning how to use it is not as trivial as many make it seem. Even advanced users often don't use branching to its full potential or have other troubles as well. SCM takes some getting used to as well since up to this point we'd never come into contact with anything like it.

3. Our project required us to learn a new language (java), while languages can be picked up relatively quickly it does slow down initial development especially when combined with the large group size.

4. We looked into reusing old code from a previous project, but unfortunately there was nothing of use to us there. It's typically better to expand on code then start from scratch if you can help it, no reason to reinvent the wheel especially when working on free software projects.

Overall we learned a great deal about how large group coding/research projects work and the basics of group software development. We also nearly finished a desktop version of the application we set out to complete and now have a good handle on java and git. Our participation in RCOS also allowed us to see many other exciting, complex and successful free software projects also being worked on that got us excited about our future participation and while we sensed some hostility towards our group from a few members, many were very helpful and expressed interest in seeing us succeed.

Thank you Professor Moorthy for a great semester!

Saving/Loading

We need to implement a way to export the data entered by a user to a file type the program can later load the information from. There is also the idea for the program to generate a nice looking graphic of the student's information.

Graphical User Interface

We have begun work on our GUI. Here are some initial screen shots.

Command Line Interface

As stated in an earlier blog, we have decided to partition our group to look at three different scenarios at once.

To update on the command line interface: Work has begun and is progressing rapidly. Thus far, we have taken advantage of the grade logic and have created an interface that uses most of the existing methods. Most of the focus at the moment is on completing functionality and creating a way for data to be stored. A viable time frame for this to occur is in the next 7-10 days.

Multiple Directions

Since we have the advantage of a large group and have reached the point where most of the grade logic is done we may divide into smaller groups for the next step. The original goal for the android app is one direction we want to take the current code and one smaller group can work on that, another smaller group can make a command line interface for pc users and a third group can work on a desktop gui. This way we'll reach people who may not necessarily have an android phone and it'll be easier for everyone in the group to participate.

Important Methods Added, Code Properly Commented

There has been a lot of functionality added to the grader lately, including editing grades, removing courses, calculating averages and more. All of the basic logic necessary for a grade tracker should be in place now, and what follows will be improved error checking, and a gui. The code has also been commented with proper javadoc comments, so that others will be able to understand the code more easily.

Branching and deciding code layout.

We're learning how to use git to our advantage and have made several branches to work on new ideas. Looking at the code from last semester we decided to take a more object orientated approach. Rather than having one object with many methods which is common c++ code, we're going to have every piece be it's own object and extend the primary class as necessary. We're going to get the logic done and have a working command line version so that all that's left is adapting the code to android.