Add dms lecture notes

.gitea/workflows/deploy.yaml

@@ -1,61 +1,44 @@
-name: Build Notes Site
+name: Build and Deploy MkDocs
 
 on:
   push:
-    branches: [ main ]
+    branches:
+      - main
 
 jobs:
-  build:
+  deploy:
     runs-on: ubuntu-latest
-    container:
-      image: node:20-bookworm  # Node for checkout
 
     steps:
-      # 1️⃣ Checkout repository
-      - uses: actions/checkout@v4
+      - name: Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Important for switching branches
 
-      # 2️⃣ Install Python for MkDocs build
-      - name: Install Python
+      - name: Build and Extract Site
         run: |
-          apt-get update
-          apt-get install -y python3 python3-venv python3-pip
+          docker build -t mkdocs-temp -f ci/mkdocs/Dockerfile .
+          docker create --name temp-container mkdocs-temp
+          # Copying content to a folder named 'output_content' to avoid naming collisions
+          docker cp temp-container:/build/site ./output_content
+          docker rm temp-container
 
-      # 3️⃣ List repo files (debug)
-      - name: List repo files
-        run: ls -R "${{ github.workspace }}"
-
-      # 4️⃣ Build MkDocs site locally
-      - name: Build MkDocs site
+      - name: Deploy to docs-static Branch
         run: |
-          python3 -m venv .venv
-          .venv/bin/pip install --upgrade pip
-          .venv/bin/pip install -r ci/mkdocs/requirements.txt
-          .venv/bin/mkdocs build --clean --site-dir site_output
+          git config user.name "gitea-actions[bot]"
+          git config user.email "actions@noreply.gitea.io"
           
-      # 5️⃣ Install Docker CLI so we can copy to volume
-      - name: Install Docker CLI
-        run: |
-          apt-get update
-          apt-get install -y ca-certificates curl gnupg lsb-release
-          install -m 0755 -d /etc/apt/keyrings
-          curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
-          chmod a+r /etc/apt/keyrings/docker.gpg
-          echo \
-            "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
-            https://download.docker.com/linux/debian $(lsb_release -cs) stable" | \
-            tee /etc/apt/sources.list.d/docker.list > /dev/null
-          apt-get update
-          apt-get install -y docker-ce-cli
+          # Increase buffer to handle larger media files
+          git config http.postBuffer 524288000
 
-      # 6️⃣ Copy the site output into notes_public Docker volume
-      - name: Copy site to notes_public volume
-        run: |
-          docker run --rm \
-            -v notes_public:/public \
-            -v "${{ github.workspace }}/site_output:/tmp/site" \
-            alpine sh -c "cp -r /tmp/site/* /public/"
+          mv output_content /tmp/site_final
+          git checkout --orphan docs-static
+          git rm -rf .
+          cp -r /tmp/site_final/. .
 
-      # 7️⃣ Optional: Verify files in volume
-      - name: List notes_public volume
-        run: |
-          docker run --rm -v notes_public:/data alpine ls -la /data
+          # Optional: Remove source maps to save space
+          find . -name "*.map" -type f -delete
+
+          git add .
+          git commit -m "Automated MkDocs build"
+          git push origin docs-static --force

ci/mkdocs/Dockerfile

@@ -1,7 +1,9 @@
 FROM python:3.13-slim
 
-WORKDIR /work
+WORKDIR /build
 
-COPY requirements.txt /tmp/requirements.txt
+RUN pip install --no-cache-dir mkdocs mkdocs-material mkdocs-minify-plugin
 
-RUN pip install --no-cache-dir -r /tmp/requirements.txt
+COPY . .
+
+RUN mkdocs build

docs/lectures/dms/01_java_collections.md

@@ -0,0 +1,135 @@
+# Java Collections
+
+Week 3 (Oct 5th)
+
+**Part 1**
+
+In java a *collection* is an object that represents a group of objects.
+The collections API is a unified framework for representing and manipulating collections independently of their implementation.
+
+An *API* (application programming interface) is an interface protocol between a client and a server, intended to simplify the client side software.
+
+A *library* contains re-usable chunks of code.
+
+**Java Collections framework**
+- We have container objects that contain objects
+- All containers are either "collections" or "maps"
+- All containers provide a common set of method signatures, in addition of their unique set of method signatures
+
+*Collection* - Something that holds a dynamic collection of objects
+*Map* - Defines mapping between keys and objects (two collections)
+*Iterable* - Collections are able to return an iterator objects that can scan over the contents of a collection one object at a time
+
+NOTE: Vector is a legacy structure in Java replaced with *ArrayList*
+      Stack is now *ArrayDeque*
+
+`LinkedList(Collection<? extends E> c)` - means some type that either is E or a subtype of E. The `?` is a wildcard.
+
+```java
+public static void main(String[] args) {
+     LinkedList list = new LinkedList();
+     list.add("string");
+     String s = (String)list.getFirst();
+     System.out.println(s);
+}
+```
+
+This is bad coding practice, the collection constructor are not able to specify the type of objects the collection is intended to contain. A `ClassCastException` will be thrown if we attempt to cast the wrong type.
+
+```java
+public static void main(String[] args) {
+     LinkedList<String> list = new LinkedList<>();
+     list.add("string");
+     String s = list.getFirst();
+     System.out.println(s);
+}
+```
+
+This is a type safe collection using generics.
+- Classes support generics by allowing a type variable to be included in their declaration.
+- The `<>` show the same type as stated (in this case string)
+- You cannot type a collection with a primitive data type eg int
+
+**HashMap Class**
+- A HashMap is a hash table based implementation of the map interface. This implementation provides all if the optional map operations, and permits null values and the null key.
+
+```java
+public static void main(String[] args) {
+     HashMap<String, Integer> userData = new HashMap<>();
+	 userData.put("Emma", 30);
+	 userData.put("John", null);
+	 userData.put("Millie", 17);
+
+	 Set<String> keys = userData.keySet();
+
+	 for (String key:keys){
+	 	System.out.println(key + "=" userData.get(key));
+	 }
+}
+```
+
+```
+Emma = 30
+John = null
+Millie = 17
+```
+
+**Part 2**
+
+__Relationships between objects__
+
+*Aggregation* - The object exists outside the other. It is created outside so it is passed as an argument.
+An animal object *is part of* a compound object (semantically) but the animal object can be shared and if the  compound object is deleted, the animal object isn't deleted.
+
+```java
+public class Compound {
+	private Animal dog;
+
+	public void setAnimal(Animal dog){
+		this.dog = dog;
+	}
+}
+```
+
+![Image](assets/1.png)
+
+*Composition* - The object only exists if the parent object exists, if the parent object is deleted then so is the child object.
+The zoo object owns the compound object. If the zoo object is deleted then the compound object is also deleted.
+
+```java
+public class Zoo {
+	private Compound dogArea = new Compound();
+}
+```
+
+![Image](assets/2.png)
+
+**Inheritance**
+A way of forming new classes based on existing classes. Has a "is-a" relationship.
+
+*Polymorphism* - A concept in object oriented programming. Method overloading and method overriding are two types of polymorphism.
+- *Method Overloading* - Methods with the same name co-exist in the same class but they must have different method signatures. Resolved during compile time (static binding).
+- *Method Overriding* - Methods with the same name is declared in parent and child class. Resolved during runtime (dynamic binding).
+
+```java
+public class Child extends Parent {
+	public Child(String name){
+		super(name);
+	}
+	
+	@Override
+	Public void eat() {
+		chew();
+	}
+}
+```
+
+The super keyword called the parent class' constructor.
+
+![Image](assets/3.png)
+
+**What is the difference between an abstract class and an interface**
+- Java abstract class can have instance methods that implement a default behaviour. May contain non-final variables.
+- Java interfaces have methods that are implicitly abstract and cannot have implementations. Variables are declared final by default.
+
+Interfaces are less restrictive when it comes to inheritance, interfaces can have many levels of inheritance where as a class can only have one level.

docs/lectures/dms/02_uml.md

@@ -0,0 +1,92 @@
+# Unified Modelling Language
+
+12/10/20
+
+**UML**: A specification defining a graphical language for visualising, specifying, constructing and documenting the artefacts of distributed object systems.
+
+Latest version: **2.6**
+
+**Benefits of UML**
+
+- Enhances communication and ensures the right communication 
+- Captures the logical software architecture independent of the implementation language.
+- Helps to manage the complexity
+- Enables reuse of design
+
+<img src="assets/4.png" alt="img" style="zoom:80%;" />
+
+
+## Object Orientated Analysis
+
+**Use case diagrams**
+
+- Describe a set of actions that some system should or can perform in collaboration with one or more external users of the system.
+- No attempt to represent an order or a number of executions.
+
+**Use case diagram components**
+
+`Actors` - Entities that interface with the system. Can be people or other systems.
+
+`Use case` - Based on user stories and represent what the actor wants your system to do for them. In the use case diagram only the use case name is represented.
+
+`Subject` - Classifier representing a business, software system, physical system or device under analysis design, or consideration.
+
+`Relationships` 
+
+> Relationships between use case and actor
+>
+> 1. Association indicates which actor indicates which use case
+>
+> Relationship between two use cases
+>
+> 1. Specifying common functionality and simplifying use case flows
+> 2. Using <<include>>  or <<extend>>
+
+**`<<include>>`**- multiple use cases share a piece of same functionality which is placed in a separate use case.
+
+**`<<extend>>`** - Used when activities might be performed as part of another activity but are not mandatory for a use case to run successfully.
+
+
+**Use case diagram of a fleet logistics management company**
+
+![image](assets/5.png)
+
+
+**Base Path** - The optimistic path (best case scenario)
+
+**Alternative Path** - Every other possible way the system can be used/abused. Includes perfectly normal alternate use, but also errors and failures.
+
+
+Use Case: `Borrow copy of book`
+
+> **Purpose**: The book borrower (BB) borrows a book from the library using the Library Booking System (LBS)
+>
+> **Pre-conditions**: 
+>
+> 1. The book must exist
+> 2. The book must be available
+>
+> **Base Path**:
+>
+> 1. LBS requests membership card
+> 2. BB provides membership card
+> 3. BB is logged in by LBS 
+> 4. LBS checks permissions / debts 
+> 5. LBS asks for presenting a book 
+> 6. BB presents a book 
+> 7. LBS scans RFID tag inside book 
+> 8. LBS updates records accordingly 
+> 9. LBS disables anti-theft device 
+> 10. BB is logged out by LBS 
+> 11. LBS confirms that process has been completed successfully
+>
+> **Alternative Path**
+>
+> 1. BB's card has expired: Step 3a: LBS must provide a message that card has expired; LBS must exit the use case
+>
+> **Post conditions for base path**
+>
+> **Base path** - BB has successfully borrowed the book & system is up to date.
+>
+> **Alternate Path 1** - BB was NOT able to borrow the book & system is up to date.
+

mkdocs.yml

@@ -65,4 +65,8 @@ nav:
           - Chapter 1. Reliable, Scalable and Maintainable Applications: books/designing_data_intensive_applications/part1/chapter1.md
           - Chapter 2. Data Models and Query Languages: books/designing_data_intensive_applications/part1/chapter2.md
     - Structure and Interpretation of Computer Programs: books/structure_and_interpretation_of_computer_programs/index.md
+  - Lecture Notes:
+    - Developing Maintainable Software:
+      - Java Collections: lectures/dms/01_java_collections.md
+      - UML Diagrams: lectures/dms/02_uml.md