I've been enjoying using the new, native, VS Code integration with local models. I can use LM Studio on my Mac with LM Link to start an OpenAI-compatible server running on my DGX Spark, and plug it in to VS Code for offline/private inference.
Typst also has native scripting! For fun, I've been working on a small statistical distributions library in Typst, distro[^1] that uses plain Typst.
It's really nice having a decently powerful scripting component, it makes for some fun literate-style programming. You can package things up pretty easily for others to use, too[^2]. It even supports WASM plugins, if you want to go wild.
This package, conch[^3], renders a mini OS and terminal, based on Typst:
> A shell simulator that renders interactive terminal sessions in Typst, powered by a Rust WASM plugin.
> Type shell commands in your Typst document. Conch executes them against a virtual filesystem and renders a realistic terminal window — complete with colored output, syntax highlighting, and animation support.
Possibly controversial, but I think short commands should be disallowed. This is the stance the AWS CLI takes, and it 1) vastly improves readability, especially for those learning the syntax 2) makes it less easy to shoot yourself in the foot with a typo.
(Disclaimer: I am not a cryptographer and this is a heavily simplified explanation). Homomorphic encryption is built on the foundation of 'hard problems' (e.g. the Learning with Errors Problem) - loosely, computational problems that are thought to be impossible to reverse without being in the possession of a secret key.
The crux of HE is that it provides a _homomorphism_: you map from the space of plaintext to the space of cipher texts, but the mapping preserves arithmetic properties such as addition and multiplication. To be clear - this means that the server can add and multiply the cipher texts, but the plaintext result of that operation is still irreversible without the private key. To the server, it looks like random noise.
I don't think it's helpful to think about this as connected to deep learning or embedding spaces. An excellent resource I'd recommend is Jeremy Kun's guide: https://www.jeremykun.com/2024/05/04/fhe-overview/
Handwritten! (aka no LLM assistance :) It wasn't transpiled or anything like that. I've been meaning to post a little about it on my blog; just been caught up with other stuff atm.
One thing that was a _little_ frustrating coming from Python, though, was the need to rely on crates for basic things like random number generation and network requests. It pulls in a lot, even if you only need a little. I understand the Rust community prefers it that way as it's easier to evolve rather than be stuck with backwards-compatability requirements. But I still missed "batteries included" Python.
I had good fun transliterating it to Rust as a learning experience (https://github.com/stochastical/microgpt-rs). The trickiest part was working out how to represent the autograd graph data structure with Rust types. I'm finalising some small tweaks to make it run in the browser via WebAssmebly and then compile it up for my blog :) Andrej's code is really quite poetic, I love how much it packs into such a concise program
I recently wrote an eigenvalue solver for an interactive component on my blog with Rust compiled to WebAssembly. Being able to write-once and compile for the web and desktop felt like the future. But then, I'm no fan of JavaScript and wouldn't have attempted it if WASM didn't exist.
Thanks for writing this game! I came across it after seeing your Checkers written in Rust for WASM game[0], and thought it deserved an HN submission of its own.
Ooh, thanks for sharing that algorithm! Somehow, I didn't come across this and jumped straight into using the QR algorithm cited everywhere.
I found it hard to find a good reference that had a clean implementation end to end (without calling BLAS/LAPACK subroutines under the hood). It also wasn't easy to find proper convergence properties for different classes of matrices, but I fear I likely wasn't looking in the right places.
> We did a complete overhaul of Hugo’s template system in v0.146.0. We’re working on getting all of the relevant documentation up to date, but until then, see this page.
I don't mind breaking changes, but it'd sure be nice if the documentation reflected the changes.
Pitch: Currently working as a Data Scientist and early-careers AI researcher at a major Australian bank. Bachelor in mathematics & CS, looking to go back for a Masters in mathematics. I'm looking for challenging roles that ideally involve maths. I enjoy functional programming, reading books and papers, blogging about arcane things and learning new languages and algorithms.
I'm writing a toy eigenvalue solver in Rust using the QR algorithm.
I didn't intend to, but I recently discovered the Gershgorin Circle Theorem and thought it'd be neat to create an interactive visualisation for my [blog](https://abstractnonsense.xyz).
I don't like JavaScript, and I've been meaning to learn Rust for a while, so I'm compiling the Rust algorithm to WebAssembly to run in the browser natively! It's been a fun trip back into the arcane world of numerical algorithms and linear algebra!
I prefer btop over more traditional resource monitor CLI/TUIs as it handles affordances in a more thoughtful and intuitive way (to me, at least - it's definitely a personal preference!). I think it's worth a test drive even just to explore a different sort of interaction mechanism for TUIs.
I think the latest version of MathJax (v4) has rendering speed comparable to, if not faster than, KaTeX. It also looks (subjectively) significantly better than KaTeX, and supports a wide array of accessibility features.
Thank you!! After some discussion with a kind reader, I actually managed to compile a working regex! It's 10s of millions of characters in length, but it works! (I've updated the post with the details :)
This was a problem that was obsessing me for a couple sleepless nights...
Ordinarily, when you look up "regex for card numbers" you get a list of card provider prefixes and length constraints, but this doesn't do any validation on the check digit (calculated using the Luhn algorithm)!
Spoiler: Regex's _can_ recognise the set of valid card numbers, but the resulting regex would be exponential in the number of states for the minimal DFA (as far as I can reason).
Blog: https://abstractnonsense.xyz
Email: [email protected]