CSCE-315: Programming Studio (Fall 2013)

Project 3: Android App Development

Updates

Updates will be posted here.

Team configuration

The team configuration will be the same as project 2.

Project Goal

This project is meant to help familiarize you with:

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

Project Outline

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

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-Driven Development

For this project, you will use the 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 (document these clearly in your development log).
  • 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.

There are several test-support tools for the Android platform such as Robotium and Robolectric. You may choose to use any one of these.

XML

Android SDK provides a rich set of XML-related functionality.
  • You need to use DTD or XML schema to formally define the legal syntax for your XML file.
  • You must validate your XML data file against the DTD or XML schema everytime you use it.

First decide on that kind of app data you will store and make available to the user. XML Resources:

Grading

There will be a team grade assigned for the project, and like the first project, the team grade will be apportioned out to the individuals. The rough breakdown of team grade is:

10% TDD methodology -- unit tests for all major functionality, evidence of regression testing and refactoring.

20% App concept and design (concept, features, artistic aspect, etc.).

30% App functionality (must meet all requirements and function properly [GUI, XML use, etc.])

10% Scientific data usage: novel and creative uses of scientific data.

5% XML: design and usage (including validation)

5% Code style (naming, commenting, layout, etc.)

10% Reports and documentation

10% Final presentation

For intermediate submissions (except for design docs), the following rubric will be used.

  • all deliverables submitted 10%
  • all requirements implemented 30% (regardless of function)
  • all requirements function properly 30%
  • code orgaization and readability 15%
  • documentation (input, output, TDD activity log, etc.) 15%

Deliverables

See course web page for deadlines.
  1. Design documents and XML design.
    • The design document requirements are the same as Project 1.
    • Include an illustration that shows a rough transition diagram between different user-interface components of your app: Main screen, buttons, what other screens will be displayed when certain buttons are pressed, menus, response to the "back" button, etc.
    • The XML design can be rough. You should first decide what information to keep track of. You don't need a full DTD or XML schema. An example XML file would be fine. Of course the XML file should reflect what kind of app you will build and what data it is expected to store.
    • Indicate which scientific data you will use and in what way it will be utilized in your app. Specify the source (URL) and point to the exact data file(s) you will use. Simply displaying data is not enough.
  2. User interface code.
    • This will include all displays and user interface elements such as buttons, text entry fields, etc. It would be like an hollow shell that provides all major user interaction capability (navigating through different components), without any meat (no actual functionality).
    • Include an updated illustration of your transition diagram.
    • Include a brief report on how you used TDD and include ample screen-shots.
  3. Core algorithm implementation.
    • Include main computational functionality of your app, including a fully functioning XML-based app data storage.
    • At this point, it is not required that the functionality is fully integrated with the user interface.
    • Include a brief report on how you used TDD and include ample screen-shots.
  4. Final version.
    • Fully integrated, polished app.
    • An updated version of your design document.
    • post production notes (changes you had to make to your design and why, difficulties, solutions, lessons learned)
    • individual work load distribution (percentage)
    • self-evaluation (briefly discuss how you contributed to the project) and peer evaluation (rate all other team members on the scale of 1 to 5, 5 being best; plus brief comments). Peer evaluation should be submitted individually.
    • Development log.

Presentation

All teams are required to give a short presentation.
  • 7 minutes per presentation.
  • Team presentation order will be announced later.
  • Presentations are limited to 6 pages including the title page, and should follow the exact format as follows:
    1. Title: project title, team #, list of members (with photos).
    2. Intro: brief intro of the app concept/design
    3. Technical aspects: overall design
    4. Code snippets: major highlights
    5. Screen shots:
    6. Conclusion: lessons learned, etc.
  • Since the presentations will be before the final due date, reporting on stuff that are "in progress" will be fine.