I learned R for statistical programming at uni, where there was less emphasis on vectorised computation, so it didn't jump to mind, but yes! I've never quite felt like numpy 'clicked' for me in the same way, though. It always felt a bit bolted on, which I suppose it is, as a library (though @ operator overloading etc makes things somewhat nicer now).
As it happens, I had the same job as the author at uni. I shelved books at the biomedical and sciences library. As a life-long book lover, it was a dream uni job being surrounded by all sorts of historical treatises on medical arcana.
I've been really exercising my non-fiction reading muscles of late. I'm trying weaponise it as an antidote to AI slop and doom-scrolling. My last read was Designing Data-Intensive Applications by Martin Klepmann (the newly released second edition), it was a wonderful read!
I'm no fan of closed-source languages, and lord knows MATLAB has its warts. But I can't deny that it was pretty seamless to write efficient vectorised code for numerical simulations at uni. I don't have much experience with it, but my understanding is that Julia is the closest thing to a more modern and expressive language that has similar vectorisation capabilities.
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!
Blog: https://abstractnonsense.xyz
Email: hello@<blog-domain>