#
Requirements
The following sections outline the requirements for the course project. In general terms, we are building graphical applications that leverage cloud services and remote databases. The project should be a non-trivial application that demonstrates your ability to design, implement, and deploy a complex, modern application that solves a problem for real-world users.
You will be assessed based on:
- How well you define the problem you are solving, and understand the users you are solving it for.
- How well you design features to address that problem; the quality of your design.
- The clarity, quality and ease-of-use of your application.
- Your ability to work as a team to incrementally deliver features over time.
There are multiple milestones in this project, each with a specific set of requirements that you must address. You should be working towards these requirements incrementally, and you should be able to demonstrate your progress at each milestone. In other words, you are assessed based on your ability to incrementally build a complex application, not just on the final product.
#
Basic Features
You will design and build a multi-platform console or desktop application (Windows, macOS, Linux) or a mobile application (Android) that meets the following requirements:
- Your application should be a non-trivial application that solves a problem for real-world users. You should be able to articulate the problem you are solving, and the users you are solving it for, in a few sentences. See the
next section for more details. - Your application should have a compelling, clear, and well-designed user interface (and it must be a graphical user interface for desktop or mobile applications). You must use MVVM or some variant of that design pattern in your implementation.
- You should manipulate some type of data relevant to your application, and persist that data to a database between application sessions. This should be a remote database hosted in the cloud. The exact details will vary based on the type of application you are building. e.g., a fitness application might store your workout history in a cloud database.
- You are expected to use the architectural styles, patterns and design principles that we discuss in lectures.
- You are expected to write and include a reasonable number of unit tests for your application. These should be executed as part of your build.
- You should meet the platform-specific requirements for the platform you are targeting. e.g., Android applications should follow the Material Design Guidelines and handle issues like screen rotation gracefully. You should support input validation, and cut/copy/paste functionality for text data.
- You must use the technology stack that we present and discuss in-class. The following are mandatory: Gradle, Kotlin, JUnit and GitLab. For graphical applications, Compose is also required. Other libraries may be used at your discretion, provided that you follow the course policies.
I expect that most teams will build a graphical desktop or mobile application, but I'm "leaving the door open" for a team to create an amazing command-line application if they wish. There are some use-cases where that actually makes more sense than a graphical application. Keep in mind that if you go that route, you would be expected to have OUTSTANDING command-line support and probably a Text UI (TUI) interface.
#
Custom Features
As part of your Project Proposal, you will define your target users, a problem to address, and a set of custom features to address that problem. These features will be unique to each team, but should be non-trivial features that demonstrate your ability to design and implement complex functionality to address a problem. You should be able to articulate how these features make your product different or better than existing applications.
#
Advanced Features
In addition to the features above, you must implement at least one of the following. Note that these get progressively more difficult as you move down the list:
- Use live data from an existing cloud service as part of your core functionality (e.g. search Twitter data; load image data from Google; lookup names of Pokemon on a custom REST service). See Selecting a Project for some potential APIs that you can use to query online data.
- Author your own cloud service, which provides additional logic to your application. Must be RESTful, with a well-defined API, and be hosted on {AWS, GCP, Azure}. This would extend and build on your remote database functionality.
- Support multi-user scenarios. This means supporting different users, each with their own data stored in the cloud. Your application would need to support user authenticaton, so that each user could only see and use their own data. Authentication must be secure; leveraging platform-specific authentication is a good idea. e.g., Google Sign-In for Android.
- Support single-user multi-device scenarios. This requires the ability to have your data shared across different instances of your application, which are running concurrently e.g., being logged into your applicaiton on two separate devices. Each application instance would need to detect and handle changes from the other application instance. This likely requires some form of real-time data synchronization between a custom cloud service and your application.
- Publish to the appropriate application store (e.g. Google Play for Android). This is a non-trivial process that requires you to follow the guidelines for the store, and have a well-designed application that meets the store's requirements. Submitting to the app store is not sufficient; you must actually pass all gating criteria and be published such that I can purchase your application.
- Build up a full CI-CD pipeline, with runners, and automated deployment to a test environment (not just unit tests). This would require cloud hosting e.g., AWS, GCP, Azure, and a CI-CD tool e.g., Jenkins, GitLab CI, Travis CI.
- Deliver your application across 2 or more different platforms, using a shared codebase. e.g., desktop AND Android phone. It's reasonable for one of these to be a "lightweight" version that has fewer features. e.g., a notes application where the desktop version has more features than the Android version.