Requirements#

Your project will need to address product requirements(what your product does), technology constraints (what tools you should use), and project requirements (how you will work together). All three of these factors contribute to your final grade.

1/ Product Requirements#

What should your product look like? How does it work?

General#

You product design must met all of these requirements.

1. Run on a current version of one of these operating systems.

   • Desktop: Windows, macOS, Linux (with JVM).
   • Mobile: Android, iOS.

2. If you design a mobile application, you should support the standard style and interaction idioms of that platform e.g., swipe to navigate forward or backward, use navigation buttons to move between screens and so on.

3. If you design a desktop application, you must incorporate standard interaction and presentation idioms of that platform. e.g., keyboard shortcuts for common actions, a menubar presenting most commands, the ability to resize a window, and handle resizing window contents.

4. Your application must store some portion of its data in a database e.g., recipes for a recipe tracking application, or user preferences like choice of theme. The minimum requirement would be a local database that was installed alongside your product e.g., a desktop or Android application that uses a SQLite database stored on the file system.

5. You must identify at least one area of your application where operations can be streamlined by handling tasks asnchronously. You must use coroutines to manage performance in these sections of code.

6. Your application must also deliver functionality that is suitable to the particular problem you are solving. As part of your project proposal, you will define a user, their problem, and user-stories i.e., problems and expected solutions. This will require you to identify the features that are specific to your application e.g., sorting recipes in a cooking application, display a social feed for other users in a multiuser application.

   This list of features will be different for each project but should be sufficient to address all of the functionality that the user might expect. You should expect that most of your features fall into this category!

Advanced#

Additionally, you must implement one or more of the following requirements.

1. Consume data from an external data source such as a web API, or LLM. e.g., a recipe application might import recipe data from a web api, or a handwriting recognition application might use an LLM for shape detection.

2. Use an external database to store your data (or, split your data between local and remote databases). This external database must be a relational database, and you must implement appropriate privacy and security measures for your data i.e., implement an authentication mechanism with support to add/edit/delete accounts, store passwords securely and so on.

3. Target multiple platforms with a single (shared) codebase. e.g., you might decide that your recipe application needs to work on both Android and iOS. This feature should use Kotlin Multiplatform, and focus on building a single application that shared source code for each platform.

Carefully think through your features at the start of the project to ensure that you will meet all of the requirements. Grades are awarded for both exceptional design and exceptional delivery of a solution. Just like in the real-world, “polish” counts ¹!

2/ Technology Constraints#

Your application must be built using the following technologies, which we will cover in lectures ².

• Kotlin for a programming language.
• Kotlin Toolchain for build configuration.
• kotlin-test and JUnit for test coverage.
• Jetpack Compose and Compose Multiplatform for user interfaces.
• Coroutines for concurrency.
• Ktor for network connectivity (database, agent or other).
• Koog for LLM agent integration.
• SQLite and Room API for local data storage.
• Supabase for online data storage.

3/ Project Requirements#

You are expected to follow practices that we discuss in-class. This includes:

• Meeting twice weekly as a team, and recording meeting minutes in your Wiki.
• Logging and tracking tasks in GitLab.
• Following suggested practices for branching and releasing from Git.
• Following our architectural and design guidelines.
• Writing adequate unit tests.