CSCE-315: Programming Studio (Spring 2010)

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
  • the use of a web-based API
  • picking up and using a new language
  • presenting your work to others

Project Outline

For this project, you will write an application that helps a group of people to put together a media-rich book project. The book will contain most of the following:

  • Book info (title, authors, ISBN, etc.), foreword, preface, chapters (contains sections, subsection), references, and index.
  • Figures: images and captions, movies and captions, sound-clips and captions.
  • Tables and captions.
  • Table of contents and index building.
  • Interactive elements: java applets, customized google maps, etc.
  • etc.
Since this is a book project, you will also need to implement a system for collaboration:
  • Login
  • Access control to different parts of the book project.
  • Comments and discussions about parts of the book project. For example, a simple threaded discussion forum, linked to email (like google groups).
  • Editing and revision control.
  • Managerial stuff, such as advertising, email lists.
  • etc.

Your team should design and create an XML description (DTD or alternative) for maintaining the application information. You will want to design this portion with the second portion of the code in mind. Your XML document should store all of the relevant information regarding the application, and your XML should be reasonably complicated (e.g. an XML document that had text and picture elements with no attributes would not be sufficient) - you should have attributes, elements of different types, subelements, etc. defined.

Your system should allow users to both add material to the application (i.e. create XML files) and view/browse the application (i.e. read the XML). You may do this using separate applications ("content builder" and "content viewer") or in one integrated program.

Your team should put together at least one (preferably more) sample XML file of reasonable complexity that can be used to demonstrate the full range of capabilities of your system. Pick an example book project, and create a demo content. For example, "wilderness survival guide", etc.

A necessary part of your application should be an interface to a web-based system that can be used for some portion of the system. The choice of online system is up to you, but you should choose a system that:

  • Requires authentication of some sort
  • Supports a range of querying operations

An obvious example of this would be to use web-apps like Flickr for storing or sharing photos, possibly determining tags for uploaded photos from your application information. A significant portion of your grade will be based on how well you are able to incorporate such online resources into your system. The goal here is to give you experience with using web services, so you should try to make such services a significant part of your project.

Note that if you need department machines that can run scripts, etc., please let the instructor and TA know, and we will coordinate with CSG to try to get accounts/machines made available.

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 language to use, is to carefully plan 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).

Programming Language

Your team is to make use of a language that is not C, C++, C#, or Java, and it is strongly suggested that you use a scripting language such as Ruby, Python, PHP, Javascript, etc. You should pick a language that your team is not very familiar with, if possible. You may use a combination of languages in your project, including C/C++/C#/Java, but a significant portion of the project should be done in a language that you are less familiar with. The idea here is to give you practice at quickly learning and using a new language.

If your team would like to use a language such as C++ that everyone is familiar with, this is acceptable, but you may lose some points on the overall project grade.

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.

Use of external libraries

Note that for this assignment, your team might find it helpful to use various external libraries and programs (e.g. for image display, for interface widgets, for parsing). This is allowed, but you should remember a few key things:
  • You should not use external code that essentially does the entire task for you - if you have any questions, ask the instructor or TA
  • You should make sure that any use you make of these conforms to the license/restrictions of that other code. For example, if you are creating an open-source project, make sure that it is OK to use that external library within an open-source application.
  • You should clearly document what external library/libraries you use.

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

Tuesday, November 16, 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 description of the language(s) your team will be using, along with a description of how familiar your team is with the language, and why you chose to use it.
  • The unit testing framework your team will be using

    Note: by this point, your team should have already begun writing small amounts of tests and code, sufficient to have become familiar with the unit test framework that you have chosen to use.

  • A summary of the application your team plans to build, including a list of major and minor features. For any aspects that might be questionable, give a brief rationale for why you are choosing to include or not include this material.
  • 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)

Tuesday, November 23, 11:59 p.m.

By this point, you should have a system with significant functionality, including the ability to read and write at least a significant subset of the XML document. 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 very 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

(Day before project presentation - see below, 11:59 p.m.)

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 below 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 Thu December 2 and Tuesday December 7.

We will discuss as a class which date/time will work best for students. If no other time can be agreed upon, the default time will be during class on December 7 (last day of class).

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

Individual Report

One day after final Project Due

The individual report will follow a format similar to that in project 1.

Grading

15% XML document definition, and sample XML data file

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

10% Incorporation and use of web-based resources in your program (minimal use will get only half credit, the more extensive, the more credit)

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

10% Code style/naming/etc.

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

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