CSSE7023 Advanced Software Engineering Assignment 1 - Sheep
Advanced Software Engineering (CSSE7023)
Assignment 1 — Semester 1, 2024
One must learn by doing the thing; for though you think you know it, you have no certainty, until you try. — Sophocles
Overview This assignment delivers practical experience developing a Java project based on a supplied specification. The specification is provided in the form of JavaDocs, which describe the classes and interfaces that your assignment must implement. You will be assessed on your ability to
• implement a program that complies with the specification,
• and develop code that conforms to the style conventions of the course.
Task Spreadsheet applications are powerful programs that combine data and formulae to perform calculations. In this assignment, you will be implementing SheeP (Sheet Processor), a spreadsheet application. SheeP is similar to Google Sheets or Microsoft Excel. It consists of a grid of cells , each of which contains either data or a formula. The formulae can reference other cells in the grid to use their values. Formulae are evaluated to produce a value for the cell. A cell is updated whenever the data or formulae in any cell it references changes.
Common Mistakes Please carefully read Appendix A. It outlines common and critical mistakes which you must avoid to prevent a loss of grades. If at any point you are even slightly unsure, please check as soon as possible with course staff.
Plagiarism All work on this assignment is to be your own individual work. By submitting the assignment you are claiming it is entirely your own work. You may discuss the overall general design of the application with other students. Describing details of how you implement your design with another student is considered to be collusion and will be counted as plagiarism.
You may not copy fragments of code that you find on the Internet to use in your assignment. Code supplied by course staff (from this semester) is acceptable, but must be clearly acknowledged as described in the next paragraph.
You may find ideas of how to solve problems in the assignment through external resources (e.g. StackOver- flow, textbooks, ...). If you use these ideas in designing your solution you must cite them. To cite a resource, provide the full bibliographic reference for the resource in file called refs.md. The refs.md file must be in the root folder of your project. For example:
In the code where you use the idea, cite the reference in a comment. For example:
/**
* What method1 does.
* [1] Used a method to avoid gotos in my logic.
* [2] Algorithm based on section 6.4.
*/
public void method1() ...
/**
* What method2 does.
*/
public void method2() {
System.out.println("Some " + "content.") // [3] String concatenation using + operator. }
Specification
The specification document is provided in the form of JavaDocs.
-
Implement the classes and interfaces exactly as described in the JavaDocs.
-
Read the JavaDocs carefully and understand the specification before programming.
-
Do not change the public specification in any way, including changing the names of, or adding additional, public classes, interfaces, methods, or fields.
-
You are encouraged to add additional private members, classes, or interfaces as you see fit.
You can download the JavaDoc specification from BlackBoard (Assessment → Assignment One) or access it atthe link below.
Getting Started
To get started, download the provided code from BlackBoard (Assessment → Assignment One). This archive includes code for the GUI components. Extract the archive in a directory and open it with IntelliJ.
Task
Implement each of the classes and interfaces described in the JavaDoc specification.
Figure 1: Class diagram of the specification for assignment 1.
Project Overview
sheep.core This package contains the interface between the model of a spreadsheet and the user interface. Implementations of the SheetView interface tell the interface how to render a spreadsheet and communi-
cate this information via the ViewElement object.
Implementations of the SheetUpdate interface handle user updates to the spreadsheet and provide the
result of the update via a UpdateResponse object.
sheep.sheets This package contains implementations of the SheetView and SheetUpdate interfaces and other supporting classes. Primarily it implements three different types of spreadsheets: FixedSheet, DisplaySheet, and Sheet.
sheep.expression Within a spreadsheet, the value at a particular cell is represented by an expression. This package stores the Expression interface that all expressions must implement.
Expressions are constructed via expression factories that implement the ExpressionFactory interface, e.g. CoreFactory.
This package also stores relevant exceptions.
sheep.expression.basic This package stores core expression implementations, namely, the empty cell, Nothing,
a constant number value, Constant, and a reference to another cell, Reference. sheep.expression.arithmetic Arithmetic expressions are contained in this package. All arithmetic expres-
sions are subclasses of the abstract class Arithmetic.
sheep.parsing A parser accepts string input and constructs an appropriate expression. For example, given
the string “5”, a parser would construct an instance of the Constant expression that represents 5.
All parsers implement the Parser interface. If a parser cannot parse a string, a ParseException is
thrown.
sheep.fun Provided classes that pre-load spreadsheets with test data, such as the Fibonacci sequence using
the Fibonacci class.
sheep.ui Provided implementation of the user interface.
Stages
Software of any reasonable size or complexity should be developed in stages. This technique is called incremental development. It allows you to determine that your logical approach is working and that you can implement a working solution. In professional software development, it allows you to get feedback from clients as you develop the system. This contrasts with a “big bang” approach of taking months or years to develop the entire system, and then showing it to clients to find out that it does not do what they want.
The assignment is decomposed into stages to encourage incremental development. You should finish each stage before moving on to the next . The provided Main class allows you to run each stage individually by uncommenting the appropriate lines in the main method. Figure 1 highlights the classes that you will implement in each stage: green for stage 0, blue for stage 1, yellow for stage 2, and purple for provided code. At each stage, ensure that you thoroughly test your implementation.
Stage 0 Create a simple implementation of a spreadsheet, FixedSheet. The FixedSheet class must be within the sheep.sheets package and implement the sheep.core.SheetView and sheep.core.SheepUpdate interfaces. After implementing the FixedSheet class and uncommenting the appropriate lines in the main method, the program should display as below when executed.
© The University of Queensland 2024 Page 4
Stage 1 Implement the basic types of expressions within the spreadsheet: constant values, references to other cells, and empty cells. Create an expression factory to create these expressions and a parser to parse expressions from strings. Finally create DisplaySheet to show the results of these expressions. When the appropriate lines in the main method are commented out, the program should display as below when executed.
Stage 2 Complete the implementation of expressions to include arithmetic operations. Your parser and expression factory should be able to parse and create these expressions. Create the full Sheet implemen- tation, this sheet should appropriately update cells when other cells change. When the appropriate lines in the main method are commented out, the program should display as below when executed.
Automated Testing & Checking
Functionality and style check grading will be done automatically in a Linux environment. The environment will not be running Windows, and neither IntelliJ nor Eclipse (or any other IDE) will be involved. OpenJDK 21 with the JUnit 4 library will be used to compile and execute your code. To prevent infinite loops, or malicious code, from slowing down Gradescope, any test that takes longer than 10 seconds to execute1 will be killed and identified as failing.
IDEs like IntelliJ provide code completion hints. When importing Java libraries they may suggest libraries that are not part of the standard library. These will not be available in the test environment and your code will not compile. When uploading your assignment to Gradescope, ensure that Gradescope says that your submission was compiled successfully.
Automated Style Check
Your grade for automated style checking is based on the number of style violations identified by the Checkstyle tool2. It will be run in the same environment as the JUnit automated functionality tests. Multiple style violations of the same type will each count as one additional violation.
Note: There is a plug-in available for IntelliJ that will highlight style violations in your code. Instructions for installing this plug-in are available in the Java Programming Style Guide on BlackBoard (Learning Resources → Guides). If you correctly use the plug-in and follow the style requirements, it should be relatively straightforward to get high grades for this section.
Human Readable Style
Course staff will grade the readability of the code you submit. This will assess the structure, style, documentation and logic of your code. The high-level evaluation is how easily can another programmer, who is familiar with Java, understand your code. This includes layout of code, use of descriptive identifier names, and concise and informative comments. It also includes the detailed design of your code’s logic and how much code is unnecessarily duplicated. See Appendix B for criteria that will be used to assess the readability of your code.
Submission
Submission is via Gradescope. Submit your code to Gradescope early and often. Gradescope will give you some feedback on your code, but it is not a substitute for testing your code yourself.
What to Submit Your submission must have the following internal structure:
folders (packages) and .java files for classes described in the JavaDoc.
src/
refs.md file containing the references for any citations in your code.
Included in the root directory of the provided code are the files bundle.sh and bundle.bat. For MacOS and Unix users, double-click the bundle.sh file to execute it. For Windows users, double-click the bundle.bat file to execute it. This will create a submission.zip file for you to upload to Gradescope.
You can create the submission zip file yourself using a zip utility. If you do this, ensure that you do not miss any files or directories. Also ensure that you do not add any extra files. We recommend using the providing bundle scripts.
A complete submission would contain the following files in their specified directories.
1All tests should execute in a small fraction of a second. Any test taking longer than a second to execute indicates faulty logic or malicious code.
2The latest version of the course Checkstyle configuration can be found at http://csse7023.uqcloud.net/checkstyle.xml. See the Style Guide on BlackBoard for instructions on how to use it in IntelliJ.
src/sheep/expression/CoreFactory.java
src/sheep/expression/Expression.java
src/sheep/expression/ExpressionFactory.java
src/sheep/expression/InvalidExpression.java
src/sheep/expression/TypeError.java
src/sheep/expression/arithmetic/Arithmetic.java
src/sheep/expression/arithmetic/Divide.java
src/sheep/expression/arithmetic/Equal.java
src/sheep/expression/arithmetic/Less.java
src/sheep/expression/arithmetic/Minus.java
src/sheep/expression/arithmetic/Plus.java
src/sheep/expression/arithmetic/Times.java
src/sheep/expression/basic/Constant.java
src/sheep/expression/basic/Nothing.java
src/sheep/expression/basic/Reference.java
src/sheep/parsing/ParseException.java
src/sheep/parsing/Parser.java
src/sheep/parsing/SimpleParser.java
src/sheep/sheets/CellLocation.java
src/sheep/sheets/DisplaySheet.java
src/sheep/sheets/FixedSheet.java
src/sheep/sheets/Sheet.java
src/sheep/sheets/SheetBuilder.java
refs.md
Ensure that your classes and interfaces correctly declare the package they are within. For example, Reference.java should declare package sheep.expression.basic;.
Only submit the src folder and the refs.md file in the root directory of your project. Do not submit any other files (e.g. no .class files or IDE files).
Provided tests A small number of the unit tests (about 10-20%) used for assessing functionality will be provided in Gradescope. These will be used to test your submission, each time you upload it.
These are meant to provide you with an opportunity to receive feedback on whether the basic functionality of your classes works correctly or not. Passing all the provided unit tests does not guarantee that you will pass all the tests used for functionality grading.
