This site is from a past semester! The current version will be here when the new semester starts.

Week 2 [Fri, Jan 15th] - Topics

[W2.1] Automating the Build Process

[W2.1a] Implementation → Integration → Introduction → What :
[W2.1b] Implementation → Integration → Build Automation → What :
[W2.1c] Implementation → Integration → Build Automation → Continuous integration and continuous deployment :

[W2.2] Class/Object Diagrams: Basics

[W2.2a] Design → Modelling → Modelling Structure → OO structures :
[W2.2b] Design → Modelling → Modelling Structure → Class diagrams - basic :
[W2.2c] Design → Modelling → Modelling Structure → Object diagrams :
[W2.2d] Tools → UML → Object versus class diagrams :

[W2.3] Class Diagrams: Intermediate-Level

[W2.3a] Tools → UML → Notes :
[W2.3b] Tools → UML → Constraints Unknown level !!! -1
[W2.3c] Tools → UML → Class Diagrams → Associations as attributes :
[W2.3d] Design → Modelling → Modelling Structure → Class diagrams - intermediate :
[W2.3e] Paradigms → OOP → Associations → Association classes :

[W2.4] OO Domain Models

[W2.4a] Design → Modelling → Modelling Structure → Object oriented domain models :

[W2.5] Sequence Diagrams

[W2.5a] Design → Modelling → Modelling Behaviors Sequence diagrams - basic :
[W2.5b] Design → Modelling → Modelling Behaviors Sequence diagrams - intermediate :
[W2.5c] Tools → UML → Sequence Diagrams → Reference frames :
[W2.5d] Tools → UML → Sequence Diagrams → Parallel paths :

[W2.6] Activity Diagrams

[W2.6a] Design → Modelling → Modelling Behaviors Activity diagrams - basic
[W2.6b] Design → Modelling → Modelling Behaviors Activity diagrams - intermediate

[W2.1] Automating the Build Process

W2.1a :

Implementation → Integration → Introduction → What

Can explain integration

Combining parts of a software product to form a whole is called integration. It is also one of the most troublesome tasks and it rarely goes smoothly.

W2.1b :

Implementation → Integration → Build Automation → What

Can explain build automation tools

Build automation tools automate the steps of the build process, usually by means of build scripts.

In a non-trivial project, building a product from its source code can be a complex multi-step process. For example, it can include steps such as: pull code from the revision control system, compile, link, run automated tests, automatically update release documents (e.g. build number), package into a distributable, push to repo, deploy to a server, delete temporary files created during building/testing, email developers of the new build, and so on. Furthermore, this build process can be done ‘on demand’, it can be scheduled (e.g. every day at midnight) or it can be triggered by various events (e.g. triggered by a code push to the revision control system).

Some of these build steps such as compiling, linking and packaging, are already automated in most modern IDEs. For example, several steps happen automatically when the ‘build’ button of the IDE is clicked. Some IDEs even allow customization of this build process to some extent.

However, most big projects use specialized build tools to automate complex build processes.

Some popular build tools relevant to Java developers: Gradle, Maven, Apache Ant, GNU Make

Some other build tools: Grunt (JavaScript), Rake (Ruby)

Some build tools also serve as dependency management tools. Modern software projects often depend on third party libraries that evolve constantly. That means developers need to download the correct version of the required libraries and update them regularly. Therefore, dependency management is an important part of build automation. Dependency management tools can automate that aspect of a project.

Maven and Gradle, in addition to managing the build process, can play the role of dependency management tools too.

Getting Started with Gradle -- documentation from Gradle
Gradle Tutorial -- from tutorialspoint.com

Gradle is used for,

a. better revision control
b. build automation
c. UML diagramming
d. project collaboration

(b)

W2.1c :

Implementation → Integration → Build Automation → Continuous integration and continuous deployment

Can explain continuous integration and continuous deployment

An extreme application of build automation is called continuous integration (CI) in which integration, building, and testing happens automatically after each code change.

A natural extension of CI is Continuous Deployment (CD) where the changes are not only integrated continuously, but also deployed to end-users at the same time.

Some examples of CI/CD tools: Travis, Jenkins, Appveyor, CircleCI, GitHub Actions

[W2.2] Class/Object Diagrams: Basics

Video

W2.2a :

Design → Modelling → Modelling Structure → OO structures

Can explain structure modeling of OO solutions

An OO solution is basically a network of objects interacting with each other. Therefore, it is useful to be able to model how the relevant objects are 'networked' together inside a software i.e. how the objects are connected together.

Given below is an illustration of some objects and how they are connected together. Note: the diagram uses an ad-hoc notation.

Note that these object structures within the same software can change over time.

Given below is how the object structure in the previous example could have looked like at a different time.

However, object structures do not change at random; they change based on a set of rules, as was decided by the designer of that software. Those rules that object structures need to follow can be illustrated as a class structure i.e. a structure that exists among the relevant classes.

Here is a class structure (drawn using an ad-hoc notation) that matches the object structures given in the previous two examples. For example, note how this class structure does not allow any connection between Genre objects and Author objects, a rule followed by the two object structures above.

UML Object Diagrams are used to model object structures and UML Class Diagrams are used to model class structures of an OO solution.

Here is an object diagram for the above example:

And here is the class diagram for it:

W2.2b :

Design → Modelling → Modelling Structure → Class diagrams - basic

Can use basic-level class diagrams

Contents of the panels given below belong to a different chapter; they have been embedded here for convenience and are collapsed by default to avoid content duplication in the printed version.

Classes form the basis of class diagrams.

Associations are the main connections among the classes in a class diagram.

The most basic class diagram is a bunch of classes with some solid lines among them to represent associations, such as this one.

An example class diagram showing associations between classes.

In addition, associations can show additional decorations such as association labels, association roles, multiplicity and navigability to add more information to a class diagram.

Here is the same class diagram shown earlier but with some additional information included:

Which association notations are shown in this diagram?

a. association labels
b. association roles
c. association multiplicity
d. class names

(a) (b) (c) (d)

Explanation: '1’ is a multiplicity, ‘mentored by’ is a label, and ‘mentor’ is a role.

Explain the associations, navigabilities, and multiplicities in the class diagram below:

Draw a class diagram for the code below. Show the attributes, methods, associations, navigabilities, and multiplicities.

class Box {
    private Item[] parts = new Item[10];
    private Item spareItem;
    private Lid lid; // lid of this box
    private Box outerBox;

    public void open() {
        // ...
    }
}

class Item {
    public static int totalItems;
}

class Lid {
    Box box; // the box for which this is the lid
}

W2.2c :

Design → Modelling → Modelling Structure → Object diagrams

Can use basic object diagrams

Object diagrams can be used to complement class diagrams. For example, you can use object diagrams to model different object structures that can result from a design represented by a given class diagram.

This question is based on the following question from another topic:

Draw a class diagram for the code below. Show the attributes, methods, associations, navigabilities, and multiplicities.

class Box {
    private Item[] parts = new Item[10];
    private Item spareItem;
    private Lid lid; // lid of this box
    private Box outerBox;

    public void open() {
        // ...
    }
}

class Item {
    public static int totalItems;
}

class Lid {
    Box box; // the box for which this is the lid
}

Draw an object diagram to match the code. Include objects of all three classes in your object diagram.

W2.2d :

Tools → UML → Object versus class diagrams

Can distinguish between class diagrams and object diagrams

Compared to the notation for class diagrams, object diagrams differ in the following ways:

Show objects instead of classes:
- Instance name may be shown
- There is a : before the class name
- Instance and class names are underlined
Methods are omitted
Multiplicities are omitted

Furthermore, multiple object diagrams can correspond to a single class diagram.

Both object diagrams are derived from the same class diagram shown earlier. In other words, each of these object diagrams shows ‘an instance of’ the same class diagram.

Which of these class diagrams match the given object diagram?

(1) (2)

Explanation: Both class diagrams allow one Unit object to be linked to one Item object.

[W2.3] Class Diagrams: Intermediate-Level

Video

W2.3a :

Tools → UML → Notes

Can use UML notes

UML notes can augment UML diagrams with additional information. These notes can be shown connected to a particular element in the diagram or can be shown without a connection. The diagram below shows examples of both.

Example:

W2.3b Unknown level !!! -1

Tools → UML → Constraints

Can specify constraints in UML diagrams

A constraint can be given inside a note, within curly braces. Natural language or a formal notation such as OCL (Object Constraint Language) may be used to specify constraints.

Example:

W2.3c :

Tools → UML → Class Diagrams → Associations as attributes

Can show an association as an attribute

An association can be shown as an attribute instead of a line.

Association multiplicities and the default value can be shown as part of the attribute using the following notation. Both are optional.

name: type [multiplicity] = default value

The diagram below depicts a multi-player Square Game being played on a board comprising of 100 squares. Each of the squares may be occupied with any number of pieces, each belonging to a certain player.

A Piece may or may not be on a Square. Note how that association can be replaced by an isOn attribute of the Piece class. The isOn attribute can either be null or hold a reference to a Square object, matching the 0..1 multiplicity of the association it replaces. The default value is null.

The association that a Board has 100 Squares can be shown in either of these two ways:

Show each association as either an attribute or a line but not both. A line is preferred as it is easier to spot.

W2.3d :

Design → Modelling → Modelling Structure → Class diagrams - intermediate

Can use intermediate-level class diagrams

A class diagram can also show different types of relationships between classes: inheritance, compositions, aggregations, dependencies.

Modeling inheritance

Modeling composition

Modeling aggregation

Modeling dependencies

A class diagram can also show different types of class-like entities:

Modeling enumerations

Modeling abstract classes

Modeling interfaces

Which of these statements match the class diagram?

a. A Snake must belong to at least one Board.
b. A SnakeHeadSquare can contain only one Snake head.
c. A Square can contain a Snake head.
d. A Snake head can be in more than one SnakeHeadSquare.
e. The Board has exactly 5 Snakes.

~~(a)~~(b)(c)(d)(e)

Explanation:

(a) does not match because a Snake may or may not belong to a Board (multiplicity is 0..1)
(b) matches the diagram because the multiplicity given is 1
(c) matches the diagram because SnakeHeadSquare is a Square (due to inheritance)
(d) matches the diagram because the multiplicity given is *
(e) matches the diagram because the multiplicity given is 5

Explain the meaning of various class diagram notations in the following class diagram:

Consider the code below:

public interface Billable {
    void bill();
}

public abstract class Item
         implements Billable {
    public abstract void print();
}

public class StockItem extends Item {
    private Review review;
    private String name;

    public StockItem(
        String name, Rating rating) {

        this.name = name;
        this.review = new Review(rating);
    }

    @Override
    public void print() {
        //...
    }

    @Override
    public void bill() {
        //...
    }
}

public enum Rating {
    GOOD, OK, POOR
}

public class Review {
    private final Rating rating;

    public Review(Rating rating) {
        this.rating = rating;
    }
}

import java.util.List;

public class Inventory {
    private List<Item> items;

    public int getItemCount() {
        return items.size();
    }

    public void generateBill(Billable b) {
        // ...
    }

    public void add(Item s) {
        items.add(s);
    }
}

(a) Draw a class diagram to represent the code. Show all attributes, methods, associations, navigabilities, visibilities, known multiplicities, and association roles. Show associations as lines.
(b) Draw an object diagram to represent the situation where the inventory has one item named spanner and a review of POOR rating
i.e., new Inventory().add(new StockItem("spanner", new Review(Rating.POOR))).

W2.3e :

Paradigms → OOP → Associations → Association classes

Can explain the meaning of association classes

An association class represents additional information about an association. It is a normal class but plays a special role from a design point of view.

A Man class and a Woman class are linked with a ‘married to’ association and there is a need to store the date of marriage. However, that data is related to the association rather than specifically owned by either the Man object or the Woman object. In such situations, an additional association class can be introduced, e.g. a Marriage class, to store such information.

Implementing association classes

There is no special way to implement an association class. It can be implemented as a normal class that has variables to represent the endpoint of the association it represents.

In the code below, the Transaction class is an association class that represents a transaction between a Person who is the seller and another Person who is the buyer.

class Transaction {
    
    //all fields are compulsory
    Person seller;
    Person buyer;
    Date date;
    String receiptNumber;
    
    Transaction(Person seller, Person buyer, Date date, String receiptNumber) {
        //set fields
    }
}

Which of these are suitable as an Association Class?

(a)(b)~~(c)~~(d)

Explanation: Mileage is a property of the car, and not specifically about the association between the Driver and the Car. If Mileage was defined as the total number of miles that car was driven by that driver, then it would be suitable as an association class.

[W2.4] OO Domain Models

Video

W2.4a :

Design → Modelling → Modelling Structure → Object oriented domain models

Can explain object oriented domain models

The analysis process for identifying objects and object classes is recognized as one of the most difficult areas of object-oriented development. _{--Ian Sommerville, in the book Software Engineering}

Class diagrams can also be used to model objects in the the relevant information that needs to be examined to understand a problemproblem domain (i.e. to model how objects actually interact in the real world, before emulating them in the solution). Class diagrams that are used to model the problem domain are called conceptual class diagrams or OO domain models (OODMs).

The OO domain model of a snakes and ladders game is given below.

Description: The snakes and ladders game is played by two or more players using a board and a die. The board has 100 squares marked 1 to 100. Each player owns one piece. Players take turns to throw the die and advance their piece by the number of squares they earned from the die throw. The board has a number of snakes. If a player’s piece lands on a square with a snake head, the piece is automatically moved to the square containing the snake’s tail. Similarly, a piece can automatically move from a ladder foot to the ladder top. The player whose piece is the first to reach the 100th square wins.

OODMs do not contain solution-specific classes (i.e. classes that are used in the solution domain but do not exist in the problem domain). For example, a class called DatabaseConnection could appear in a class diagram but not usually in an OO domain model because DatabaseConnection is something related to a software solution but not an entity in the problem domain.

OODMs represents the class structure of the problem domain and not their behavior, just like class diagrams. To show behavior, use other diagrams such as sequence diagrams.

OODM notation is similar to class diagram notation but omit methods and navigability.

This diagram is,

a. A class diagram.
b. An object diagram.
c. An OO domain model, also known as a conceptual class diagram.
d. Can be either a class diagram or an OO domain model.

(a)

Explanation: The diagram shows navigability which is not shown in an OO domain model. Hence, it has to be a class diagram.

What is the main difference between a class diagram and an OO domain model?

a. One is about the problem domain while the other is about the solution domain.
b. One has more classes than the other.
c. One shows more details than the other.
d. One is a UML diagram, while the other is not a UML diagram.

(a)

Explanation: Both are UML diagrams, and use the class diagram notation. While it is true that often a class diagram may have more classes and more details, the main difference is that the OO domain model describes the problem domain while the class diagram describes the solution.

[W2.5] Sequence Diagrams

W2.5a :

Design → Modelling → Modelling Behaviors Sequence diagrams - basic

Video

Can draw basic sequence diagrams

Explain in your own words the interactions illustrated by this Sequence Diagram:

Consider the code below:

class Person {
    Tag tag;
    String name;

    Person(String personName, String tagName) {
        name = personName;
        tag = new Tag(tagName);
    }
}

class Tag {
    Tag(String value) {
        // ...
    }
}

class PersonList {
    void addPerson(Person p) {
        // ...
    }
}

Draw a sequence diagram to illustrate the object interactions that happen in the code snippet below:

PersonList personList = new PersonList();
while (hasRoom) {
    Person p = new Person("Adam", "friend");
    personList.addPerson(p);
}

Find notation mistakes in the sequence diagram below:

W2.5b :

Design → Modelling → Modelling Behaviors Sequence diagrams - intermediate

Video

Can draw intermediate-level sequence diagrams

Method calls to static (i.e., class-level) methods are received by the class itself, not an instance of that class. You can use <<class>> to show that a participant is the class itself.

In this example, m calls the static method Person.getMaxAge() and also the setAge() method of a Person object p.

Here is the Person class, for reference:

What’s going on here?

a. Logic object is executing a parallel thread.
b. Logic object is executing a loop.
c. Logic object is creating another Logic instance.
d. One of Logic object’s methods is calling another of its methods.
e. Minefield object is calling a method of Logic.

(d)

Explain the interactions depicted in this sequence diagram.

First, the createParser() method of an existing ParserFactory object is called. Then, ...

Draw a sequence diagram to represent this code snippet.

if (isFirstPage) {
    new Quote().print();
}

The Quote class:

class Quote {

    String q;

    Quote() {
        q = generate();
    }

    String generate() {
        // ...
    }

    void print() {
        System.out.println(q);
    }

}

Show new Quote().print(); as two method calls.
As the created Quote object is not assigned to a variable, it can be considered as 'deleted' soon after its print() method is called.

W2.5c :

Tools → UML → Sequence Diagrams → Reference frames

Can interpret sequence diagrams with reference frames

UML uses ref frame to allow a segment of the interaction to be omitted and shown as a separate sequence diagram. Reference frames help you to break complicated sequence diagrams into multiple parts or simply to omit details you are not interested in showing.

Notation:

The details of the get minefield appearance interactions have been omitted from the diagram.

Those details are shown in a separate sequence diagram given below.

W2.5d :

Tools → UML → Sequence Diagrams → Parallel paths

Can interpret sequence diagrams with parallel paths

UML uses par frames to indicate parallel paths.

Notation:

Logic is calling methods CloudServer#poll() and LocalServer#poll() in parallel.

If you show parallel paths in a sequence diagram, the corresponding Java implementation is likely to be multi-threaded because a normal Java program cannot do multiple things at the same time.

[W2.6] Activity Diagrams

Video

W2.6a

Design → Modelling → Modelling Behaviors Activity diagrams - basic

Can use basic-level activity diagrams

Software projects often involve workflows. Workflows define the a connected sequence of stepsflow in which a process or a set of tasks is executed. Understanding such workflows is important for the success of the software project.

Some examples in which a certain workflow is relevant to software project:

A software that automates the work of an insurance company needs to take into account the workflow of processing an insurance claim.

The algorithm of a piece of code represents the workflow (i.e. the execution flow) of the code.

Which of these sequences of actions is not allowed by the given activity diagram?

i. start a b c d end
ii. start a b c d e f g c d end
iii. start a b c d e g f c d end
iv. start a b c d g c d end

(iv)

Explanation: -e-f- and -g- are parallel paths. Both paths should complete before the execution reaches c again.

(a) Draw an activity diagram to represent the following algorithm used for calculating the grade of a student.

Read project score from keyboard
Read exam score from keyboard
Calculate the total
Calculate the grade
Print total and grade

(b) Update the activity diagram you drew above to also include the following logic that is used when calculating the grade.

A: at least 25 marks for each component and at least 60 in total (for brevity, you can call this condition-A -- i.e., if condition-A is met, give grade A)
B: at least one component has 25 or more marks and at least 50 in total (i.e., condition-B)
C: otherwise

At the very beginning, ask the user how many grades need to be calculated.
Repeat the whole grade calculation process for the number of times specified by the user.

_{[source:wikipeida]}

Draw an activity diagram to represent the following workflow a burger shop uses when processing an order by a customer.

First, a cashier takes the order.
Then, three workers start preparing the order at the same time; one prepares the drinks, one prepares the burgers, and one prepares the desserts.
In the meantime, the customer pays for the order. If the customer has a voucher, she pays using the voucher; otherwise she pays using cash.
After paying, the customer collects the food after all three parts of the order are ready.

_{[source:wikipeida]}

W2.6b

Design → Modelling → Modelling Behaviors Activity diagrams - intermediate

Can use intermediate-level activity diagrams