202206191300 Computer Science

#structure

The nitty-gritty of computation and technology. Contrasted with 202109061338 Software Engineering which is more about the practice of writing software and careers or organizations in that field.

Curriculum

• 202208101944 Zero to engineer
• 202206282018 Curriculum design for software engineering
• Maybe start here?: MIT OpenCourseWare for Computer Science
• Maybe I should make this yet another structure note that lays out the whole process and what order and how things are connected? Probably just start doing that in this note and maybe split it out later.

Programming Languages

• 202107272307 Data-first pipe design
• 202107272306 Data-last pipe design
• Go kind of sucks?
  • I want off Mr. Golang's wild ride
  • Lies we tell ourselves to keep using golang
• 202405170938 Pratt parsing

Asynchronous computing

• 202111091028 Task scheduling is a fuzzy process
• How does asynchronous stuff really work in JS? Promises, async/await, under the hood etc. #thread answer: JS spec requires implementations of JS to implement an event queue which JS processes fifo. Could be fun to implement a JavaScript runtime in Rust or something. (Might already exist from Mozilla, V8 is written in C++)
• Parallelism vs concurrency
• Js WebWorkers running Rust WASM
  • Handling difference between worker_threads and WebWorker in Node vs browser?

Type Systems

• 202206121309 Homoiconic programming languages
• 202206281449 Types, and why you should care
• 202207181946 Category Theory in Life
• Types as the core tool of domain modeling and documentation (see ~40 min in this video for a particular interesting thing about private types and constructors as domain control)
  • Make illegal states unrepresentable
• Category theory
  • Algebraic Data Types
  • The expression problem
  • Closed and open world assumptions
  • 202207271324 Creating a monad from a set
• Static
• Dynamic
• Strong
• Weak
• Correctness, soundness, completeness
• Is strong/static typing useful?
  • 202110111901 Run to change ratio of a program
• Structural vs nominal typing

Data Structures and Algorithms

• Graphs
  • good overview of graphs via rust petgraph in particular the idea of parallelizable todo lists from DAGs. This could be interesting when working on dependency graphs for developer tooling, local environments, ephemeral environments etc.

Databases

• MetricsDB
• Gorilla
• FoundationDB
• TigerBeetle
• Timescale

Threads

Since there’s an entire lifetime of knowledge that can go under this topic, this is a bucket that I can dump interesting threads to pull on instead of interleaving the #thread tag everywhere.

• Information theoretic model of project architecture? Information as in “processing of” as well as “communication about ‘processing of’ to future devs”

  flowchart LR
    source((Source))
    esf[Standard Format]
    ecf[Channel Format]
    noise((Noise))
    channel[Channel]
    dsf[Standard Format]
    dcf[Channel Format]
    sink((Sink))
  
    source --> encoder
    subgraph encoder
      direction LR
      esf --> ecf
    end
    encoder --> channel
    noise:::noiseClass --> channel
    channel --> decoder
    subgraph decoder
      direction LR
      dcf --> dsf
    end
    decoder --> sink
  
    classDef noiseClass fill:#f08666,color:#282a2f;
  

• CE Shannon’s Information theory has the surprise of something as the main measurement for the amount of information it carries. He measures this as the negative logarithm of the probability of the occurrence of that information. For instance, If you are told something you’re already certain of you would gain no new information (i.e. $-\log p=i$ or $-\log 1=0$ for the certain case and $$\underset{x\to 0}{lim}-\log x=\mathrm{\infty }$$ shows that you gain more knowledge the closer the event is to impossible (does infinite knowledge gain really make sense though for something that “can’t” occur?))

• Could abelian groups be interesting for storing data in an order-insensitive way among distributed systems? Vis-à-vis Commutativity of operations. Something like $f(\text{some data}d)=\text{some numeric encoding}e$ results in an abelian group $G=e|e\in f(d)$. What would this even mean for things that aren't defined as abelian groups anyway? I.e. saying that the total is $2+3=5$ or $3+2=5$ doesn't change the interpretation of $5$. Can I even think of any non-trivial things that are order-insensitive operations besides mathematical ones? Formal definition

  • Good intuition, CRDTs are this basically. Not necessarily abelian groups, but adding commutativity and associativity to a merge function on data.

• $L_{\mathrm{1}}$, $L_{\mathrm{2}}$, and $L_{\mathrm{\infty }}$ as metric (i.e. strict definition as distance functions) for $n$-dimensional design for systems.¹

• Sophisticated signal processing on analytics data to "find the signal in the noise."¹ (Ch. 14–17)