Computer Science and Information Technology Department

College of Engineering
CSC202 – Spring 24-25 – Project
Marks: out of 15 marks
Objective and Overview
(15%)

 A Java programming project that implements and reinforces the concepts of Classes, Constructors,
Encapsulation, and Association.
Group submissions
Grading Rules - rubric (See end of document for more details) (2-3 members per
group)
 Tasks completion: Checks if all the tasks mentioned the assignments tasks section
6 marks
are covered and completed.
 Presentation: Presentation evaluation criteria will focus on communication skills,
3 marks
convincing talk and accuracy of information presented, and presentation dynamics.
 Functional Errors: Checks if the implemented system works as intended, no errors
2 marks
in the implementation as described below in the Java error section.
 Code explanation and documentation: Assesses your ability to explain your code
and design choices, through in-code comments and a separate document outlining
2 marks
your thought process, challenges faced, and the rationale behind your
implementation choices.
 Code organization and structure: Evaluate the overall organization and structure
of the code, ensuring it is modular, easy to read, and follows best practices. This 1 mark
includes proper indentation, use of whitespace, and appropriate commenting.
 Report format: Proper format and organization of the report. You need to use
proper citation and referencing (IEEE or APA), consistent font style/size, consistent
1 mark
alignment, consistent headings, and page numbers. All figures and tables must have
captions and they must be referenced inside the text.
 (Bonus) Creativity and uniqueness: Reward for unique or innovative solutions,
demonstrating your ability to think critically and develop your own approaches to 1 mark
solving the problem.
Submission Rules

 Submit on blackboard all classes along with report explaining them and your thought process.
 Due date: June 2nd, 2025.
 Late submissions will be penalized by 1 mark per day after the deadline.
 Plagiarized work will be reported to OAI.
 A student who misses the presentation day/time will get a zero grade; no make-ups allowed.
(PowerPoints alone will not be accepted)

1
o Overview:

This Java programming exercise aims to implement an Online Marketplace System that utilizes
the majority of the following concepts: Classes, Constructors, Encapsulation, Association,
Polymorphism, Exception Handling, Text I/O, Abstract Classes and Interfaces, Concurrency,
Graphical User Interface (GUI), and Multi-threading.

o Objectives:
Develop a system connecting farmers directly with consumers for fresh produce orders, featuring:
1. Seasonal product listings.
2. Subscription models (e.g., weekly vegetable boxes)..
3. Real-time inventory and delivery tracking.

Assignment Tasks:
1. Product Class: Create a class that stores information about farm products, including product ID,
name, description (e.g., organic, seasonal), price, quantity available, and harvest date.
2. Customer and Farmer Classes: Implement these classes to manage user details, both inheriting
from an abstract User class.
o The Customer class should include: customer ID, name, email, delivery address, and a
shopping cart for produce selections
o The Farmer class should include: farmer ID, name, email, farm address, and a list of
available products with harvest dates
3. DeliverySystem Class: Develop the core system that:
o Maintains an inventory of seasonal products
o Matches orders to nearby farmers based on product availability
o Processes transactions and updates inventory quantities
o Manages subscription-based orders (e.g., weekly vegetable boxes)
4. Encapsulation: All class data members must be private, with appropriate getter/setter methods
to:
o Validate prices (positive values)
o Ensure harvest dates are future-dated
o Verify delivery addresses
5. IProductSearch Interface: Design an interface with methods for:
o Searching by seasonality (searchBySeason(LocalDate))
o Filtering by farm distance (searchByProximity(int radius))
o Finding products by category (e.g., dairy, vegetables)
6. ProductSearchEngine Class: Implement the IProductSearch interface with polymorphic
methods that:
o Prioritize in-season products
o Sort by farm-to-table distance
o Highlight organic options
7. Custom Exceptions:
o OutOfSeasonException (when ordering non-seasonal items)
o DeliveryUnavailableException (for out-of-range addresses)
o HarvestDateException (invalid harvest timing)
8. File I/O Operations: Implement persistence for:
o Farm products (produce.txt) with harvest dates

2
 o Customer profiles (customers.txt) with delivery zones
o Farmer inventories (farmers.txt) with location coordinates
9. Abstract User Class: Define common attributes/methods including:
o User authentication
o Location-based service eligibility checks
o Notification preferences for seasonal updates
10. Concurrency:
o Handle concurrent seasonal demand spikes with thread-safe inventory updates
o Process multiple delivery route calculations simultaneously
o Manage real-time harvest quantity adjustments
11. (Bonus) GUI: Develop an interface with:
o Farmer dashboard: Upload harvest schedules/photos
o Customer portal: Seasonal availability calendar
o Delivery tracking map (simulated)

o Grading rubric:

ABET Criteria
Criteria 50%-70% (Poor) 70%-90% (Good) 90%-100% (Excellent) Marks

Most of the tasks are All tasks mentioned in the Project Design
Only a few tasks are
Tasks implemented, but a few assignment are
implemented, or none of /6
completion are missing or implemented and working
them are completed.
incomplete. correctly.
Project
Presentation is mostly Presentation is engaging, Demonstration
Presentation is unclear, clear and accurate, but with clear communication,
Presentation inaccurate, or lacks proper may have minor issues accurate information, and /3
presentation dynamics. with engagement or strong presentation
presentation dynamics. dynamics.
Code is well-documented Project New
Code has some with clear in-code Learning
Code lacks proper
documentation and comments and a separate
Code documentation and
explanation, but could document explaining design /2
explanation explanation, making it
be improved in clarity choices, challenges faced,
hard to understand.
or comprehensiveness. and rationale behind
implementation choices.
Project Impact
Program has major errors Program has a few
or multiple minor errors, minor errors, but still Program runs without any
Functional
making it unable to produces mostly errors and produces correct /2
Errors
produce correct output for correct output for test output for all test cases.
most test cases. cases.

3
 Project Testing

Code is mostly Code is well-organized,

Code is disorganized, organized and modular, easy to read, with
Code
difficult to read, and does readable, but has a few proper indentation, /1
organization
not follow best practices. inconsistencies or whitespace, and follows
areas for improvement. best practices

Report is well-formatted, Project

using proper citation and References
Report is mostly well- referencing (IEEE or APA),
Report is poorly formatted
formatted, but has a consistent font style/size,
Report Format or lacks proper formatting /1
few inconsistencies or alignment, headings, page
elements.
areas for improvement. numbers, and includes
captions and references for
figures and tables.

o Java Errors: In Java, errors can be classified into two main categories: Compile-time errors and
Runtime errors. Here's a brief description of each category and some common examples:

 Compile-time errors: These errors occur during the compilation process when the Java
compiler attempts to convert the source code into bytecode. Compile-time errors are usually
caused by syntax issues or incorrect use of the Java language features. Examples of compile-
time errors include:
o Syntax errors: Missing semicolon, unmatched parentheses, undeclared variables,
etc.
o Type-checking errors: Incompatible data types, incorrect method signatures,
incorrect variable assignments, etc.
o Access control errors: Accessing private members from outside the class,
attempting to inherit from a final class, etc.

 Runtime errors: These errors occur during the execution of a Java program. Runtime errors
are caused by issues that are not detected during the compilation process, such as logical
errors or exceptional conditions. Examples of runtime errors include:
o NullPointerException: Attempting to access an object's member using a null
reference.
o ArrayIndexOutOfBoundsException: Accessing an array element with an index that
is out of bounds.
o ArithmeticException: Performing an illegal arithmetic operation, such as dividing by
zero.
o ClassCastException: Attempting to cast an object to an incompatible class.
o FileNotFoundException: Trying to access a file that does not exist or is not
accessible.
o IOException: Encountering an I/O error while reading from or writing to a file.

4
 Logical errors: Logical errors are mistakes in program logic that cause incorrect or
unexpected results. They are not detected during compilation or runtime but stem from
flawed logic or incorrect assumptions made by the developer. Common examples include:
o Incorrect calculations: Using the wrong mathematical formula, operator, or
precedence can lead to incorrect results.
o Off-by-one errors: These errors occur when a loop iterates one too many or one too
few times, often due to an incorrect loop condition or improper initialization of the
loop counter.
o Wrong conditional expressions: Using incorrect or incomplete conditional
expressions in if-else statements or loops can cause the program to take the wrong
path during execution.
o Incorrect data handling: Failing to properly initialize, update, or reset variables can
lead to unintended consequences or incorrect program state.
o Improper use of functions or methods: Calling functions with incorrect arguments,
returning incorrect values, or using functions in the wrong order can result in logical
errors.