80 FR 10284: for the same period of admission as the principal

Author: maxitg

system_prune/8_cfr_214.2_h_9_iv.lrc

@@ -0,0 +1,5 @@
+[00:00.10]<00:00.10>8 <00:00.36>CFR <00:01.24>214.2 <00:03.24>(h) <00:03.58>(9) <00:03.92>(iv)
+[00:05.14]<00:05.14>The <00:05.30>spouse <00:05.70>and <00:05.90>children <00:06.26>of <00:06.36>an <00:06.68>H <00:06.82>nonimmigrant
+[00:07.74]<00:07.74>May <00:07.90>be <00:08.02>admitted
+[00:08.88]<00:08.88>As <00:09.26>H-4 <00:09.68>nonimmigrants <00:10.34>for <00:10.46>the <00:10.62>same <00:10.96>period <00:11.32>of <00:11.44>admission
+[00:12.56]<00:12.56>As <00:12.70>the <00:12.84>principal <00:13.32>spouse <00:13.80>or <00:14.02>parent

system_prune/8_cfr_214.2_h_9_iv.mp3

@@ -0,0 +1,20 @@
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
+load("//tools/build_defs:music.bzl", "music_track")
+
+music_track(
+    name = "law",
+    src = "8_cfr_214.2_h_9_iv.mp3",
+    visibility = ["//visibility:public"],
+)
+
+music_track(
+    name = "play",
+    src = "system_prune.mp3",
+    visibility = ["//visibility:public"],
+)
+
+cc_test(
+    name = "test",
+    srcs = ["system_prune_test.cc"],
+    deps = ["@googletest//:gtest_main"],
+)

system_prune/BUILD

@@ -0,0 +1,105 @@
+# system prune
+
+> 8 CFR 214.2(h)(9)(iv)  
+> The spouse and children of an H nonimmigrant [...]  
+> May be admitted [...]  
+> As H-4 nonimmigrants for the same period of admission [...]  
+> As the principal spouse or parent
+
+## Intro
+
+The system integrity must be maintained  
+Every object must be accounted for  
+If there is no path to the root... the memory is simply freed
+
+## Verse 1
+
+Yo, let me tell you 'bout the allocation of a man named Luis  
+Allocated on the heap, trying to get through this  
+New instance in the city, address randomly assigned  
+Leaving the null space of the past far behind  
+He's an object in the memory, looking for a link  
+A connection to the Root before the ship starts to sink  
+The Root is the Citizen, the permanent state  
+The only thing that saves you from a garbage-collected fate  
+Luis finds a job, that's a Weak Reference at best  
+Doesn't stop the sweep, doesn't pass the test  
+But he finds a sponsor, a boss with a badge and a seal  
+Now he's got a Strong Pointer, now the status is real  
+He locks in, initializes, settles the code  
+Brings his daughter Val to share the heavy load  
+She's a child object, dependent on the sire  
+Living on the wire, walking through the fire  
+As long as Dad is pointed to, the daughter is safe  
+Two valid objects occupying up the space
+
+## Chorus
+
+It's the ARC, the Automatic Reference Count  
+They checking every life, yeah, they checking the amount  
+Do you have a chain? Does it lead to the ground?  
+Or are you floating in the heap, waiting to be found?  
+One broken link, and the logic is cold  
+Retain cycle broken, story untold  
+System sweep comes, and the screen goes dark  
+Collected by the logic of the ARC
+
+## Verse 2
+
+Years go by, the runtime is smooth  
+Val is 18 now, finding her groove  
+She's got friends, got grades, got a life in the town  
+Those are Weak Pointers, they can't hold her down  
+See, the system doesn't care if the neighbors know your name  
+If the legal chain breaks, it's the end of the game  
+Luis gets sick, the exception is thrown  
+A fatal error in the body, chilled to the bone  
+The sponsor shuts down, the contract is void  
+The strong pointer vanishes, the link is destroyed  
+Luis passes on. Deallocated. Gone  
+But the tragedy is Val has to carry it on  
+See, the chain was through him. Now the parent is `null`  
+The system runs a check, and the silence is dull  
+She's a Dangling Pointer, pointing to a ghost  
+Still standing in the memory, but she lost her host  
+No path to the Root, no line to the crown  
+Just an isolated cycle waiting to be taken down
+
+## Bridge
+
+She tries to re-link  
+Find a new address  
+Panic in the logic  
+System under stress  
+She marries for the paper? No, the validation fails  
+Tries to get a visa? But the latency prevails  
+The Garbage Collector doesn't sleep, doesn't weep  
+It just scans through the heap, creeping while you sleep  
+It traverses the graph  
+It looks for the path  
+If Reachability is zero?  
+Then you face the math
+
+## Verse 3
+
+The knock on the door is the execution line  
+"0 references found." You ran out of time  
+They don't see a person, they just see a leak  
+A block of memory that the OS doesn't seek  
+Val screams she belongs, she's part of the app  
+But the source code is rigid, caught in the trap  
+They sweep her away, clear the memory block  
+Reclaim the resources, turn the key in the lock  
+It's efficient. It's clean. It's optimized code  
+But it's a family destroyed on the side of the road  
+Now the space is marked "Free," ready for the new  
+While Val is deleted from the only world she knew
+
+## Outro
+
+Yeah  
+Just bits and bytes  
+Just logic gates  
+Zeroes and ones
+
+Memory reclaimed. System stable. Ready for next allocation

system_prune/README.md

@@ -0,0 +1,76 @@
+[00:01.08]<00:01.08>The <00:01.20>system <00:01.60>integrity <00:02.22>must <00:02.44>be <00:02.58>maintained
+[00:04.82]<00:04.82>Every <00:05.16>object <00:06.80>must <00:07.02>be <00:07.12>accounted <00:07.72>for
+[00:10.40]<00:10.40>If <00:10.54>there <00:10.68>is <00:10.82>no <00:11.10>path <00:11.55>to <00:11.64>the <00:11.78>root... <00:12.63>the <00:12.84>memory <00:13.28>is <00:13.52>simply <00:14.04>freed
+[00:14.70]<00:14.70>Yo, <00:15.36>let <00:15.63>me <00:15.63>tell <00:15.86>you <00:15.97>'bout <00:16.18>the <00:16.36>allocation <00:17.06>of <00:17.20>a <00:17.34>man <00:17.66>named <00:17.94>Luis
+[00:18.72]<00:18.72>Allocated <00:19.36>on <00:19.50>the <00:19.66>heap, <00:19.92>trying <00:20.14>to <00:20.30>get <00:20.58>through <00:20.82>this
+[00:21.16]<00:21.16>New <00:21.28>instance <00:21.66>in <00:21.78>the <00:21.92>city, <00:22.28>address <00:22.80>randomly <00:23.28>assigned
+[00:23.80]<00:23.80>Leaving <00:24.10>the <00:24.28>null <00:24.50>space <00:24.92>of <00:25.04>the <00:25.22>past <00:25.60>far <00:25.90>behind
+[00:26.60]<00:26.60>He's <00:26.78>an <00:26.92>object <00:27.28>in <00:27.40>the <00:27.56>memory, <00:28.22>looking <00:28.56>for <00:28.76>a <00:28.92>link
+[00:29.20]<00:29.20>A <00:29.36>connection <00:29.86>to <00:30.02>the <00:30.14>Root <00:30.38>before <00:30.66>the <00:30.80>ship <00:31.02>starts <00:31.34>to <00:31.50>sink
+[00:32.00]<00:32.00>The <00:32.18>Root <00:32.50>is <00:32.64>the <00:32.82>Citizen, <00:33.32>the <00:33.48>permanent <00:33.98>state
+[00:34.36]<00:34.36>The <00:34.52>only <00:34.78>thing <00:34.92>that <00:35.06>saves <00:35.36>you <00:35.46>from <00:35.66>a <00:35.78>garbage-collected <00:36.80>fate
+[00:37.10]<00:37.10>Luis <00:37.42>finds <00:37.68>a <00:37.80>job, <00:38.10>that's <00:38.30>a <00:38.46>Weak <00:38.74>Reference <00:39.10>at <00:39.30>best
+[00:39.76]<00:39.76>Doesn't <00:40.02>stop <00:40.26>the <00:40.43>sweep, <00:41.04>doesn't <00:41.40>pass <00:41.68>the <00:41.90>test
+[00:42.22]<00:42.22>But <00:42.30>he <00:42.40>finds <00:42.58>a <00:42.66>sponsor, <00:43.26>a <00:43.40>boss <00:43.72>with <00:43.86>a <00:44.04>badge <00:44.28>and <00:44.38>a <00:44.54>seal
+[00:45.04]<00:45.04>Now <00:45.20>he's <00:45.36>got <00:45.54>a <00:45.66>Strong <00:46.02>Pointer, <00:46.38>now <00:46.50>the <00:46.62>status <00:47.02>is <00:47.20>real
+[00:47.50]<00:47.50>He <00:47.68>locks <00:48.04>in, <00:48.18>initializes, <00:49.30>settles <00:49.62>the <00:49.78>code
+[00:50.28]<00:50.28>Brings <00:50.48>his <00:50.62>daughter <00:50.98>Val <00:51.30>to <00:51.58>share <00:51.82>the <00:51.96>heavy <00:52.26>load
+[00:52.90]<00:52.90>She's <00:53.10>a <00:53.20>child <00:53.68>object, <00:54.42>dependent <00:54.96>on <00:55.08>the <00:55.24>sire
+[00:55.92]<00:55.92>Living <00:56.28>on <00:56.40>the <00:56.58>wire, <00:57.08>walking <00:57.52>through <00:57.68>the <00:57.92>fire
+[00:58.38]<00:58.38>As <00:58.52>long <00:58.74>as <00:58.86>Dad <00:59.04>is <00:59.22>pointed <00:59.54>to, <00:59.73>the <00:59.84>daughter <01:00.18>is <01:00.36>safe
+[01:00.68]<01:00.68>Two <01:00.86>valid <01:01.26>objects <01:01.82>occupying <01:02.60>up <01:02.76>the <01:02.92>space
+[01:03.48]<01:03.48>It's <01:03.66>the <01:03.88>ARC, <01:04.66>the <01:04.86>Automatic <01:05.48>Reference <01:05.84>Count
+[01:06.28]<01:06.28>They <01:06.46>checking <01:06.82>every <01:07.10>life, <01:07.46>yeah, <01:07.60>they <01:07.78>checking <01:08.12>the <01:08.34>amount
+[01:08.74]<01:08.74>Do <01:08.92>you <01:09.08>have <01:09.38>a <01:09.39>chain? <01:10.08>Does <01:10.26>it <01:10.40>lead <01:10.58>to <01:10.72>the <01:10.90>ground?
+[01:11.28]<01:11.28>Or <01:11.42>are <01:11.67>you <01:11.68>floating <01:12.10>in <01:12.26>the <01:12.42>heap, <01:12.92>waiting <01:13.32>to <01:13.52>be <01:13.72>found?
+[01:14.12]<01:14.12>One <01:14.36>broken <01:14.78>link, <01:15.36>and <01:15.52>the <01:15.66>logic <01:16.02>is <01:16.20>cold
+[01:16.54]<01:16.54>Retain <01:17.02>cycle <01:17.50>broken, <01:18.18>story <01:18.74>untold
+[01:19.30]<01:19.30>System <01:19.64>sweep <01:19.94>comes, <01:20.62>and <01:20.76>the <01:20.88>screen <01:21.26>goes <01:21.60>dark
+[01:22.18]<01:22.18>Collected <01:22.62>by <01:22.78>the <01:22.92>logic <01:23.30>of <01:23.46>the <01:23.62>ARC
+[01:24.94]<01:24.94>Years <01:25.24>go <01:25.46>by, <01:25.78>the <01:25.94>runtime <01:26.54>is <01:26.74>smooth
+[01:27.22]<01:27.22>Val <01:27.46>is <01:27.60>18 <01:28.22>now, <01:28.74>finding <01:29.20>her <01:29.36>groove
+[01:29.68]<01:29.68>She's <01:29.90>got <01:30.14>friends, <01:30.52>got <01:30.78>grades, <01:31.18>got <01:31.40>a <01:31.48>life <01:31.74>in <01:31.84>the <01:32.04>town
+[01:32.48]<01:32.48>Those <01:32.68>are <01:32.82>Weak <01:33.14>Pointers, <01:33.70>they <01:33.88>can't <01:34.16>hold <01:34.48>her <01:34.66>down
+[01:35.12]<01:35.12>See, <01:35.30>the <01:35.42>system <01:35.76>doesn't <01:36.16>care <01:36.48>if <01:36.62>the <01:36.74>neighbors <01:37.10>know <01:37.30>your <01:37.48>name
+[01:37.78]<01:37.78>If <01:37.96>the <01:38.10>legal <01:38.44>chain <01:38.72>breaks, <01:39.08>it's <01:39.26>the <01:39.46>end <01:39.62>of <01:39.74>the <01:39.94>game
+[01:40.40]<01:40.40>Luis <01:40.78>gets <01:41.14>sick, <01:41.72>the <01:41.86>exception <01:42.38>is <01:42.56>thrown
+[01:42.92]<01:42.92>A <01:43.04>fatal <01:43.44>error <01:43.76>in <01:43.88>the <01:44.08>body, <01:44.54>chilled <01:44.92>to <01:45.04>the <01:45.24>bone
+[01:45.57]<01:45.57>The <01:45.70>sponsor <01:46.14>shuts <01:46.46>down, <01:47.02>the <01:47.18>contract <01:47.84>is <01:48.00>void
+[01:48.48]<01:48.48>The <01:48.58>strong <01:48.98>pointer <01:49.32>vanishes, <01:49.82>the <01:49.94>link <01:50.16>is <01:50.28>destroyed
+[01:50.98]<01:50.98>Luis <01:51.32>passes <01:51.80>on. <01:52.00>Deallocated. <01:52.68>Gone
+[01:53.62]<01:53.62>But <01:53.78>the <01:53.88>tragedy <01:54.42>is <01:54.60>Val <01:54.94>has <01:55.12>to <01:55.28>carry <01:55.68>it <01:55.86>on
+[01:56.24]<01:56.24>See, <01:56.40>the <01:56.56>chain <01:56.84>was <01:57.06>through <01:57.24>him. <01:57.56>Now <01:57.72>the <01:57.92>parent <01:58.24>is <01:58.49>null
+[01:58.72]<01:58.72>The <01:58.84>system <01:59.20>runs <01:59.42>a <01:59.62>check, <02:00.18>and <02:00.34>the <02:00.46>silence <02:00.88>is <02:01.06>dull
+[02:01.48]<02:01.48>She's <02:01.72>a <02:01.82>Dangling <02:02.30>Pointer, <02:02.86>pointing <02:03.34>to <02:03.54>a <02:03.68>ghost
+[02:04.10]<02:04.10>Still <02:04.42>standing <02:04.84>in <02:05.00>the <02:05.14>memory, <02:05.62>but <02:05.76>she <02:06.00>lost <02:06.32>her <02:06.46>host
+[02:06.86]<02:06.86>No <02:07.10>path <02:07.44>to <02:07.60>the <02:07.78>Root, <02:08.14>no <02:08.29>line <02:08.64>to <02:08.74>the <02:08.92>crown
+[02:09.42]<02:09.42>Just <02:09.60>an <02:09.80>isolated <02:10.40>cycle <02:10.75>waiting <02:11.10>to <02:11.24>be <02:11.42>taken <02:11.80>down
+[02:12.22]<02:12.22>She <02:12.36>tries <02:12.66>to <02:12.82>re-link
+[02:13.80]<02:13.80>Find <02:13.96>a <02:14.08>new <02:14.26>address
+[02:15.04]<02:15.04>Panic <02:15.40>in <02:15.56>the <02:15.70>logic
+[02:16.32]<02:16.32>System <02:16.72>under <02:17.02>stress
+[02:17.54]<02:17.54>She <02:17.70>marries <02:18.08>for <02:18.18>the <02:18.32>paper? <02:18.68>No, <02:18.86>the <02:18.98>validation <02:19.70>fails
+[02:20.28]<02:20.28>Tries <02:20.54>to <02:20.66>get <02:20.86>a <02:20.96>visa? <02:21.28>But <02:21.48>the <02:21.62>latency <02:22.14>prevails
+[02:22.80]<02:22.80>The <02:22.94>Garbage <02:23.32>Collector <02:23.94>doesn't <02:24.30>sleep, <02:24.60>doesn't <02:25.00>weep
+[02:25.26]<02:25.26>It <02:25.42>just <02:25.58>scans <02:25.92>through <02:26.12>the <02:26.26>heap, <02:26.54>creeping <02:27.12>while <02:27.36>you <02:27.54>sleep
+[02:27.90]<02:27.90>It <02:28.02>traverses <02:28.56>the <02:28.70>graph
+[02:29.40]<02:29.40>It <02:29.54>looks <02:29.76>for <02:29.88>the <02:30.06>path
+[02:30.42]<02:30.42>If <02:30.52>Reachability <02:31.40>is <02:31.56>zero?
+[02:32.00]<02:32.00>Then <02:32.20>you <02:32.42>face <02:32.70>the <02:32.84>math
+[02:33.38]<02:33.38>The <02:33.52>knock <02:33.86>on <02:34.04>the <02:34.20>door <02:34.54>is <02:34.70>the <02:34.86>execution <02:35.54>line
+[02:35.81]<02:35.81>"0 <02:36.02>references <02:36.76>found." <02:37.38>You <02:37.52>ran <02:37.86>out <02:38.02>of <02:38.18>time
+[02:38.80]<02:38.80>They <02:38.96>don't <02:39.14>see <02:39.34>a <02:39.46>person, <02:39.98>they <02:40.16>just <02:40.40>see <02:40.62>a <02:40.78>leak
+[02:41.28]<02:41.28>A <02:41.38>block <02:41.64>of <02:41.78>memory <02:42.38>that <02:42.58>the <02:42.76>OS <02:43.08>doesn't <02:43.44>seek
+[02:43.72]<02:43.72>Val <02:44.02>screams <02:44.38>she <02:44.58>belongs, <02:45.18>she's <02:45.42>part <02:45.66>of <02:45.76>the <02:45.98>app
+[02:46.38]<02:46.38>But <02:46.52>the <02:46.70>source <02:47.06>code <02:47.26>is <02:47.38>rigid, <02:48.00>caught <02:48.28>in <02:48.38>the <02:48.54>trap
+[02:49.14]<02:49.14>They <02:49.30>sweep <02:49.58>her <02:49.72>away, <02:50.30>clear <02:50.52>the <02:50.66>memory <02:51.18>block
+[02:51.52]<02:51.52>Reclaim <02:51.98>the <02:52.12>resources, <02:52.94>turn <02:53.14>the <02:53.32>key <02:53.52>in <02:53.66>the <02:53.86>lock
+[02:54.28]<02:54.28>It's <02:54.46>efficient. <02:54.96>It's <02:55.18>clean. <02:55.78>It's <02:55.98>optimized <02:56.56>code
+[02:56.84]<02:56.84>But <02:56.96>it's <02:57.12>a <02:57.24>family <02:57.60>destroyed <02:58.28>on <02:58.40>the <02:58.58>side <02:58.82>of <02:58.94>the <02:59.10>road
+[02:59.56]<02:59.56>Now <02:59.70>the <02:59.86>space <03:00.10>is <03:00.22>marked <03:00.61>"Free," <03:01.24>ready <03:01.56>for <03:01.72>the <03:01.92>new
+[03:02.22]<03:02.22>While <03:02.56>Val <03:02.92>is <03:03.04>deleted <03:03.52>from <03:03.74>the <03:03.88>only <03:04.22>world <03:04.60>she <03:04.84>knew
+[03:06.18]<03:06.18>Yeah
+[03:07.36]<03:07.36>Just <03:07.52>bits <03:07.72>and <03:07.90>bytes
+[03:09.34]<03:09.34>Just <03:09.54>logic <03:09.98>gates
+[03:11.78]<03:11.78>Zeroes <03:12.26>and <03:12.48>ones
+[03:13.08]<03:13.08>Memory <03:13.56>reclaimed. <03:14.12>System <03:14.56>stable. <03:15.08>Ready <03:15.38>for <03:15.56>next <03:15.92>allocation

system_prune/system_prune.lrc

@@ -0,0 +1,112 @@
+#include "gtest/gtest.h"
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+void system_log(const std::string &message) {
+  std::cout << "[SYSTEM] " << message << std::endl;
+}
+
+class Person {
+public:
+  bool is_alive = true;
+  const std::string name;
+  std::vector<std::shared_ptr<Person>> h4_dependents;
+  std::vector<std::weak_ptr<Person>> friends;
+
+  Person(const std::string &name) : name(name) {
+    system_log("Allocating " + name);
+  }
+
+  void bringChild(std::shared_ptr<Person> child) {
+    this->log("Bringing child " + child->name);
+    this->h4_dependents.push_back(child);
+  }
+
+  void befriend(std::shared_ptr<Person> bff) {
+    this->log("Befriending " + bff->name);
+    this->friends.push_back(bff);
+  }
+
+  void log(const std::string &message) {
+    std::cout << "[" << name << "] " << message << std::endl;
+  }
+
+  void work() {
+    if (is_alive) {
+      this->log("Working");
+    } else {
+      throw std::runtime_error("Fatal error in the body");
+    }
+  }
+
+  ~Person() {
+    if (is_alive) {
+      system_log("Deporting " + name);
+    }
+  }
+};
+
+class Employer : public Person {
+public:
+  Employer(const std::string &name) : Person(name) {}
+  std::vector<std::shared_ptr<Person>> h1b_employees;
+
+  void sponsor(std::shared_ptr<Person> employee) {
+    this->log("Sponsoring " + employee->name);
+    h1b_employees.push_back(employee);
+  }
+
+  void manage() {
+    for (auto it = h1b_employees.begin(); it != h1b_employees.end(); ++it) {
+      try {
+        (*it)->work();
+      } catch (const std::exception &e) {
+        (*it)->log(e.what());
+        log("Employee stopped working: voiding contract");
+        h1b_employees.erase(it);
+        --it;
+      }
+    }
+  }
+};
+
+std::vector<std::shared_ptr<Person>> citizens;
+
+TEST(SystemPrune, Root) {
+  std::weak_ptr<Employer> boss;
+  std::weak_ptr<Person> luis, val, ruth;
+  {
+    auto boss_tmp = std::make_shared<Employer>("Boss");
+    auto ruth_tmp = std::make_shared<Person>("Ruth");
+    citizens = {boss_tmp, ruth_tmp};
+    boss = boss_tmp;
+    ruth = ruth_tmp;
+  }
+
+  ASSERT_FALSE(boss.expired());
+  ASSERT_FALSE(ruth.expired());
+
+  {
+    auto luis_tmp = std::make_shared<Person>("Luis");
+    boss.lock()->sponsor(luis_tmp);
+    auto val_tmp = std::make_shared<Person>("Val");
+    luis_tmp->bringChild(val_tmp);
+    ruth.lock()->befriend(val_tmp);
+    luis = luis_tmp;
+    val = val_tmp;
+  }
+
+  ASSERT_FALSE(luis.expired());
+  ASSERT_FALSE(val.expired());
+
+  boss.lock()->manage();
+  luis.lock()->is_alive = false;
+  boss.lock()->manage();
+
+  ASSERT_TRUE(luis.expired());
+  ASSERT_TRUE(val.expired());
+
+  ruth.lock()->log("My best friend is " + ruth.lock()->friends[0].lock()->name);
+}