COS 333 Project: Preliminary Description

Mon Feb 4 13:47:30 EST 2008


The COS 333 project is an opportunity to work on a task larger and more elaborate than any of the assignments, to design and implement a significant piece of software, working in groups of 3 or 4 people.

The intent is that this will not be just hacking, but a serious attempt to simulate some aspects of reality: choosing something suitable to work on, planning how to get it together, designing it before building it (though allowing for the inevitable changes of direction as things evolve), building it in stages, testing it thoroughly, and documenting and presenting the result, all as part of a small team. If you do it well, this should be something that you can show with pride to friends and prospective employers.

The project will involve many of the issues of software engineering as they occur in small, multi-person real-world projects. Some of this material will be discussed in class, and some will be found in assigned readings.

The considerations affecting the form of the project are:

Project Definition

A large number of real-world systems are based on what is often called the "three-tier model": a user interface, a database for persistent storage, and some process(ing) between them. Many web services use this architecture. For example Amazon has a web-based user interface; the data is a book catalog and customer information, and the process is a wide variety of searching and data-mining operations. News and financial services are analogous: again, a user interface, a background information gathering and filing service, and mechanisms that let a client register for, access and process interesting items.

The project this year will be much the same as in the past few years:

This is a very open-ended specification, so the big problem is likely to be defining a topic of the right size. Almost every web service will suggest something, perhaps novel or perhaps "We can do that much better"; either would likely be fine. Hiding, selecting, or merging data from existing web services is a possibility; shopping, news and other bots are examples, as are the myriad mashups that combine information from multiple sources.

Numerous web services (including Google, Amazon and Yahoo) provide program interfaces, which might be a way to put a different face on some aspect of their systems; Google Maps is a particularly interesting one, and Google Earth appears to have promise too. Using these APIs could be good for potential projects, and creating a good API is a fine example of a non-graphical user interface.

Look around campus for other possibilities: maps, tours, notification services, databases, and so on are all potentially interesting and feasible, though make sure that the information that you want to use is available -- concerns for privacy, property and turf can all get in the way of a great idea. I often talk about projects with staff and faculty friends, and there are definitely potential projects there; if you want to explore a bit, come talk to me. You can probably find others by talking to faculty and staff in other departments.

Some of the best projects come from noticing a task that is done by hand or poorly by machine, when it could be done really well by a suitable program, or where something complicated could profit from a neat user interface, or just one that's a lot faster. Think about how Ajax might be used in something new, or how some standalone program could be web-ified, or how some web service could work on the desktop. Or maybe focus on tools that make it easier to build things, and create a couple of simple examples that demonstrate the wonders of your tools.

In my experience, in successful projects the people are really turned on by what they are doing, whether because it's their own idea and that's sufficient motivation, or because they are doing something that someone else cares a lot about too. Either way, that kind of engagement usually leads to the best results. Be wary of projects where none of you are really interested, where one member is driving the whole thing, or where the application is too far away from your own experience.

Previous projects have included web-based calendars and financial systems; numerous improvements of campus services and agencies; rental and exchange systems; course evaluation, selection and scheduling; information services for the local environment; social networks; and several map mashups.

The assignment is to create such a system, using any combination of existing tools and new code. The functionality that you should provide includes the following:

How big? There's no official requirement, but it ought to ultimately involve some thousands of lines of code; churning out a thousand lines of repetitive PHP or mechanically generating a bunch of Python with Django isn't enough. Some systems have been as big as 10,000 lines of C++; that's more than necessary, though it was great work. In any case, I will expect to see clean, well-written code, with appropriate attention to principles of sound software engineering.

Some Options

Distributed or local? Most systems are distributed: the user interface runs on a client machine and the data is stored on a server. The processing might be at either end, or some of each. I strongly encourage systems that involve a network connection, even if it is only to a local host or the databse, so as to leave open the option of distributed operation.

Languages, tools and environment? You can use any combination that appeals for any aspect -- web-based or stand-alone; Windows or Unix or Mac or cell phone; Java or VB or Javascript or C#; CGI or PHP or JSP; Google Web Toolkit or Ruby on Rails or Django. The only restriction is that your running system must be readily accessible so you can demo it effectively and we can run it for grading.

Make versus buy? Much modern software development is done by combining code and components that others have created. You can use as much of this as you like, as long as the finished product acknowledges the work of others, and has a substantial contribution of your own.

Things to Think About

I have attempted to make this as open-ended as possible. This is your chance to invent something new, or to do something better than others do. You might think of this as practice for a new e-business or e-service, the sort of e-thing that made some of your predecessors here (like Meg Whitman and Jeff Bezos and the late Phil Goldman) into e-zillionaires. Of course if you have a really good idea and sell out to Google or do an IPO by Dean's Date, it's an automatic A+.

But you have only about 12-13 weeks, so you can't get too carried away. Part of the assignment is to plan exactly what you are going to create, what each team member will be responsible for, and what interfaces you will require between components so independently-created pieces will fit together. What schedule will you follow? How can you work on different parts in parallel and keep them integrated? How will you ensure, if your time estimates are too optimistic (as they inevitably will be), that you have a working subset, rather than a non-working collection of partially completed pieces? How will you convince a skeptical TA and instructor that you are making progress, not just writing code (or doing nothing at all)?

Since the project will involve multiple people, a major task is to divide the work into suitable pieces, with planned interfaces. Each of these components should be a separate entity that can be implemented and tested separately. But you will have to think carefully about the interfaces between them: the problems caused by poor interfaces are a recurring theme in comments from previous projects (and, happily, so are the strongly positive experiences reported by groups that did a good job on interfaces).

The project will represent 60-65 percent of your course grade. All members of a team will get the same grade (with the potential for a correction in the unlikely event of someone not carrying their fair share of the load), so be sure that you all agree on who will do what, by when, and to what standard. Each person must contribute their fair share, including writing a reasonable fraction of the code for the system, no matter what other role they play.

Here are some things you should start thinking about now; this list will be augmented over the next few weeks, and we will talk about it in class as well.


The following schedule is subject to change in details but the spirit is right. Take note.

Since the project involves more than half a semester, it is possible to develop a significant piece of software. At the same time, serious planning and steady work will be required for your project to be completed on time. To encourage planning, organization and regular activity, the project will have several deadlines that will be enforced. [Some of the dates near the end may shift a bit; there will be adequate warning.] The TAs will be responsible for primary supervision of the teams and I will act as backup and second-level ("bungee") management. You will be required to meet with your TA/manager each week after spring break. These meetings are a graded component of the project, so preparation and attendance are mandatory -- no excuses.

We will also try to follow good software engineering practice as much as possible. I will lean heavily on things that have been helpful in previous offerings, such as design documents, status reports and reviews aimed at helping you to organize and me to monitor. I hope also to have design reviews involving multiple teams, where you get a chance to critique what others are doing, and have your own work assessed as well. All of these are also mandatory and graded.

	 S  M Tu  W Th  F  S
Feb	                1  2
	 3  4  5  6  7  8  9	start thinking about possible projects & people
	10 11 12 13 14 15 16
	17 18 19 20 21 22 23	
	24 25 26 27 28 29	
Mar	                   1
	 2  3  4  5  6  7  8	initial project discussions with bwk by 3/7
	 9 10 11 12 13 14 15	design document due before break
	16 17 18 19 20 21 22	spring break
	23 24 25 26 27 28 29	first TA meeting this week
	30 31
Apr	       1  2  3  4  5
	 6  7  8  9 10 11 12	project prototype
	13 14 15 16 17 18 19
	20 21 22 23 24 25 26	alpha test
	27 28 29 30
May	             1  2  3	beta test (last class 5/1)
	 4  5  6  7  8  9 10	project presentations
	11 12 13 14 15 16 17	Dean's date; project due
	18 19 20 21 22 23 24

  • March 3-7: I will meet with each team for half an hour to discuss your plans before they are set too firmly. If you need help finding a topic or choosing among several, please talk to me and the TAs well before this meeting; we're happy to respond to ideas, make random suggestions, and help steer you, starting any time. But don't come to this meeting with 2 or 3 vague ideas, no team consensus, and no concrete plans. It is your responsibility to come up with a project and partners, so don't leave this to the last minute. If you want to explore projects that involve other parties on campus, come see me early so I can help you make connections.

  • March 10-14: Your team must have been formed, and you must have sketched out what you expect to accomplish in your project, and how. Each team must submit a brief design document for their project. This must include an overview of what your system will do, the basic organization and components, a rough schedule of what you expect to accomplish each week, and who will be doing what. It should identify any significant risk factors and what you'll do if bad things happen. ("We're expecting a large donation to buy a server; we will drop the course if this doesn't come through in time.") A template will be available.

  • March 24-28: Each team must meet with their TA to go over their project in more detail, to describe their schedule, the components and interfaces, and the allocation of people to tasks. It is highly desirable to plan a sequence of stages such that each represents a working system; if your schedule proves too optimistic, this gives you a fallback that you can still demonstrate. You must meet with your TA each week from now on.

  • March 31-April 4: Design reviews (tentative). Sometime around here, we will likely arrange meetings with 3 or 4 teams at a time so you can discuss your own project and others in a small group. This is a loose simulation of a peer review of designs.

  • April 11: Prototype. By this date, you should have a bare-bones prototype that shows approximately what you are trying to do, and what your system will look like. It need not do much, but it must do some minimal part of the job. You should not be considering major or even many minor feature changes after this date, though you need not have them all implemented.

  • April 25: Alpha test. By this date, you must demonstrate an almost working version of the core functionality of your project. "Core" means the basic operations that form the essence of your project; if you were doing Amazon-2, for instance, this might mean searching for books and accepting orders. "Almost working" means that wizards (you) can help experienced programmers (us) to use the system. Your code may crash and need restarting. But you must be able to convince us that your project can be completed by the deadline.

  • May 2: Beta test. Your code should largely work, all intended features should be installed and working, no major component should be incomplete. A determined sadist might be able to break your system, but a casual experimenter should not. It's very helpful if you can get real users before the beta: ask other teams, your friends and roommates, and anyone else to try your system to see how well it works. Drafts of written material should be underway.

  • May 7-9: Demo days. Each group will give a 30 minute public presentation of their work. All team members must attend the presentation. You must also attend at least two other presentations, for instruction and moral support. Typical projects are great; you should come and hear about them.

  • May 13: Dean's Date. Everything must be done and handed in by 5:00 PM on this date, without exception. Final submission includes the code you wrote, something to entice new users, short documents describing implementation and installation, and a report on how the project and the team worked out and what you learned.


    Grading for the project will be based on a number of criteria, including

    There will be more information as we go along, to flesh out or clarify some of the sketchy parts here. There will also be class lectures on some of the pieces, like networking basics, user interface programming, and database software.

    You are encouraged to ask questions that will help clarify things for everyone. Murphy's Law applies to projects and their administration, so there will undoubtedly be screwups. I apologize for those in advance, but of course they too will be a simulation of reality...