CS360 - labs

Lab 5 Instructions

2024-08-26T00:00:00+05:00

Dr. Suleman Shahid and Dr. Abdul Ali Bangash, Department of Computing Science, LUMS (2026). Dr. Hazel Campbell, Department of Computing Science, University of Alberta (2019, 2023, 2024). Dr. Abram Hindle, Department of Computing Science, University of Alberta (2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023). Alexander Wong, 2019. status: published summary: Lab 5 Instructions [TOC]

Lab 5 Instructions

Read Firestore 🔥.pdf for introduction of Firestore Follow instructions on Lab 5 Firestore Integration Instructions.pdf along with the TA. Complete Lab Exercise.

Download Starter Code here

Lab 5 Participation Exercise

Proper completion of this exercise is considered as part of course participation.

In this exercise it is your task to add the ability to delete Cities and integrate this functionality with the Firestore database, allowing for the persistence of deletions.

After applying the changes in the lab demo (LINK TO INSTRUCTIONS), add the ability to delete cities from the ListView and apply these same deletions to your instance of the Firestore database. If you have implemented this functionality correctly, restarting your app should not have an impact on what cities are displayed in your ListView after any addition or deletion actions.

Note: the design of the deletion functionality is up to you, however, we have uploaded a few mockups to give you some ideas.

Submission

LMS

Due Date

Tuesday 5PM

Lab 6 Instructions

2024-08-26T00:00:00+05:00

Lab 6 Instructions

Follow the slides on Javadoc and JUnit
Follow instructions on this link along with the TA.
Complete Lab Exercise.

Some known issues:

"test events were not received" --> Solution: link
"Error creating JavaDoc" --> Solution: link

Lab 6 Participation Exercise

Proper completion of this exercise is considered as part of course participation.

In this exercise your task is to implement and test the following methods in the CityList class AND create Javadocs for the main source files (not tests):

1) Implement and test these methods: - hasCity(City city) - When given a city, return whether or not it belongs in the list

    - Test to see whether your method is correct (Read https://www.infoworld.com/article/3305792/comparing-java-objects-with-equals-and-hashcode.html) delete(City city)

    - Check if a city is present in the list. If it does then remove it from the list, if not then **throw an exception**

    - Test to see if your method actually removes it from the list

    - Test to see if the exception is actually thrown (Read more here https://howtodoinjava.com/junit5/expected-exception-example/) countCities()

    - Return how many cities are in the list

    -  Test to see whether your method is correct

2) Add Javadocs to all methods in CityList class and City class AND generate the javadocs to /app/javadocs

Submission

LMS

Due Date

Tuesday 5PM

Lab 7 Instructions

2024-08-26T00:00:00+05:00

Lab 7 Instructions

Lab Topic/Demo

Lab 7 Participation Exercise

# Implement and test activity: ShowActivity (create by yourself to have the following property)

- By clicking on the city list, the UI should change to another activity which is "ShowActivity"

- The activity shows the city name you have clicked on

- Create a back button which goes back to MainActivity

# Test: (create 3 test cases/functions to test the 3 following functionalities)

- Check whether the activity correctly switched

- Test whether the city name is consistent

- Test the "back" button

Submission

LMS

Due Date

Tuesday 5PM

Lab 8 Participation Exercise

2024-08-26T00:00:00+05:00

Lab 8 Instructions
Lab 8 Slides
- Updated Slides
- Original Slides
Lab 8 Instructions
Lab 8 Participation Exercise
Submission

Lab 8 Instructions

In this lab, we will learn about test driven development (TDD) and continuous integration (CI). These are both solutions for solving some common software engineering problems using unit testing. We will go through the slides (updated version) posted below, and go through a live demo in class based on the instructions below to show you how to use TDD and CI.

Lab 8 Slides

Updated Slides

These slides are based on the original slides posted below, but have a couple more diagrams and a more concise format. If you want to read more about the topic, check out the original slides.
Lab 8 Updated Slides

Original Slides

Lab 8 Slides

Lab 8 Instructions

Lab 8 Instructions

Lab 8 Participation Exercise

Lab Exercise

• Implement has city, delete city, and count cities (same as lab 6), however, this time using TDD.

• Create each functionality one at a time, creating (and pushing) a test to create a failing build, before adding functionality to make it pass.

• e.g., create hasCity test, push for failing build, write functionality for hasCity to make passing build. Repeat for delete city and count cities.

Submission

LMS

Due Date

Tuesday 5PM

Lab 1

2024-08-19T00:00:00+05:00

Lab 1 Slides
Instructions
- Walkthrough
Lab1 Participation Exercise Requirements
Submission

Lab 1 Slides

Lab 1 Slides

Instructions

Download and install Android Studio from the official Android website

https://developer.android.com/studio

Check for specific installation guide unique to your Operating System

https://developer.android.com/studio/install

Walkthrough

Create a new LonelyTwitter project (File > New > New Project > Select "Empty Views Activity"). Make sure that the project language is Java, not Kotlin!
Create Tweet Class (Click > New > Java Class)
Make attributes (Date date & String message) (use alt+enter (windows) or Option-Enter (Mac) to include/import any packages)
- Note: Access modifiers
  - private= class only
  - No modifier = within package
  - protected = within package and through inheritance
  - public = everyone!
Create two Constructors (one with the only Message and the other with Date+Message as arguments) and use Date = new Date() (current date and time) for the first constructor (the Default value for date).
Note: Java Object Class (everything extends it, calls its constructor and it has built-in methods like toString())
Note: the this keyword (message = message doesn't do anything!)
Make a regular tweet in MainActivity (pass in an empty string)
Getters and setters
Inheritance
Make ImportantTweet child class (extends Tweet)
- call super in both of ImportantTweet's constructors
Now have access to the parent's methods and attributes. except constructors! (try and make an important Tweet)

ImportantTweet(String message){
        super(message);
    }

Super calls the parent's constructor (there is a hidden call to Object's constructor)
Change the Tweet to an ImportantTweet in MainActivity
Abstract Stuff
Make Tweet Class Abstract
- public abstract class Tweet { ... }
  - Note: Abstract classes cannot be instantiated.
- public abstract Boolean isImportant();
  - This is an abstract method, it has no implementation and must be overridden by child classes (to add functionality).
  - Note: Abstract methods cannot be called using any objects.
What if they need to behave differently? @Override isImportant() to create a compile-time check
- You need to override the method in the child class as it is an abstract method in the parent class that has no implementation.
- Overriding the method allows the child class to have its own implementation of the method.
  - ex. the Normal Tweet is not important, so it returns false. The ImportantTweet is important, so it returns true.
- The methods in the child classes need to be overridden to behave differently.
Make a NormalTweet class, could have many types of tweets
- call super in both of NormalTweet's constructors
- isImportant method should return Boolean.FALSE
- What if we want to use both in our list? (Implicit upcasting)

ArrayList tweetList = new ArrayList(); tweetList.add(normalTweet);

Abstract method and base class so all the classes have the isImportant() method
An interface can also be used to force the use of some methods

public interface Tweetable {
     public String getMessage();
     public Date getDate();
   }

Make Tweet implement Tweetable

Lab1 Participation Exercise Requirements

Add three new model classes to LonelyTwitter: the first should be an abstract base class which represents the current mood. The second and third should be non-abstract classes which represent different moods (Ex: happy, sad, etc.) and inherit from the abstract class.
Each mood should have a date and getters and setters to access the date.
A constructor which sets the date to a default and a constructor which takes a date as an argument should be provided.
Encapsulation should be followed.
Each mood should have a method which returns a string representing that mood.
Your new code should have examples of classes, methods, attributes, access modifiers, encapsulation, constructors, inheritance and abstract base classes.

Submission

LMS

Note: Running the project is not necessary.

Due date: Check the schedule. (Usually Tuesday 5PM)

Lab 2 Instructions

2024-01-06T00:00:00+05:00

Lab 2 Instructions
Lab 2 Participation Exercise
Submission

Lab 2 Instructions

In Lab 2, we'll be doing the following:

Quick review of OOP principles Android Basics (Lab 2 Android Basics PDF under Lab 2) Displaying a list of items using ListView/ListAdapter (Lab 2 ListView Demo Example - Instructions PDF under Lab 2) Lab Exercise - adding and removing items from ListAdapter (see the Lab 2 Participation Exercise below for more details.)

Lab 2 Participation Exercise

Task: Modify/Expand ListyCity to allow for the addition of new cities as well as the deletion of existing ones in the ListView. The specifics of the design of this functionality are up to you.

If you could not attend the labs or do not have the code for ListyCity, follow the instructions in Lab 2 ListView Example - Instructions.

Hints:

You may want to use the OnClickListener methods discussed in the lab.
Ideally you should consider treating the cities as objects, however, in this exercise it may not be necessary.

Here are some screenshots from an example application that demonstrate the required functionality.

Your app does not need to look exactly like this demo！！！

Press "ADD CITY" then type the name and press "CONFIRM". This adds a new city name to the listview
Tap a city name to select it then press "DELETE CITY" to remove the city from the listview.

Submission

LMS

Note: Proper completion of this exercise is considered as part of course participation.

Due Date

Tuesday 5PM

Lab 3 Instructions

2024-01-06T00:00:00+05:00

Lab 3 Instructions - What we'll do in lab!
Lab 3 Participation Exercise
Submission

Lab 3 Instructions - What we'll do in lab!

In Lab 3, together we'll go through the following:

Going through Lab 3 Slides PDF (customize ArrayAdapter and Fragments)
Supporting a ListView with items that have multiple views using a custom ArrayAdapter and Using a Fragment to add new cities to ListyCity (customize ArrayAdapter and Fragments code & walkthrough)

Download the Starter code here

Read about Java code conventions (see the Code Conventions (Schoepp) PDF).

Editing existing cities in ListyCity (see the Lab 3 Participation Exercise below for more details)

Lab 3 Participation Exercise

Note: Proper completion of this exercise is considered as part of course participation.

Task: Add functionality to ListyCity to allow editing an existing city. The specifics of the design of this functionality are up to you.

If you could not attend the labs or do not have the code for the updated Lab 3 ListyCity, follow Lab 3 Instructions for ListyCity CustomList and then ListyCity Fragment. You can also download the "Lab 3 Demo" code from eClass.

Your app does not need to look exactly like the screenshots. All that is required is the ability to edit an existing city. You can implement it and make it look like however you want.

Hints: 1. Add setters to your City class so that you can modify its name and province.

You may need to pass the City object that is clicked in the Activity into the Fragment. One way to do this is to make a constructor for the Fragment that takes in a City, and store the City in the Fragment as an instance variable. If you do this, make sure to also add an empty constructor to the Fragment so you can use it when adding a new City. Another way you can send a City object from the Activity to the Fragment is by adding a "newInstance" method in the Fragment, and use this method to create a new Fragment when editing a City. In this method, you take in a City and store it in the Fragment's Bundle object (if you do this, make sure that your City class implements the "Serializable" interface, so that it can be saved into the Bundle). Later on in your onCreateDialog method, you can access the Bundle using getArguments() and retrieve the City object there. Note that storing data in a Bundle is similar to storing data in an Intent using key-value pairs. (This is the preferred way to do it in Android, because you usually should not have custom constructors for your Fragments. See here for more info).

Example of a newInstance method in AddCityFragment (Hint #3)

Submission

LMS

Due Date

Tuesday 5PM

Lab 4 Participation Exercise

2024-01-06T00:00:00+05:00

Lab 4 Slides
- Extra Information
  - Command Line Authentication to GitHub
- Sensitive Information and Git
  - What is Sensitive Information
Lab 4 Participation Exercise

Lab 4 Slides

Extra Information

Command Line Authentication to GitHub

In the slides, authentication with GitHub is done using a token you generate with our account.
GitHub has a command line tool which makes this process easier, and will generate and manage the token for you.
GitHub has documentation about how to do this here.
The summary of these steps is to first install the GitHub CLI, which will depend on what operating system you are using. The instructions for installation is here.
Then, with the CLI tool installed, run the command gh auth login. The terminal will guide you through what you need to do. Please make sure to select that you want a GitHub.com account and want to use SSH as your protocol.
The documentation for the authentication command is located here

Sensitive Information and Git

What is Sensitive Information

Git is a version control system which tracks all files, past and current, that you commit to it.
This means that even if you remove a file or part of a file from your repository, it is still tracked and accessible in the history of your repository.
As such, if you commit sensitive data, it is very difficult, if not impossible, to remove it.
Sensitive data includes anything such as ID numbers (like your student ID number), API keys, passwords, etc.
GitHub as some excellent documentation about best practices for avoiding this, located here.
There is also information about removing sensitive information from your repository, but this should only be used in an emergency as it can have severe consequences if not done properly.

Lab 4 Participation Exercise

This task is for teams.

As a team:
- Create an Organization in GitHub and then create a repository (repo name: Team name) under this organization.
- Add your members as collaborators so the whole team will be able to commit to their branches.
- Create a new Android Studio project (1 project per team) with the same name as the repo name (Team name).
- Your android project folder is your local repository and write all the commands within this repo/directory.
- Use 'git init', 'git add', 'git commit', and 'git push' to push your code to the remote
- Use 'git remote add origin' to add the URL of your remote repo to this local repo.
- The repository should include .gitignore to not include Android Studio settings files (.idea) and the project build folder.
- Create an abstract class Shape (java file) with x and y integer fields (as a team).
- Commit the change and push it to GitHub.
As a member, on your local machine:
- (Do not fork) Clone the repository and create a branch with your name (do not use RollNum).
- Create a model class (ex. circle, rectangle, star, etc) (new java file) that extends Shape in your own branch.
- Commit the change and push the branch to GitHub.
- Create a pull request to main in Github.
- Ask another member to merge it.
- Edit the Shape class by adding a color string field. (String color = "blue";) (local your-own branch)
- Commit the change. (Don't push it)
- As a team:
- Edit the Shape class in the main branch on GitHub by adding a color string field. (String color = "$PUT_YOUR_CHOICE_OF_COLOR";)
- Commit the change in GitHub.
- As a member, on your local machine:
- Pull the main branch from GitHub. You should have a conflict. (Origin/main -> local your-own)
- Resolve the conflict.
- Commit the change.
- Push the branch to GitHub.

Please submit:

Your RollNum
Link to your branch in the repository at LMS

Due Date

Tuesday 5PM

Lab 4 Participation Exercise Past Notes

2024-01-06T00:00:00+05:00

PAST Lab Git Notes (Romansky)

PAST Lab Git Notes (Romansky)

Preliminaries: Git has two modes it runs in. You can run it as a client which is what most uses will be. Or, you can run it as a server service. Github runs git as a service. As a client, you can connect your computer to the service. The computer offering git as a service is after referred to as a remote, or remote computer. You should setup a Github account for this course. Your Github account should be professional. Please be safe for work! Your git repositories in this class should all use a FOSS license! You can read about .gitignore files if you want git to ignore files matching regular expressions like backup files that end in a ~.

cmd: git config --global user.name "yourUserName"
cmd: git config --global user.email "your@email.com"
cmd: git config --global core.editor nano
cmd: git config --list

description: these commands setup your workstation git configurations which will be associated with each of the file changes you make through git. So, you should set them before you do anything.

cmd: git clone description: allows a developer to make a copy of a git repository from a remote location to the developers local work station. example: git clone https://github.com/bpython/bpython.git result: makes a copy of the bpython repo on your computer!

cmd: git branch description: create a new code branch. The new branch will contain a copy of the current branches code. example: git branch bug444 result: creates a branch named bug444

cmd: git branch -a description: shows all current branches associated with the current working repo. This will list branches that exist on the local work station and the remote repositories associated with the repo.

cmd: git push -u origin description: this will push a local branch to a given remote git service. You have to run this command when you make a new local branch that you would also like to track on the remote server.

cmd: git add cmd: git rm description: add or remove a file from gits file tracking system

cmd: git status description: print the current changes that git can track or is not tracking

cmd: git checkout cmd: git checkout --branch description: git checkout lets you change which branch you are working in. The latter usage changes your current branch and creates a new branch with the given name.

cmd: git merge description: git merge will take a given branch name and merge it into your current working branch. This is useful if you would like to grab features from another branch of code.

cmd: git pull cmd: git push description: fetch the latest commits from origin, or push your latest changes to origin

Other commands, git remote, git rebase, and git fetch

Last modified: Tuesday, 3 September 2019, 11:58 PM