Project

Project #

Students enrolled in this course are expected to deliver a group project.

Two alternative options #

Students can develop either:

  1. A project of their choice, or
  2. Their own version of the board game used as our running example.

Groups who choose the second option (board game), will benefit from:

  • a graphical user interface (so that it is sufficient to implement the mechanics of the game),
  • additional content provided during the lectures (as illustrations), which can be incorporated to the project.

Requirements #

Here are some requirements common to both options (free project or board game).

Source code #

The source code for the project must be written in Java 17 or lower.

The code should be original (or mostly original). If a project incorporates external code, it has to be referenced clearly in the README.md file of the project. If the project takes inspiration from a tutorial or the source code of another project, then this should be referenced as well.

The source code must be submitted as a GitHub repository. The commit history must reflect the individual contribution of each member of the group. For this reason:

  • each student should use a different (and only one) GitHub account, and
  • each student should commit his/her own code.

The repository should contain at its root a .gitignore file hat indicates files that should not be tracked. In particular, a repository should not contain:

  • compiled classes,
  • jars,
  • logs,
  • run-time files,
  • IDE-generated files (e.g. .idea/),
  • OS-generated files (e.g. .DS_Store),
  • etc.

Dependencies, build and packaging #

Any additional Java library can be used in a project.

The project should be build with either Maven or Gradle. It should run on the evaluation environment via command line instructions.

For instance (depending on how the project is designed), the instructions to build the executable may be:

mvn package

and the instruction to run the executable may be (assuming that the executable is called myJar.jar and that the program takes two strings as input):

java -jar myJar.jar "firstInput" "secondInput"

If the executable cannot be built in the evaluation environment, then an über-jar should be provided that can run in this environment (via command line still).

Documentation #

The git repository should contain at its root a README.md file (written in Markdown). This file should contain at least the following information:

  • members of the group and their respective GitHub identifiers,
  • clear instructions for building and running the project,
  • a description of the project,
  • a user’s guide for the project (either a written guide, or a link to a video),
  • a brief overview of the implementation of the project. This should include information on:
    • the different (high-level) components and interfaces between components,
    • which third-party libraries were used (if any), and
    • some programming techniques (seen in the course or not) that were particularly relevant for this project.
  • a description of the human experience in this project. This should include information on:
    • how the workload was distributed between the members of the project,
    • how git was used, and
    • challenges that each member faced (at least one per person).

For further information about what a README.md file usually contains, one may look at this web page.