University Application

1. The Problem

Currently, there are no applications dedicated to students in universities. Students want to participate in
university courses and see announcements in these courses, but have this information spread out on multiple
websites, which are hard to find. They want to find fellow students with the same interests and share their
opinion about courses and course material, however this is not possible yet. They also want to discuss exam
questions and find the right place where the exam takes place without searching on Google.

2. Scenarios

Ben, is studying computer science at UPT. He has business administration as minor subject and is already used
to visit the courses in the computer science building. The business administration courses however, are located
in a lecture hall in another building in the city center of Tirana. He never visited the other building before, so he
does not know how to find the lecture halls for his minor subject. He browses through the courses in the course
catalog of the University Application and finds the course “Foundations of Business Administration” with course
times and the location of the lecture hall on a map. While he is attending the course, he makes contact with
fellow students who also attend the course and reads their comments. He likes one comment “Great exercises”
by Jenny, who is also studying informatics. From Jenny’s picture, he remembers that they met a week ago at the
coffee machine. He requests friendship with Jenny (she might help him to pass the final) and adds a new
comment about exam questions from earlier exams. While he is browsing, Jenny is notified about the friend
request and accepts it. Ben, in turn, is notified that Jenny has accepted his request and now browses through all
the courses that Jenny is visiting. He finds another interesting course “Cost Accounting” that he wants to visit
and saves it into his course list.

3. Functional / Non-Functional Requirements

The following functional requirements (FR) and nonfunctional requirements (NFR) have to be addressed in the
project *

FR1: Create a new account and sign in

FR2: Search for available courses: A student can see all courses of the current semester in his major and minor
subject. He is able to join the course which saves it into his course list. He can also drop a course.

FR3: Check course details: A student can see details about a course such as the course times, the location of the
lecture hall on a map and other course attendees including their name and picture.

FR4: Update profile: A student can update his profile settings and his profile picture. He can also change the
notification settings.

FR5: Add comments: A student can add comments about a course and thus start a discussion. Others can like the
comment and write follow-up comments.

* The functional requirements capture what it is that the system should do, whereas, the nonfunctional requirements
capture properties that the system should have
FR6: Request friendship: A student can request friendship with another student who then receives a notification
about the request. The second student can accept and reject friendship which both notifies the first student.

FR7: Browse friends’ courses: A student can browse the courses of his friends.

FR8: View announcements: A student can view course announcements and comment/like them.

FR9: Post updates to timeline: A student can post updates to his timeline. Friends are notified about updates and
can comment and like them. Certain updates are posted automatically such as saving a course into the course
list or commenting on a course.

FR10: See course calendar: A student can see all courses in a calendar

FR11: 24 hours before the course start, a student should get a notification.

FR12: The application should be in two languages: Albanian and English. The user can choose the language in
login screen

NFR1: Usability: The app should be intuitive to use and the user interface should be easy to understand. All
interactions should be completed in less than three clicks.

NFR2: Conformance to guidelines: The design of the app should conform to the usability guidelines for the chosen
operating system.

NFR3: Target platform: The app has to be developed in Java.

Additional constraints:

• The version control system must be git.

• Source code documentation must be in HTML format (Use the javadoc utility. Read uploaded file:
‘Deitel_Java How to Program_appendix_M_using_javadoc’).
• The application can be created as a web / desktop application

4. Target Environment

The application should be demonstrated in Java.

For this assignment you have to build teams of 3 members that work together.
Part I (Requirement specification: AGILE METHODOLOGIES (SCRUM) - SPECIFY USER
STORIES)
Consider requirements specification “University Application”

1. Role Product Owner: Create the product backlog -- Write all necessary user stories in order to create the
university application (Document 1)
2. Role SCRUM Master: For each sprint, specify the sprint backlog. (Stories which depends to each other
should not be inserted in the same sprint – except for the cases when these stories are so small that can
be implemented in the same sprint but in not overlapping times) (Document 2)

Suppose that the developer team is composed of 5 developers. Each sprint last three weeks.

Remember that:

- a user story is implemented by one developer

- should be implementable in one sprint (including also the time needed to test the story).
- during the same sprint one developer can implement more than one story – in cases when the stories
are small.

Each story should have a point number. In order to specify this number, you should consider the complexity and
the time needed to implement the story. One day is converted to 0.5 points.

(Read uploaded document: “TaskAgile - Example Agile Requirements.pdf”. This document can help you writing
user stories)

Part II (Implementing/Testing Software)

Consider requirements specification “University Application”

• Implement the application using Java as a programming language and a relational database

Apply what you have learned about software architecture, software design, and internal quality.

The code should not only work but also it should be written in a way that it is easily maintainable
(readable, understandable…). Apply the refactoring patterns discussed in the lectures.

• Write Unit/Integration tests using the Junit testing framework in order to achieve not less than 50% of
code coverage

The tests should be maintainable (have a good internal quality)

Part III (Review)

Each group will review the code of another group. After the code review process, all the issues should be
documented.

Deliverables
• The two documents created in part I
• Source code under version control including source code documentation (part II). The commits should
be done based on the user stories created in part I.
• Code review document (part III)