Farside collects a category of alternative libre front-end proxies to popular services. It tests their availability automatically and only show the working ones.

Vulkan learning guide.

Detailed scan report for URL: domain/IP info, http transactions, links, javascript behavior analysis, etc.

VirusTotal has this public tool that shows detailed information about IP address/domain: historical Whois lookup and certificate log. Similar to crt.sh.

I always confuse the concept of ours and theirs. Every time I have to choose one I need to search which is which. Turns out I'm not alone! This website explains what each term refers to. TL;DR: the currently checked out branch is "ours" in merge, but "theirs" in rebase.

TIL the faintness sensation come from hyperventilation is a result of respiratory alkalosis, which is caused by reduced CO2 (acidic) level in blood. CO2 is equilibrated with HCO3- (basic) in blood as a pH buffering solution. The lung controls the amount of CO2 whereas the kidney controls the amount of HCO3-. So breathing rate is determined by the level of CO2. Although the CO2 exhaled contributes to the majority of weight loss in human, hyperventilation is not a feasible way to lose weight because the benefit is marginal compared to the downside of respiratory alkalosis. A better way to lose weight is through producing more CO2, which is achieved by increasing metabolism rate.

Pratt parsing is a parsing algorithm that solves the awkward handling of left-recursion in a recursive descent parser. It elegantly handles both operator precedence and associativity using a single "binding power" concept. The core algorithm is as simple as follows:

fn expr(input: &str) -> S {
    let mut lexer = Lexer::new(input);
    expr_bp(&mut lexer, 0) 
}

fn expr_bp(lexer: &mut Lexer, min_bp: u8) -> S { 
    let mut lhs = match lexer.next() {
        Token::Atom(it) => S::Atom(it),
        t => panic!("bad token: {:?}", t),
    };

    loop {
        let op = match lexer.peek() {
            Token::Eof => break,
            Token::Op(op) => op,
            t => panic!("bad token: {:?}", t),
        };

        let (l_bp, r_bp) = infix_binding_power(op);
        if l_bp < min_bp { 
            break;
        }

        lexer.next(); 
        let rhs = expr_bp(lexer, r_bp);

        lhs = S::Cons(op, vec![lhs, rhs]); 
    }

    lhs
}

fn infix_binding_power(op: char) -> (u8, u8) {
    match op {
        '+' | '-' => (1, 2),
        '*' | '/' => (3, 4),
        _ => panic!("bad op: {:?}"),
    }
}

Like the now shut down RawGit, it's a free CDN for serving raw files from GitHub and other platforms.

curl ifconfig.io
curl ifconfig.me
curl ifconfig.co
curl ip.sb
curl icanhazip.com
curl myip.wtf/text
curl geofind.me # has geolocation info

port reachability test:

ifconfig.co/port/22

Method: train a sparse autoencoder on the activation on the residual stream. The sparsely activated components ensure only few features are activated for similar activation patterns in residual stream. Each of the feature is in turn interpreted by an LLM for its semantics. One can use these feature to semantically interpret the working of the model and steer the model towards desired goals.

A database of captured fMRI videos for the articulation of various sounds in the IPA.

An IPA chart with example pronunciations.

An interger hash function is a bijection in the domain of N-bit unsigned integers with hashing properties. To make a good hash function, for each flip in input bit, roughly 1/2 of the output bit should flip (known as "high avalanche effect"). Furthermore, there should be no correlation between flipped input bits and output bits (known as "low bias"). The author of this article describes an algorithm to generate integer hash functions by composing reversible functions, and test the two hashing properties on the function to find the best ones.

A LLM uncensoring technique by finding the embedding direction of refusals in the residual stream outputs. One can choose to negate the refusal direction in the output to block the representation of refusals.

More on LLM steering by adding activation vectors: https://www.lesswrong.com/posts/5spBue2z2tw4JuDCx/steering-gpt-2-xl-by-adding-an-activation-vector

A non-traditional neuron network architecture where the activation functions are trained instead of fixed as in multi-layer perceptron (MLP). The output of the activation functions are merely summed in each layer. Each of the activation function is described as a linear combination of basis functions where the coefficients are trained.

Read https://github.com/GistNoesis/FourierKAN/ for a simple implementation of the core idea. See further discussion at https://news.ycombinator.com/item?id=40219205.

This approach originates from the question: how much does the architecture compared to the weights that affect the performance of a neuron network?

This article describes a non-traditional machine learning approach: using genetic algorithm to find NN architectures optimized for 1) weight-agnostic and 2) least complex. The resulting architecture works for a wide range of weight shared across the nodes.

An IDE and debugger for the esoteric programming language Piet.

In-depth and low-level knowledge about GPU.

Normally when we implement ray tracing, each ray of light carries a RGB vector. Spectral Ray Tracing is the technique of instead of treating a ray of light as a particle in a straight line, the algorithm treats light as a wave spectrum - spectral power distribution (SPD). This allows more realistic rendering such as dispersion, diffraction, etc.

A 4-part writeup on how GPS works and how to implement a GPS receiver: I/Q data, asynchronous CDMA, GPS C/A and P code, Heterodyne demodulation, etc.