subset

Iago Leal's blog: https://iagoleal.com/

Some incredibly interesting perspectives on maths and computing

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.

[^1]: https://github.com/stochastical/distro

[^2]: https://typst.app/universe/package/distro

[^3]: https://typst.app/universe/package/conch/

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.

Gosh, tired brain moment apologies. I thought it'd linked to the original code gist.

Andrej Karpathy has a walkthrough blog post here: https://karpathy.github.io/2026/02/12/microgpt/

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 think that web browsers only allow up to 4GB of memory per tab.

https://abstractnonsense.xyz/

My personal blog, I normally post about maths and computer science. But sometimes random design things, or bits about linguistics and words.

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.

[0] https://github.com/kevinAlbs/Checkers

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.

In particular, Hugo overhauled its templating system in [v0.146](https://gohugo.io/templates/new-templatesystem-overview/) which resulted in build fails for my blog when I upgraded.

As of today, the [docs](https://gohugo.io/templates/lookup-order/) still haven't been fully adjusted to reflect the new system:

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.

Location: Melbourne, Victoria, Australia Remote: Yes (preferably) Willing to relocate: Yes. Willing to to relocate to England.

Technologies: Python. Have also worked with Haskell, C, Prolog, Java, MATLAB, SAS to various degrees of proficiency.

Résumé/CV: Please check my LinkedIn from my profile.

Email: hello@abstractnonsense.xyz

Blog: https://abstractnonsense.xyz. I like to blog about mathematics and computer science.

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've written up some thoughts on the design of btop here: https://abstractnonsense.xyz/micro-blog/2025-04-26-btop-of-y...

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).

If I'm not mistaken, the latest iOS 26 release supports HDR screenshots.

I literally just integrated MathJax v3 with Hugo last night for my blog (abstractnonsense.xyz) so I can write some maths posts, and v4 is released today ...

Keen to try it out! I'm hoping it improves rendering - I was seeing some issues with SVG output for inline maths in Safari.

KaTeX is neat and fast, but alas the quality of the typesetting is really sub-par compared to MathJax.

Ooh this looks really neat! I'd love to see more content in the future on Structured outputs/Guided generation and sampling. Another great reference on inference-time algorithms for sampling is here: https://rentry.co/samplers

A small release notes highlight I whipped up: https://abstractnonsense.xyz/micro-blog/2025-05-29-apache-sp...

First time trying a code golf solution, managed to do Part 2 in 231 characters.

  p="one two three four five six seven eight nine".split();sum(int(x[0]+x[-1])for x in["".join([["",s[0]][s[0].isdigit()],str(p.index(w)+1)][s.startswith(w)]for s in[l[i:]for i in range(len(l))]for w in p)for l in open("input.txt")])

I would love to see a combination of Markdown + Pandoc used to generate LaTeX whilst keeping the writing process content-centric.

I find the mathematical typesetting functionality of LaTeX to be incredible, but anything else (tables, columns, etc.) to be an absolute nightmare.

Pandoc allows for Lua filter to pre-process an AST generated from raw Markdown, and can then convert to 'traditional' LaTeX - why can't we utilise the best of both worlds?

For example, I used Pandoc to create Beamer slides in Markdown, with nice `div` syntax and maths typesetting - the advantage was I could focus on the semantics (and have a directly readable document) without any LaTeX fluff that was purely aesthetic.

The most infuriating bug for me is that Preview opens each PDF in a new window instead of tabs (even with 'Prefer tabs always' selected in Sys Pref).

There are also set-theoretic constructions of the Reals that satisfy the axioms (e.g. Dedekind cuts)

A set-theoretic approach to calculus has me intrigued. Well calculus (and more generally, analysis) really does hinge on set theory. For example, points of accumulation for limits and hence differentiation, Riemann integration via the supremum and infimum etc are all set-theoretic ideas. Just generally encountered in a Real Analysis class and introductory calculus largely abstracts over the fundamental set concepts that underpin the mechanics.