Requirements

What is a full-stack application?

A full-stack application is an app that has a front-end/client component that runs on a personal device (computer, phone), and one or more back-end components that run on a remote system (server) to provide additional capabilities.

We often do this when we have data that needs to be shared, or we want to leverage a system with different/greater capabilities than our local devices.

Many of the applications that you use are full-stack applications!

• a web browser is a front-end client for a remote web server that contains shared data/pages.
• the Twitter client pulls tweets from a number of online sources and presents them in a local client.
• Microsoft Word is mostly a local application, but it integrates with OneDrive (Microsoft’s remote storage solution) for document storage.
• even a text editor like Visual Studio Code integrates with a number of remote services for automatic updates, pulling down extensions and so on.

You and your team will propose, design and build a full-stack application that runs locally but leverages one or more remote services (at least one of which you must create yourself).

Functional requirements

You can either choose one of the projects listed here, or suggest your own.

Option 1. Course notes journal

• Users: Students that take notes.
• Purpose: Allow users to import and track information on courses that they’ve taken. e.g. ratings, lecture notes, prof’s birthday.
• Similar: Noteability, UWFlow
• Functionality:
  • Local: Browse available courses, import and display course information from UW Open API.
  • Remote 1: Imports course information from UW Open API (read-only).
  • Remote 2: Store notes and course comments in a custom service (read-write).
  • Remote 3: Integrate with UWFlow (read-write) – optional

Option 2. Collaborative whiteboard

• Users: Professionals that collaborate visually (students, designers, developers, architects).
• Purpose: Provide a large canvas where people can sketch (e.g. virtual whiteboard), and changes are shared across multiple clients.
• Similar: Miro
• Functionality:
  • Local: Shape editor that allows you to drag/drop shapes, connect them, add text to a large canvas.
  • Remote: Stores drawings (“source-of-truth”) in a custom service and keeps multiple clients synchronized.

Option 3. Journaling Application

• Users: Anyone that wants to track recurring information.
• Purpose: Have a single multi-purpose application to track day-to-day information (e.g. medication journal, work tasks, TODO lists).
• Similar: Notion, DayOne
• Functionality:
  • Local: Create, view, organize collections of notes; Support rich formatting (rich-text, markdown or similar).
  • Remote: Store notes on a custom service, where they can be loaded across multiple devices. Multiple collected clients should remain synchronized as changes are made.

Option 4. Create Your Own

You and your team are free to choose a project topic. As a starting point you should:

1. Identify target users. You should be solving a problem for them.
2. Identify the purpose of your application. e.g. devise a better way to store code snippets for a developer; build a e-book reader that stores books and user ratings; a system for UW students to plan courses using UW Open API data.
3. Determine the basic requirements and features that would be required to address this problem. Look at competing products to get ideas. Brainstorm with your team and try to be original in solving the problem in a unique and better way!
4. Identify local and remote functionality - make sure that you are dividing features across both a client and service.

Core guidelines

Regardless of whether you choose one of the topics above, or define your own project, you are expected to meet some common criteria:

1. You are required to use our technology stack. Deviating from this list in any way requires explicit instructor permission (typically an email thread that you include in your project documentation).
2. Plan to design and build at least one client and one service. Your client can be an Android application, or a Desktop application (macOS, Windows or Linux). We will provide assistance in all of these. For bonus marks, you could support a second client.
3. Your client application must adhere to the conventions of the given platform. e.g.
   • Desktop applications should support min/max/resizing; user functions should be clear and easy to find and use (through menus, toolbars, keyboard shortcuts); standard features like copy/paste, undo/redo should be implemented.
   • Mobile applications should use conventions for that platform: touch for selection, other gestures as appropriate; popup menus or hamburger buttons that expand to list functionality and so on.
4. Your application must save and restore data between sessions. This typically means saving user preferences for the client on the local filesystem (e.g. window position and size), and shared data in database on your remote service (e.g. for a notes application, notes would reside in some database so that they were not lost if you rebooted the system).
5. All other functional requirements are to be determined by you and your team. This is important, since a significant portion of your final grade will be based on (a) how well you solve the problem for your user, and (b) how well your design “fits” the target platform. You will be required to submit a proposal early in the course, describing your proposed features, and get feedback/approval for your specification.