Lesley's Digital Garden
Search
Search
Dark mode
Light mode
Explorer
Notes
__syncthreads
"Evaluated at" in Latex
0-index vs 1-index
0.999... = 1
2D rotation matrix
20-20-20 rule
20-second rule
21 Days to Form a Habit is a Myth
30 seconds recitation
50 30 20 rule
68-95-99.7 rule
A double can perfectly represent all values of a 32 bit int
a one dimension case study of Monte Carlo integration and importance sampling
ABA problem
abductive reasoning
absolute convergence of series
absolute convergence test
abstract syntax tree
access control
acetylcholine
action bias
active listening
active object
adenosine
adherent point
affirming the consequent
aggregation vs composition
algebraic structure
Algorithms and Data Structures MOC
aliasing
aligning equations in Latex
Allegory of the cave
allocators for zig containers
alternating series test
ambiguous grammar
Amygdala
analysis of LTIC systems
analysis paralysis
angular frequency
Anki
Anki conditional replacement
annotate terms in Latex
anti-procrastination techniques
any square matrix can be written as the sum of a symmetric and skew-symmetric matrix
API design
appeal to popularity
Application Binary Interface
approval testing
approximate integral of product as product of integral
arc length
argument
argument from anecdote
AST representation
Astro
Astro component props
async Rust
atomics
authelia
availability heuristic
avoid blocking
AVR assembly
AVR assembly instruction cheatsheet
axiom schemas
ball (topology)
bandwidth
bank conflicts
bank note
Barnum effect
barycentric coordinates
base rate fallacy
basic blocks
basis
basis functions
Bayes' theorem
benchmarking
Bernstein basis
Bézier Curve
Bézier Patch
Bias and Fallacies in Statistics and Probability
Bidirectional Reflectance Distribution Function
bidirectional search
Big Five personality traits
bilateral Laplace transform
binary relation
binary thinking
Binet's Formula
binomial coefficient
binomial distribution
bit operations cheat sheet
bivector
blank sheet method
block certain sites on Google search result
block diagram
Boids Flock Simulation
Bolzano-Weierstrass theorem
Bootstrapping
bounded sets
Bounding Volume Hierarchy
boxplot
bra-ket notation
branchless programming
Bril
BVH refitting
C & C++ Incompatibilities
C and C++ sanitizers
C compound literals
C declaration syntax
C external and tentative definitions
C linkage
C object
C preprocessor
C scope
C storage duration and lifetime
c token-pasting operator
C++
C++ "Swap And iterate" Pattern
C++ Concepts and Constraints
C++ Coroutines
C++ iterators
C++ iterators are not really iterators
C++ latches and barriers
C++ memory model
C++ Method Hiding
C++ Name Lookup
C++ NULL vs nullptr
C++ ranges
C++ SIMD operator== debate
C++ Type Traits Vs Concepts
cache line
Calculus MOC
caller-saved and callee-saved registers
capability system
Cargo (Rust)
cargo expand
cargo plugins
cargo workspaces
cascade layers
catastrophic cancellation
category
Cauchy criterion
Cauchy sequence
Cauchy-Schwarz inequality
causal signal
causal system
center of mass
central limit theorem
chain of recurrences
chain rule
changing variables in multiple integrals
characteristic equation
charting method
Check whether a sequence is strictly increasing
chemical imbalance theory of depression
Chi-squared test
chromaticity
chromaticity diagram
chronotypes
chsh
chunking
Church-Turing thesis
CIA Triad
CIE 1931 color space
circadian cycle
circadian rhythm sleep disorders
circle of fifths
cite in markdown
classical mechanics
cli tools
closure property
closure property of vectors
clustering illusion
CMake
CMake builtin to decide if you are a parent project
CMake presets
coffee nap
Cognitive Behavioral Therapy for Insomnia
cognitive bias
cohesion and coupling
Collatz conjecture
color in Latex
color science
color space and color model
column space
commodity
Common Range in C++
communication protocol
compact metric space
comparison test
compiler
compiler IR
compiler optimizations
complete metric spaces
completeness
completing the square
complex frequency
complex numbers
computer graphics MOC
computer networking
Computing MOC
Conan package manager
concept map
concept notes
concurrency patterns
Concurrency, Parallelism, and Asynchronous Programming MOC
condition variable
conditional expression
conditional probability
conditional proofs
confidence interval
confounding variable
conjugate transpose
conjunctive normal form
connected space
conservative vector fields and curl
constexpr vs static constexpr
constinit
construct a symmetric matrix
constructive solid geometry
context-free grammar
continuity correction
continuous functions
contradiction
contraries
control flow graph
convenience sampling
conventions of spherical coordinates
convergence of sequences
convergence of series
convergence tests of series
convex and concave function
convex optimization
convolution
convolution as smoothing
convolution theorem
coordinate system conventions across graphics applications
coordinate system handedness
coordinate systems in graphics programming
copy compute overlap
Cornell notes
coroutines
correlation
correlation does not imply causation
countability
covariance and contravariance
Covariant Arrays in Java and C#
CPU cache
Cramer's rule
create control flow graph from basic blocks
critical point
criticism of progressive summarization
cross product
cross-site scripting
cryptographic hash functions
cryptography
CSS
CSS container queries
CSS selectors cheatsheet
CUDA
CUDA atomics
CUDA cache
CUDA global and constant memory
CUDA local memory
CUDA memory and cache architecture
CUDA memory coalescing
CUDA performance
CUDA register
CUDA stream
CUDA task graph
CUDA Thread Hierarchy
cue-induced craving
culling
Cunningham's law
curl
currency vs banking principle
curvature
curve
customization point object
cycloid
CYK algorithm
D-notation
dangling else problem
data collection
data flow analysis
data parallelism vs task parallelism
Data Science
data visualization plots
Database
database models
database transactions
De Morgan's laws
dead code elimination
decompose linear transformations
deductive reasoning
deductive soundness
definite matrix
degenerate triangle
Del operator
Delaunay triangulation
delayed sleep phase disorder
deliberate practice
Deno
denoising for ray tracing
denotational semantics
depression
Deref polymorphism anti-pattern
derivative
derivative as a linear operator
descent methods
descriptor indexing
descriptor sets
design a system for the laziest version of yourself
Design Patterns and Idioms
desirable difficulty
detached shadow
determinant
deterministic finite automaton
developer tool in Obsidian
difference equations
different format of notes
differential equations
Diffie-Hellman Key Exchange
digital gardens
digital signature
dimension of a vector space
Dirac comb
Dirac delta
direct proofs
direction fields and integral curves
directional derivative
discrete signals and systems
dispersion
distance between a point and a line
distinct types
divergence
diversity in interview
do the hardest thing first
docker
Doctest in Rust
Documentation in Rust
don't always study in a fixed location
don't commit data until it is ready
don't edit when writing
don't use bed for things other than sleeping
dot product
dot production is distributive over the addition
double integrals
double integrals in polar coordinates
drink water after waking up
Dunning-Kruger effect
During sleep, brain remove toxins
ecological correlation
economy and finance
effective strategies
ego depletion theory
eigenvalue decomposition
eigenvalues and eigenvectors
Einstellung effect
elaborative interrogation
electric circuit
electric current
electric power
electromagnetism
elementary algebra
elementary matrix
em vs rem
Emacs
emotional regulation
Encoding in Memory
encryption
enshittification
entailment and provability
enthymemes
environment lighting
equation of lines
equation of planes
equivalence of DFAs, NFAs, and regular expressions
equivalence relation
equivocation
error handling in programming languages
essentialism
Euclidean vector space
Euler's formula
Euler's method
Euler's number
even and odd functions
examples are important in documentaiton
exclusive or
exercises
exercises and sleep
expectation
experimental Languages
expertise reversal effect
exponential random variable
expression-oriented language
Extension Trait in Rust
exterior product
external vs internal iteration
extreme value theorem
fallacy of composition
false dilemma
false-uniqueness effect
falsifiability
fiat money
fiber
Fibonacci sequence
filter (signal processing)
find relative minor key from major key
finite-state machine
first-order linear differential equation
Fitch proof system
fixed-point number
flashcards
fleeting notes
flexbox
floating-point number
floating-pointer normalization
focused and diffuse modes of thinking
form basic blocks from IR
formal system
four fundamental subspaces
Fourier series
Fourier transform and music instruments
frac
frequency
frequentist inference
function space
functional dependency
functions
fundamental attribution error
fundamental theorem of calculus
G.I. Joe fallacy
GatsbyJS
Gauss–Jordan elimination
Gaussian elimination
Gaussian function
Generalized Algebraic Data Type (GADT)
generating uniform distributed integer
geometric algebra
geometric intuitions of determinant
geometric product
geometric series
geometrical optics
geometry
geometry processing
geometry representations
geometry type system
Gibbs phenomenon
Git
git alias
git blob object
Git branches
git cat-file
git cheat sheet
git commit
git configurations
git directory
git hash-object
Git index
Git internals
git ls-tree
git maintenance
Git objects
Git plumbing commands
git puts objects into directories named with the first two characters of the hash
git rebase
git reset
git switch and git restore
git tree object
git worktree
git write-tree
glancing solutions without practices
goals vs systems
good and bad tags for notes
Goodhart's law
goto
Gottman's Four Horsemen
GPU Programming
gradient
gradient theorem
Gram-Schmidt process
Graph Searching Algorithms
grass rendering
greek letter xi
greek letters
Green's theorem
group
growth mindset
habit
habit cue
habit stacking
Hadamard product
half vector in microfacet BRDF
halfedge data structure
harmonic series
hashing
health
hedonic treadmill
Heine-Borel theorem
Helmholtz reciprocity
helpful mindsets
Hessian
highlighting in note taking
highlighting is ineffective
Hilbert system
homeostasis
homogeneous coordinates
homogeneous system of linear equation
how to design flashcards
how to support people who have depression
htop
HTTP status code
human memory
hybrid encryption
hydration
Hypertext Transfer Protocol (HTTP)
hypothesis testing
hypothesis testing in R
identity relation
IEEE 754 Floats
illusion of progress
image of a function
implementation intention
implicit dependencies
implicit function theorem
implicit parameters
implicit variable declaration
importance sampling
imposter syndrome
improve small talk questions by asking what they experienced lately
impulse convolution
impulse response
inclusion
independence
indeterminate form
index of refraction
inductive reasoning
inference rules
inference rules in Latex
infinity norm
Injective Function
inner product
instruction set architectures
integration by parts
Interior, Exterior, and Boundary Points
interleaving vs blocking in study
intermediate value theorem
interpolate linear transformations
intrusive data structures
intuition for Fourier coefficients
inverse function theorem
inverse Laplace transform
inverse lerp
Inverse of a orthogonal matrix is its transpose
inverse transform sampling
involution
involutory matrix
io_uring
irradiance
isomorphisms
isosurface extraction
iterative deepening depth-first search
iterative methods
Iterator Pattern
Jacobian
JavaScript
JavaScript bind()
javascript decorators
javascript object vs map
JavaScript variable hoisting
javascript with statement
join in SQL
journaling
Jujutsu
Jujutsu revisions
Jujutsu rewrite history
Jujutsu working with remote
Karush-Kuhn-Tucker conditions
Kerckhoff's Principle
keys in relational database
Kronecker Delta
L'Hôpital's rule
L2 Gradient
L2 inner product of functions
L2 norm
Lagrange multiplier
Laplace transform
late binding
late binding closure in Python
latency vs throughput in benchmarking
latex
latex cheat sheet
law of excluded middle
law of exclusivity
law of large numbers
law of sine
law of useful return
learn a math definition by finding examples and non-examples
learning
learning by teaching
learning math
least upper bound property
left recursion
legal tenders
lerp
level sets
life hacks
life MOC
Lifetime Variance in Rust
limit definition of e
limit point
Limits to 7 lines in a slide
line integral
linear algebra
linear blend skinning
linear combination
linear differential equation
linear form
linear independence
linear span
linear system
linear time-invariant system
linear transformation
linearity of derivative
linearization
Linux
Linux LVM
list of inference rules
literature notes
LL and LR parsing
local value numbering
logarithm
logic
logic programming
logical biconditional
logical conditional
logical connective
logical consistency
logical equivalence
logical fallacies
long-term focus
loop subdivision
low-pass filter
Lp Norm of a Vector
LU factorization
MAC-then-Encrypt vs Encrypt-then-MAC
machine languages and bytecodes
magnitude and phase of Fourier transform
Manhattan distance
manifold
map of concepts
matching unicode properties in regex
mathematical optimization
Mathematics
matrices in latex
matrix
matrix inverse
matrix multiplication
matrix-vector multiplication
measuring a qubit
mem transmute in Rust
memory latency hiding
memoryless property
Men and women are not from different planets
mere exposure effect
mermaid diagram in Obsidian
meshlets
message authentication code
Metabolic Equivalents (METs)
metacognition
metric space
microfacet theory
microgeometry
mimic bound method in JavaScript
Mitchell's best candidate algorithm
mnemonic devices
MOC in Obsidian
Model-View-Projection Matrix
modern alternative for unix cli tools
modulation
modulo
moment generating functions
moment of inertia
money
monitor filesystem change
monoid
monotone convergence theorem
Monte Carlo integration
Monte Carlo methods
morphism
MPEG2 Approach for Temporal Reprojection
Multi-dimensional derivative, gradient, and directional Derivative
multi-index notation
multiple buffering
multiple comparisons problem
multivariable chain rule
mutable default arguments in Python
mutually exclusive events
Myers–Briggs Type Indicator
nanogeometry
necessarily truth-preserving
network security
network topology
never miss twice
Newton's method
nginx
nibble
niebloid
nondeterministic finite automaton
norm
normal approximation
normal distribution
Normal Forms
normal forms (logic)
normal vectors
normalized device coordinate
Not all predictions made by a scientific theory carry the same weight
Notations used in this note
note index
Note Taking MOC
null space
number theory
numerical analysis
numerical integration
numerical methods for ordinary differential equations
numerical summaries of data
NURBS
Nyquist-Shannon theorem
object intersections
observational study
Obsidian block
Obsidian callout
Obsidian CSS snippets
Obsidian Keyboard Shortcuts
Obsidian Latex Suite
obsidian mathlinks
Obsidian MOC
Obsidian transclusion
obstructive sleep apnoea
octahedron encoding
Odin (programming langauge)
omega-3 fatty acids
one-time pad
open and closed sets
open cover
operator precedence parser
opportunities to move
optics
order of integration
ordering of real numbers
ordinary differential equation
Organize Rust integration tests into a single crate
orthogonal functions
Orthogonal Matrices Preserve Norm
orthogonal matrix
orthogonal projection
orthogonal transformation
Orthogonality of Vectors
orthonormal basis
orthonormality
outer product
overlearning
overloading is mulyiple dispatch
p-value
PARA framework
paradoxical reward for procrastinating
parallel algorithms
parallel reduction
parallel scan
parentheses around the condition
parser combinator
Parseval’s theorem
parsing
parsing expression grammar
partial derivative
partial_sum, exclusive_scan, and inclusive_scan
Pascal's rule
Passing overload set in C++
Pearson correlation coefficient
people lack the metacognitive skills to learn effectively
perfect number
perfect secrecy
performance MOC
performance profiling
period
periodic function
philosophy
philosophy of science and metascience
physics
pigeonhole principle
pip
pipeline hazard
pixel
Poisson distribution
polar coordinates
polar decomposition
polymorphism
polynomial multiplication as convolution
positivity of real numbers
power of element
power series
PowerShell
predicate logic
prefix sum
Prenex normal form
present bias
prevent browser caching for development purpose
prime numbers
principle of atomicity
principle of explosion
proactive mindset
probability
probability density function
probability distributions in R
probability mass function
probability MOC
problems of the p-value
procrastination
procrastination share features with addiction
product of two orthogonal matrices is orthogonal
product rule
productivity MOC
Programming Language Design MOC
programming languages MOC
progressive summarization
projection matrix
proof by assertion
proof system
proposition
propositional logic
propositional satisfiability problem
proximity principle
pseudocode programming process
pseudorandom number generator
psychology
pull parser vs push parser
pushdown automaton
Python
python -m pip
Python conditional expression
Python generators
python gotchas
Python List/Dict Comprehension
python main function
Python structural pattern matching
Python variadic functions and unpack operators
Python virtual environment
QR decomposition
Quadratic Approximation of Functions
quadratic form
quadratic formula
quantifier raising
quantile function
quantum computing
quantum logic gates
Quartz
Quartz customization log
qubits
questionable cause
quota sampling
quotient rule
R data frames
R function
R functions cheat sheat
R language
R Vectors
Race Condition vs. Data Race
radiance
radiometry
radiometry quantities
RAII
random variable
randomized algorithms
randomized controlled trials
rank of matrices
rasterization
ratio test
rational number
ray marching
ray tracing
reaching definition
reader-writer lock
reading MOC
Real Analysis
real number
real-time PBR rendering
reduced row echelon form
ref keyword in Rust
referential transparency
reflection
refraction
region of convergence for Laplace transform
register file extensions and mime types in Linux
register renaming
Regular and Semiregular Types in C++
regular expression
regular language
relation between hash functions and PRNGs
relational algebra
relationship between bilateral Laplace transform and Fourier transform
remap capslock key
remap from an input range to an output range
rendering equation
rendering voxels
repeatedly reread sources does not help learning
reservoir sampling
resize images in Obsidian
respect
restart docker container automatically
retrieval practice
return oriented programming
reverse proxy
root mean square error
root test
rotation
rotors
rumination
Runge's phenomenon
Russian Roulette
Rust
Rust anyhow
Rust Argument-Position Impl Trait
Rust borrow checker
Rust borrow splitting
Rust BufReader
Rust cloning vs copying
Rust concepts I wish I learned earlier
Rust concurrency
Rust conversions
Rust deref
Rust disallow simultaneous aliasing and mutation
Rust drop order
Rust ecosystem
Rust error handling
Rust Future trait
Rust generic
Rust interior mutability
Rust IO
Rust iter iter_mut and into_iter
Rust message passing
Rust modules
Rust Naming Conventions
Rust never type
Rust newtype idiom
Rust ownership
Rust PhantomData
Rust RefCell
rust references does not propagate mutability
Rust Return-Position impl Trait
Rust Send and Sync
Rust smart pointers
Rust Traits
Rust wasm pack + vite
rustc architecture
rustc dependency structure
rustc key data structures
rustc memory management
sample reconstruction
sampling (disambiguation)
sampling (signal processing)
sampling bias
satisfiability
scalar potential
scalar triple product
scaling
scene graph
Schlick's approximation
science progress refine existing theories
sea of nodes
search google by site
second brain
second brain capture
second brain distill
second brain organize
second derivative test
self-hosting
self-occlusion
self-perception theory
semigroup
separation of variables
sequence algorithms
sequences
series
server-side request forgery
set theory
shader
shadow array
shadow mapping
shadow rendering
shadowing and masking on a microfacet BRDF
Shapiro-Wilk Test
sheering
shells
Sieve of Eratosthenes
sigmoid function
signal
signal operations
signal operators
signal processing
Simpson’s paradox
sinc function
single return rule
singular value decomposition
sinusoid
SiYuan
size of a signal
skepticism
skew-symmetric matrix
sleep
sleep hygiene
sleep procrastination
sleep stages
smoothness
Snapshot Test in Rust
Snell's Law
social psychology
Socratic method
Software Documentation
software engineering
Software Testing
solve quadratic equations
solvency
soundness (formal system)
spaced repetition
spaced repetition in habit forming
spacing effect
spatial transformation
special functions
Specify Cargo dependency from git repository
spectral power distribution
spectral theorem
spherical coordinates
spherical harmonics
spline
SQ3R
SQL
sRGB
SSH in emacs
ssh setup
stack and frame pointers
standard error
static site generators
static-single assignment
statistical parameters and estimates
statistical population
Statistics MOC
std_exchange
std_exchange_in_move
std_launder
std_max_returns_wrong_value
STL algorithms
stream compaction
streaming multiprocessor
stringtify arguments of C macro
strip plot
structured concurrency
Student's t-distribution
Student's T-test
subdivision surface
subnormal number
subsequence
subspaces
substitution
sum of random variables
sum of same frequency sinusoids
sunk cost
support (mathematics)
suppress warnings in Rust
surface area heuristic
surjection
Swift
Swift concurrency
symmetric difference
symmetric matrix
symmetry of second derivatives
synapse
synaptic plasticity
synchronization quadrant
synchronized waiting and dead lock
System Admin
System F
system of linear equation
system programming
system stability
systems
tail call
tangent space
tangent-space-object-space-normal-maps
tangent, normal, and binormal vectors of curve
tau vs pi
tautology
Taylor series
Taylor series for multi-variable functions
Temporal Reprojection
temptation bundling
testing and debugging strategies for compiler development
Testing Command Line Applications in Rust
Testing in Rust
Texas sharpshooter fallacy
the aggregation of marginal gains
the barbell method of reading
the C programming language
The chameleon effect
the collector's fallacy
the habit loop
The Hadamard Gate
The Hylo Programming Language
the identity predicate
The Quantum NOT Gate
the split sum approximation
The two‐process model of sleep regulation
Thompson's construction
thread block
tidy data
tidyverse
time and frequency domain
time invariant system
time scaling property of convolution
tone mapping
top-down vs bottom-up parsing
total derivative
total differential
total internal reflection
trace of matrices
transfer function
transformation of random variables
translate English to predicate logic
translation
Transport Layer Security (TLS)
Transpose of Matrices
tree data structures
triangle mesh
triangular matrix
trig identities
trigonometry
Tripartite soul
tristimulus theory of color
truth table
truth tree
Turing decidable and recognizable languages
two reflections give a rotation
two wrongs make a right
two-dimensional flux
type Isomorphism
Type Punning
type theory
Type-generic macro
types of software documentation
TypeScript
Typescript never type
TypeScript satisfies
Typescript utility types
Typestate pattern in Rust
undetermined coefficients
unification
uniform continuity
unit step function
unitary matrix
universal Turing machine
Unix
unix permissions
Unix Shell
unix shell background
unix shell control flow
unorm and snorm
unpack the normal distribution
update docker images
Using Camera matrix for temporal reprojection
Using MVP matrix and motion vectors for temporal reprojection
valid argument
valid formula
Validity
validity and reliability
value-oriented programming
Vandermonde's identity
variadic functions
variance and standard deviation
variance reduction methods
vector field
vector projection
vector space
vertex buffer compression
visual explanation of convolution
vividness bias
Voronoi diagram
voxel MOC
vulkan
Vulkan synchronization
Wald's equation
Walrus Operator in Python
wavefront
Web Development MOC
webassembly
what would we see when approaching speed of light
when microbenchmark becomes misleading
why C++ coroutines allocate on the heap
why some compilers preserving parenthesis in AST
why some grammar distinguish declarations with statements
wildcard import enum constants in Rust
Windows
Windows package managers
work (physics)
work efficiency
x86 assemblers
x86 assembly
x86 function prologue and epilogue
x86 status flags
Z-test
zero-input response and zero-state response
Zettekasten and build a second brain
Zettelkasten
的地得
Reference
'Overview of Spaced Repetition' note
Why Aren't Programming Language Specifications Comprehensive
Writings
Avoid premature generalization
debating is unproductive
Eisenhower Matrix
focus on what kind of person you want to be rather than future achievement
Obsidian spaced repetition
on brutalist and neobrutalist web design
On default visibility
on estimated reading times
on programming language complexity and bad features
On RTFM
On the IQ bell curve meme
On trolley problems and other sacrificial dilemmas
on viral annotations
Psychology Today
scapegoats and silver bullets
software reviews
Summary of reading: January - March 2020
Summary of reading: January - March 2024
Summary of reading: October - December 2020
summary of readings
the suggestion 'think before you code' may not always lead to the best outcomes
website reviews
weeding courses are bad teaching
you can only fix it when you spot it
Home
❯
Notes
❯
quotient rule
quotient rule
Dec 15, 2025
parent
:
calculus
math/calculus/differentiation
Let
, then
Derivation from the
product rule
and
chain rule
Graph View
Backlinks
Calculus MOC
derivative