vault backup: 2024-04-07 14:08:09

Author: abhiaagarwal

content/education/omscs/cs-6200.md

@@ -0,0 +1,16 @@
+---
+tags:
+  - thoughts
+aliases:
+  - gios
+---
+My first class I took at Georgia Tech's OMSCS program was cs-6200, or Graduate Introduction to Operating Systems (**GIOS**). I took it in **Spring 2024**. This is my first formal CS class, ever. I took a couple in college but they were mostly fluff and designed around numerical applications of code. I took it alongside [[cs-7674|ml4t]]. 
+
+I loved the class. It's probably my favorite class I've taken in anything, ever. 
+
+In GIOS, the cool thing is that the projects are open-ended. All you have to do is pass a test suite they provided. For Project 1, I did it strictly by the book. For Project 3, I did something very weird and zany to the point where the Autograder actually got confused by my project, leading to a manual grading required (apologies to my TA).
+### Notes I wrote because of this class
+
+[[sending-fds-through-uds]]: I utilized this in Project 3.
+[[fcntl-atomic-locks]]: I utilized this in Project 3, though I had to scrap my usage of it because I discovered it doesn't work as expected.
+[[macos-native-docker]]: The class environment is on an Ubuntu 20.04 environment and x86, I needed to run a docker image to perfectly replicate our testing environment (provided by the class) to make sure I wasn't dealing with quirks. I use a M1 Pro Macbook 14 that I absolutely adore, and didn't want to deal with a Cloud VM to develop.

content/education/omscs/cs-7674.md

@@ -0,0 +1,10 @@
+---
+tags:
+  - thoughts
+aliases:
+  - ml4t
+---
+My second class at OMSCS was cs-7674, Machine Learning for Trading (**ML4T**). I thought it was... alright? It's mostly just Python stuff, of which I'm very familiar with. I took it alongside [[cs-6200|gios]]. It's kind of like an introduction into data science techniques with a focus on ML. Now I'm not an ML person at all, my undergraduate background is in Economics and Math, but ML is just statistical models.
+
+I spent maybe 10 hours per week on the class. 
+

content/education/omscs/index.md

@@ -0,0 +1 @@
+Notes about all the classes I took at OMSCS, with a mini review and any thoughts I had about them.

content/health/adhd/regret-and-adhd.md

@@ -0,0 +1,45 @@
+---
+tags:
+  - thoughts
+title: Regret and ADHD
+description: I got diagnosed with ADHD when I was 21 years old. I was illuminating, and extremely frustrating.
+---
+I've always been a person who kinda, "does their own thing". You could call it selfishness. You could call it eccentricity. The truth is probably somewhere in the middle.
+
+I learned it's called, "my dopamine regulators are just a teensy bit fucked up".
+
+I've never been a good student. According to my GPA, at least. In high school, I was constantly engaged, pretty funny, and all my teachers would always tell me I was one of their favorite students. But I seldom did homework, I skipped class all the time because I was bored, and my GPA was *low*. Like, in the low 3.0s *weighted*, which is nuts considering I took many Honors and AP classes. I did well on the standardized tests, which were my saving grace, but I never really cared to study for them. And why would I? I got 98 percentile scores. I ended up getting into an "elite" college which had a test-optional policy.
+
+Had I studied, I would've gotten 99 percentile scores. And that's the damn problem.
+
+In college, I decided to reinvent myself. I would throw myself into the library for hours each day, refusing to do homework in my room. I tried every strategy I could, using pomodoro, forcing myself to take hand-written notes. My grades rapidly improved in college.
+
+But my grades were not improving because I had become a better student, it was because the distribution of my homework had changed. I didn't have busy work. At the time, I prided myself on my dedication and hustle. I knew that if I put my mind to anything, I could do anything. 
+
+But I was burnt out. So, so heavily burnt out. While I saw my friends take notes that would only take them a couple hours, it took me double that. And that's not to say that the actual *process* of consuming information and writing notes was difficult, but hunkering down to take the notes was the actual problem. I would get distracted.
+
+At the age of 21, I got diagnosed with ADHD from a psychiatrist. She remarked to me that "it's incredible that I got so far with my level of hyperactivity and inattentiveness". I think she was trying to make me feel better, but in all honesty, it made me feel like dogshit.
+
+When I was a child, I had been misdiagnosed with ASD, which then corrected itself after some speech therapy. Turns out, they had identified there really was something fucky-wucky with my brain, but the wrong causality was attributed to it. I'm not the only one, nor will I be the first.
+
+Sorry for all the swearing. You might be able to tell, but this whole topic makes me feel pretty emotional.
+
+I started taking Vyvanse at the start of my senior fall semester, which cost me 50 bucks a month. I had to quit it later that semester since I had poor cardiovascular health that was being exacerbated by the drug, but for the first time in my entire life, I had *focus*. I could do things without expending mental effort. I wrote my entire thesis while on this amphetamines. 
+
+Like most brain disorders, ADHD is not well-understood. Anyone claiming they definitively *know* how ADHD works is an idiot or a grifter. The general consensus seems to be that people with ADHD have messed-up dopamine receptors. That is, their risk-reward functions are messed up. While I can logically conceptualize the advantages of risk-reward, my ADHD brain doesn't agree with my logical processing. That was the source of my exhaustion, I was waging a war with my own brain, convincing it to believe the own things I reasoned myself to do. Amphetamines solve this by reversing the dopamine transmission inside the brain, enabling people with this so-called "dopamine deficiency" to have the same *feelings* of reasoning that other people do. It's no longer a war, my body agrees with (or defers? to) my logic.
+
+What could I have been if I were to be properly medicated? Could I be a quant making 500k? Whatever, I'm a software engineer in America, I make so much money relative to my peers and the entire world that complaining I'm not making quadruple that deserves a punch in the face.
+
+Would I have done a better job developing meaningful relationships with other people instead of dropping in and out of their lives, treating them like our relationships are ephemeral? This is the thing that kills me the most. My whole life, I've treated relationships like they should *always* be there. I've had friends I haven't talked to in months, and then expect them to be the exact same when I return. My logic being, "I'm gonna treat you the same way I always treated you, why would you change?" This is not how people work. I've lost many relationships by treating people like this.
+
+And those aren't things I can get back. No one cares or wants to listen to "sorry I treated you terribly, my dopamine receptors suckkkk bro". 
+
+I feel embarrassed talking about this, in all honesty. I don't want to be the person who blames my problems on something outside of me. But what exactly *am* I supposed to do? It's disingenuous to say that my literal brain chemicals aren't responsible, at least partially, for my behavior. The way I try to rationalize it is that the ADHD provides an explanation, but it doesn't really provide an excuse. I'm ultimately responsible for my actions, regardless for why they happened. It doesn't make me feel good to reach this conclusion, but it's the only one that doesn't run contrary to my own values.
+
+I'm luckier than most. I got diagnosed when I was 21. I was high-performing *before* my diagnosis, and high-performing *after*. If you read this piece as "a smart, accomplished person complaining he's in the 90th percentile not the 95 percentile." you would be right. Comparison is the thief of joy. But in this case, the comparison is to myself. 
+
+Amphetamines aren't considered addictive in the chemical sense. However, people without ADHD get psychologically hooked onto them because they unlock a higher level of cognition, and they find that they don't acknowledge themselves outside their meds. Their better version is who they are. I can relate and understand. But to me, I don't consider myself on my meds to be *a better version of myself*, I consider them to be *who I am meant to be*. 
+
+So what can I do? I can keep moving forward. I can try and not feel regret. But it's damn hard. For the formative years of my life, I was working with a penalty. I accomplished so much, but I could've accomplished more. Instead of beating myself up every single night and feeling intense self-loathing, wondering why I simply can't do things the way other people do, I could've had something else to blame.
+
+I can't take back my actions. All I can do is improve. I hope someday I will no longer feel regret. I think it will happen, some day in the future. But for now, all I can do is live with it.

content/media/books/world-war-z.md

@@ -0,0 +1,5 @@
+---
+tags:
+  - thoughts
+---
+I watched the movie, World War Z, and hated it. Then I read the book, World War Z, and I loved it.

content/sports/nba/advanced-stats.md

@@ -3,7 +3,7 @@ tags:
   - notes
 ---
 - EPM
-- Raptor
+- RAPTOR
 - BPM
 - RAPM
-- 
+- DARKO

content/sports/nba/basketball-makes-me-really-emotional.md

@@ -1,6 +1,8 @@
 ---
 tags:
   - thoughts
+title: Basketball makes me really emotional
+description: My attempt to articulate why Basketball as a sport speaks deeply to me.
 ---
 I saw this tweet the other day.
 

content/tags/notes.md

@@ -1 +1,3 @@
-Notes about various topics, both for my book-keeping and to cite any sources or articles I found interesting. I wouldn't consider these comprehensive or pointing in any one direction or opinions, just a dump of bullet points.
+Notes about various topics. I wouldn't consider these comprehensive or pointing in any one direction or opinions, just a dump of bullet points and citations.
+
+These are continually in a work-in-progress state. The world is constantly changing, and I am constantly learning. I will update them as needed. Please feel free to view the "History" button on the right sidebar to watch the evolution of these notes, which are stored in git.

content/tags/observations.md

@@ -1 +1 @@
-Observations about things. I would probably consider this the most structured content on this site, focusing on something I discovered or learned and wanted to document. 
+Observations about things. I would probably consider this the most structured content on this site, focusing on something I discovered or learned and wanted to document.

content/tags/thoughts.md

@@ -1 +1 @@
-Just general thoughts about things. Not necessarily fully formed or analytical in nature, just musings, often opinionated.
+Just general thoughts about things. Not necessarily fully formed or analytical in nature, just musings, often opinionated. I try to keep these as a snapshot of my mindset at a given time, but I will correct any factual errors. If I have new additional thoughts, I will do this with an errata in the footnotes or new section, and not try to overwrite an old perspective.

content/technology/index.md

@@ -0,0 +1 @@
+Stuff about technology. I'm mostly focusing on programming, but I do have a fascination with hardware, and not enough money or skill to really focus on it.

content/technology/programming/index.md

@@ -0,0 +1,3 @@
+Notes about programming! I'm not really sure the best-way to organize this, as programming involves a lot of moving parts, of which includes the language of choice, how the language interfaces with the operating system, etc.
+
+So, this is organized as "best-effort", basically. I try to jot down interesting things as I find them. Use the search bar for anything specific!

content/computers/programming/linux/fcntl-atomic-locks.md renamed to content/technology/programming/linux/fcntl-atomic-locks.md

@@ -1,6 +1,5 @@
 ---
 tags:
-  - docker
   - observations
 title: Docker on MacOS with close-to-native performance
 ---

content/computers/programming/linux/sending-fds-through-uds.md renamed to content/technology/programming/linux/sending-fds-through-uds.md

@@ -0,0 +1,43 @@
+---
+tags:
+  - notes
+---
+- Python threading by default is the worst of both words. In its current form, it sucks, completely.
+- Threads are **concurrent** but not **parallel**. Each thread created also corresponds with an os thread (pthreads on unix, for example), but only one "thread" can perform work at a given time.
+- This is due to the **Global Interpreter Lock** (GIL), which only allows one thread to run at every given time.
+	- Despite the Global Interpreter Lock, it does not guarantee safety. Operations in Python in general, are not guaranteed atomic.
+	- For example: the statement `x += 1` invokes multiple different bytecode instructions, the GIL may pause the thread in the middle of execution of this statement and other threads can observe the state beforehand, leading to data races and "undefined behavior".
+		- In this case, the GIL is *preemptive* multithreading not *cooperative* multithreading. This is also similar to how OS threads operate. But in this case, the GIL doesn't necessarily control when threads run, the OS does, but it does control the *lock* that determines whether threads can run.
+		- The OS and the GIL often have orthogonal interests when it comes to determining which thread gets to run!
+			- OSes obviously do not want to let programs determine when their threads get to run (cooperative), as the OS has a broader view of all the various programs on a system asking for resources and needs to properly schedule everything.
+			- Note: OSes *do* have a form of cooperative multithreading, called *fibers*. I don't know much about them. I hope someday I do!
+		- [Reference](https://stackoverflow.com/questions/33352298/how-does-python-handle-thread-locking-context-switching), [Another Reference](https://verdagon.dev/blog/python-data-races).
+	- Note that the Global Interpreter Lock is **not** part of the Python specification. It's part of the reference implementation, CPython, but there are several Python interpreters (such as [IronPython](https://github.com/IronLanguages/ironpython3), based on .NET) that do not use a GIL at all (in the case of IronPython, the synchronization is done by the underlying .NET runtime).
+	- There are efforts to remove the GIL, culminating in [PEP 703](https://peps.python.org/pep-0703/), which has been accepted, and will make the GIL optional in Python 3.13.
+		- This does come at a reduction to single-threaded performance (estimates ~10%), but there are already initiatives to increase Python's speed ([Faster CPython Team](https://devblogs.microsoft.com/python/python-311-faster-cpython-team/)) so the net impact is likely negligible per release.
+		- `nogil` Python may become the default in the future. It doesn't affect Pure python code (since as I've pointed out, the GIL doesn't prevent data races), but CPython extensions will need to be recompiled.
+			- Most CPython code is heavily optimized and doesn't necessarily assume a GIL context (does the synchronization) by itself, so this won't require huge rewrites, in general. It does require a recompilation on the right ABI.
+			- Note: Python wants to avoid a 2->3 fiasco again which very nearly killed the entire language, so the design is conservative to ensure that gil->nogil won't break existing code. If it detects code that relies on the GIL, it will automatically switch to a GIL context.
+- Threads aren't necessarily pinned to core (TODO: Find more information about this), so this invokes context switches, even if `nthreads < ncores`. [Reference](https://discuss.python.org/t/python-context-switching-how-is-it-done/8635). 
+	- Context-switching is expensive! The speed of IO has increased tremendously with technologies like NVME, etc.
+	- If a thread gets moved to a different core, that can invoke cache misses. The thread context will get "serialized" then "deserialized" on the core for execution.
+	- This can be mitigated by a `ThreadPool` (which is recommended anyways in nearly all sort of multithreaded programming in all languages, since the creation and destruction of threads are expensive).
+- Async Python partially mitigates the preemptive-ness of the GIL, instead with cooperative multithreading as functions can signal when to give up control with an `await`. 
+	- However, Async Python is still single-threaded. The way tasks are run is agnostic to *how* they're run, its an implementation detail.
+		- Though in practice, we can't have a mulithreaded executor in Python. 
+	- Python futures are defined by the coroutine, which is very similar to Rust's `futures`! It's just a function that's transformed into a finite state machine.
+	- [`uvloop`](https://github.com/MagicStack/uvloop), for example, is an async runtime based on `libuv` (which powers Node.js) that makes the default `asyncio` runtime much faster. I believe it's multithreaded (don't quote me on this!)
+- However, in Python code that interfaces with the "outside world" (ie. Cython, Pyo3, etc.) is allowed to release the GIL.
+	- This is prevalent in numpy, tensforflow, etc. Python is kinda a glorified bash here, with the actual work being deferred to the underlying "low-level" code.
+	- Read/write/IO functions often do release the GIL (since the "Pure Python" in this case is just CPython which is doing syscalls, etc).
+	- So in practice, we can get "true multithreading" in Python. But you don't get to control the semantics of when this multithreading occurs, it's done when the program essentially feels liek it.
+- Multiprocessing is the alternative for people who want **parallel** execution, as in this case, the Python Interpreter *forks* itself and provides an ergonomic API over this.
+	- Each Interpreter gets its own GIL, so multiple interpreters can run code at the same time.
+		- Theoretically, you can do *multithreading* per *multiprocess*, but I haven't explored the ergonomics of this or if it even really makes sense.
+	- However, each process has its own separate address space, which can be *very* expensive.
+		- Similar to `ThreadPool`s, `ProcessPool`s mitigate the creation and destruction of separate address spaces.
+	- Processes have to communicate via IPC. Python makes this transparent-*ish* to you, by sharing objects between threads by [pickling them](https://laszukdawid.com/blog/2017/12/13/multiprocessing-in-python-all-about-pickling/).
+		- This can suck. The most obvious reason is that deserializing and serializing an object invokes a real run-time cost.
+		- It also means that for objects that can't/don't be pickled, you need to define your own custom logic for sending it across processes, while you don't care with threads.
+		- Arguably, Python's ergonomics here are not really correct, and it abstracts the real complexity away from the user. But I digress.
+- In short: Python is not well-suited for true parallel workloads. In the current form of Python (as of 3.12), it is impossible to run *truly parallel* workloads in "pure" Python.