Android Dev

What We Learned ~ One Semester Later

2010-06-03T22:42:00.002-04:00

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

2010-04-20T12:33:00.002-04:00

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

2010-03-26T15:52:00.003-04:00

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

Command Line Interface

2010-03-18T21:24:00.002-04:00

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

2010-03-16T08:48:00.003-04:00

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

2010-03-02T11:22:00.002-05:00

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.

2010-02-23T16:22:00.002-05:00

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.

Small Updates

2010-02-15T14:31:00.000-05:00

We had a group meeting and determined that mobile web development makes more sense for the textbook and carpool applications from a user base standpoint, but a native android app is better suited for the academic toolkit. We reviewed the code left from a previous project and determined that we'll be able to modify the class to what we want, but we're not going to use the gui because it doesn't suit our needs. The current setup of the old file uses the object 'String Tokenizer' which has since been deprecated. We're going to use ArrayList to store the percentage data for each quiz or test instead of breaking apart strings. We also added a quiz method in addition to the homework, test and other methods since quizzes are common in the majority of courses. Our next steps involve converting usage to ArrayList and then writing a basic main for testing.

From SVN to Git

2010-02-14T15:01:00.000-05:00

We decided that since the documentation for github was much better than that for subversion and would allow us get our project going faster we'd make the switch. Our projected is now hosted on github along with a piece of code from one of last semesters RCOS projects that has the beginnings of a java class we'll be able to modify to our needs.

General Information

2010-02-10T22:11:00.000-05:00

We're creating an RCOS android development group that will develop
several applications for google's gnu/linux based mobile platform.
We've chosen android because it closely aligns itself with the open
source community and is relatively new allowing better market
penetration for our applications.

Currently we have three ideas:
1. An 'Academic Toolkit' that will provide the following...
-Grade tracking for multiple classes.
-Computes average based on guidelines set by professors.
-Updates average when new grades are added.
-Provides user with graphs showing averages for different
assignment types, as well as current average throughout the semester.
-Ability to compute GPA for current semester.
-Alert students when their average falls below a predetermined
amount.
-Computes grade needed on certain assignments for user to maintain
their current letter grade, or improve it.
2. A college text book selling/buying application that eliminates the
middleman.
3. A college car pool application to help students find rides within
their university.

We're going to start with the Academic Toolkit application because
it's lack of network features will make it easier for us to learn the
characteristics of android and get an application to market.

Goals
Our group is large (7 people), our plan is to create a part of RCOS
that is fluent with android development so in the future we'll be able
to teach android development to new members without them having to
read through all of the documentation and slowly figure out how it's
done.
We want to have an application on the android market in 5 weeks.
While the first app is on the market we will begin work on the second
without abandoning the first, we plan to continue adding features and
improving the applications from user comments and reviews.
Google may also be having another developer competition and we will
submit our applications (this will be nice for RCOS if we become
featured from the competition).

The first will be the most difficult because we'll be learning a lot
about the android operating system and how to develop for it, once
we've accomplished this we think we'll be able to develop more complex
applications more efficiently.

Code:http://github.com/alberz/Academic-Toolkit
Presentation: http://docs.google.com/present/edit?id=0AZtVQthUOVqsZGduOXJoNXhfNHh4bTVzYmdw&hl=en

Hello World

2010-02-07T12:40:00.000-05:00

Thank you Sean O'Sullivan for supporting the Renssealer Center for Open Source Software.