System Design

System Architecture

The system is built using a layered architecture consisting of Structures, Services, and Interfaces.

Structures correspond to the domain or data layer in Domain-Driven Design (DDD). They are responsible for holding the application's state and entities, as well as modeling real-world objects, such as domain objects like AssignmentDetails.

Services represent the service layer, containing the business logic of the application. This includes components like the TestRunner, which runs tests for assignments.

Interfaces serve as the abstraction layer, defining abstract contracts that enable loose coupling and provide necessary functionality. For example, the TestRunner interface outlines the required behaviors for any test runner implementation.

Submission Grading

1. Submission Extraction

• The SubmissionExtractor class handles the extraction of submissions from the uploaded submission.zip file.
• Submissions are extracted and organized into directories, each corresponding to an individual student's submission.

2. Submission Testing

• The AssignmentTestRunner class runs predefined test cases on each submission.
• These tests evaluate the correctness and behavior of the code based on the assignment specifications.

3. Submission Grading

• The results of AssignmentTestRunner are passed to the GradeFactory where grades are allocated for each test case based on whether it passed or failed.
• These grades are then stored in AssignmentGrade along with more descriptive feedback for if a test case passed or failed.
• StudentDetails are also extracted from the submission and stored in an AssignmentDetails object with AssignmentGrade.

4. Feedback Generation

• The PDFGenerator class creates a detailed report for each submission using the AssignmentDetails. This report includes the the overall score obtained as well as detailed feedback on passed and failed test cases.

Development Cycle

This software system was developed using an iterative approach, organized into distinct phases: Development, Testing, and Refactoring.

The Development phase focuses on introducing new functionality through extensions.
The Testing phase ensures the correctness and performance of pre-existing functionality.
The Refactoring phase aims to improve the modularity and extensibility of the codebase.

Development and testing phases can occur in parallel, as long as interfaces are agreed upon and adhered to. Refactoring is typically done concurrently or one at a time, with careful attention to the main branch.

For more details on this workflow, refer to our internal docs.