Materials for Final Projects

This posting has files & materials that will be useful for each project. It also contains a few important requirements for your first project check-in meeting to be held by April 11.

1. First Project Check-In

Our goal in collecting project proposals in March is to give you as much time as possible to make these projects as successful as you want! But we recognize that you are busy: coursework, job searches, personal matters, and sleep are all extremely important. So, we want to keep the scheduling for this project as flexible as possible. If you want to make something really well polished to put into your portfolio, it’s probably a good idea to get started now with a few hours per week on this project. If you are more interested in just “getting it done”, that’s fine too—projects do not need to be perfect in order to earn high scores.

To encourage you to think about these projects and give you enough time to appreciate the work involved, we have a first TA check-in that must be completed by April 11th. You can schedule the check-in with your assigned project TA at any time before then. At the time of the first check-in, you must:

  • Set up your team’s GitHub project and populate it with several features to be implemented
  • Design your classes and create a class diagram to explain your choices to your TAs
  • Identify which design patterns you plan to implement and demonstrate these in the class diagram.
  • Identify one (or more!) elements of the project that you anticipate being the most challenging or confusing. You must also formulate one (or more!) questions that you would like assistance with. Your TAs may be able to help you; if not, they will forward the questions to me.

2. Themed Project Files & Materials

Othello

Project Outline

A thorough writeup is provided here.

Movie Name Game

Project Outline

  • 📁 Data files for the top 5000 movies & their credits) from TMDB. (Downloaded from Kaggle.)
  • 🔗 Link to TMDB API for optional project features

Small Programming Language

Project Outline

Here is the specification for the language.

Data Types

Integer is the only data type supported. All variables store integers. Integers can be negative or positive. While the language should support some conditional structures, these should follow C rules: 0 is considered “false” and every other value is “true”.

Comments

Single-line comments should be indicated with ---. These should be able to appear anywhere within a line and have the remaining characters of that line ignored.

--- this is a single line comment
--- you do not need to support multi-line comments.
var cube = 3 * 3 * 3; --- this comment comes as the end of a line.

Variable Declaration and Assignment

All identifiers (variable names and functions) must consist only of lowercase letters and underscores (_). this_is is a valid variable name, but thisIsNot is not.

The assignment operator will be <-. To declare a variable, the var keyword must be used. Use of a variable before its declaration is not allowed.

var x <- 5;
var y <- 10;
x <- x + 1;

Your language should support the declaration and initialization of several variables on the same line, like so:

var price <- 10, tax <- 8, discount <- -3;

It should not be possible to declare a variable without assigning it:

var q; --- not a valid program!

Variable assignment should be a statement, not an expression: while the assignment changes the value of the variable, it should not produce a value:

var b <- (var a <- 3); --- not a valid program!

Basic Arithmetic Operations

  • Addition: +
  • Subtraction: -
  • Multiplication: *
  • Division: / (Integer division only, remainder discarded)
  • Modulus: % (Remainder of division)

Basic Relational Operations

Support the following operators: <, >, <= >=, = (“equals”), and ~ (not equals). Because there is only one data type in this language, these operators should produce 0 when the output is false and 1 otherwise.

Function Calling Syntax and Built-in Functions

abs(x): Returns the absolute value of x

var negative <- -5;
var positive <- abs(negative);  --- positive is 5

max(x, y): Returns the larger of two integer values

var larger <- max(5, 10);    --- larger is 10
var negatives <- max(-5, -10);  --- negatives is -5

min(x, y): Returns the smaller of two integer values

var smaller <- min(5, 10);    --- smaller is 5
var negatives <- min(-5, -10);  --- negatives is -10

Control Structures

Conditional statements follow the same rules as Java’s. A key difference is that your language should support the elif keyword in lieu of a full else if.

if (x > 5) {
    y <- 10;
} elif (x = 3) {
    y <- 9;
} else {
    y <- 5;
}

Your programming language should support while loops and run-while loops. while loops should behave exactly as they do in Java, including with respect to rules about scoping: variables declared within a loop are accessible only within that loop block.

run-while loops are like do-while loops in Java. If you aren’t familiar with do-while loops, Java’s documentation provides the following explanation:

The difference between do-while and while is that do-while evaluates its expression at the bottom of the loop instead of the top. Therefore, the statements within the do block are always executed at least once.

while (x ~ 10) {
    x <- x + 1;
}

run {
    print x;
    x <- x * 2;
} while (x < 10)

Functions follow Java-like rules.

  • Declare a function with the function keyword.
  • Give the function a name, which must be a valid identifier (lowercase letters and underscores only).
  • In parentheses, provide a comma-separated list of parameter variables.
  • Use the return keyword to return a single value and exit the function.
function add(a, b) {
    return a + b;
}

var result <- add(5, 10); --- would store 15

Input/Output

These are two special function-like commands that do not use parentheses.

print x;            --- Output a value
var z <- input;     --- Read an integer from standard input

Entry Point and Scope

Your program should start execution by calling the function called entry() (like main() in C/Java). The only code permitted at the top level should be function definitions. It should be possible to call a function earlier in the file than where it is defined, like in Java.

Make sure that your program exhibits proper scoping rules:

  • Block scope
    • variables declared within a block are only accessible within that block
    • blocks contained inside of another block inherit the scope of the parent block
  • Function scope
    • parameters are local to the function
    • the caller scope is not visible to the callee

Reminder: General Requirements & Restrictions

Team Structure

  • Teams will have 3 members
  • All members must contribute, verified by peer evaluations and GitHub history

Version Control

  • Teams must use GitHub project management tools (discussed after Spring Break)
  • Projects should be broken down into discrete tasks. These tasks will be managed & assigned using GitHub and tracked from planning through completion
  • Regular commits/pull requests from feature branches expected

Technical Requirements

  • All code must be written in Java (firm requirement)

Timeline

  • Groups formed by March 3 ✅
  • First proposal due: March 7 ✅
  • Feedback provided by: March 19 ✅
  • Required check-in meeting by: April 11
  • Second check-in meeting by: April 25 (Independent Projects Only)
  • Project code due: May 12
  • Project presentations to TAs: Until May 13 (can be scheduled after May 1 at group & TA discretion)

Documentation

  • All code must be documented with comments and tests
  • Fully featured JavaDocs included as optional “completeness” feature
  • Work with outside resources (books, websites, LLMs/Copilot) is permitted but must be cited

Reminder: Evaluation Scheme

Core Features (35%)

This category includes the portion of your grade that comes from correctly implementing the core features of the project. Points for this category will be allocated differently for different projects.

Extended Features (5%)

This category includes the portion of your grade that comes from completing one or more of the optional features specified in the project descriptions. For independent projects, groups are responsible for proposing their own ideas for “stretch” features.

Design (10%)

This category measures two requirements:

  • successful implementation of two design patterns. For the Movie Name Game and Othello projects, one of the design patterns is specified for you.
  • system design that exhibits high cohesion and low coupling

GitHub (5%)

Use of Git & GitHub for:

  • version control purposes (frequent commits; pull requests to implement features; multiple students contributing)
  • project planning purposes (project tracking; enumerating features)

Testing (30%)

From this category, 25 out of the 30 percentage points are allocated for reaching 80% testing coverage. The remaining 5 percentage points are allocated for qualitative analysis of your tests: do you have many specific tests, or one large test? Are your tests meaningful, or do they just aim to execute as many lines of code as possible? Do you handle edge cases? Do you test both for inputs & outputs as well as state changes?

Documentation (5%)

Is your code commented? Do you have a UML diagram that correctly describes all of your class relationships?

Presentation (5%)

Do you have all of the required sections?

  • Project design
  • Initial project plans
  • Choices made for optional requirements
  • Project demo
  • Challenges faced/project retrospective
  • TA Q&A

Team Assessment (5%)

Points awarded for completing an anonymous Google form. All of the points for this category come from completion of the form, but I (Harry) reserve the right to adjust any group member’s overall score as a result of information that teams share about their members.