Tony Finch

This reminded me of one of my favorite links ever on HN. https://dotat.at/@/2023-05-26-whence-time.html

It's quite hard to write mktemp securely[1]. It would be great if POSIX didn't make people attempt to do that error-prone task themselves. [1]: There's some explanation in this recent post: https://dotat.at/@/2024-10-22-tmp.html

Not entirely a bot and not entirely old content. I’ve got a lot of good stuff in my link log https://dotat.at/:/ so I thought it might be fun to share a few retro classics. There has been some good discussion, so it seems to be worth it.

Tony Finch's email address is still my favourite. https://dotat.at/email.html

Any chance of also including GLL (generalized LL)? I found the paper (http://dotat.at/tmp/gll.pdf) quite hard to follow, and haven't been able to find a good explanation anywhere else.

This guy famously has an email address that can only be parsed one way... with a little thought: http://dotat.at/ (scroll to the bottom for mail)

Cool, yes. Useful or a good idea, I dunno. Reading through the (non-reference) documentation on SOM, I’m struck by how they never could give a convincing example for the utility of metaclasses. (Saying this as someone who does love metaclasses in Python, which are of course an inferior interpretation of the same academic sources.) The SOM documentation is also surprisingly shallow given its size: with a copy of Brockschmidt, Box, the COM spec, and the Platform SDK manual, you could reimplement essentially all of COM (not ActiveX though), whereas the IBM’s documentation is more like “here’s how you use our IDL compiler and here are the functions you can call”. (This is in contrast with the Presentation Manager documentation, which is much tighter and more detailed than the one for USER/GDI ever has been.) From what I can infer of the underlying principles, I feel SOM is much more specific about its object model, which, given the goal is a cross-language ABI, is not necessarily a good thing. (I’d say that about WinRT too.) And of course COM does do implementation inheritance: despite all the admonitions to the contrary, that’s what aggregation is! If you want a more conventional model and even some surprisingly fancy stuff like the base methods governing the derived ones and not vice versa, BETA-style, then WinRT inheritance[1] is a very thin layer on top of aggregation that accomplishes that. Now if only anybody at Microsoft bothered to document it. As in, at all. (I don’t…

Well, sometimes I'm digging through my (multiple!) lists of links when I remember a tidbit that relates to what I'm working on but most of the time those lists gather dust. In the future I'd like to maintain a link log or something similar on my personal website like some people do: - https://matklad.github.io/links.html - https://dotat.at/:/ - https://til.simonwillison.net/ The weird thing about saved links in my case is that I get the most satisfaction out of them when I share them with friends and so on, a bit of "Hey! I think this might be helpful, here you go" and that ends up being the extent of that particular link's usefulness for myself most of the time. Of course I can't accurately gauge how helpful it actually is for the other person.

Tony Finch is a real person: https://dotat.at/social.html He used to be [email protected], amongst other things. Why he’s farming internet points on HN I’ve no idea!

You may be interested in unifdef, which selectively evaluates and removes ifdefs. https://dotat.at/prog/unifdef/ I used it once at work for a niche usecase. It’s main use case seems to be making it easier to simplify platform-specific code when you remove support from old platforms in legacy codebases.

Crit bit tries are also, therefore, sorted. They can be iterated in order. See also https://dotat.at/prog/qp/README.html

Do you mean the conversion from YYYY-MM-DD to Unix Time? That can be quite fast; I wrote a blog article showing some algorithms that take less than 10ns to perform the conversion: https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.htm… Recently I came across another variant of the algorithm that is even smaller and simpler. I've been meaning to test this variant and add it to my article (assuming it is correct), but I haven't had the chance: https://dotat.at/@/2008-09-10-counting-the-days.html

Kind of off-topic, but this person's e-mail address is "dot at dotat dot at", which is very unique (see https://dotat.at/email.html).

Here's Tony Finch's discussion of the data structures he's working on for ISC's BIND: https://dotat.at/prog/qp/README.html

This can be accomplished with the TCP socket options TCP_CORK on Linux and TCP_NOPUSH on FreeBSD and OpenBSD. When enabled only full TCP frames are sent; upon disabling any partial frame is immediately sent. See tcp(7) on Linux, tcp(4) on FreeBSD, and http://dotat.at/writing/nopush.html clarifying the behavior.

Related: qp-tries and critbit tries: https://dotat.at/prog/qp/README.html, https://cr.yp.to/critbit.html

How have you totally missed GLL and GLR parsing?! http://dotat.at/tmp/gll.pdf

Unifdef http://dotat.at/prog/unifdef/ Saved me 100+ hours _this week_ :-). Thanks, Tony Finch &co!

Welcome. :) Here's the link to first paper I saw I think: http://dotat.at/tmp/gll.pdf

There also some tools I think should be added: I'm not sure if linking to AddressSanitizer is okay (as its (an underused) part of Clang and GCC), but I consider include-what-you-use, unifdef, and maybe C++ Compiler Explorer a worthwhile addition. What about mbedTLS (formerly PolarSSL)? It's dual licensed though. https://code.google.com/p/address-sanitizer/(Apache 2.0) https://code.google.com/p/include-what-you-use/ (same license as LLVM/Clang) http://dotat.at/prog/unifdef/ (BSD) http://gcc.godbolt.org/ (BSD) https://tls.mbed.org/ (GPLv2) Edit: midipix is something one should look out for. What it promises to support and how, sounds much more appealing to me than Cygwin or MinGW-w64, but it's still in early development: http://midipix.org/

This is an old Unix utility, OpenBSD versions <=5.5 shipped with a much older version from CSRG times. It was recently updated to the rewrite done by Tony Finch. http://dotat.at/prog/unifdef/

The algorithm used is Generalized LL parsing (http://dotat.at/tmp/gll.pdf), which promises linear-time parsing of LL grammars and cubic-time parsing of arbitrary grammars. For some reason this isn't mentioned until the very end.

Even in the parser corner, the parser combinator / graph-structured stack / GLL algorithm is both new and exciting. GLL was published in 2010: http://dotat.at/tmp/gll.pdf

I think listlife is a simple and efficient algorithm: http://dotat.at/prog/life/life.html Some years ago I implementend something similiar in javascript: http://pmav.eu/stuff/javascript-game-of-life-v3.1.1/ The benchmark can be really slow in some steps.

https://jrock.us/ https://jgc.org/ http://kaledavis.com/ https://aegir.sexy/ https://www.gwern.net/ https://jacquesmattheij.com/ https://danwin.com/ https://www.kalzumeus.com/ https://www.magic.do/ https://edweissman.com/ https://jakeseliger.com/ http://www.fogus.me/ https://www.stavros.io/ https://jasonlefkowitz.net/ https://minimaxir.com/ https://www.robinwhittleton.com/ https://ciexinc.com/ https://rongarret.info/ https://williampietri.com/ https://bpier.re/ https://joshtriplett.org/ https://ooer.com/ https://feross.org/resume/ https://www.brandons.me/ https://benjaminpbreen.com/ http://hokstad.com/ https://www.scott-a-s.com/ https://www.bermita.com/ http://tlrobinson.net/ https://ldpreload.com/ https://dotat.at/ http://xavvy.com/ https://correa.in/ https://adriann.github.io/ https://leclan.ch/ https://joeyespo.com/ https://pius.me/ https://adamierymenko.com/ https://drewdevault.com/ https://battlepenguin.com/ https://chris.improbable.org/ https://www.snellman.net/ https://ocdtrekkie.com/ https://www.cryptolotus.com/ https://www.gregkogan.com/ https://david.kitchen/ In no particular order. From: https://jessimekirk.com/blog/hn_users_links/. I went through about half of the list looking for personal websites to use as inspiration for my own.

Paging Tony Finch: https://dotat.at/email.html

Generalized LL Parsing - http://dotat.at/tmp/gll.pdf Parse ambiguous context-free grammars in worst-case cubic time and unambiguous grammars in linear time, with an intuitive recursive-descent-ish algorithm. GLL is the future of parsing IMO, more powerful than packrat/PEG parsers and comparatively easy to write by hand. It also handles ambiguities more elegantly than GLR, IMO. Dependency-Based Word Embeddings - https://levyomer.files.wordpress.com/2014/04/dependency-based-word-emb… word2vec algorithm with context based on linguistic dependencies instead of a skip-gram approach. A quick explanation is skip-grams give words related to the embedding (ex: Hogwarts -> Dumbledore) and dependencies give words that can be used like the embedding (ex: Hogwards -> Sunnydale). It's not meant to replace skip-grams, but augment them; skip-gram contexts learn the domain and dependency-based contexts learn the semantic type.