Documentation of a dual-boot setup where Arch Linux ARM’s userspace runs on top of the kernel, modules, firmware, and initramfs from a working Ubuntu 26.04 aarch64 install. Ubuntu’s GRUB loads the kernel and points its root= at the Arch partition.

Date: 2026-10-20 Hardware: HP OmniBook X 14 (fe0xxx), Qualcomm Snapdragon X, aarch64 Host: Ubuntu 26.04, kernel 7.0.0-38-generic Guest: Arch Linux ARM, ArchLinuxARM-aarch64-latest.tar.gz (ARMv8 AArch64 Multi-platform) from https://archlinuxarm.org/about/downloads

How it works

The Arch ARM tarball is only a userspace root filesystem. It has no kernel that boots this laptop, so:

The laptop boots via ACPI, so no devicetree line is needed in the GRUB entry. This was verified by grepping grub.cfg for devicetree and dtb and finding nothing.

Disk layout used

UUIDs used below (replace with yours from lsblk -f):

• Ubuntu root (p5): c8b9b28b-eab1-4441-a158-027c42288db5
• Arch root (p7): ef3b53f1-ab9a-4ca0-a1eb-12b9fa018402

Step 1: Create the Arch root partition

Shrink Ubuntu or use free space (use a live USB if you need to shrink a mounted root), then create a partition with cfdisk /dev/nvme0n1. Format and extract:

sudo mkfs.ext4 /dev/nvme0n1p7        # double-check the device first, this erases it
sudo mkdir -p /mnt/arch
sudo mount /dev/nvme0n1p7 /mnt/arch
cd ~/Downloads
sudo bsdtar -xpf ArchLinuxARM-aarch64-latest.tar.gz -C /mnt/arch

• Use bsdtar (sudo apt install libarchive-tools), not GNU tar, to avoid xattr and file-capability problems.
• Run it as root with -p so permissions are preserved.
• ls /mnt/arch should show bin boot dev etc home usr var ....

Gotcha: An early attempt failed because the commands contained placeholders (nvme0n1pX, nonexistent /mnt/arch). Always substitute your real partition and create the mount point first.

Step 2: Copy modules and firmware from Ubuntu

sudo mkdir -p /mnt/arch/usr/lib/modules /mnt/arch/usr/lib/firmware
sudo cp -a /lib/modules/$(uname -r) /mnt/arch/usr/lib/modules/
sudo cp -a /lib/firmware/. /mnt/arch/usr/lib/firmware/

The modules must match the kernel version exactly. Firmware is critical on Snapdragon X laptops (GPU, Wi-Fi, remoteprocs).

Step 3: Collect the boot parameters

uname -r
ls /boot
cat /proc/cmdline
sudo grep -E "menuentry |devicetree|dtb" /boot/grub/grub.cfg

Working Ubuntu command line on this machine:

BOOT_IMAGE=/boot/vmlinuz-7.0.0-38-generic root=UUID=c8b9b28b-... ro clk_ignore_unused pd_ignore_unused cma=128M efi=noruntime crashkernel=...

The extra parameters (clk_ignore_unused pd_ignore_unused cma=128M efi=noruntime) are what make Snapdragon X laptops boot reliably, so they are carried over to the Arch entry. crashkernel= is omitted since it only matters for crash dumps.

Step 4: Chroot setup

Use mount propagation flags so unmounting the chroot cannot affect the host’s /dev:

sudo mount --rbind /dev /mnt/arch/dev
sudo mount --make-rslave /mnt/arch/dev
sudo mount -t proc proc /mnt/arch/proc
sudo mount --rbind /sys /mnt/arch/sys
sudo mount --make-rslave /mnt/arch/sys
sudo mount --bind /run /mnt/arch/run
sudo mount --make-slave /mnt/arch/run

# the tarball's resolv.conf points at a resolver that isn't running in the chroot
sudo mv /mnt/arch/etc/resolv.conf /mnt/arch/etc/resolv.conf.bak
sudo cp /etc/resolv.conf /mnt/arch/etc/resolv.conf

sudo chroot /mnt/arch /bin/bash

Inside the chroot (the prompt becomes [root@... /]#):

pacman-key --init
pacman-key --populate archlinuxarm
passwd
echo "UUID=ef3b53f1-ab9a-4ca0-a1eb-12b9fa018402 / ext4 defaults 0 1" > /etc/fstab

# keep the generic ARM kernel out
pacman -R linux-aarch64
pacman -Syu networkmanager nano sudo
systemctl enable NetworkManager

# restore the resolver symlink for normal boot
rm /etc/resolv.conf
ln -s ../run/systemd/resolve/stub-resolv.conf /etc/resolv.conf
systemctl enable systemd-resolved

useradd -m -G wheel <yourname>
passwd <yourname>
exit

Back on the Ubuntu host, allow sudo for the wheel group and clean up:

sudo sed -i 's/^# %wheel ALL=(ALL:ALL) ALL/%wheel ALL=(ALL:ALL) ALL/' /mnt/arch/etc/sudoers
sudo umount -R /mnt/arch

Gotchas hit during this step

1. sudo: command not found. The commands were pasted while still inside the chroot, where sudo is not installed. Run exit to return to the Ubuntu prompt (jade@...) before pasting host commands.
2. sudo: unable to open pty on the host. Plain --bind mounts of /dev share propagation with the host, so unmounting inside the chroot side removed the host’s /dev/pts. Fix: reboot (or pkexec mount -t devpts devpts /dev/pts -o gid=5,mode=620,ptmxmode=666). The --make-rslave mounts above prevent this.
3. umount: /mnt/arch/dev: target is busy. pacman-key --init leaves a gpg-agent / dirmngr running inside the chroot. Kill them, then unmount again:

   sudo pkill -f 'gpg-agent --homedir /etc/pacman.d/gnupg'
   sudo pkill -f 'dirmngr --homedir /etc/pacman.d/gnupg'
   sudo umount -R /mnt/arch
   

4. A user literally named yourname was created, because a placeholder was pasted as-is. Rename it with:

   sudo usermod -R /mnt/arch -l <realname> -d /home/<realname> -m yourname
   sudo groupmod -R /mnt/arch -n <realname> yourname
   

Step 5: Verify before touching GRUB

Read-only checks from Ubuntu with /mnt/arch mounted:

ls -l /mnt/arch/usr/bin/nmcli /mnt/arch/usr/bin/NetworkManager
ls -l /mnt/arch/etc/systemd/system/multi-user.target.wants/NetworkManager.service
ls -l /mnt/arch/usr/bin/wpa_supplicant
cat /mnt/arch/etc/fstab
ls /mnt/arch/boot                       # should be empty
ls /mnt/arch/usr/lib/modules            # should only show 7.0.0-38-generic
ls -l /mnt/arch/etc/resolv.conf         # symlink to ../run/systemd/resolve/stub-resolv.conf

All of these passed.

Step 6: Add the GRUB entry

Append to the end of /etc/grub.d/40_custom (keep any existing entries):

menuentry 'Arch Linux ARM' {
    search --no-floppy --fs-uuid --set=root c8b9b28b-eab1-4441-a158-027c42288db5
    linux /boot/vmlinuz-7.0.0-38-generic root=UUID=ef3b53f1-ab9a-4ca0-a1eb-12b9fa018402 rw clk_ignore_unused pd_ignore_unused cma=128M efi=noruntime
    initrd /boot/initrd.img-7.0.0-38-generic
}

sudo update-grub
sudo umount /mnt/arch

Notes:

• search ... --set=root points GRUB at the Ubuntu partition, which holds the kernel and initramfs.
• root=UUID= points the kernel at the Arch partition.
• The version is pinned (7.0.0-38-generic) instead of using the vmlinuz symlink, so it always matches the copied modules.
• Ubuntu’s initramfs works for Arch because it only needs to find the root device (nvme, ext4) and switch_root into it.
• Ubuntu’s own entries are untouched, so it is always possible to boot back into Ubuntu.

Step 7: First boot and post-install

First boot reached a working shell. Networking came up through enu1 (a wired/USB network adapter) via systemd-networkd, and pacman worked.

Fix IgnorePkg placement

IgnorePkg was appended to the bottom of /etc/pacman.conf, under the [aur] section, where pacman ignores it (it printed directive 'IgnorePkg' in section 'aur' not recognized). Move it into [options]:

sudo sed -i '/^IgnorePkg = linux-aarch64/d' /etc/pacman.conf
sudo sed -i '/^\[options\]/a IgnorePkg = linux-aarch64 linux-aarch64-headers' /etc/pacman.conf
sudo pacman -Syu

Confirm the generic kernel is not installed:

sudo pacman -Q linux-aarch64      # should say "was not found"
grep -n IgnorePkg /etc/pacman.conf

Wi-Fi

ip link
rfkill list
sudo dmesg | grep -iE 'ath12k|wlan|firmware' | tail -30
nmtui

Use NetworkManager for Wi-Fi. iwd was installed during testing; do not run it alongside NetworkManager (two Wi-Fi daemons conflict). Once Wi-Fi is confirmed, disable the duplicate network service:

sudo systemctl disable --now systemd-networkd

Cleanup

sudo userdel -r alarm
sudo hostnamectl set-hostname <hostname>
sudo timedatectl set-timezone <Region/City>
# uncomment en_US.UTF-8 UTF-8 in /etc/locale.gen, then:
sudo locale-gen

Desktop

sudo pacman -S mesa vulkan-freedreno plasma-meta konsole dolphin sddm
sudo systemctl enable sddm

The install completed (555 packages). The qcom-battmgr ... failed to send synthetic uevent: -11 messages during the udev hook are harmless; udev poked the battery devices while the Qualcomm battery manager was busy.

Status at the time of writing: SDDM was enabled but not yet booted into. Result of the first graphical boot is not recorded here.

If the graphical boot fails

• Press Ctrl+Alt+F3 for a text console.
• Or at GRUB press e on the Arch entry, append 3 to the linux line, and press Ctrl+X to boot to a text console without starting SDDM.
• Gather logs:

  journalctl -b -u sddm
  sudo dmesg | grep -iE 'msm|drm|adreno'
  

• SDDM’s default X11 greeter can be switched to Wayland, which suits Snapdragon X better.
• Escape hatch: sudo systemctl disable sddm returns to a text-mode boot.

Maintenance: when Ubuntu updates its kernel

The Arch root depends on the Ubuntu kernel’s exact modules. After every Ubuntu kernel update:

1. Boot Ubuntu and note the new version (uname -r).
2. Copy the new modules into the Arch root:

   sudo mount /dev/nvme0n1p7 /mnt/arch
   sudo cp -a /lib/modules/<new-version> /mnt/arch/usr/lib/modules/
   sudo cp -a /lib/firmware/. /mnt/arch/usr/lib/firmware/
   

3. Update the version numbers in the Arch Linux ARM entry in /etc/grub.d/40_custom, then run sudo update-grub.
4. Keep the old kernel’s modules and entry until the new one is confirmed working.

Alternative: bind-mount or symlink Ubuntu’s /lib/modules into the Arch root so there is a single source of truth.

Caveats

• Do not delete /usr/lib/firmware/qcom/... in Arch. The laptop-specific blobs came from Ubuntu, and Arch’s linux-firmware package may not include them.
• Arch’s Mesa and Wayland are newer than Ubuntu’s. This is usually fine or better, but occasionally breaks GPU acceleration on this hardware.
• Keep Secure Boot configured so the Ubuntu-signed GRUB and kernel keep loading.
• The Arch ARM linux-aarch64 package must stay ignored and uninstalled. It does not boot this laptop.

Quick reference

Fix Wi-Fi issue

1. Boot into Ubuntu First, verify that Wi-Fi still works on Ubuntu:

   mcli device status
   uname -r
   

Then identify the partitions:

lsblk -f

We need to find the Arch root partition.

1. Mount your Arch installation For example, if Arch is installed on /dev/nvme0n1p7:

   sudo mkdir -p /mnt/arch
   sudo mount /dev/nvme0n1p7 /mnt/arch
   

Replace /dev/nvme0n1p7 with your the Arch root partition. Don’t guess the partition number.

If Arch uses Btrfs subvolumes, LUKS encryption, or a separate /usr partition, the mounting procedure may differ.

1. Compare the firmware directories Before entering the chroot, we can compare Ubuntu’s working firmware with Arch’s.

On Ubuntu:

ls /lib/firmware/ath11k/

Then:

ls /mnt/arch/usr/lib/firmware/ath11k/

Since the HP OmniBook X 14 previously needed Qualcomm firmware adjustments, pay particular attention to:

ath11k/
└── WCN6855/
    ├── hw2.0/
    └── hw2.1/

We should also check for HP-specific firmware files.

If Ubuntu has firmware that Arch is missing, we can copy the relevant files.

Don’t copy the entire firmware directory yet. Identify exactly which files Arch needs.

1. Enter the Arch chroot Once the partition is mounted:

   sudo mount --rbind /dev /mnt/arch/dev
   sudo mount --make-rslave /mnt/arch/dev
   sudo mount -t proc proc /mnt/arch/proc
   sudo mount --rbind /sys /mnt/arch/sys
   sudo mount --make-rslave /mnt/arch/sys
   sudo mount --rbind /run /mnt/arch/run
   sudo mount --make-rslave /mnt/arch/run
   sudo chroot /mnt/arch /bin/bash
   

   Once operating inside Arch’s filesystem while Ubuntu’s kernel is running.

You can inspect installed packages and modify Arch’s firmware.

For example:

pacman -Q | grep firmware

One limitation: loading kernel modules inside the chroot affects the running Ubuntu kernel, not a future Arch boot. So avoid using modprobe as a test of whether Arch’s Wi-Fi is fixed.

Now run these commands from Ubuntu:

ls -lah /lib/firmware/ath11k/WCN6855/hw2.1/

And:

ls -lah /mnt/arch/usr/lib/firmware/ath11k/WCN6855/hw2.1/

Also compare the hw2.0 directories:

ls -lah /lib/firmware/ath11k/WCN6855/hw2.0/
ls -lah /mnt/arch/usr/lib/firmware/ath11k/WCN6855/hw2.0/

From Ubuntu, outside the chroot, run:

sudo mkdir -p /mnt/arch/usr/lib/firmware/ath11k/WCN6855

First, back up Arch’s existing firmware:

sudo cp -a \
  /mnt/arch/usr/lib/firmware/ath11k/WCN6855 \
  /mnt/arch/root/WCN6855-backup

Then copy Ubuntu’s working firmware:

sudo cp -a \
  /lib/firmware/ath11k/WCN6855/. \
  /mnt/arch/usr/lib/firmware/ath11k/WCN6855/

This copies both hw2.0 and hw2.1, including the firmware modifications that made Ubuntu work.

It doesn’t modify Ubuntu’s firmware.

One caveat: If Arch has uncompressed firmware files alongside Ubuntu’s compressed .zst files, copying may leave both versions present. We’ll need to check for that if Wi-Fi still doesn’t work. Step 3: Check kernel modules Because both installations use the same kernel version, check whether Arch has the necessary driver modules.

From Ubuntu:

ls /mnt/arch/usr/lib/modules/

Then:

find /mnt/arch/usr/lib/modules/ -name 'ath11k_pci.ko*'

If nothing appears, Arch may not have the appropriate modules installed, even though it’s booting Ubuntu’s kernel.

Reboot into arch and connect to wifi :)

On the microblog within the lessons, if you were to make a post, you can spam the button and that would create basically a million different posts.

My plan is to add a rate limiting feature by adding a new file

Made by: Zhengji, Rudra

Microblog rate limiting

Implemented in the pages repository on fix/microblog-rate-limit. Documentation is in the separate CSA repository on the same branch name.

Behavior

• Posts, edits, and replies share one 30-second cooldown per browser origin.
• The cooldown starts before a write request is sent. Failed requests also consume the cooldown to prevent repeated retries from flooding the API.
• Save and Reply buttons display Saving... and are disabled while their request runs. A second write is rejected while a request is pending, even after 30 seconds.
• Attempts during cooldown use the existing browser alert popup to explain how many seconds remain. The form stays open and keeps the entered content.
• Local storage preserves the cooldown across refreshes, navigation, and tabs. Web Locks prevents simultaneous admission from multiple tabs where supported.
• HTTP 429 responses extend the cooldown using Retry-After in seconds or HTTP date format. Missing/invalid headers retain the default cooldown.
• Reading posts and replies is not limited.

Files

• pages/assets/js/api/microblog.js: routes all three write functions through the shared limiter; API paths and request bodies are unchanged.
• pages/assets/js/api/microblog-rate-limit.js: cooldown, persistence, pending request protection, cross-tab admission, and server backoff handling.
• pages/_includes/microblog_foundation.html: shared create/edit/reply forms, disabled buttons during requests, and existing error popups.
• pages/tests/microblog_rate_limit.test.mjs: deterministic behavioral tests.

Change MICROBLOG_COOLDOWN_MS in the limiter to adjust the default interval.

Scope and limitations

This is client-side protection against UI spam, not an enforceable API quota. Clearing storage, using another browser, or calling the API directly bypasses it. When storage is unavailable, protection falls back to page memory and logs a warning. Browsers without Web Locks have a potential simultaneous cross-tab race. The shared interval also applies when switching accounts in the same browser.

The API module sends requests to the separate Flask service’s /api/microblog and /api/microblog/reply endpoints; it does not directly create Git commits. For protection against deliberate abuse, the backend must independently enforce an authenticated-user quota before database writes or downstream side effects. For cross-origin server backoff, expose Retry-After through CORS. No backend code or deployment is changed by this patch.

Verification

From CSA Folder/pages, run:

node --test tests/microblog_rate_limit.test.mjs tests/microblog_forms.test.mjs
git diff --check

Manual browser checks after serving the site through the repository Makefile:

1. Open a page that includes the microblog, sign in, and save a post. During the request, confirm Save displays Saving... and cannot be clicked again.
2. Immediately try an edit or reply. Confirm the popup gives the remaining wait, the draft remains available, and no additional write appears in Network.
3. Reload or open another page/tab and try again within 30 seconds; it should remain blocked. After the interval, one new write should succeed.
4. With a slow request, confirm no additional write can start while it is pending.
5. Simulate an HTTP 429 with Retry-After: 120; confirm the longer wait is shown.

Automated tests cover duplicate rejection, reload persistence, cooldown expiry, pending requests, failed requests, numeric/date server backoff, shared admission through all three API write functions, unrestricted reads, disabled form buttons, popup text, and preserving a rejected draft. Requests are mocked; these tests do not create real posts or commits.

Windows local setup (2026-10-14)

The subsequent Debian WSL Make repair makes WSL the local default: .bundle/config now uses vendor/bundle-debian. For the Windows commands below, set $env:BUNDLE_PATH='vendor/bundle' first. Use make directly in Debian.

Ruby 3.3 was already installed. Installed Bundler 4.0.19 and RubyInstaller’s MSYS2/MINGW toolchain (ridk.cmd install 1 3) to build native gems, then installed the bundle into pages/vendor/bundle. The ignored .bundle/config records that path, so subsequent bundle exec commands find the installed gems.

Generated Courses, Blogs, and Topics layouts with the existing scripts/publish_project.rb publisher. In the agent’s restricted shell Ruby Dir.glob returned empty results; publication needed an unrestricted shell. The checked-in Python virtual environments refer to Linux paths and do not run on Windows. The local, ignored _sass/projects/_all.scss was generated with the same directory scan as scripts/generate_sass_imports.py using Node instead. This prepares the existing checked-out Markdown for Jekyll; it does not run the full notebook/DOCX conversion pipeline.

Cached the configured jekyll/minima HEAD theme in vendor/minima-local/minima-HEAD. The ignored _config.local.yml selects that copy and explicitly enables jekyll-remote-theme, jekyll-include-cache, jekyll-seo-tag, and jekyll-feed. Production _config.yml is unchanged.

Start from CSA Folder/pages:

bundle exec jekyll serve --config _config.yml,_config.local.yml --host 127.0.0.1 --port 4500 --no-watch

--no-watch matches the repository’s Jekyll target; restart to rebuild edits. The full Makefile conversion workflow still requires a working Python environment and its dependencies. MSYS2 supplies Make, accessible through ridk.cmd exec make.

Verified results

• Jekyll completed generation in 174.702 seconds and started serving on http://127.0.0.1:4500/. Existing post_url deprecation warnings remain.
• HTTP 200 verified for /microblog, /assets/js/api/microblog.js, /assets/js/api/microblog-rate-limit.js, and /assets/js/api/config.js.
• The served microblog HTML contains both forms, the disabled-button handling, and popup handler; the served API imports the limiter. Config Liquid values were rendered successfully.
• All five Node tests pass, including simulated simultaneous tabs with Web Locks.
• git diff --check passes.
• No browser connection was available for visual testing. Form behavior was tested through the actual handlers with mocked DOM/API objects. The Flask backend was not started, and no live microblog writes were made.

Ok so the mcq was lowk a pain in the ass

but i did it :D

7

Which of the following expressions can be used to replace /* missing code */ so that this code segment prints the string ”HIDE”?

String original = "DEFGHI";
String result = /* missing code */;
System.out.println(result);

my answer:

original.substring(4) +  original.substring(0, 1)

correct answer:

original.substring(4) +  original.substring(0, 2)

I believed that it was inclusive 1 so it would print D and E instead it only prints D

0,2 is correct as it prints D and E

9

Which of the following best explains why an error occurs when the classes are compiled?

public class Measurement
{
   private int feet;
   private int inches;

   public Measurement(int numFeet, int numInches)  
   {
      feet = numFeet;
      inches = numInches;
   }

  private int toInches()
  {
     return feet * 12 + inches;
  }
}

public class Calculations
{
   public static boolean compare(Measurement m1, Measurement m2)
   {
      if (m1.toInches() >= m2.toInches())
      {
         return true;
      }
      return false;
   }
} 

my answer: The variables feet and inches cannot be accessed from the method toInches.

correct answer: The toInches method cannot be accessed from a class other than Measurement.

why ? The problem is not that feet and inches are private.

The real issue is this line:

toInches() is declared as:

and private means:

it can only be used inside the Measurement class itself it cannot be called from another class like Calculations

So when Calculations.compare(…) tries to call m1.toInches(), Java throws a compile-time error because the method is not accessible outside Measurement.

##

19

int r = (int) (Math.random() * 6) + 10;

my answer: It generates a random integer between 10 and 16, inclusive, and assigns it to r.

answer : It generates a random integer between 10 and 15, inclusive, and assigns it to r.

35

public static boolean mystery(ArrayList<Integer> numbers)
{
   int prev = Integer.MAX_VALUE;
   for (int num : numbers)
   {
      if (num > prev)
      {
         return false;
      }
      prev = num;
   }
   return true;
}

my answer: It returns true if numbers is sorted from least to greatest and returns false otherwise.

correct answer: It returns true if numbers is sorted from greatest to least and returns false otherwise.

i made this entire file within vim, hence the name “fucking around” :)

godspeed

-jade

System info: HP OmniBook X 14 (Model 14-fe0xxx) Snapdragon X Elite 16gb 1TB ssd Win 11 Home, Ubuntu 26.04 LTS

Try to boot Fedora 44, KDE Plasma desktop env,

4GB usb, flashed w/ rufus in dd mode.

In Fedora GRUB, countdown and boots into fedora workstation, however nothing happens

Fix

As I already have a working Ubuntu install on my laptop, I can directly chainload off of my Ubuntu GRUB

1. Have usb plugged into laptop, run lsblk -o NAME,LABEL,UUID,FSTYPE
2. find uuid of Fedora-KDE-Live-44, in my case my uuid was 2026-04-22-14-19-37-00
3. Add Fedora to the Ubuntu GRUB, run sudo nano /etc/grub.d/40_custom, paste the following text (replace 2026-04-22-14-19-37-00 with your uuid)

   menuentry "Start Fedora Live via Ubuntu GRUB" --class fedora {
    insmod part_gpt
    insmod ext2
    search --no-floppy --fs-uuid --set=root 2026-04-22-14-19-37-00
    linux /boot/aarch64/loader/linux root=live:UUID=2026-04-22-14-19-37-00 rd.live.image quiet rhgb clk_ignore_unused pd_ignore_unused arm64.nopauth modprobe.blacklist=qcom_q6v5_pas systemd.tpm2_wait=0
    initrd /boot/aarch64/loader/initrd
   }
   

4. update grub by running sudo update-grub

After this I restarted laptop, and on Ubuntu GRUB screen there is option “Start Fedora Live via Ubuntu GRUB”, where I can boot Fedora via Ubuntu’s GRUB After this I continue w/ Fedora installation normally

Learning Targets

• Explain which object this refers to.
• Distinguish instance variables from parameters with the same name.
• Use this in constructors and instance methods.
• Pass the current object as an argument.
• Explain why a static method cannot use this.

What Does this Mean?

this is a reference to the current object. In an instance method, it refers to the object receiving the method call. In a constructor, it refers to the object being initialized.

Think of this.score as “this object’s score.” Each object has its own instance variables, so the object receiving the call determines which score is accessed.

Example: Two Players

Save this complete example as Player.java and run it. Later snippets labeled as methods belong inside their indicated class; driver statements belong in main.

public class Player {
    private String name;
    private int score;

    public Player(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public void addPoints(int points) {
        this.score += points;
    }

    public void printInfo() {
        System.out.println(this.name + ": " + this.score);
    }

    public static void main(String[] args) {
        Player jade = new Player("Jade", 10);
        Player alex = new Player("Alex", 20);

        jade.addPoints(5);
        jade.printInfo();
        alex.printInfo();
    }
}

Output:

Jade: 15
Alex: 20

How Does This Work?

For jade.addPoints(5), this refers to the same object as jade. The method changes that object’s score. When alex.printInfo() runs, this refers to Alex’s object instead.

Popcorn Hacks

1. Create a third player and add points to it.
2. Predict all three scores before printing them.
3. Explain why changing one player’s score does not change the others.

Parameter Shadowing

Shadowing happens when a parameter or local variable has the same name as a field. Within that variable’s scope, the plain name refers to that variable; this.name explicitly accesses the current object’s field. Oracle’s this tutorial explains this distinction.

// Constructor inside Player
public Player(String name, int score) {
    this.name = name;
    this.score = score;
}

In this.score = score;:

• Left side, this.score: the object’s instance variable.
• Right side, score: the constructor parameter.
• Assignment: copies the parameter’s value into the field.

The Self-Assignment Bug

The Stack Overflow discussion supplied for this lesson asks why a constructor using j = j; and k = k; leaves integer fields at zero. Both sides refer to parameters, so neither field changes.

Here is an original version of that bug:

// Incorrect replacement for the Player constructor
public Player(String name, int score) {
    name = name;
    score = score;
}

This compiles, but new Player("Jade", 10) leaves name as null and score as 0. Calling printInfo() immediately afterward prints null: 0.

Those are field default values. A field with an explicit initializer would retain that value instead. Local variables do not automatically receive these defaults.

When Is this Optional?

If the names differ, there is no shadowing:

// Alternative constructor inside Player
public Player(String playerName, int startingScore) {
    name = playerName;
    score = startingScore;
}

In a getter with no shadowing, return score; and return this.score; have the same effect.

Popcorn Hacks

Fix this method inside Player. It should replace the player’s score with the argument’s value.

public void setScore(int score) {
    score = score;
}

Explain what each occurrence of score means before and after your fix.

Calling an Instance Method with this

An instance method can call another instance method on the current object:

// Add inside Player
public void celebrate() {
    this.addPoints(10);
    this.printInfo();
}

Calling jade.celebrate() adds points to Jade and prints Jade’s information. In this example, writing addPoints(10); and printInfo(); would work too.

Passing this as an Argument

Sometimes another method needs the whole current object. Passing this supplies that reference. This use appears in both the uploaded Fiveable lesson and the supplied Stack Overflow discussion.

// Add inside Player
public void join(Team team) {
    team.addPlayer(this);
}

Add this separate class after the closing brace of Player in Player.java:

class Team {
    public void addPlayer(Player player) {
        System.out.print("Joined team: ");
        player.printInfo();
    }
}

Then add these driver statements to main:

Team team = new Team();
jade.join(team);

Here, this in join and the parameter player in addPlayer refer to Jade’s same object. No new Player is created. This simplified team announces the player; it does not store a roster.

Popcorn Hacks

Modify Team.addPlayer to award the incoming player three points before printing. Predict whether printing jade afterward will show that increase, and explain why.

Why Static Methods Cannot Use this

A static method belongs to the class and has no current object. This method inside Player produces a compile-time error:

// Intentionally invalid
public static void showScore() {
    System.out.println(this.score);
}

Two valid alternatives are:

// Instance method: the receiving object supplies this
public void showScore() {
    System.out.println(this.score);
}

// Static method inside Player: use an explicit object reference
public static void showScore(Player player) {
    System.out.println(player.score);
}

The second method assumes player is non-null. It can access the private field because the method is declared inside Player.

In main, use jade.showScore() for the first version or Player.showScore(jade) for the second.

Optional Extension: this(...) and return this

The uploaded Fiveable guide treats constructor chaining and fluent method chaining as enrichment. Focus first on object references, shadowing, passing this, and static contexts.

Constructor Chaining

this(...) calls another constructor in the same class. Add this overload alongside the original two-parameter Player constructor:

public Player(String name) {
    this(name, 0);
}

new Player("Sam") delegates initialization to Player(String, int), using zero as the initial score. It initializes one object. Put this(...) first for compatibility with Java 21 and earlier; newer Java versions have more flexible constructor-body rules. Constructor calls must not form a recursive cycle.

Returning the Current Object

// Add inside Player
public Player award(int points) {
    this.score += points;
    return this;
}

The driver statement jade.award(5).award(2); adds seven points to the same player. Returning this allows another method call on that object.

Practice: Trace and Debug

1. Predict the Output

class Counter {
    private int count;

    public Counter(int count) {
        this.count = count;
    }

    public void add(int count) {
        this.count += count;
        count++;
    }

    public int getCount() {
        return count;
    }
}

Driver statements in main:

Counter c = new Counter(4);
c.add(3);
System.out.println(c.getCount());

Which value is printed?

• A. 3
• B. 4
• C. 7
• D. 8

2. Identify the Error

Why does score = score; compile in the buggy constructor, while this.score inside a static method fails to compile?

3. Apply the Idea

Create a Book class with title and pages fields. Include:

1. A constructor whose parameter names match the fields.
2. A setPages(int pages) method.
3. A method that prints the book’s information.
4. Two objects demonstrating that changing one does not affect the other.

Answer Check

1. C: 7. this.count += count adds three to the field. count++ changes only the local parameter, so the field stays seven.
2. Self-assignment is legal Java even though it fails to update the intended field. A static method has no current object, so this is unavailable.
3. The constructor should use this.title = title; and this.pages = pages;. The setter should use this.pages = pages;.

Quick Review

• Identify the object receiving the call to determine what this means.
• Check parameter and local-variable names before tracing a field update.
• Use this.field to access a field hidden by a parameter.
• Passing or returning this does not copy the object.
• Static methods need an explicit object reference to access instance data.

Sources

• Lesson structure: the supplied 2025-09-21-3.9.ipynb notebook, adapted into learning targets, examples, explanations, and Popcorn Hacks.
• Core topics and debugging emphasis: uploaded AP CSA 3.9: this Keyword in Java, Fiveable.
• Self-assignment question and additional uses: The use of “this” in Java — Stack Overflow.
• Java language reference: Using the this Keyword — Oracle.

My original design is an administrator-facing account directory. I chose Option B so Spring can load records and render HTML in one application. The portfolio contains this documentation; the working forms must run on the Spring server.

The following implementation examples build on the Phase 2 entity. They require integration into the backend before they can run. The linked backend could not be retrieved from this environment, so its package name, dependency compatibility, login flow, and security filter rules have not been verified.

Repository

DirectoryAccountRepository.java, in the same package as the entity:

package YOUR_APPLICATION_PACKAGE.directory;

import org.springframework.data.jpa.repository.JpaRepository;

public interface DirectoryAccountRepository
        extends JpaRepository<DirectoryAccount, Long> {
}

Spring Data creates the repository implementation at runtime. findAll() retrieves records, findById(id) returns an Optional, save(account) inserts or updates an entity, and delete(account) removes it. The interface inherits these operations, so I do not write SQL for each route. No custom query is needed for this first version.

Routes

Controller

DirectoryAccountController.java:

package YOUR_APPLICATION_PACKAGE.directory;

import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@Controller
@RequestMapping("/mvc/directory")
public class DirectoryAccountController {
    private final DirectoryAccountRepository repository;

    public DirectoryAccountController(DirectoryAccountRepository repository) {
        this.repository = repository;
    }

    @InitBinder("account")
    void bindEditableFields(WebDataBinder binder) {
        // A submitted form cannot choose the primary key or creation time.
        binder.setAllowedFields("name", "email", "school", "studentID",
                "githubUsername", "accountType");
    }

    @ModelAttribute("accountTypes")
    AccountType[] accountTypes() {
        return AccountType.values();
    }

    @GetMapping
    String list(Model model) {
        model.addAttribute("accounts", repository.findAll(
                org.springframework.data.domain.Sort.by("id")));
        return "directory/list";
    }

    @GetMapping("/{id}")
    String detail(@PathVariable Long id, Model model) {
        model.addAttribute("account", requireAccount(id));
        return "directory/detail";
    }

    @GetMapping("/new")
    String createForm(Model model) {
        return form(new DirectoryAccount(), null, model);
    }

    @PostMapping
    String create(@Valid @ModelAttribute("account") DirectoryAccount account,
                  BindingResult errors, Model model,
                  RedirectAttributes redirect) {
        if (errors.hasErrors()) return form(account, null, model);
        DirectoryAccount saved = repository.save(account);
        redirect.addFlashAttribute("message", "Account created.");
        return "redirect:/mvc/directory/" + saved.getId();
    }

    @GetMapping("/{id}/edit")
    String editForm(@PathVariable Long id, Model model) {
        return form(requireAccount(id), id, model);
    }

    @PostMapping("/{id}")
    String update(@PathVariable Long id,
                  @Valid @ModelAttribute("account") DirectoryAccount submitted,
                  BindingResult errors, Model model,
                  RedirectAttributes redirect) {
        DirectoryAccount existing = requireAccount(id);
        if (errors.hasErrors()) return form(submitted, id, model);
        copyEditableFields(submitted, existing);
        repository.save(existing);
        redirect.addFlashAttribute("message", "Account updated.");
        return "redirect:/mvc/directory/" + id;
    }

    @PostMapping("/{id}/delete")
    String delete(@PathVariable Long id, RedirectAttributes redirect) {
        repository.delete(requireAccount(id));
        redirect.addFlashAttribute("message", "Account deleted.");
        return "redirect:/mvc/directory";
    }

    private DirectoryAccount requireAccount(Long id) {
        return repository.findById(id).orElseThrow(() ->
                new ResponseStatusException(HttpStatus.NOT_FOUND,
                        "Directory account not found"));
    }

    private String form(DirectoryAccount account, Long editingId, Model model) {
        model.addAttribute("account", account);
        model.addAttribute("editingId", editingId);
        return "directory/form";
    }

    private void copyEditableFields(DirectoryAccount source,
                                    DirectoryAccount target) {
        target.setName(source.getName());
        target.setEmail(source.getEmail());
        target.setSchool(source.getSchool());
        target.setStudentID(source.getStudentID());
        target.setGithubUsername(source.getGithubUsername());
        target.setAccountType(source.getAccountType());
    }
}

@Controller interprets a returned string such as directory/list as a template name. @RestController would write that string to the HTTP response body instead. @PathVariable reads the row ID from the URL. @ModelAttribute binds form fields, and @Valid applies the entity’s validation rules. BindingResult immediately follows the validated argument so invalid values can be displayed in the form.

Constructor injection makes the repository dependency explicit. Updates load the existing row and copy only editable fields, preserving the original creation timestamp. The path ID selects the record; an injected form field named id cannot redirect the update to a different row.

Session security integration

This directory contains personal information. Before enabling it, protect all /mvc/directory routes with the backend’s existing administrator authority, use its session login flow, and keep CSRF enabled on these routes. Do not create a competing security filter chain or assume the backend uses the authority name ROLE_ADMIN; inspect its existing rules first.

The form in Phase 4 includes a CSRF token. Spring Security must expose and validate that token. Thymeleaf rendering alone does not enable CSRF protection. If the existing backend ignores CSRF globally, that configuration must be corrected for these session-based MVC routes before deployment. Same-origin MVC forms do not need @CrossOrigin.

Error handling

Database failures are not caught and silently treated as success. Use the backend’s existing error page and logging policy to show a generic failure while keeping SQL and personal data out of the response. This small version uses last-write-wins updates; concurrent edit protection would require a version field and conflict handling.

Browser testing plan

These are expected results to verify, not recorded passing tests. Run the backend on its configured port; the assignment uses http://localhost:8585.

For each successful mutation, inspect DevTools Network: the form POST should return a redirect, followed by a GET for the destination HTML. Capture the list, detail, edit, validation, and success states. Re-run SELECT in SQLite to confirm browser actions changed stored rows.

Evidence to add: real browser screenshots and actual test outcomes. Postman JSON collections belong to Option A and are not required for this MVC choice.

Continue to Full-Stack MVC Application.

I chose Option B in my ideating post. My frontend is a set of Thymeleaf templates served by Spring. GitHub Pages hosts the write-up, while Spring hosts the interactive directory.

Browser request
    -> Spring Security: session, administrator access, CSRF for POST
    -> DirectoryAccountController
    -> DirectoryAccountRepository
    -> JPA / Hibernate -> SQLite directory_accounts
    -> Controller adds records to Model
    -> Thymeleaf renders HTML -> Browser

The entity defines the data and the controller defines the workflows. The templates below complete the implementation example. They have not been installed or browser-tested in the Spring backend, so this post does not claim a deployed application or completed screenshot evidence.

List view

Create src/main/resources/templates/directory/list.html in the Spring repository:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Account directory</title>
</head>
<body>
<main>
  <h1>Account directory</h1>
  <p th:if="${message}" th:text="${message}" role="status"></p>
  <p><a th:href="@{/mvc/directory/new}">Add account</a></p>
  <p th:if="${#lists.isEmpty(accounts)}">No accounts yet. Add the first account.</p>
  <table th:unless="${#lists.isEmpty(accounts)}">
    <caption>Students and guests</caption>
    <thead><tr>
      <th scope="col">Name</th><th scope="col">School</th>
      <th scope="col">Student ID</th><th scope="col">GitHub</th>
      <th scope="col">Type</th><th scope="col">Joined (UTC)</th>
      <th scope="col">Actions</th>
    </tr></thead>
    <tbody><tr th:each="account : ${accounts}">
      <td th:text="${account.name}"></td>
      <td th:text="${account.school}"></td>
      <td th:text="${account.studentID}"></td>
      <td th:text="${account.githubUsername}"></td>
      <td th:text="${account.accountType}"></td>
      <td th:text="${account.createdAt}"></td>
      <td>
        <a th:href="@{/mvc/directory/{id}(id=${account.id})}">View</a>
        <a th:href="@{/mvc/directory/{id}/edit(id=${account.id})}">Edit</a>
      </td>
    </tr></tbody>
  </table>
</main>
</body>
</html>

th:each repeats a row for every account supplied by the controller. th:text escapes displayed values, so a name containing HTML is displayed as text. th:if and th:unless select the success message and empty/list states. Account type is shown in text so distinguishing students from guests does not depend on color.

Detail view

Create src/main/resources/templates/directory/detail.html:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Account details</title>
</head>
<body>
<main>
  <h1 th:text="${account.name}">Account details</h1>
  <p th:if="${message}" th:text="${message}" role="status"></p>
  <dl>
    <dt>ID</dt><dd th:text="${account.id}"></dd>
    <dt>Name</dt><dd th:text="${account.name}"></dd>
    <dt>Email</dt><dd th:text="${account.email}"></dd>
    <dt>School</dt><dd th:text="${account.school}"></dd>
    <dt>Student ID</dt><dd th:text="${account.studentID}"></dd>
    <dt>GitHub username</dt><dd th:text="${account.githubUsername}"></dd>
    <dt>Account type</dt><dd th:text="${account.accountType}"></dd>
    <dt>Joined (UTC)</dt><dd th:text="${account.createdAt}"></dd>
  </dl>
  <p>
    <a th:href="@{/mvc/directory}">Back to directory</a>
    <a th:href="@{/mvc/directory/{id}/edit(id=${account.id})}">Edit account</a>
  </p>
  <form method="post"
        th:action="@{/mvc/directory/{id}/delete(id=${account.id})}">
    <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}">
    <p>Deleting removes this directory entry. It does not delete a login account.</p>
    <button type="submit">Delete directory entry</button>
  </form>
</main>
</body>
</html>

Deleting uses POST rather than a link that changes data with GET. The detail view shows all eight fields, while the list keeps email off the overview. Both views still require administrator authorization.

Creation and edit form

Create src/main/resources/templates/directory/form.html:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Edit directory account</title>
</head>
<body>
<main>
  <h1 th:text="${editingId == null ? 'Add account' : 'Edit account'}"></h1>
  <form method="post" th:object="${account}"
        th:action="${editingId == null} ? @{/mvc/directory} : @{/mvc/directory/{id}(id=${editingId})}">
    <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}">
    <div th:if="${#fields.hasErrors('*')}" role="alert">
      <p>Please correct these fields:</p>
      <ul><li th:each="error : ${#fields.errors('*')}" th:text="${error}"></li></ul>
    </div>
    <p>
      <label for="name">Name (required)</label>
      <input id="name" th:field="*{name}" required maxlength="100" autocomplete="name">
    </p>
    <p>
      <label for="email">Email (required)</label>
      <input id="email" type="email" th:field="*{email}" required
             maxlength="254" autocomplete="email">
    </p>
    <p>
      <label for="school">School (optional)</label>
      <input id="school" th:field="*{school}" maxlength="120">
    </p>
    <p>
      <label for="studentID">Student ID (optional)</label>
      <input id="studentID" th:field="*{studentID}" maxlength="40">
    </p>
    <p>
      <label for="githubUsername">GitHub username (optional)</label>
      <input id="githubUsername" th:field="*{githubUsername}" maxlength="39">
    </p>
    <p>
      <label for="accountType">Account type</label>
      <select id="accountType" th:field="*{accountType}" required>
        <option th:each="type : ${accountTypes}" th:value="${type}" th:text="${type}"></option>
      </select>
    </p>
    <button type="submit">Save account</button>
    <a th:href="@{/mvc/directory}">Cancel</a>
  </form>
</main>
</body>
</html>

th:object selects the form’s model object. th:field binds each input’s name and current value, including rejected values after validation. th:value supplies each dropdown option’s value. The controller supplies accountTypes for both new forms and forms returned with errors.

For minimal typing, editing preloads the saved values and account type uses a dropdown. ID and join date are generated, so they are not inputs. Names and identifiers still require text because their possible values are not known in advance. These templates use semantic HTML with no inline styling; visual integration should reuse the admin panel’s existing layout and SCSS pipeline.

Click → save → display

1. The administrator clicks Edit. The browser sends GET /mvc/directory/1/edit.
2. The controller loads record 1 and puts it into the model as account.
3. Thymeleaf renders the existing values in the form.
4. Save submits URL-encoded form fields and the CSRF token to POST /mvc/directory/1.
5. Spring validates the fields, loads record 1, copies editable values, and saves it through JPA.
6. The controller redirects to GET /mvc/directory/1 with a one-time success message.
7. Thymeleaf renders the updated row. Refresh now repeats the GET rather than the mutation.

This is POST-Redirect-GET. Invalid submissions return the form directly with errors instead of redirecting and losing validation feedback.

CSRF and model binding

Session cookies are automatically sent by the browser, which is why a malicious website could otherwise attempt a form submission using a logged-in administrator’s session. Spring Security validates the form’s CSRF token against the expected token. The templates explicitly include _csrf.parameterName and _csrf.token; a correctly configured Spring Security/Thymeleaf integration can also add a hidden token automatically.

The _csrf attribute must exist. Do not hide a missing token by conditionally omitting it; fix the security integration. CSRF protection requires enabled server-side validation, and it does not replace administrator authorization. The controller’s allowlist also prevents form binding from accepting an attacker-supplied primary key or creation timestamp.

MVC compared with REST

MVC suits the server-hosted admin panel I described in Phase 1. A separate REST frontend would be useful for additional clients, but it is not required for this choice. There is no config.js or browser fetch() call in this workflow; Thymeleaf’s @{...} URLs target the Spring application and respect its context path.

Screenshots and completion evidence

After backend integration, visit the local directory while signed in with the appropriate administrator account. This address is a local test target, not a published demo.

Run the Phase 3 test matrix and add observed results alongside the screenshots. The documentation and implementation examples are provided; compiling, security integration, live schema validation, and browser evidence remain to be completed in the Spring environment.

• Master POJO Design — Understand how Plain Old Java Objects form the foundation of both the AP CSA exam and modern frameworks like Spring
• Implement Data Persistence — Use JPA and SQLite to reliably store and retrieve your data object
• Build a REST API — Create Spring Boot endpoints that expose your data with proper HTTP methods (GET, POST, PUT, DELETE)
• Design Full-Stack Architecture — Connect a backend API to a frontend (GitHub Pages OR Thymeleaf admin page)
• Portfolio & Exam Preparation — Document your work in a blog that demonstrates OOP mastery and prepares you for AP CSA exam

DATA OBJECT DOMAIN MODEL

what is my team per se
my team is like
backend
we have admin panel
what coudl be useful?

i find things useful

i find that simple infographics and ui screen useful

i make

a dedicated chart with graphics of different users, their schools, their github and student ids, as well as name and join date. this chart will differentiate between students as well as guest accounts added through the mentors

therefore i choose option b

Design your POJO based on your data object

Identify all required fields (e.g., id, name, description, createdAt, updatedBy)
Choose appropriate data types (primitives, Strings, LocalDateTime, etc.)
Consider relationships (e.g., a Project belongs to a Team)

required fields:
id
name
createdAt
email

data types:
localdatetime
strings

relationships:
my project should tie into the admin panel and be a useful tool for administrators when dealing with account problems/reset passwords and similar.

Lombok Annotations:

https://dev.to/gianfcop98/10-lombok-annotations-every-java-developer-should-know-pcd

review review review

https://medium.com/javarevisited/all-the-16-lombok-annotations-explained-in-a-4-minute-article-926f71934ec6

this is my pojo

import jakarta.persistence.*
import lombok.*

@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor

public class POJO {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;
    private String school;
    private String studentID;
    private String githubUsername;
    private String accountType;
    private LocalDateTime createdAt;

}

Lombok generates the repeitive code, and the annotations automatically generate the missing code when compiling.

The @Entity annotation is part of the JPA library, it bridges the gap between java code and the database

The @Id annotation is part of the JPA library, it specifies the primary key of an entity – this allows for multipule users of the same name

The @GeneratedValue annnotation is used with the @Id annotation, and is used to generate primary values for an entity

The @NoArgsConstructor creates a constructor with no paramaters, however if not possible then compiler error. On the other hand, @AllArgsConstructor ccreates a constructor with one parameter for each field in the class.

The @Getter and @Setter annotations are used to generate the default getter/setter, without needing to write them down

A getter allows another part of the program to retrieve a private instance variable.
For example in the following code:

public String getName() {
    return name;
}

I can then write:

Admin user = new Admin();

user.setName("Ish Anjha");

System.out.println(user.getName());

The output will be:

Ish Anjha

A setter modifies an object’s instance variable.
For example in the following code:

public void setEmail(stringEmail) {
    this.email = email;
}

Interjecting the

user.setEmail("ishanjha100@gmail.com")

The state of the user object has now changed The keyword this refers to the object

this.email = email;

In this example:

• this.email = email; is the instance variable
• email is the parameter in the method

Connection to APCSA

Even if it is used in professional enviornments, Lombok is not used in the APCSA exam
Therefore, I need to learn how to write the methods Lombok generates by myself.

Instance Variables

My POJO contains these variables
private String name;
private String email;

These variables have the same class design used in APCSA
Using the private variable helps show encapsulation, which is one of the core OOP pillars of java

Constructors

In CSA, code I normally write code such as this

public AdminUser(String name, String email) {
    this.name = name;
    this.email = email;
}

Lombok automatically generates these annotations, however I still need to know what a constructor is

A constructor:

• Creates the initial state of an object
• recives values through parameters
• assigns those values to instance variables

Accessor Methods

In CSA, getters are known as acessor methods, as they provide access to a state of object, without changing it.

For example,

public String getName(){
    return name;
}

@Getter performs the same task

Mutator Methods

Setters are known as mutator methods as they “mutate” (modify) the state of an object

Example:

public void setName(String name) {
    this.name = name;
}

Lombok generates this through @Setter

Lombok vs CSA

basically its like this:

csa: I learn how and why these methods work
|
V
Lombok&Spring boot:
Getter
Setter
Constructor

TL;DR

Lombok removes repetitive code, after I know how it works

My Code

This is Codex’s implementation record, separate from Jade’s assignment posts. Jade supplied the completed Phase 1 work and selected Option B: a Spring MVC/Thymeleaf administrator directory for students and guests. I used that design to prepare the Phase 2–4 documentation and extract individual implementation files. I did not change the original Phase 1 post, POJO, bytecode, screenshots, Jokes example, or existing pom.xml.

Documentation created

Published documentation routes are Persistence, Backend, and Frontend.

Individual files created

The source bundle is beside these posts in directory-implementation/. Its folder structure groups files by their destination in the Spring application; it is not a standalone Spring project.

directory-implementation/
  README.md
  java/directory/
    AccountType.java
    DirectoryAccount.java
    DirectoryAccountRepository.java
    DirectoryAccountController.java
  templates/directory/
    list.html
    detail.html
    form.html
  config/
    application-directory-example.properties
  validation/
    inspect-directory.sql

Implementation decisions

I renamed the generic example class to DirectoryAccount while preserving the Phase 1 data fields. Student IDs remain strings to retain leading zeros. Account type is an enum to limit accepted categories. Creation time and primary key are server-managed; the controller’s binding allowlist excludes both from submitted fields. Updates load the existing entity so creation time is preserved.

The implementation uses @Getter and @Setter rather than @Data. The documentation explains why these annotations differ and avoids claiming that getter/setter annotations generate equality or string methods. Templates display user values with escaped th:text expressions.

The directory has no login credentials, password-reset feature, mentor approval workflow, or relationship to the existing authentication entity. Administrator access control must be integrated with the backend’s actual security configuration. CSRF tokens in HTML are only effective if the server validates them.

Integration steps

1. In the Spring repository, inspect its application package, build instructions, dependencies, existing account entities, and security configuration.
2. Copy the four Java files into a directory package below that application package. Replace YOUR_APPLICATION_PACKAGE in every Java file with the actual parent package.
3. Copy the three templates to src/main/resources/templates/directory/.
4. Confirm compatible Jakarta Persistence, Jakarta Validation, Lombok annotation processing, Spring MVC, Spring Data JPA, Thymeleaf, Spring Security, SQLite JDBC, and Hibernate SQLite dialect support. Use the backend’s dependency management; no new pom.xml was invented.
5. Protect all directory routes with its established administrator authority and session login. Enable CSRF validation for these MVC POST routes using the existing security setup.
6. Select a disposable database and intentionally merge the example properties into a development profile. Ensure the configured database directory exists and is writable. Do not activate create-drop on retained or shared data.
7. Build and start with the backend’s documented workflow, then run the Phase 3 browser test matrix and the supplied SQL inspection queries.
8. Add genuine schema and browser screenshots to the assignment posts, and record actual outcomes. No screenshots or passing results were fabricated.

Verification and limitations

The individual Java and HTML files were extracted from the documentation examples and checked against their corresponding code blocks. The bundle contains four Java sources, three templates, one properties example, and one SQL script. Source names match their public Java types; templates match the controller’s return paths. The three new assignment posts have balanced code fences and distinct permalinks.

The remote Spring repository could not be retrieved during the earlier documentation work. Therefore its actual package, dependency versions, login behavior, and security rules remain unverified. The generated Java files deliberately retain a visible package placeholder rather than guessing the backend’s package.

No Spring compilation, automated runtime tests, SQLite execution, Jekyll build, or live browser workflow was run. This request extracts existing examples without changing their behavior. The Phase 3 manual test matrix supplies validation cases but is not evidence that they passed. The remaining work is backend integration and runtime verification, including access control and CSRF rejection tests.

No remote repository was modified, no application was deployed, and no database was deleted. These files are implementation sources for review and integration in Spring; storing Thymeleaf HTML in the portfolio repository does not make a running MVC application.