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.
- 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
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
- 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
- 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
Deadlines and Materials to Turn In
Initial Team Report
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)
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
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:
- Ran into cases where new changes caused failure of earlier tests
- Refactoring of specific routines.
Project Presentation
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
The individual report will follow a format similar to that in project 1.
Grading
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