project-proposal-2025

[RoastMyCards]

Abstract

Do you know Anki? a popular spaced repetition system, cross-platform software, which helps numerous college students get satisfying scores in their studies. A real magic that basically can help you to remember everything. If you never used it, just think about RiPPLE. Maybe you don’t like it, but it’s widely used in many courses, at least in UQ.

It’s highly suggest that you should create your cards on your own. This is the only best way empower you most. However, you’d better to repeat your cards when you’re pretty sure they’re free of errors. Don’t repeat yourself if they contain a lot of mistakes. Even though AI and GPT-like tools are popular, many students still tend to get feedback from real persons, just like asking questions on ED and waitting for their teachers or tutors to answer or correct.

So are your flashcards. The painpoint is that you can’t just export your cards and sent them to your friends to do this. After trying this several times, you’ll find how annoying it is.

Therefore, why not use RosastMyCards to let your friends to modify cards for your and automactically sysn with your Anki?

Author

Name: Junchen Zheng

Student number: 48706126

Functionality

Account System

Account Registration - Register an account via email.

User Search - Search for users within the page.

Friend Addition - Apply to add a friend.

Friend Deletion - Delete an existing friend.

Friend Request Revocation - Revoke a friend request.

Friend Remark Modification - Modify the remark of a friend.

Friend Request Sending - Send a friend request via a link.

Friend Grouping - Group friends by tags.

Card Modification Request

Request to a Single Friend - Send a request to a selected single friend.

Request to Tagged Friends - Send a request to all friends under a certain tag.

Community Sharing - Share your own cards to the community group of the topic.

Friend Viewing - Let friends view your cards waiting for modification.

Direct Modification by Friend - Allow friends to directly modify the fields of your cards.

Comment by Friend - Let friends leave comments on the fields of your cards.

Personal Card Viewing

Card List Viewing - View the list of your own cards.

Comment Viewing - View friends’ comments.

Accepting Modification Changes - Directly accept the modification changes made by friends.

Course Community

Viewing Public Cards - View the content of others’ publicly - available cards.

Scope

Because of the limited time we have, for our Minimum Viable Product (MVP), there are some restrictions. When users upload cards, they can only use plain text. We don’t support adding images or audio to the cards for now. Also, when it comes to reviewing the cards, friends can only leave comments in plain text. They can’t add audio or images to their comments either. Right now, the main things our system focuses on are letting users send invitations to their friends and allowing them to review and modify the cards among themselves.

Also, currently, we only plan to support adding and deleting friends. In the MVP, there will be no support for revoking sent friend requests.

Regarding the evaluation, due to the limited time, we may only be able to add a logging system and won’t be able to add a system-level monitoring system to monitor the smooth operation of the entire system.

In addition, we need to emphasize that this system is an Anki card review and modification system, not a complete Anki application. Therefore, basic operations such as creating and modifying cards still need to be carried out within Anki. Moreover, the operation of selecting cards for uploading is completed through an extension. Of course, the extension will be provided as well.

Quality Attributes

Interoperability

Interoperability in this Django-based system refers to its ability to smoothly share information and exchange data with internal Django apps (components) as well as other external systems. For example, the user authentication app in Django should be able to interact with other identity management systems for seamless authentication. Also, the system might need to communicate with third-party educational platforms (APIs) to import or export course materials. The use of Django’s REST framework or other appropriate libraries should enable easy integration with external systems while maintaining data integrity and security.

Extensibility

In the context of a Django project, extensibility means that new features or apps can be added to the system with relative ease over its lifespan. Django’s modular architecture, with its concept of apps, allows for the separation of different functionality. New features like additional card formatting options, more advanced friend grouping features, or enhanced privacy settings can be implemented as separate apps or added to existing ones. This quality attribute ensures that the system can adapt to evolving user needs and technological advancements.

Availability

Availability ensures that the Django-based system can be accessed on demand by end users, whether at any time or on any platform, or both. Django applications are typically deployed on web servers, and ensuring high availability involves managing aspects such as server configuration, load balancing, and database connection pooling. Users should be able to perform actions like account registration, friend invitation, card review, and access to course community features without significant interruptions.

Evaluation

1. Code Structure and Modular Design - The project should follow Django’s MVT (Model-View-Template) architecture to clearly separate business logic, data, and the presentation layer. You can also use the MVC (Model-View-Controller) pattern. In Django, the controller layer can be done through views and templates. - Each main function of the project should be put into different Django apps, following Django’s modular design idea. This makes it easy to add new apps and expand the project without affecting other parts, and it’s flexible and easy to maintain. - Organize the codebase so that each Django app is in charge of a specific function. This separation helps new features be developed and added to the system with less trouble.
2. URL Design - Use Django’s urls.py file to manage route definitions. This gives a clear way to see how URLs are linked to specific views or resources. - It’s important to use Django’s include() function to manage routes in multiple files. This makes the URL structure easier to handle, especially in big projects, and helps with scaling. Adding new routes or apps won’t make the routing system messy. - For RESTful API routing, use a versioned structure like /api/v1/ or /api/v2/. This helps with backward compatibility and makes it smooth when new API versions come out.
3. Database Extensibility - Use Django’s ORM (Object-Relational Mapping) for database management. It makes database work simpler and reduces the need for complex raw SQL queries. - Design the database schema to easily handle changes, like adding new models or changing existing ones, without breaking the system. - As the data amount grows, design the database to scale well. You can use methods like database sharding, partitioning, or multiple replicas for load balancing. Django’s ORM can easily work with scalable database solutions, so the system can grow with user data without major changes.
4. API Design - Use Django REST Framework (DRF) to design RESTful APIs. DRF is a great tool for creating APIs with a clear and easy-to-maintain structure. It’s easy to integrate with third-party systems and handle different data formats. - Design the API to handle the system’s core functions, separating models and views clearly. Using serializers and viewsets properly makes it easy to expand the API for new features, like more endpoints or advanced filtering. - Version the API endpoints and provide clear documentation for users and developers. This ensures that future changes or expansions won’t break existing integrations.