6
$\begingroup$

Some Computer Science programs in the US have a course that is informally referred to at a Capstone Course that attempts to bring together most of what the student has learned. The course may be required or not and is usually offered to students just prior to graduation, having several prerequisites.

One possible design is a Project (Senior Project) that may be team based on individual. The student may or may not have an advisor, similar to a thesis course. It may or may not require a write-up or a computer program.

What is a good design for a Capstone Course that requires the student to use most of what they have learnt in their program.

Most helpful would be examples with which you have some experience and which you can attest to success. Also useful would be notable failures and caveats that an implementer might need to be aware of.

Finally, what other changes do you believe are necessary to prepare the student for their future Capstone Experience.

$\endgroup$
  • 1
    $\begingroup$ Normally I wouldn't think of a broad question as a good question. In this case I do. It is too broad to answer without having options all over the place. There's no way to design a capstone course without knowing much more about the path the student has taken to reach this point. The question seems to be asking for examples of designs (hopefully good ones) for a capstone course. I'm going to guess that you mean how to evaluate a designed course to determine if it is a good one. I.e.: criteria, not samples. I can't be sure, however, and had to VTC as too broad. :( $\endgroup$ – Gypsy Spellweaver Aug 6 '17 at 5:15
  • $\begingroup$ Actually, I'm very happy with examples, provided they provide some background. I suspect that a reader of answers will get ideas from samples and use their own judgement about institutional fit. And caveats based on disaster evaluation is also good. $\endgroup$ – Buffy Aug 6 '17 at 13:27
5
$\begingroup$

Personally, I'm a believer in a project based capstone and a group one at that.

The project should involve going from generating (and pitching) an idea through design, development and ultimately delivery and should require integrating multiple tools.

Since many kids would want to use such a course as preparation for internships and jobs, I'd say it's more appropriate to take in the junior rather than senior year. That's ok though since you're done with most if not all core major requirements by then and are taking electives.

I know taking a capstone prior to the senior year sounds wrong to some but it should show mastery of many if not all of the core concepts in a typical CS major and fill a big hole in a students development.

$\endgroup$
  • $\begingroup$ Thanks. I don't disagree about the course placement under appropriate circumstances. Can you say a bit more, though, about the course and its environment? The more you can write, the better. Thanks again. $\endgroup$ – Buffy Aug 6 '17 at 13:29
4
$\begingroup$

The answer depends on the desired outcomes for your program, as the capstone should accomplish at least some of your program outcomes.

For better or worse, we have a variety of outcomes for our CS program, some of which are college-wide outcomes and others of which are CS-specific. We are unable to accomplish all of these in a single course, so we have our seniors complete two requirements:

  • CS 384, Perspectives on Computing, a 3-credit course in which the students read, discuss, and write about the social and ethical issues related various aspects of computing technology (e.g., algorithmic bias, data privacy, software responsibility, etc.). Students take this course during their final Spring semester, so that they have as much experience as possible to bring to the table. We also have our seniors take the ETS CS Major Field Test (CS-MFT) during this course, as one piece of our assessment plan. This course fulfills a college-wide requirement under the college's definition of capstone experience.
  • CS 396 (Senior Project I) and 398 (Senior Project II), two 2-credit courses in which the students work either individually or in teams to complete a significant project, usually but not necessarily a software system. Students normally take 396 during their final Fall semester and 398 during their final Spring semester. This 2-course approach spreads the senior project over their entire senior year. Students meet once per week with a faculty mentor for an hour; the faculty member gets an hour of teaching credit for the year for each project they supervise. Students typically do the initial research, background and design work during the Fall semester (396), may build an initial prototype, and give a progress report in December. During the Spring semester (398), the students complete their project, write a final report (usually multiple revisions), and give a public presentation.

At many places, the 396+398 combination would be considered a capstone experience, and so far as technical skills go, they do provide that sort of outcome. But to meet our college-wide outcomes, our program outcomes include this:

Analyze the social and ethical issues surrounding the use of computing and its effects on society

so we use a 2-pronged approach to achieve both the technical and contextual outcomes. A benefit of this approach is that we don't have to choose between a project-oriented capstone or a non-project capstone; our students effectively get both.

That's one model. It probably isn't for everyone, but it works for us.

$\endgroup$
  • $\begingroup$ Hi Joel! You've been posting a lot of answers lately (and I might add, high quality ones at that). Feel free to come by The Classroom and introduce yourself :) $\endgroup$ – Ben I. Aug 10 '17 at 23:50

Your Answer

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.