CS 4243-4: Senior Design
What constitutes a Senior Design project?
In a nutshell, an SD project needs to have core computer
science as its "meat", something that's innovative,
somethat that will challenge you and take you out of
your comfort zone. We know that some projects
involve a lot of work, but a lot of programming is
not a substitute for innovative core CS content.
To illustrate, here are some projects that would NOT
be acceptable, no matter how ambitious the programming effort:
- Any project where a dbase-backed website is the
You already know how to build
websites - there is no new technical or algorithmic
achievement is merely building a more feature-rich website.
Websites can definitely be part of a project, but not the
- Any project that is mostly a
direct application of sophisticated APIs.
A good example is populating Google maps with data from
some other source. For example, showing restaurants
and their ratings on maps. Again, we know you can
use APIs and piece together an innovative application.
- Any project whose primary contribution is
game design. Even if the game is dazzling and innovative,
if the effort is primarily in game design and graphics-package
mastery, it won't suffice for a project.
Now, there are exceptions. For example:
However, to be granted an exception, you will have to make
a strong case for an exception.
- A website can be part of a project whose core
includes some algorithmic or systems content.
Or your website can be include some key algorithmic
component. For example, you can show school bus
routes on a map and also provide a sophisticated
scheduling algorithm, demonstrating why it's effective.
- Similarly, you can do a game if your primary contribution
is something core in graphics or computational geometry.
Here are some criteria to use in looking for projects:
- Does the project have an algorithmic challenge
and a compelling application of the algorithm?
Again, it is not enough to merely code up
an algorithm to a problem, as you might in
a research project or an algorithms course.
The algorithm needs to be part of a substantive
- Are there novel CS abstractions/mechanisms and a
- Will your project build or significantly augment
a software tool (e.g., language, compiler, OS) that
is useful and innovative in some way?
- Does your project make use of interesting hardware
where there's a challenge in controlling the hardware?
- If your project is based on, say, machine learning and you
want to use machine-learning tools, will your project perform
significant testing with actual data?
- If your project is primarily about a new type of interface
(so, an HCI-based project), will your project feature thorough
user-testing followed by data analysis?
A few more points about the project:
- If the success of your project depends on a lot
of data, then you'll need to explain how you're
going to get the data. For example, if you were
going to create a searchable image database (with
a new kind of search algorithm), to show that
it's effective, you'll need lots of images.
Where are these going to come from?
- Your project needs to be innovative - not a
copy of some previous project, or some existing product.
We urge you to think out of the box.
- Another informal criterion to apply is: will your
project excite a patent lawyer (for its technical
- You also need to think about what you will demo
and you will make your demo compelling. Thus, you could
think that roughly 70% of your project is about the technical
meat, while 30% or so is to be devoted to the "wow" factor.
Of course, we understand that it's harder to demonstrate
"wow" with an OS project than, say, a robotics project.
We will weight accordingly, and help you with that aspect.
- In 2019-20, we anticipate that most students will be in a
team of three.
- Accordingly, your project needs to be substantive enough
for a team of three (so, roughly twice as big as the examples below, all
of which are individual projects).
- Also, your project will need to have three roughly equal
sized components, and you'll need to explain what these are,
why they are comparable, and who is responsible for what.
- Team projects will also need to explain how the components
will be integrated and tested without the last minute
unpleasant surprise of "I can't help it that my teammate's part
is not working".
Examples of Past Senior Design projects
Here are some examples of past (single-person, not team) projects that fit
(Note: if you are a prior award winner and your project
isn't listed here, please get in touch with Prof. Simha).
- OpenNetVM (Phil Loprieto, 2017, Meltzer Prize)
is a highly efficient network packet processing framework that provides simple abstraction for developing and running network functions. The ONVM platform provides load balancing, flexible packet flow management, individualized service abstractions, and basic software defined networking (SDN) capabilities. The platform already offers best-in-class performance with the ability to maintain 40 Gbps speeds while routing packets through dynamically created chains of network functions and lowers the barriers to deploying production network functions (NFs) in software, all while running on inexpensive commodity hardware. However, this idea can be improved upon: we have made it possible for multiple instances of ONVM to process packets in tandem, with seamless inter-routing, making it possible to run software-based network services at production scale. In addition, network functions have the ability to automatically scale themselves in accordance with the current system load.
- Dolphin image processor (Andrew Zysk, 2017, Bard
is an analysis tool for crime scene investigation. Dolphin allows the intended user, a forensic scientist or crime scene investigator, to upload images of crime scene evidence to determine whether an image contains bloodstains, as well as analyze information about the bloodstains. The purpose of Dolphin is to apply a modern image processing and machine learning approach to help crime scene investigators make expedient and accurate analyses.
Dolphin is implemented using the Play Framework, with Java for the back-end, a MySQL database to store derived data from uploaded samples, and Weka for machine learning.
- A cellphone enabled secure voting system (Alex Florescu, 2010,
In this project, Alex designed and built a system consisting
of a mobile device, a voting machine, and a central server.
A user enters a voting booth, makes choices on the voting
machine, receives an unforgeable electronic receipt on the
cellphone, while the vote gets tallied by the central
server. Through a complex set of security protocols, it
can be shown that the vote is private, is always counted
and that the user can ensure that it was recorded correctly.
Thus, the project involved implementing user interfaces,
some of it on a cellphone, a series of complex security
protocols, and the communication between three devices.
As an interesting aside, an earlier version of this
system was used in the first voter-verifiable
secure election in the U.S, for Tacoma Park local
elections in 2009. See
Prof. Vora's website for more details.
- Secure, permanent postal addresses (Sam Sternberg, 2010,
In this project, Sam built and demonstrated a system of
using encrypted addresses on envelopes so that addresses
are private and can be mapped to changing physical addresses,
along with an unforgeable delivery receipt.
From a technical viewpoint, the project combined
elements of security, optical character recognition,
printer control, and web development.
- A 3D gesture-recognition system (Adam Zeldis, 2007,
This project featured a webcam aimed at a PC user and set
up to track fingertips. The idea is that the user can
make fingertip gestures, which can then be used to
control the desktop - for example, to open or close
windows, interact with applications etc.
The project involved video and image analysis,
along with programming the desktop API.
- Sython - a language for privacy-preserving programming
(Michael Gaiman, 2004, Meltzer Prize).
Mike modified the Python language to support a certain type
of security feature: privacy-preserving programming. The idea
was to create a programming language for out-sourced
development so that those developers would be able to
write server code without actually being on the server
or being able to access the actual data in the databases
that the applications would be using. Thus, a programmer
could write and test an application for a hospital dbase without
actually being able access the actual data.
This is a good example of a top-to-bottom "systems"
project, involving a language modification (grammars,
interpreters), systems support (servers, runtime systems)
and networking (between client and server). The project
resulted in a publication and release of open-source
- A tablet-grading system for writing classes
(Sean Hanlon, 2002, Meltzer Prize).
The goal of this project was to build a complete system
for English writing assignments - an editor for students,
a tablet-based grader for professors, and a system that
would track student drafts and assignments. The project
involved development on a tablet PC to recognize gestures,
and display pen-strokes, Java GUI development (the editor,
and grading system), and backend servers (to upload and download
drafts). This project was eventually extended (after Senior Design
was over) into one of the most successful products to come
out of Senior Design, resulting in an actual test in University
Writing (UW20) at GW. Blackboard Inc., previewed the project
but ultimately declined to commercialize it.
- SmartMail - an enhanced email system (Herve Roussel in 2002,
Nayan Patel and Scott Levi in 2000).
Starting in 2000, a series of Senior Design projects took on
email, with the idea of enhancing the user experience by
adding features to track emails, provide receipts,
open chat windows, preempt emails with standard responses,
allow multiple users into a single account, and so on.
Many of these are now standard, but this was not the
case 10 years ago. These projects involved significant
GUI and protocol development, and all of them resulted
in sophisticated full-featured email clients, one of
which was demonstrated to a group that was studying
email for the U.S. Congress.