Main

Projects

Overview

The last few weeks of the term will include the development of a more significant piece of software than typically done for weekly assignments. For the project you will work in teams of 2-4 people.

Project Proposal: What to submit by Wednesday of Week 5:

Everyone:

  • Create a file project.txt and add it to your uoregon-cis330 repo's top-level directory (for team projects, all team members should do this; the file will be identical for all members in a team). The file should contain the following: 
** Project name:

** Project repository:

** Team members:

** Description (1-3 paragraphs):

** Implementation approach:

** Risk management plan (max 1 paragraph):
  • Teams may not use individual uoregon-cis330 repositories (those must remain private). Individual projects can keep using their uoregon-cis330 repositories, just place your project files in a project subdirectory.
  • Your implementation approach description should mention languages you plan to use, any third-party software dependencies, team coordination approach, and an approximate timeline of your work.
  • Your risk management plan depends on what kind of project you select. For many stand-alone projects, the answer here would be "No significant risks." For more complex projects you may want to think, for example, about what you would do if you discover that a third-party library your project relies on does not work on Unix or cannot provide certain functionality that's critical to the success of your project.

Requirements

  • The implementation should be primarily in C++ (and optionally C), and must compile and run in a Unix environment.
  • You can also use other languages as needed, but make sure that at least 2/3 of the code is in C and/or C++.
  • You can use third-party libraries and frameworks, but you must create sufficiently complex new functionality that you design and implement.
  • Do not copy entire projects or large portions of code from other projects.
  • Either use external code as a library, or design your own implementations. Simple code snippets from StackOverflow are fine to use as starting points.
  • Team work is strongly encouraged but not required. Teams larger than 4 people must get the instructor's approval. A note on working in teams.

Project Grading

Each week (by end of day on Sunday), you must add weekly notes to your project repository, summarizing what the team did during this week, including meetings, problems encountered, and overall progress. Please save these notes in a notes subdirectory, naming the files week6.txt, week7.txt, etc., to make it easier for the instructors to find them.

The git history of each team member will be considered when assigning individual scores for the implementation portions of the project. If a team member has contributed significantly less actively than the rest of the team, their implementation score will be respectively lower. In addition, the implementation score will be distributed over weeks 7-10, so if you made no code contributions during week 7, for example, your score can be only 80% of the maximum possible.

The final deadline for the projects is Thursday of week 10, at 11:59pm, when your implementations will be officially submitted. During week 10, we will have several 2-hour time slots during which teams will present their work. The presentations will contribute 10 points to the project's overall score (total 100 points). Each project will get 10-15 minutes, and everybody is welcome to attend (there will be some refreshments). Project proposals (in week 5) contribute 10 points. Weekly notes (weeks 6-10) contribute 10 points (2pts each). The implementations will be reviewed by the instructors after they are submitted, contributing the remaining 70 points of the overall project score.

Project Ideas

Below are some examples to give you a rough idea of the expected scope of your project. You are free and encouraged to come up with your own project ideas. Keep in mind that this should involve a more substantial design and implementation effort by teams of students over a few weeks. While I don't think that code size is indicative of an application's complexity or worthiness, you can expect that most projects' implementations will exceed 1,000 lines of code.

Web Server Examples

Web servers can be simple to implement and illustrate a lot of OS concepts (they are little OS's themselves).

  • Basic server: single process, single thread, one connection per thread (blocking IO)
  • Optionally extend the basic server with: multi-processing (Unix IPC or threads), streaming video (or other streaming), support CGI, anything else you wish to add

2-D Game Examples

Numerous possibilities exist. The main decision is what game engine to use (or even try to write a stand-alone game w/o relying on a game engine). Make sure it works on Unix before you commit to any third-party software. SDL and Qt are good C++ options. Here are some possibilities

  • Maze-based application, such as an RPG game

(:comment similar to the maze you implemented in Assignment3, but with the ability of the user to specify new targets (as opposed to just the exit), and add some hazards along the way. :)

  • Simple adventure Super Mario-like game where a character must pass through various obstacles to achieve some objective (look for old 2-D versions for inspiration)
  • A text-based (ASCII) game, for example Hangman, Mastermind, Battleship, and many other board games. This can be single- or multi-player -- you decide. Any of these can also be graphical, but are also amenable to ASCII implementations.

Operating Systems Examples

  • If you are interested in operating systems but cannot take CIS415 or want to sail through it, consider doing Phase I (or more if you are ambitious) of Virtual OS in C++ Project
  • Virtual file system (VFS). Build a user land application that emulates the VFS layer of an operating system. Start with support for a calls that do simple local file IO, and then optionally build it up to also support NFS.

Client-Server Examples

  • Chat Application: Create a chat application which allows you to connect directly to another computer and chat with another person (this can be completely text-based or include a GUI). You can implement chat rooms (e.g., as supported by Internet Relay Chat (IRC) or XMPP (gtalk, etc)) or a more direct chatting style like MSN). For added complexity, create your own protocol to facilitate this chatting. This can be implemented as either a purely command line application or have a GUI for the client.
  • Mail checker: The user enters various account information include web server and IP, protocol type (POP3 or IMAP) and the application will check for email on several accounts at a given interval. This can be purely command line or have a GUI.

Image Manipulation Examples

  • Command-line image transformation (e.g., with Instagram-like functionality), which applies a number of filters to the image supplied as input (e.g., a PNG image).
  • Image morphing -- given two input images, create an animation (e.g., animated GIF) that morphs one into the other.

Past years' examples

  • Project descriptions from Winter 2014.
  • Project descriptions from Winter 2015.

Other

Green Marinee theme adapted by David Gilbert, powered by PmWiki