Programming Project 1, Part 1
(worth 25% of overall Project 1 grade)
Summary of Deadlines
- By Wed Jan 30 at 5pm: Find a
team-mate or email Deepti if you need help finding one.
- During the week of Mon Feb 4 through Fri Feb 8: Meet with a TA
or the instructor to discuss your application and design (details below).
This is a required meeting.
- By Wed Feb 13 at
1:10pm: Submit a
hard-copy with your final project description (details below).
Teams
You will carry out this project in teams of two.
If you can't find a team-mate,
please follow these steps:
- Post a message
in the class discussion board on CourseWorks asking for a team mate - the
best way.
- Send email to
Deepti right away (and definitely before Wed Jan 30 at 5pm) asking
her to pair you up with another student without a team-mate. Deepti will do
her
best to find you a team-mate.
You do not need to notify us of your team composition. Instead,
when you submit the first part of your project you should
indicate in your submission your team composition.
Important notes:
- If you decide to drop the class, or are even remotely
considering doing so, please be considerate and notify
your team-mate immediately.
- On a related note, do not wait until the day before the
deadline to start working on the project, just to realize
then that your team-mate has dropped the class or moved
to another planet. It is your responsibility to start
working on the project and spot any problems with your
team-mate early on.
- You might be able to do the project by yourself if you
have a compelling reason, but we strongly discourage this.
(See below for more details.) This is a large
class, and we are relatively understaffed, so we simply
cannot handle a large number of individual projects. If
you want to do the project by yourself, you should get explicit
permission by email from
Deepti: Please send her email giving a
compelling reason why you want to work by yourself.
- Not knowing
other people in the class is not
a compelling reason, and you should use the
discussion board or ask Deepti to help you find a team-mate.
(See above.)
- Please check the class web page
for important information of what kinds of collaboration are allowed for
projects.
Computer accounts
You will need a CS account to do the final parts of Project
1 (not for Part 1, though). Consequently, at least one of the team members
should have a CS account. If neither of you have a CS account, please
open one from https://www.cs.columbia.edu/~crf/accounts/cs.html.
Choose the appropriate "student" category as the "account type." There
is a $50 charge to open a CS account. Please refer to CRF's homepage for
details on infrastructure and policies of the CS department.
Overview of Project 1
In Project 1, you will build a substantial real-world database
application of your choice. You will do the conceptual design of
the database on paper (Part 1), then you will
create an actual database on PostgreSQL (Part 2), and finally
you will write an application (in PHP or Java: your choice) that manipulates the database through
updates and queries, through a simple web front-end (Part
3). Parts 2 and 3 will be based on your description and
design of Part 1.
Pick an application that you will enjoy working with, since you will be stuck
with it for a substantial part of the semester! A suggestion is that you build a
database about something that you are interested in --a hobby, a favorite web
site, material from another course, a research project, etc. It's especially
nice if you pick an application where you can populate your database using real,
as opposed to fabricated, data. As the project progresses, you'll end up
creating a database of at least dozens of entities/relationships. If you have an application where you can get a large amount
of real data to populate your database, all the better, but it's not necessary.
Recall that we have a project contest, and
that the best three projects (as decided by the class staff) will
get a 10% boost in the Project 1 grade.
Overview of Part 1 of Project 1
For Part 1 of this project, which you should
submit in hard copy , you should define the
general "domain" of your application, construct an
Entity-Relationship diagram for the database, and map it to a
relational schema using the mapping technique that we will cover in
class.
Try to pick an application with a schema that is relatively
substantial, but not too large. As general guidelines:
- If you are doing the project in a team of two (which
should be the general case), your E/R design should have
around seven entity sets and a similar number of
relationship sets. This is a ballpark figure only:
something in the 5-to-10 range should be fine. You will
get a sense if your design is too simple or too complex.
Please talk with a TA during office hours
if you are in doubt about this.
- If you are doing the project by yourself (you need
explicit permission; see above), your E/R design should
have around five entity sets and a similar number of
relationship sets. This is a ballpark figure only:
something in the 3-to-7 range should be fine. You will
get a sense if your design is too simple or too complex.
Please talk with a TA during office hours
if you are in doubt about this.
Try to make your application interesting, including a variety
of different kinds of attribute domains (e.g., strings, integers,
etc.) and relationships (i.e., with different key and
participation constraints). It is important that you include as
many relevant constraints for your application from the real
world as possible in your E/R diagram.
Important note for two-person teams: Since
students do occasionally drop classes, and to prevent last-minute
surprises, we suggest that you also include in your submission a "contingency
plan" for the unfortunate case in which one of the
team-mates drops the class later in the semester. This
contingency plan should indicate how you will "downgrade"
the project to a simpler one in such a case, so that it is
appropriate for a single person to complete. (See guidelines for
single-person projects above.) If your team-mate drops the class,
rather than finding a new team-mate to complete the project,
which is problematic for a number of reasons, you will complete
the "downgraded" version of your original project.
Including such a contingency plan is optional,
but if you choose not to submit it when you submit Part 1 and
your team-mate drops the class later, you will have to complete
the original project as planned, and no exceptions
will be made at that point.
What you need to do for Part 1
- Find a team-mate. There's no need to
notify us of this; you will simply indicate who your team-mate
is when you submit Part 1.
- Get a CS account if neither you nor your
team-mate has one.
- Decide on an application for your project and write
a relatively informal, one-paragraph description of the
application, highlighting interesting and
challenging parts. If you're having trouble thinking of
an application, take a look at any web shopping site (e.g.,
Amazon). They all
have a similar theme: products, customers, orders,
shopping baskets, etc., and typically make for an
interesting and appropriately sized application. (You can ignore all
"security"-related issues (e.g., user authentication, encryption) in your
application.)
- Meet with a TA or the instructor during the week of Feb 4 through Feb 8 to discuss your
design and make sure that it is appropriate (i.e.,
challenging enough, but not unrealistically so). This
meeting is required and should last about
five minutes. Your grade for Part 1 will be
decreased substantially if you don't meet with any of the
class staff. We will have expanded
office hours during that week --- see the discussion board. Please show
up early in the week to minimize delays. We will not
be taking appointments, so please show up
directly during office hours. Both team members
should attend the meeting, at the same time.
For this meeting, bring a one-paragraph written description of
the application, not to exceed 20 lines or so. The more concrete your written description, the more
efficient and useful the meeting with the class staff
will be. This paragraph should include:
- A high-level description of the general domain of
the application, plus specific details as to how
users will interact with it. For example, if your
application is somehow inspired in the Internet Movie
Database, your description should describe
the general "entities" that are
involved, plus explain that your application
might ask users for a movie title and return as a
result the actors in the movie; you might also
let users store in the database the fact that
they liked certain movies and disliked others;
finally, given a userid, your application might
give recommendations on the movies that the user
might like, given the user's previously recorded
preferences, according to some simple "recommendation"
algorithm.
- An idea of what entities and relationship sets
you will have, including attributes and
constraints. You don't need to have your design
completely finalized, though, but of course it
will help if you bring to the meeting at least a preliminary
entity/relationship diagram, so we encourage you to do so.
- An idea of what data you will use to populate
your database later on.
- After a TA or the instructor have OKed your general
application, modify it based on the feedback that you
were given, and write an E/R diagram (following
the syntax that we saw in class) of your database,
specifying as many of the real-world constraints for your
application as possible.
- Using the method that we will have covered in class, map your E/R
diagram into a relational schema in SQL,
capturing as many of the E/R constraints (e.g., key and
participation constraints) as possible.
- Submit a hard copy of (a)
your one-paragraph description of the application (which
you should have revised based on the feedback from your
meeting with one of the class staff), (b)
your E/R diagram, and (c) your resulting
SQL schema at the beginning of class (1:10pm) on Wed Feb 13.
- Keep a copy of all these materials for
yourselves, since you will need them for Parts 2 and 3 of
the project.
Important note 1: Try to meet
with a TA or the instructor early in the week of Mon Feb 4. If you wait
until Fri Feb 8 to do so, you will only have a little more than a weekend to
complete Part 1 of the project. If you meet with us early
in the week of Mon Feb 4, you will still have the chance to attend any of our
office hours later that week to discuss further and get answers to any
questions that you might have.
Important note 2: If you observe religious holidays that overlap with this
part of the project, please email
the instructor to arrange for alternative deadlines.
Grading for Part 1
Your grade for Part 1 of Project 1 will be split as follows:
- Meeting with class staff: 7 points.
If you come to the meeting prepared with your written
description as specified in item (4) above, you can
expect to get all points, even if you are asked to
make changes or revisions to your proposal.
- Quality of final one-paragraph description of your application:
6 points.
We will evaluate the overall quality of your final hard-copy
one-paragraph description of your application, especially
in terms of how thoroughly you incorporated any revisions
suggested during your meeting with the class staff.
- Quality of E/R diagram: 6 points.
We will evaluate how well your E/R diagram models your
proposed application, including how well you modeled any
relevant real-world constraints.
- Quality of your SQL schema: 6 points.
We will evaluate how well you mapped your E/R diagram,
including constraints, into a SQL schema using the
technique that we covered in class.
Important note: Please check the
class web page for lateness policies.
- Q: I have a really cool idea for Project 1, but
in order to implement it I would have to work alone. Can
I?
A: Unfortunately this is not a "compelling"
enough reason for a one-person team. Please modify your
project idea so that it becomes appropriate for a two-person
team.
- Q: Can my team have 3 (or 4, or 12) students for
Project 1?
A: No, your team has to have exactly two
students (unless you get explicit permission from Deepti for a one-person team;
see above).
- Q: What do I need to prepare for my meeting with the TA or the
instructor during the week of Mon Feb 4 through Fri Feb 8?
A: You should have a clear one-paragraph
written description of your application for Project 1, as
specified above, to make the discussion concrete and
efficient. This includes: (a) a
description of what your overall application will look
like: in Part 3 you will write a simple program that gets
some input over the web and as a result generates some
queries for the database (and/or perhaps some updates).
For example, if your application is somehow inspired in
the Internet Movie
Database, your program might ask users for a movie
title and return as a result the actors in the movie; you
might also let users store in the database the fact that
they liked certain movies and disliked others; finally,
given a userid, your program might give recommendations
on the movies that the user might like, given the user's
previously recorded preferences, according to some simple
"recommendation" algorithm; (b)
an idea of what entities and relationship sets you will
have, including attributes and constraints (you don't
need to have your design completely finalized, though); (c)
an idea of what (hopefully real) data you will
use to populate your database.
- Q: Why use PostgreSQL for Parts 2 and
3 of Project 1? Can I use my favorite DBMS instead?
A: As much as we would like to be more flexible, we
just don't have the staff to handle several diverse systems and platforms.
Unfortunately, you cannot use any other DBMS.
- Q: Can I use Ada (or some other language other than PHP or Java) for Part 3 of Project 1?
A: Please see the answer to the previous question.