Skip to content

ProjectDescription.md

Latest commit

 

History

History
95 lines (71 loc) · 4.28 KB

ProjectDescription.md

File metadata and controls

95 lines (71 loc) · 4.28 KB
Raw

TEAM PROJECT – LEARNING INTEGRATION ASSESSMENT (LIA):

1. General Requirment

In a team setting (two or three members), students will implement a GUI-based desktop application, with the aspects mentioned below:

  • Respecting the design specifications and using the new programming language (C#) used in this course.
  • Following the proposed development steps. This includes specifications analysis, task breakdown, progress tracking, deployment.
  • Presenting the final application product,
  • Writing and submitting the application documentation (user manual).
  • Using a data source such as a database or file.
  • Manage and manipulate data input by the user, keeping track of changes.
  • Create an internationalized application using I18N and L10N concepts.
  • Apply design patterns if applicable.
  • Utilize data structures, collections, and LINQ processing (with or without Lambda expressions).
  • Collaborate through a Git repository for version control, issue tracking, and team collaboration.
  • Follow a Test-Driven Development (TDD) approach.

2. Design Requirements

  • A clear and well-designed GUI for input and output is essential.
  • Utilize relevant class libraries.
  • The application must support at least two languages (e.g., French and English), using I18N Java classes like ResourceBundle and Locale.
  • Choose appropriate data structures that best fit the data model.
  • At least two hierarchies of classes, each one has two layers (such as User, Teacher, Student) is required for the project.

3. Steps to follow

  1. Create UML diagrams (ER if database is used, class, and activity diagrams).
  2. Design the user interface (GUI).
  3. Develop the core classes.
  4. Write test class(es) using unit to test the controller methods.
  5. Add internationalization features using at least two Locale objects.

4. Deliverables:

4.1 Deliverable 1 - Project Description:

Submit a project idea, addressing the following points:

  • Scenario: Explain the scenario under which your project will operate.
  • Design Paradigm: List the functionalities you plan to demonstrate.
  • Expected Output: Describe the expected results and the actions the user can perform with your application.
  • Git Repository: Initialize a Maven project with valid .gitignore, and a README.md file for a project description. Create a doc folder which contains diagrams and the the Deliverable 1 PDF.

4.2 Deliverable 2 - 50% Checkpoint:

Submit the source code as a .zip file. The application structure must be in place, with:

  • Implementation of all core classes and data structures.
  • Database connectivity.
  • Updated Git repository.

The Git repo must be updated too.

4.3 Deliverable 3 - Final Submission:

Submit the complete application, including:

  • Project source code (as a .zip file).
  • Executable JAR file that includes all necessary resources to run the project without recompilation.
  • A user manual

The Git repo must be updated too.

4.4 Project Report:

Submit a project report consisting of:

  • Cover page with your name, project title, and course name.
  • Outline/Table of Contents.
  • Project Description (same as Deliverable 1).
  • Program Features and Screenshots (showing how the project meets the requirements, with output and execution examples).
  • Challenges (any unimplemented features or issues faced during development).
  • Learning Outcomes (what you gained from the project).

5. Submission Requirements

  1. Deliverable 1 and the Project Report should be submitted as PDF files via the Lea system.
  2. Deliverables 2 and 3 should be uploaded to the Git repository.
  3. Deliverables 2 and 3 must also be zipped and submitted via Lea.

6. Grading Criteria

The following criteria will be used to evaluate the project:

The project will be evaluated based on the following:

  • Functionality (accuracy of output, performance, etc.)
  • Robustness (handling edge cases, exceptions, and invalid inputs)
  • Adherence to project specifications
  • Appropriate use of data structures and the Collections API
  • Correct application of design patterns, I18N, MVC, Lambda expressions, and OOP principles (e.g., information hiding, polymorphism)
  • Code documentation
  • Thorough testing
  • Quality of presentation and completeness of output
  • Appropriate use of Git for commits and collaboration
  • A recentable code testing coverage
  • Git repository is appropriated used.