a_e_k

You can also set:

    layout = neato;

in a dot file, call dot, and it will use the neato layout engine.

(See https://graphviz.org/docs/attrs/layout/)

And if I look in my /usr/bin, I see that neato is just symlinked to dot. It's pulling the usual trick of one executable that behaves slightly differently depending on the invocation name.

The subreddit also had a policy of not unlocking the megathread until the leaderboard was filled up. So any hints there will also be too late for the making the global leaderboard.

And the old About noted what you just said about there being nothing preventing someone from using AI:

> If you want to use AI to help you solve puzzles, I can't really stop you, but I feel like it's harder to get better at programming if you ask an AI to do the programming for you.

I like the NATO one.

It occurred to me that it would be more useful to me in Emacs, and that might make a fun little exercise.

And that's how I discovered `M-x nato-region` was already a thing.

For my fellow visual thinkers who might be looking for a linear algebra book that focuses more on developing the geometric intuition for stuff like this, rather than just pure numeric linear system solving, let me recommend:

"Practical Linear Algebra: A Geometry Toolbox" by Farin and Hansford.

This is one of those things that's perennially annoying in computer graphics. Depending on the API you can have different conventions for:

- data layout (row-major vs. column major)

- pre-multiplication vs. post-multiplication of matrices

Switching either of these conventions results in a transposition of the data in memory, but knowing which one you're switching is important to getting the implementation of the math right.

And then on top of that for even more fun you have:

- Left- vs. right-handed coordinate systems

- Y-up or Z-up

- Winding order for inside/outside

There are lots of small parity things like this where you can get it right by accident but then have weird issues down the line if you aren't scrupulous. (I once had a very tedious time tracking down some inconsistencies in inside/outside determination in a production rendering system.)

I remember that being the Newegg philosophy w.r.t. patent trolls.

I really don't get this move.

It's one thing to try to steer basic, non-technical users toward an MS account by default. Fine; I may not like that, but I get it. But at this point, anyone left who's still using these methods to create a local account is likely to be a technical user who's deliberately and intentionally wanting a stay on local account for whatever their own reasons.

I suspect that's a rather small group, which leaves me puzzled: (1) is the juice really worth the squeeze, and (2) is it really worth being so hostile to your power users?

Sounds like a perfect recipe for the Abilene paradox.

https://en.wikipedia.org/wiki/Abilene_paradox

That's at BF16, so it should fit fairly well on 24GB GPUs after quantization to Q4, I'd think. (Much like the other 30B-A3B models in the family.)

I'm pretty happy about that - I was worried it'd be another 200B+.

A good first exercise for new hires! (And I say that as having been both a new hire who's updated the documentation after trying to execute it, and as someone who's guided a new hire when the documentation proved inadequate.)

Best Buy has been a big one for me when I need things like USB sticks or SD cards. (Bad enough with the occasional duds from the reputable sources without mixing in counterfeits on top of that.)

The other part of that argument that I've seen is that they'd be able to use generic tools made for humans.

I'm used to things like `// clang-format off` and on pairs to bracket such blocks, and adding empty trailing `//` comments to prevent re-flowing, and I use them when I must.

This was more about lamenting the need for such things. Clang-format can already somewhat tabularize code by aligning equals signs in consecutive cases. I was just wishing it had an option to detect and align other kinds of code to make or keep it more table like. (Destroying table-like structuring being the main places I tend to disagree with its formatting.)

Yes, so much this!

I've often wished that formatters had some threshold for similarity between adjacent lines. If some X% of the characters on the line match the character right above, then it might be tabular and it could do something to maintain the tabular layout.

Bonus points for it's able to do something like diff the adjacent lines to detect table-like layouts and figure out if something nudged a field or two out of alignment and then insert spaces to fix the table layout.

And Emacs was banished to a write-in this year, when it was near the middle of the pack at 4.2% (Emacs) and 0.4% (Spacemacs) last year.

https://survey.stackoverflow.co/2024/technology#1-integrated...

It's also been fairly stable over the last few years, so it's hard for me to believe that it just suddenly dropped off to 0.2%:

    | 2021 | 5.30% |
    | 2022 | 4.51% |
    | 2023 | 4.69% |
    | 2024 | 4.2%  |

Neat! IF-wise, there's also

M-x dunnet

which has shipped with GNU Emacs since 1994.

https://en.wikipedia.org/wiki/Dunnet_(video_game)

Darn. By "compact", I thought there'd be some clever sparsity or compression to get below 1 bit/flag in common cases.

I've played with a similar idea for writing technical papers. I'll give an LLM my draft and ask it to explain back to me what a section means, or otherwise quiz it about things in the draft.

I've found that LLMs can be kind of dumb about understanding things, and are particularly bad at reading between the lines for anything subtle. In this aspect, I find they make good proxies for inattentive anonymous reviewers, and so will try to revise my text until even the LLM can grasp the key points that I'm trying to make.

I was wondering that too. A DHCP server, apparently: https://www.isc.org/kea/

(This is one place where I think a little editorializing to the page title to add context would be helpful.)

Oh, that's a nice optimization!

This is hilarious. While I work, one of my cats loves to share my desk chair and sleep between me and the backrest (forcing me to sit closer to the front edge). I've noticed she favors lying on her left flank there, and she is, in fact, sleeping behind me like this right now.

(Anecdotal, but +1.)

On the other hand, she's one of a bonded pair and I'll sometimes see her and her sister sleeping curled next to each other with more varied chirality. Maybe a trusted friend outweighs this effect?

Playing around, I found that the generator approach was competitive with this if you permuted the loop nest, and often even slightly faster (at the 1000 character length):

    def any_gen_perm(s):
        return any(c in s for c in "aeiouAEIOU")

I think the crux is that you want the inner loop inside the fast C-implemented primitive to be the one iterating over the longer string, and to leave the outer loop in Python to iterate over the shorter string. With both my version and yours, the Python loop only iterates and calls into the C search loop 10 times, so there's less interpreter overhead.

I suspect that permuting the loop nest in similar variations will also see a good speed up, and indeed trying just now:

    def loop_in_perm(s):
        for c in "aeiouAEIOU":
            if c in s:
                return True
        return False

seems to give the fastest result yet. (Around twice as fast as the permuted generator expression and your find implementation on my machine, with 100 and 1000 character strings.)

This is explicitly called out in the canvas spec's best practices section with a laundry list of things you'd have to re-implement [1].

> Authors should avoid implementing text editing controls using the canvas element. Doing so has a large number of disadvantages:

> [...]

> This is a huge amount of work, and authors are most strongly encouraged to avoid doing any of it by instead using the input element, the textarea element, or the contenteditable attribute.

[1] https://html.spec.whatwg.org/multipage/canvas.html#best-prac...

You're right to ask about that! ...

Experience, though, can definitely vary by domain. Trying to get one to code an algorithm recently that I had a pretty good idea of took longer and gave worse results than just doing it myself.

On the other hand, something like wrestling with the matplotlib API? I don't have too much experience there and an LLM was a great help in piecing things together.

Now if we could only get one near Seattle!

(I've never really understood why a tech hub as large and historical as Seattle doesn't have one. It's weird that it's such a relative desert.)

If you're happy running local models, llama.cpp's built-in web-server's interface can do this.

I've been noticing your commits as I skim the latest git commit notes whenever I periodically pull and rebuild. Thank you for all your work on this (and llama.cpp in general)!

This is excellent. I've been pulling and rebuilding periodically, and watching the commit notes as they (mostly ngxson, I think) first added more vision models, each with their own CLI program, then unified those under a single CLI program and deprecated the standalone one, while bug fixing and improving the image processing. I'd been hoping that meant they'd eventually add support to the server again, and now it's here! Thanks!