tawratnibir/online-examination-design-patterns

1. Project type and runtime

- This is a plain Java console application with no external frameworks, databases, or build tooling.

- The runtime entry point is app.Main, which orchestrates object creation and prints the final exam dashboard to stdout.

2. Top-level architecture

- The system is split into four main boundaries:

- configuration for exam settings

- exam for exam domain types

- question for question abstractions and concrete families

- source for where questions come from

- The design is intentionally pattern-heavy, using Builder, Factory Method, Abstract Factory, and a simple dependency injection / IoC style for question sourcing.

3. Configuration subsystem

- configuration.ExamBuilder builds configuration.ExamConfiguration.

- ExamConfiguration is immutable and holds exam metadata such as title, duration, passing score, negative marking, shuffling, calculator permission, and auto-submit behavior.

- This subsystem is independent of question generation; it defines the exam’s policy and presentation parameters.

4. Exam domain and Factory Method

- exam.Exam is the shared exam abstraction.

- MidtermExam, FinalExam, and PracticeQuiz are concrete exam types.

- exam.factory.ExamFactory is the base factory method layer, with subclasses MidtermExamFactory, FinalExamFactory, and PracticeQuizFactory.

- The exam factory boundary decides which exam type to instantiate, while the rest of the system supplies configuration and questions.

5. Question abstraction layer

- question.Question is the common question model interface/base type.

- Supporting contracts include:

- QuestionFactory for creation

- QuestionRenderer for display formatting

- QuestionEvaluator for scoring/answer checking

- QuestionType for categorization

- This layer isolates the exam system from the details of any particular question family.

6. Abstract Factory for question families

- Concrete question families live in subpackages:

- question.mcq

- question.essay

- question.programming

- question.truefalse

- Each family typically contains four roles:

- a question data class, e.g. MCQQuestion

- a factory, e.g. MCQFactory

- a renderer, e.g. MCQRenderer

- an evaluator, e.g. MCQEvaluator

- The factory acts as the family entry point, creating consistent question objects tied to the right renderer/evaluator behavior.

7. Question source as a dependency boundary

- source.QuestionSource abstracts where question content comes from.

- Implementations are:

- BankQuestionSource for built-in curated questions

- FakerQuestionSource for generated synthetic questions

- ManualQuestionSource for directly supplied questions

- QuestionBank and QuestionFaker support the source implementations.

- Factories receive a QuestionSource instance, which decouples question creation from data origin.

8. How the pieces connect at runtime

- Main chooses an exam factory, creates an exam instance, builds configuration, and selects a question source.

- The exam factory provides the exam shell.

- Question factories use the injected source to create concrete questions of the appropriate family.

- The resulting Question objects are assembled into the exam and then rendered as a dashboard.

9. Concrete demo flow in this repository

- The current sample flow creates a MidtermExam.

- It uses BankQuestionSource.

- It composes a mixed set of question families: MCQ, MCQ, Essay, Programming, and True/False.

- It applies a configuration with title, timing, passing score, and runtime flags such as negative marking, shuffle, calculator access, and auto-submit.

10. Important architectural boundaries for a diagram

- Keep app.Main as the top orchestration node.

- Show configuration as a separate immutable settings path feeding the exam.

- Show exam.factory as the exam-type selection layer.

- Show question as the abstraction layer, with four concrete family branches.

- Show source as an injected dependency into question factories, not a direct dependency of Main on question internals.

- The key direction of dependencies is: Main → factories/configuration → exam/question objects → rendering/output.