Overview
Data is everywhere! It stands to reason that there must be smart
ways of storing and retrieving it efficiently. We'll spend time
looking at how database sytems are built, how to use them, and
fundamental principles behind management of data. The most amazing
thing about this class is that it uses ideas involving computer
hardware, data structures, algorithms, database theory, new languages,
and more. If it makes sense to talk about a course as being
"interdisciplinary within computer science," this is the one.
Instructor Information
- Instructor: Dave Musicant
- Office: CMC 326
- E-mail:
dmusican
- Office phone: (507)222-4369
- Office hours:
check my web page
- Grader: Devon Manber (manberd), Richard Lin (linr)
Textbook
- Database System Concepts (6th ed), Silberschatz, Korth, and
Sudarshan, McGraw-Hill, 2010.
Exams, dates, etc
- Exam 1: Monday, October 13
- Exam 2: Monday, November 17
Your Grade
- Assignments: 50%
- Exam 1: 25%
- Exam 2: 25%
Homework Policy
- The assignments will be a mix of programming in SQL and Java (and maybe some Python), and non-programming analysis assignments.
- Each assignment will have a specific time for which it will
be due. An assignment turned in late within one day of the due time will be
docked 25%. Two days late: 50% off; three days late: 75% off. An assignment
will not be graded if it is turned in later than that.
Working Together
- Each programming assignment will either be a "team"
problem assignment or an "individual" assignment.
- When working on team problems, you and your partner
should engage in the
pair programming model, that is both of you should be sitting
at a single machine, side by side. One of you is "driving,"
i.e. actually using the keyboard and mouse. The other is
actively engaged following along, stopping bugs, and providing
ideas. You should make sure that over the course of an assignment that
you spend roughly the same amount of time each "driving." I will also
ask you to turn in a form rating the work that your partner does.
- If you are determined to work alone on the team
assignments, that's fine. I will expect, however, that you do work of
the same amount and quality as those students with partners. You can
change whether or not you work alone each "cycle" that I assign new
partners.
- I will also be assigning analysis work. On these and on the
"individual" programming problems you may collaborate with others in the class
for ideas, but all students should turn in individual assignments for these. You
should be writing up or programming your own solutions, and not sharing
printouts with each other. You may discuss ideas with other students, but no
paper or electronic record of your conversations should exist when the
conversation is done.
Collaboration, Plagiarism, and the Difference Between the Two
There are two different kinds of working together: collaborating
and plagiarism.
Collaborating
- Collaborating is good.
- You are encouraged to collaborate on ideas and program design.
- Programming is often a social effort, and there is much you can learn
by talking out the ideas in this class with each other.
- You can by all means talk to each other, look at each others' programs
to help fix problems, and share ideas.
Plagiarism
- Plagiarism is bad. DON'T DO IT!
- Any programs that you turn in should be your work.
- Even if you work with someone else and share ideas, you must still
writ your own program.
- If a piece of your program utilizes someone else's idea, you must
make sure to give that person credit in program comments.
- Do not hand a printout of your program to other students. I
encourage you to work together to help debug your code, but you
should do so sitting together.
The following are examples of plagiarism:
- Taking someone else's program, changing comments and variable names,
putting your name at the top, and turning it in.
- Finding a similar program on the Internet, changing the variables
and comments around, putting your name at the top, and turning it in.
- Finding a similar program in a book, changing the variables and comments
around, putting your name at the top, and turning it in.
I am compelled by Carleton policy to submit plagiarism cases that I
find to the Dean of Students, who in turns brings the evidence before
the Academic Standing Committee. The academic penalty for a finding of
responsibility can range from a grade of zero in the specific
assignment to a F in the course.
Rough outline of course material and how it relates to textbook
- Chapter 1: Introduction. We'll breeze through this very
quickly, as it's your typical "Hi, I'm a textbook, here's what in me" first
chapter.
- Chapter 2: Intro to Relational Model.
- Chapter 6: Relational Algebra. The preface to the textbook
"approves" this rearrangement; chapter 6 doesn't depend on anything before it,
and my own experience is that SQL makes more sense if you've done relational
algebra first. We'll only cover 6.1. Sections 6.2 and 6.3 are on other
theoretical query languages that people don't seem to cover much anymore.
- Chapter 3: SQL.
- Chapter 4: Intermediate SQL. We'll likely only cover the beginnings of this
chapter. There's much depth and complexity to consider in "basic" SQL. More
advanced SQL doesn't really add intellectual depth; rather, it's mostly a bunch
of detailed and application-specific tweaks.
- Chapter 5: Advanced SQL. We'll likely cover briefly cover the beginning
portions on calling SQL from other languages. See comments for chapter 4 as to
why we're skipping the rest. Skim the chapter and you'll see what I mean. The
other reason we're skipping it is that the more "advanced" the SQL get, the less
standard it gets. Many real database systems don't implement many of these
concepts.
- Chapter 7: Database Design and the E-R model.
- Chapter 8: Relational Database Design.
- (We'll skip Chapter 9: it's a hodge podge of techniques in building software systems that use databases. Everything in this chapter is potentially super-useful, but there's not enough detail in this chapter about any one of these concepts to make it worthwhile to read without supplementing. Some of it is covered in other courses in our department.)
- Chapter 10: Storage and File Structure.
- Chapter 11: Indexing and Hashing.
- Chapter 12: Query Processing
- Chapter 13: Query Optimization
- Chapter 14: Transactions. Will we get this far? I'm not sure. We may do some
slices of it, depending on how time goes.
- Chapter 15: Concurrency Control. Really unlikely we'll get this far, but it would be fun. Chapters 15 through 19 would form a great starting point for an advanced databases course.