School of Computing Software Engineering Assignment: Data Structures

This Software Engineering assignment requires the development of a Java-based tool designed to visualize the behavior of various programming data structures, including stacks, queues, lists, sets, and trees. The assignment is split into two components. Component 1 requires the implementation of a basic GUI with a tab selector for different data structures and support for a graphical stack. Component 2 extends the application to support graphical representations of a queue, list, set, and a binary tree, each with associated operations, graphical displays, and informational panels. The tool should use the Java programming language and AWT/Swing libraries for the graphical user interface, allowing users to perform operations and observe their effects on the data structures. The assignment is assessed based on the completion of requirements, code quality, graphical representation, and the student's explanation during the demonstration. The marking scheme details the criteria for each grade, including the accuracy of information sections, code formatting and commenting, and the clarity of explanations. Reassessment is available with modified requirements.

Updated 13.06.16.
School of Computing, Creative Technologies and Engineering
Assessment Brief
Component 1 and 2
Module name and CRN Software Engineering CRN: 16086
Module Leader Mark Dixon
Semester B Level 5 Approx No of Students 50
COMPONENT TITLE:
COMPONENT WEIGHTING: 40% of Module Marks (Component 1)
60% of Module Marks (Component 2)
HAND-OUT DATE: Week 1 (Feb 2017).
SUGGESTED STUDENT EFFORT: 30 hours approx.
SUBMISSION DATE: Sunday 12th March 2017 at 23:00. (Component 1)
Tuesday 2nd May 2017 at 23:00. (Component 2)
SUBMISSION INSTRUCTIONS:
Submission of program code should be via the VLE, followed by demonstration to the tutor
within the subsequent lab session. Your solutions should be zipped up into a single file in
the form <studentID>.zip. You MUST submit and demonstrate your work in order to
receive a mark.
FEEDBACK MECHANISM:
You will be provided with verbal feedback regarding your work during the lab based
demonstrations.
LEARNING OUTCOMES ADDRESSED BY THIS COMPONENT:
 Explain & apply object oriented programming concepts to the solution of problems
 Develop a computer program from a problem specification using a graphical user
interface and event based programming
 Have the ability to apply object oriented modelling techniques to help develop a
program design.

NOTES:
The usual University penalties apply for late submission.
This is an individual assessment. Submission of an assessment indicates that you,
as a student, have completed the assessment yourself and the work of others has
been fully acknowledged and referenced.
By submitting this assessed work, you are declaring that you are fit to submit, and
you will therefore not normally be eligible to submit a request for mitigation for this
work.
If you fail to attend the demonstration at the scheduled date and time without
agreed mitigation, you will be given one further opportunity to demonstrate your
work (incurring a 5% late penalty) at a time scheduled by the module team. If you
miss this second opportunity, your result will be recorded as Non-Submission.
If your result for this assessment is recorded as Non-Submission or your mark for
this assessment and for the whole module is below 40%, you will have opportunity
to take reassessment with a submission date of 7th July 2017 (see Reassessment
information below). If you are granted deferral through the mitigation process, you
may complete the reassessment with a full range of marks available.
For further information, please refer to your Course Handbook or University
Assessment Regulations.
2

DETAILS OF THE ASSESSMENT
Both components of the assessment for this module are based on different sections of the
same problem (as described below). Component 1 is satisfied by completion of
requirements 1 and 2. Component 2 is satisfied by completion of requirements 3, 4 and 5.
A submission for BOTH components must be made in order for the module to be
passed.
Assignment Overview
This assignment is based on the development of a tool designed to provide instructional
information of the use of various programming data structures. The basic concept is to
produce a piece of software that allows users to visualize the behavior of stacks, queues,
lists, sets and trees. The final solution should allow users to select a particular data
structure, then perform typical operations on that structure using a graphical user interface.
As operations are performed, a graphical representation of the values should be shown in
a manner consistent with how the data structure works. For example, if the user selects a
Stack type data structure then the application would provide buttons to support Push, Pop,
and Peek operations. As the user selects the various operations a graphical representation
of the stack shows the values being added and removed.
The solution should be developed using the Java programming language and the
AWT/Swing libraries for the Graphical User Interface. The underlying storage of data may
be based on the classes provided by the Java SDK. No other 3rd party libraries outside
those available within the standard Java Development Kit (JDK) should be used.
The instructional tool should take the form of a typical desktop GUI type application. The
exact layout of the whole application is not prescribed, however certain details of the views
to be shown are given and should be adhered to as close as possible.
This work has been split into five specific requirements. Requirements 1 and 2 should be
submitted for component 1 of the assessment (due Sunday 12th March 2017 at 23:00)
and requirements 3, 4 and 5 should be submitted for component 2 of the assessment (due
Tuesday 2nd May 2017 at 23:00).
Requirement 1 – Basic GUI and collection type selection (component 1).
The first requirement for this assignment is to implement the basic Graphical User
Interface (GUI) that is capable of displaying multiple overlapping panels, one for each of
the data structures to be supported. The user should be able to select the data structure of
their choice (via a tab selector of some sort) that results in the panel for that particular data
structure being displayed. The tab selector should list the data structures that will
eventually be supported, i.e. Stack, Queue, List, Set and Tree.
Each panel should contain three sub-panels. One to display the operations that could be
performed by the user, one to display the data structure contents graphically, and one to
provide textual information about the current data structure. At this point there is no need
to populate the contents of these, however titles should be included to identify each sub-
panel. A wire frame diagram of how the interface may look at this point is shown in figure
1.
3

Figure 1. Wire frame of general interface.
The application should be designed so that it uses layout managers where appropriate,
and can be sensibly resized by the user. A menu bar should be added to provide common
operations, such as the ability to empty the currently displayed data structure, provide a
general about dialogue box, and exit the application. The menu options should also
include short-cuts and icons where appropriate.
Requirement 2 – Supporting a Graphical Stack (component 1).
The aim of requirement 2 is to extend the application so that it supports a Stack type data
structure on one of the available data structure tabs and associated panel. The three sub-
panels should be populated to show the available operation buttons, a graphical
representation of the stack contents, and information about the general rules of how a
stack data structure works (It is up to you as the programmer to write a few meaningful
paragraphs describing a stack’s fundamental behavior). An example of how the stack
panel may look is shown in figure 2.
4

Figure 2. Wire frame of the “Stack” panel
As the user presses the operation buttons, the graphical stack should be updated to
display the new contents.
Requirement 3 – Supporting a Graphical Queue (component 2).
The aim of requirement 3 is to extend the application so that it supports a Queue type data
structure on one of the available data structure tabs and associated panel. As with the
previous requirement the three sub-panels should be populated to show the available
operation buttons, a graphical representation of the queue contents, and information about
the general rules of how a queue data structure works.
Given that a queue can have movement at both ends of the storage its position may “float”
around. To handle this the graphical view should be implemented in such a way as to
“wrap” around the display area. This could be handled by wrapping a vertical or horizontal
array like structure as shown in figure 3.
Figure 3. Wire frame of a wrapped “Queue” panel
5

Requirement 4 – Supporting a List and Set (component 2).
The aim of requirement 4 is to further extend the application so that it supports two
additional data structures that represent Lists and Sets. Again by implementing
appropriate operations, graphical representation and information panels.
The supported List structure should be ordered and allow insertion and removal from a
specific indexed position. The Set data structure does not need to maintain any ordering.
In both cases it is up to you as the programmer to identify the most appropriate set of
operations to be provided via buttons within the user interface.
Requirement 5 – Supporting a Binary Tree (component 2).
The final requirements is to add support for a binary tree type data structure. This should
provide a fairly sophisticated graphical representation of an ordered binary tree that is able
to show the contained values in a sensible, and scaled manner. For this particular
requirement, the information sub-panel for the binary tree should also include information
about the time complexity measurements for each of the provided operations (presented
using the Big O notation).
6

MARKING SCHEME / CRITERIA
The marking criteria are shown below. An initial mark will be established during the
demonstration, but this may be subject to later moderation by the module team.
Note: The mark awarded is primarily for the explanation of the implemented solution as
well as the quality of the submitted code. Hence submission of a working program that
satisfies the requirements does not in itself guarantee marks. Marks will only be awarded
following a satisfactory explanation of the code and response to questions during the
demonstration.
Completion of each of the requirement contributes up to 20% of the final module mark. i.e.
Component 1 is worth up to 40%, and Component 2 is worth up to 60%. The additional
marking criteria is shown within the grid below.
Grade
80%+ 1st
70%+
2.1
60% +
2.2
50+
3rd
40%
Fail
<40%
All requirements
fully completed.
Information
section for each
data structure is
excellent and fully
accurate.
Code is well
formatted and all
aspects are fully
commented to a
professional level
All graphical
representation is
presented to the
highest standard
possible.
Explanation
during
demonstration is
impeccable
showing in-depth
knowledge.
Requirement 1-4
completed
Information
section for each
data structure is
accurate and non-
trivial.
Code is well
formatted and
commented.
Graphical
representation is
very well
presented.
Explanations to
all questions are
clear and concise
and additional
knowledge related
to the topic in
general is
apparent.
Requirement 1-3
completed, with
some attempt at
requirement 4.
Information
sections are present
and generally
accurate.
Code is generally
well formatted and
commented.
Graphical
representation is
well presented.
Explanations to all
questions are clear
and concise
Requirement 1 and
2 fully completed,
with a reasonable
attempt at
requirement 3.
Information
sections are present.
Code is generally
understandable, but
formatting could be
better.
Graphical
representation is
adequate
Explanations to
most questions are
clear and concise
Requirement 1
and 2 are
generally
completed.
Code a little
untidy but
compiles.
Explanations to
most questions
are acceptable
and generally
correct.
Zero or only one
requirement
completed to a
satisfactory level.
Code does may
not compile.
Explanations to
some questions
are incorrect or
reflect lack of
knowledge
regarding the
solution.
REASSESSMENT and DEFERRAL OPPORTUNITIES
Reassessment will take the form of resubmission, based on the original assignment
specification.
In order to reach a minimum mark of 40% you must complete Requirement 1 for
Component 1, and Requirement 3 and attempt Requirement 4 for Component 2.
Upon submission of reassessment you must contact the module leader in order to arrange
a demonstration. Details will be made available on the VLE.
7

8