ishitatsuyuki

GCP patched a similar loophole [1] in 2023 presumably because some of their customers were abusing it. I'd expect AWS to do the same if this becomes widespread enough.

[1]: https://cloud.google.com/storage/pricing-announce#network

macOS has native password autofill which opens the Keychain experience to 3rd party password managers. Unfortunately browser support is limited to Safari (even though the API itself is open), while Strongbox [1] seems to be the only option on password manager side.

Maybe this will improve with the adoption of passkeys, where browsers are actually trying to integrate with the system passkeys API (a neighbor to autofill).

[1]: https://strongboxsafe.com/updates/macos-big-sur-autofill/

Unfortunately, removal of PIIs also means less data/cues for hard-to-diagnose bugs (it can even range to CPU bugs like [1]). For Firefox, potentially PII-containing memory dumps are still sent to the server, but they're only viewable by authorized personnel [2].

There are also rule-based PII removal methods as used by Sentry minidump processing and described at [3].

[1]: https://news.ycombinator.com/item?id=37063459

[2]: https://crash-stats.mozilla.org/documentation/protected_data...

[3]: https://docs.sentry.io/product/data-management-settings/scru...

IMHO, perf's decision to write whole stacks directly to the disk and unwinding them as a post-process is a really bad design. It wastes disk space, and as the author pointed out, it also has a lot of IO overhead.

As an alternative approach, https://github.com/mstange/samply processes data streamed from perf and unwinds it in realtime. The unwinding overhead is surprisingly low: it only takes around 1% of (single) CPU per CPU profiled. Solving the disk waste alone has been a tremendous improvement of profiling experience. As a bonus, the unwinding and symbolization works reliably while I frequently had postprocessing not terminating when using the perf CLI directly.

It is… not? It simply invokes the unwinder / exception handler, like _Unwind_RaiseException. For normal exceptions, no signals are involved. You can get an idea of what is executed at http://stffrdhrn.github.io/software/toolchain/openrisc/2020/....

Serif mentioned on Twitter that the decision is partly driven by the absence of upgrading pricing options in third party app stores.

https://twitter.com/affinitybyserif/status/15903262690314649...

Rellic [1] implements an algorithm that generates goto-free control flows (citation in README), which would be a significant improvement against what Ghidra/IDA generates currently.

Unfortunately it looks like the maintenance state of the pieces around Rellic isn't very good, and it's quite rocket science to get it building. It doesn't have as much UI/GUI as Ghidra either so it's a bit far from accessible right now.

[1]: https://github.com/lifting-bits/rellic

> poor support for style libraries like tailwind

Can't relate. Tailwind works fine with anything that supports PostCSS. I run it with Vite and there's zero issues.

> the state management ecosystem is fractured between vuex and pinia

This is also just not true. Pinia is officially replacing Vuex as the recommended store library for Vue [1]. They're also vastly similar in how they do things, so the knowledge transfer over from Vuex to Pinia. And Pinia just address most of the design goals mentioned in the article in the most simple way.

As for Vue 2 -> 3 transition, lots of the larger UI frameworks in the ecosystem is struggling to migrate, despite lots of efforts on the compat layer to smooth the transition, which is a bummer. But as long as you're not doing those sophisticated things, Vue 2 examples should work out-of-box on Vue 3 as well. There are surely less resources for the composition API, but the official introduction guide has been good enough in my experience.

[1]: https://vuex.vuejs.org/#what-is-vuex

This should be (2013).

Carbon is absolutely amazing. They are using a very flat style in pursuit of a modern corporate brand, just like a lot of other tech companies today, but the design also incorporates a lot of traditional and familiar elements. It’s a rare instance of flat UI that does not feel mobile oriented and half assed on desktop.

Carbon components are also the most accessible component set I have seen, and they go through great lengths doing automated and manual accessibility testing.

The library though, is a bit lackluster. It’s tailored for IBM’s internal need, and is still a bit far from a complete framework. So you need to be prepared to write some CSS as well as designing your own components when you need one.

Funny that the subgrid example actually has a screenshot from a browser that doesn't support subgrid: https://github.com/GoogleChrome/web.dev/issues/7453

Well, that does say something about the dominance of Chrome...

Author here. Your understanding is right, and I meant that old congestion control algorithms was only using the information of packet losses.

Input lag has nothing to do with network ping.

Input lag is the time between you perform the action and the computer shows that on screen. It depends on your frame rate, refresh rate, and peripheral polling rate, as well as how good the game schedules things (which is what LatencyFleX tries to optimize).

Network ping on the other hand is often hidden away. Whether you are on 2ms ping or 100ms ping, the bullet always goes where you aim at: this is done through rollback netcode [1], which rewinds the server state to the time the action has been performed. I'm not saying that having low ping is pointless, it has an effect on things like peeker's advantage, but the effect of network ping is drastically different from the effect of input lag.

[1]: https://ki.infil.net/w02-netcode.html

I wondered what they have meant when they said "Provides especially clear text quality (via our text-specialized rendering methodology)".

Looking at their README [1], it looks to be texture filtering done a little more properly (many implementation cheaps out with bilinear interpolation, I guess). It does get rid of the aliasing artifacts, but it's still very blurry, and the look is a bit underwhelming.

What I really look forward to is getting text and vector rendering done directly in the perspective transformed space, something Pathfinder [2] has demonstrated before.

[1] https://github.com/SimulaVR/Simula#text-quality [2] https://blog.mozvr.com/pathfinder-a-first-look/

Vector graphics are much more complicated than raster images. They have to be drawn sequentially (to not mess up draw and blending order), mostly on CPU with the current software stack. And no, at 30MB you are looking at about 100000 paths, each of which consists of bezier curves which needs to be converted into polylines before drawing (there are algorithms that handles curves directly, but they are just as expensive). It's a vast amount of workload.

Images are relatively well handled with GPUs, and with a precomputed mipmap they can be rescaled very quickly, unlike vector graphics which needs to be re-rendered each time zoom level is changed.

Analog distortion of signals also affects the phase. A digital filter might or might not compensate for it, but it's not always bad.

Also, human ears tend to be more sensitive to amplitude than to the phase. Especially if the same filter is applied on both channels, which leaves the phase difference unchanged.

I don't get how they could get a chart that is so hilariously bad into a technical post. No numbers & no tick labels. It only shows that newer = better, which is pretty much obvious from the title.

Short, clear, and pragmatic. This is the kind of post I'd love to see every day.

Things like infinite scroll and autoplay should come with an option to turn them off and I think that’s well presented. Those are kind of dark patterns after All. Though, Apple probably isn’t in the position to enforce that; we unfortunately need to live with Jailbreak tweaks for them.

But the rest of the post feels so off. Constantly nagging yourself to close social media? Reminding yourself that social media is a waste of time by asking whether the time is “well spent”? No thanks. These are just dark patterns but flipped to the other side. I want control over what I do, not a random program deciding what I should do.

I also have never found Screen Time restrictions to be effective; either I unlock the restrictions by myself, or I just find other ways to waste the time. The reason people waste so much time with social media, I think, is because they simply don’t have anything else to do, or they’re not motivated enough to do what they should do.

I would be interested to know the comparison of the magic kernel to cardinal B-Splines [1]. The idea in the paper is that by combining an IIR filter with a traditional FIR/convolutional filter, you can get a much better sinc approximation, and preserve the high frequencies well. For those interested in this, many researches following that have been summed up into a book by Hugues Hoppe [2]. The book also includes some discussion of filters that are commonly used today like Lanczos.

Also, I'm not sure if I agree with this claim regarding partition of unity:

> This remarkable property, that prevents “beat” artifacts across a resized image, is not shared by any other practical kernel that I am aware of ...

Lanczos is surely a weird filter having many less than desirable properties, but IIRC cubic polynomial filters like Mitchell-Netravali and Catmull-Rom satisfies partition of unity, and both of them are popular in today's image processing. Even the bilinear filter, which can be box or triangle filter depending on whether one is minifying or magnifying, satisfies the partition of unity property. Did I get something wrong?

Edit: the bilinear filter actually does not satisfy partition of unity because it's scaled down, but a properly scaled box filter or triangle filter satisfies partition of unity.

[1] http://bigwww.epfl.ch/publications/blu9903.pdf [2] http://hhoppe.com/proj/filtering/

piet-gpu contributor here. You're right that supersampling is the easiest way to achieve AA. However, its scalability issues are immense: for 2D rendering it's typically recommended to use 32x for a decent quality AA, but as the cost of supersampling scales linearly (actually superlinearly due to memory/register pressure), it becomes more than a magnitude slower than the baseline. So if you want to do anything that is real-time (e.g. smooth page zoom without resorting to prerendered textures which becomes blurry), supersampling is mostly an unacceptable choice.

What is more practical is some form of adaptive supersampling: a lot of pixels are filled by only one path and don't require supersampling. There's also some more heuristics that can be used: one that I want to try out in piet-gpu is to exploit the fact that in 2D graphics, most pixels are only covered by at most two paths. So as a base line we can track only two values per pixel plus a coverage mask, then in rare occasions of three or more shapes overlapping, fall back to full supersampling. This should keep the cost amplification more under control.

Related: https://news.ycombinator.com/item?id=24636326

Linux has implemented hrtimer [1] a while ago and it can easily achieve sub-ms precision. You can just try some benchmark with nanosleep() on your system. It works in a similar way to the PIT you described, although I don't think it tries to offset the delay from interrupts.

What I want to say is that we already have precise timers usable on modern hardware; as for why Windows doesn't use that properly, I have no idea, but I can guess that's some technical debt in the scheduler.

[1] https://www.kernel.org/doc/ols/2006/ols2006v1-pages-333-346....

I appreciated the design of Outline, until I looked at their website and found that... it's a complete rip-off of Notion?

I've been using Notion for a while, and the commands/block mechanism has been bothering me the most. I don't think it's the way forward for WYSIWYG markup editors.

Safari and Firefox both have a blacklist of known trackers in addition to cookie blocking. Not only that, these browsers also fight against other means of fingerprinting.

I think the point is that the permission management is manual, not systematical.

This seems like typical minimalist design. Sure, it's not a bad concept at all, but there's nothing surprising here.

On the other hand, the excessive margins are making the page less functional as it should. The download section also lack emphasis, and given that using the same amount of space for all the distros/platforms that is not at all proportional to the amount of users using them, I would say that's a poor design.

I took a look at this user's GitHub activity, and it seems they have been using NewPipe daily. It's not trolling probably.

Citation needed. Almost all issue data should be available from the API, and I have seen cases where issue contents are copied over with a bot from an obsolete repo to a new repo.

It's the opposite: builds compiled from the source allows changing the flag, those builds from Mozilla have the option disabled.