CS 4243-4: Senior Design

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 core contribution. 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 core contribution.
• 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:

• 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 application.
• Are there novel CS abstractions/mechanisms and a compelling application?
• 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 contribution)?
• 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.

Team projects:

• 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 the criteria:

• 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 Prize) 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, Meltzer Prize). 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, Bard Prize). 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, Meltzer Prize). 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 software.
• 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, calendar integration, 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.