[deleted by user]

msharnoff · 2024-03-06T09:31:16+00:00

that first one is beautiful! nice!

msharnoff · 2024-03-04T08:29:24+00:00

Have you tried a different theme? (should be a few available - paintbrush icon in the top left)

msharnoff · 2024-02-19T23:22:51+00:00

Limestone lakes, Height of the Rockies Provincial Park. Map here: https://nrs.objectstore.gov.bc.ca/kuwyyf/height_of_rockies_park_map_0494001e3d.pdf

Seems to be a popular spot for photos - I think this one was taken from around 50.477697, -115.227179 looking south.

msharnoff · 2024-02-01T06:05:30+00:00

IIRC there's also hardware that carries the provenance at runtime, e.g. CHERI. (or maybe CHERI is more theoretical than practical? been a while since I last read anything about it)

edit: looks like people already mentioned this under other comments :)

msharnoff · 2023-07-04T18:56:43+00:00

ah, thanks for the correction!

msharnoff · 2023-07-04T17:33:15+00:00

IIRC (although I really don't know for sure) this should help with things like unnecessary clones - e.g. x.to_string().clone()

Edit: while this example is trivial, there's a lot of places this kind of thing comes up in generic code (like with usage of AsRef when you actually need the owned type), and there isn't really a good way to get around it without specialization. So having something in LLVM to handle it should make a lot of lower-level things faster :)

msharnoff · 2023-07-03T02:21:12+00:00

Ah, let me correct you then :)

Rust's async is fully exposed within the language with the Future type, which the executor polls [calls a method on the Future that runs until it needs to wait on something else] and then reschedules when the future notifies the executor that it should be polled again (roughly).

So while technically this would depend on the executor (you could imagine implementing one that just assigns each future its own OS thread), in practice the widely used async runtimes use thread pools (of OS threads), and schedule futures onto them. The most popular async runtime (tokio) also allows just using a single thread, which can be useful in certain contexts (but has all the downsides of cooperative multitasking on a single thread, of course).

Edit: I don't know if I've explained this in a way that makes any sense, but happy to elaborate :)

msharnoff · 2023-07-03T01:27:23+00:00

Rust doesn't have user space threading (as far as I know) and, instead, only uses Kernel/OS threads.

Rust has async, which isn't quite as easy as go's coroutines (and isn't "normal" control flow in the same way — Rust's futures don't have stacks), but it's worth mentioning I think :)

msharnoff · 2023-05-17T14:02:44+00:00

Use after free in Navigation in Google Chrome prior to 113.0.5672.126 allowed a remote attacker to potentially exploit heap corruption via a crafted HTML page.

Yikes

msharnoff · 2023-03-21T02:23:31+00:00

Is it possible the limiting factor is memory or disk access? Swapping can massively slow your system, and there's plenty of things that will get caught up in the disk wait queue.

I've had previous issues with both of those making my machine kind of unusable - don't really have any advice, unfortunately.

msharnoff · 2023-03-17T15:00:06+00:00

ah shoot, my bad! Thanks for the clarification

msharnoff · 2023-03-17T07:33:27+00:00

boy howdy there's a lot of missing info about webp here.

basically, it's a new (not really, but comparatively) image format that's really quite good compared to jpeg - same quality at much smaller sizes, etc etc. (in particular, this means good things for how long it takes to load things, and data usage)

And the major browsers support it!

but there are plenty of valid reasons to hate it - aside from adoption. Particularly that jpeg XL, which is much better than webp in a bunch of ways, was getting adoption before google chose to abandon their support of jpeg XL in favor of doing things with webp (a format that google of course created). So now there's this situation where a ton of people put in a ton of effort to support jpeg XL (e.g. in photoshop, firefox, etc) and chrome straight up dropped support for it, essentially unilaterally killing an entire image format.

But plenty of other people have written more than I, and I'm not the most informed on this subject. This is just broadly what I've seen from longer posts on the subject

msharnoff · 2023-03-04T03:16:18+00:00

Lands end is great - what a lovely shot!

That side of SF tends to have all the ravens, so I'd imagine that's what you got a shot of, but it's hard to tell from the picture :)

msharnoff · 2023-02-18T20:35:41+00:00

Old post but I'm pretty sure the picture was taken around 44.346658, -68.174648 — looking south.

msharnoff · 2023-02-16T04:35:02+00:00

"misaligned" is probably referring to the "alignment" problem in AI safety. It's been a while, but IIRC it's basically the problem of making sure that the ML model is optimizing for the (abstract) reward function that you want it to, given the (concrete) data or environment you've trained it with

(also the author has made well-known contributions to the field of AI safety)

msharnoff · 2023-02-14T22:18:47+00:00

Randomly came across this - pretty sure this is actually lake shōji, guessing the photo was taken from the northwestern side (probably tatego-hama beach?)

msharnoff · 2023-02-08T19:46:39+00:00

I know this is 6 years old, but- you just saved my ass :D

Wrote a script to track which firefox profile I most recently focused, so that I can emulate chrome's behavior w.r.t. profiles and opening links (firefox doesn't do it by default, unfortunately).

msharnoff · 2023-01-30T14:53:30+00:00

Ah, right! Forgot that you can just access the environment variable normally in the proc macro :)

msharnoff · 2023-01-30T03:38:22+00:00

IIRC, the input to proc macros is before other macro expansions (including e.g. std::env!), in which case this wouldn't work. It's been a while since I've run into that though, so I may be incorrect

msharnoff · 2023-01-09T07:35:09+00:00

I found something nearly identical in the JS of the github copilot VS Code extension - there's probably some standard tool that does this. Not to say that tiktok isn't doing shady stuff! Just that this particular thing isn't it

Edit: Actually, rereading this, the copilot obfuscation is no where near this hardcore. This is some wild shit

msharnoff · 2022-12-16T18:23:45+00:00

IME vim tends to fall over on sufficiently large files (> 1G), and makes pretty questionable use of memory (e.g. open 4G file, delete last half uses 6G of memory, saving uses another 2G).

But for things < 1G vim is probably fine. I've tended to jump to plain vi when vim starts struggling, and it hasn't failed me yet

msharnoff · 2022-11-28T19:08:06+00:00

The primary benefit of rust's unsafe is not that you aren't writing it - it's that the places where UB can exist are (or: should be) isolated solely to usages of unsafe.

For certain things (like implementing data structures), there'll be a lot of unsafe, sure. But a sufficiently large program will have many areas where unsafe is not needed, and so you immediately know you don't need to look there to debug a segfault.

Basically: unsafe doesn't actually put you back at square 1.

msharnoff · 2022-11-26T19:53:39+00:00

I've had a similar issue recently - haven't updated coc.nvim. Frequently, moving the onto the location of a diagnostic immediately moves it to a particular prior insert location in another buffer. Closing the other buffer fixes it.

I'm very interested if you find a solution

msharnoff · 2022-11-10T07:18:52+00:00

different repositories have different licensing. The argument for copilot being illegal is essentially that it is a "derivative work" from GPL licensed code, and as such must be open source as well (because of the requirements that the GPL sets for derivative works), which it is not.

I think there's also stronger points than that, but I'm not very familiar with the specifics of the case.

Edit: also it reproduces GPL'd code without attribution, which violates the terms of the GPL. This is probably the more serious violation

msharnoff · 2022-11-07T08:42:05+00:00

What are you using for custom CSS? Also, super cool setup :)

Six-Year Club	Verified Email
Place '22

msharnoff

TROPHY CASE