_ktnd

How to approach finding some kind of employment in software, given that I've been looking for a job worldwide since April last year, but haven't found one yet?

I'm open to any software or IT position. Furthermore, I graduated with a bachelor's degree in computer science in April 2023, and I'm currently based in Central Europe.

I'm skilled in C/C++, Python, and JavaScript. I also have experience with Rust, Scala 3, and the Play framework. Furthermore, I'm familiar with the Windows API (C/C++), SDL2, Qt 5, and Vue.js. Additionally, I have basic skills in Racket and Clojure. Also, I have a good enough mathematical understanding (linear algebra, 3D math etc.) and wrote basic software rasterizes and ray tracers. A simple neural network (learning XOR).

To avoid having gaps in my resume, I'm willing to work for free in remote positions. I prefer working without pay rather than being inactive any longer. If it needs to be on-site, then I will at least enough money to cover my basic needs (e.g., rent etc.).

So what are my options that can help me to avoid any further gaps in my resume? I am already in a bad position given my unemployment gap of 1 year.

Doing a master's or doing another degree is financially not feasible for me, for now.

I am running out of options, and based on the rejections so far, it seems like I will never find some kind of employment…

Any kind of tip on how to proceed from here, or even an offer is appreciated.

Or, equivalently, how would you approach running an 180B+ LLM on a Von Neumann computer with say 1 MB of main memory and virtually limitless secondary storage? Or, do you know about an approach (that you might read somewhere) that might help running a heavy LLM on virtually any Turing equivalent device?

Picture this: you're stuck with your “potato computer” (small RAM, no external GPU, very large SSD), and your LLM is saved on an external SSD.

Your task: run that LLM on your “potato PC” and try to achieve reasonable response times (e.g., 1 h to 24 h). Response times of 1 year, or higher, might be impractical for most use cases.

And on a side note, how would you figure out the response times of a language model on low-end devices (e.g., Raspberry Pi, business laptops, MSP430)? Would you just assume some basic operations such as linear algebra operations as a given and estimate the number of steps from there?

I expect the usual suspects brought up in this discussion:

— Memory Mapped I/O aka treating an I/O device such as an SSD as if it were actual RAM (mmap). BTW: `mmap` makes our secondary storage somewhat akin to an infinite tape in a Turing machine

— “LLM in a flash: Efficient Large Language Model Inference with Limited Memory”, https://arxiv.org/html/2312.11514v2 (04 Jan 2024)

— SSD "wear and tear"

Below is a list of resources that I personally like, because most of them emphasize derivations/motivations (e.g., deriving the cross product out of 3 assumptions/axioms) over (mechanical) memorization (e.g., just showing the mechanics of matrix multiplication/determinants without derivations/motivations):

   - Bari A., Algorithms, YouTube (playlist),
  https://www.youtube.com/playlist?list=PLDN4rrl48XKpZkf03iYFl-O29szjTrs_O

  - Frenkel E., UC Berkeley: MATH 53 - Multivariable Calculus with Edward Frenkel, YouTube (playlist) https://www.youtube.com/playlist?list=PLaLOVNqqD-2GcoO8CLvCbprz2J0_1uaoZ

  - Hower V., Linear Algebra Full Course, YouTube (playlist), https://www.youtube.com/playlist?list=PLpcwHaLYiaEXW5fLNOlItPH4ATorKjBuc

  - Lockhart P., Measurement

  - Axler S., Linear Algebra, Springer, 2024, https://link.springer.com/content/pdf/10.1007/978-3-031-41026-0.pdf

  - Ström et al., Immersive Linear Algebra, https://immersivemath.com/ila/index.html (online book)

  - Margalit et al., Interactive Linear Algebra, https://textbooks.math.gatech.edu/ila/ (online textbook)

  - Macdonald A., Linear and Geometric Algebra

  - Macdonald A., Vector and Geometric Calculus

  - Ramirez et al., From Vectors to Geometric Algebra, 2018, https://doi.org/10.48550/arXiv.1802.08153

  - Hertzmann et al., Computer Graphics Lecture Notes, Computer Science Department - University Toronto, 2005, https://www.dgp.toronto.edu/~hertzman/418notes.pdf

Further, see Sergey Trail's "Linear Algebra Done Wrong" and watch Grant Sanderson, Easy Theory (theoretical CS), Jacob Sorber (operating systems), Graphics in 5 Minutes, Sam Buss (computer graphics), Dr. Daniel Page (theory of computation, data structures and algorithms), First Principles of Computer Vision on YouTube.

Mr. Hertzmann has some more resources (that I haven't checked out yet):

https://www.dgp.toronto.edu/~hertzman/research.html