CSCE-315: Programming Studio (Fall 2011)

Project 3:

Team configuration

This project is a team project, ideal team size is three. If the number of students is not divisible by three, we can have a few teams with size close to three. The team will be assigned by the TA based on the individual expertise demonstrated in project 1 and 2.

Project Goal

This project is meant to help familiarize you with:

  • test-driven development approaches
  • the use of XML for data interchange
  • mobile phone application development concepts
  • mobile phone application development tools
  • presenting your work to others

Project Outline

For this project, you will write a mobile phone application (Android) of your own design.

  • Research the Android app scene to find a niche (you can browse the Android Market on the web).
  • Design your own Android app.
  • The apps should utilize 5 or more of the following features (those marked with * are mandatory):
    1. graphical user interface (*)
    2. save/read data from the SD card memory (*)
    3. design and use custom XML schema (*)
    4. communication (*)
      fetch/send info from/to other apps or the internet; launch other apps; etc.
    5. generate messages on the status bar
    6. sound
    7. sensors
      compass, GPS, accelerometer, microphone, etc.

Note that this is a relatively open-ended assignment. Therefore, the first task your team should take on, after organizing the team itself and determining basics such as what features you will try to implement, and how to go about this. Keep your expectations reasonable, and make sure you have plans for what to do, both if you are able to add additional functionality, and if you need to remove functionality. There are a lot of "new" aspects to this project, so you should make sure to keep your expectations reasonable (but not too low).

Test-Based Development

For this project, you are to follow a test-driven development approach. You should use a framework that supports unit testing of the functions, classes, etc. you develop, and your development should be focused on a test-driven development approach. That is, you should:
  • First write a test for some functionality of the portion of code you are working on
  • Your existing software should, by definition, fail that test
  • You should write code to address that test
  • Once tests are passed, you should go back through your code and refactor

Following a TDD approach will take some getting used to. You will be required to check in not only your source code, but also all of the unit tests that you develop. There should also be some evidence of refactoring occurring throughout the process.

You will be required to report on specific examples of where you refactored portions of your code and where the testing system demonstrated usefulness. So, you should note such cases as you develop your code.

Unit testing frameworks are available for almost every language you will consider using, and often (like JUnit) are integrated well into the standard language. As your team decides on a language to use, you should also consider what unit testing framework you will use on the project.

Project Organization

You are not given any requirements about how you should organize your team. However, you are strongly encouraged to adopt aspects of the previous projects that worked well when deciding on your team's organizational approach. Time spent organizing and managing the project can be considered part of your work on the project. Your team should make this decision very early on, preferably before anything else, and needs to include this within the initial team report, described below.

Deadlines and Materials to Turn In

You will be required to give various interim reports and a final oral presentation of your team's project. These reports will be extremely important, in particular the final project report. Your team's accomplishments on this project will be judged in large part based on the final project presentation.

Initial Team Report

Wednesday, November 9, Thursday, November 10, 11:59 p.m.

You are to turn in an initial team organizational statement and project plan. Specifically, you should include the following information:

  • A summary of the application your team plans to build, including a list of major and minor features.
  • A brief statement on how you settled on the proposed app, and how you used the Android Market to identify the niche.
  • The unit testing framework your team will be using
  • A list of packages will you be using from the Android SDK. This list should reflect your app features.
  • A statement describing how your team will be organized, including who will be responsible for each portion of the development.

Progress Report (one per team)

Saturday, November 19, 11:59 p.m.

By this point, you should have a system with significant functionality. On this date, please submit a short (no more than 1 page) report giving an update on team progress. Please highlight any difficulties you have encountered and whether or not you have made changes to your planned program as a result.

Also, give a separate brief (no more than one page) report on experience with the test-driven development approach. That is, you should discuss instances that might not be obvious where you followed key TDD concepts such as refactoring. (Note: this can be combined with the earlier part into a two page report).

Final Team Project

Due Thursday, December 1, 11:59pm. This is a hard deadline!

One member of the team should submit the following (vis CSNET) for the final team project:

  • All code developed
  • All test framework code and test cases
  • All documentation produced for your application. You should be sure to include any details necessary to run the program, and to access all of the features
  • A short (~ 1 page) document describing how successful or unsuccessful your team's work on the project was, compared to your original plan. Describe any features you were not able to include, those that are still buggy, and any that you added but did not originally plan for.
  • A document describing the test-driven development process you used, including specific anecdotal examples where your team:
    1. Ran into cases where new changes caused failure of earlier tests
    2. Refactoring of specific routines.

Project Presentation

(See course web page for date)

Your team will be asked to give a presentation and demonstration of your project before the rest of the class. Although code will be reviewed, this presentation will be a primary source of information for determining the team grade on the project. The quality of the presentation itself will account for a portion of the project grade.

Presentations should involve all team members, and should present a thorough overview of your application, demonstrating each of the features it supports. If there is some feature that your team has included, that you wish to be recognized for, you should be sure to demonstrate it during the presentation.

Presentations will occur on one of the following days:

  • Classes on Friday December 2 and Monday December 5.

We will discuss as a class which date/time will work best for students. We may meet 10 minutes early and run over 10 minutes in the end to allow for more time.

The project itself should be turned in no later than the night before the first project presentation date (12/1).

Individual Report

One day after final Project Due

Submit a brief report on your contributions, and your evaluation of yourself and your teammates on the scale of 1-5 (5 being best). Briefly discuss your rationale for the evaluation.

Grading

15% Application concept and design

30% Application program (features, functionality, etc.)

10% Custom XML design

15% Use of test-driven development process (developing tests before code, running unit tests regularly, refactoring)

10% Code style/naming/etc.

20% Reports and presentations - organization, progress report, final report, Final presentation

5% extra credit for more than 5 features used (see Project Outline for the mandatory and optional features).

Original concept/design/most of the text by John Keyser. Modifications by Yoonsuck Choe.