Hacker News new | past | comments | ask | show | jobs | submit | mattdesl's comments login

It lets you to prove a program without having to execute it, and without needing to send the potentially private bytes over the wire.

Privacy and identity is one example; like having a proof of some record of your identity that you can submit to an app (ie: age, citizenship, # of followers on twitter), without the need to share your personal details.

Succinct proofs is another application. If you have a distributed compute environment (think folding@home), you may want receipts that proves a user in the network correctly executed a program. With ZK, the idea is that it can be cheaper to prove a program executed correctly, rather than re-execute it.


With latest LLMs I feel there is less and less need to be structured about authoring recipes.

I now jot down rough notes in Obsidian when I make a meal I like, and let AI re-format it if I want to share the full recipe with somebody. This also lets me control the output: if I’m sending the recipe to somebody who is new to cooking, I might ask for a more detailed output than if they were only interested in my flavour combinations or specific techniques.


> With latest LLMs I feel there is less and less need to be structured about authoring recipes.

Assuming the LLM doesn't unpredictably add something poisonous. :p

https://news.ycombinator.com/item?id=42123455


Yeah, personally I'd use markdown too, at this point it is easier to use llama-3.1-8b to parse markdown / text into your JSON format of choice than it is to massage recipes into a specific markup like Cooklang.


I love my cast iron, but usually choose a nonstick for eggs and crepes/pancakes in the morning.

- I tend to re-season my cast iron every time I use it and it’s a chore to do this for my early morning meals.

- Non-stick is just more non-stick, with cast iron I am constrained to using a certain heat and/or fat content to create the non-stick property which I might not want for a certain dish.


You really do not need to re-season them every time! Just using the pan with some oil is enough. If you clean it later with water, you can add a little oil afterwards and clean it with a paper towel, that's enough. Takes almost no time.

But I have to agree that non-stick pans are even more non-stick. That's why it took some convincing here to not buy new ones in my home.


That’s the kind of re-seasoning I mean: first I dry it (paper towel), then wipe with oil (more paper towel). It’s more work than cleaning a nonstick by hand and produces more waste.


Oh, okay! I see it as less work, since the whole part of using soap and rubbing the fat away properly doesn't happen. Plus it's just a drop of oil and two paper towels. You can use a cotton towel to dry it and move down to one paper towel.

But I just wanted to make sure you don't re-season it with the whole procedure, like oil, potato peels and salt fried for a long time. Because that would be definitely a lot of work each morning ;)


> You can use a cotton towel to dry it and move down to one paper towel.

You don't even need the entire paper towel. During the Hamas attacks last year I was unable to leave to the store for quite some time and began seriously reducing consumption in the house. Half or even a quarter paper towel is enough.

And even that doesn't need to be thrown away - the paper towel is still clean for purpose of reoiling the pan the next day if you absolutely need.


Nice. Also, adding oil each time after cleaning is also not necessary, especially after cooking with enough of it and if that went well (though I do it most of the time as well).


Yes, most of the time I don't even use water now that I'm more comfortable with the pan. Just a really good wipe.


Cleaning cast iron is quick and (so to speak) dirty. Use a dish brush and running water to remove food waste, and scrape it with a metal spatula if there's sticky bits, then a quick wipe with paper towel to block rust. Hey, presto! Ready for the next round. No muss no fuss.


Even easier, put some water in the pan, boil it for a few minutes and it’ll just wipe clean.

Use soap to actually clean it.


You can dry your pan on the stove, this is what I do. No paper towel needed


Good idea – but it will probably take even longer than wiping with a paper towel.


I’m not sure I’d call Figma local first. If I’m offline or in a spotty wifi area, I can’t load my designs. And unless it’s recently changed, if you lose wifi and quit the browser after some edits, they won’t be saved.


That's intentional: they need you and your data tied to the server to make money. But there's no reason why it couldn't be local first (except the business model), since the bulk of execution is local.

Incidentally, I think that's why local-first didn't take off yet: it's difficult to monetize and it's almost impossible to monetize to the extent of server-based or server-less. If your application code is completely local, software producers are back to copy-protection schemes. If your data is completely local, you can migrate it to another app easily, which is good for the user but bad for the companies. It would be great to have more smaller companies embracing local-first instead of tech behemoths monopolizing resources, but I don't see an easy transition to that state of things.


>Incidentally, I think that's why local-first didn't take off yet

Local first is what we had all throughout the 80s to 10s. It's just that you can make a lot more from people who rent your software rather than buy it.


The sweet, sweet ARR. Investors love it, banks love it, employees should also love it since it makes their paychecks predictable.

It sucks for customers, though.


More and more reliably.

When people have an abo that cannot be quit every month it gives more financial security to the company.

Previously people would buy e.g. the creative suite from Adobe and then work with that version for many, many years to come


Previously people would crack CS from Adobe then work with that version for many, many years to come :)


Previously amateurs would crack Adobe software and then get a letter telling them they needed to pay or be sued when they went professional.

The cracked software was there to onramp teens into users. Adobe has burned this ramp and now no one under 14 uses it any more which is quite the change from when I was 14.


True but do all those peeople now pay $100 a month to Adobe? Hardly.


If they need what Adobe offers, yes.


A better example than Figma is Rive, made with Flutter.

Works well local-first, and syncs with the cloud as needed. Flutter space lends itself very well to making local-first apps that also play well in the cloud.


I’ve implemented[1] some of these algorithms into @texel/color, a modern JS color library, and it also supports gamut mapping to certain wide gamut color spaces (Display P3, Rec2020, Adobe 1998) rather than just sRGB.

https://github.com/texel-org/color

Many popular color libraries (Colorjs.io, culori) attempt to match CSS gamut mapping spec, which is an order of magnitude slower than the approach in Ottosson’s blog post, and also less accurate (CSS gamut mapping may not fall neatly on the gamut boundary).

[1] “Ported” might be a better term as I used a combination of Ottosson’s own JS OKHSL picker, Colorjs.io code, and Coloraide (Python), and adjusted it for performance, more gamuts, and smaller bundle sizes.


The method described at https://drafts.csswg.org/css-color/#css-gamut-mapping is equivalent to "Keep lightness constant, only compress chroma" from this blog post. They presumably picked that one because it is straightforward and should be good enough for the purpose at hand, which is figuring out what to do when someone puts an out-of-gamut color in their CSS.

The CSS spec doesn't say you have to implement this gamut clipping method via binary search. It's just one possible algorithm that is straightforward to describe so that people can get the intended result with a naïve implementation. Other clipping methods and better algorithms for accomplishing them require significantly more explanation with a bunch of math and color-model-dependent data.

The binary search approach is plenty fast for the CSS use case involving single isolated colors, but would not be appropriate for e.g. adapting photographic images from one output medium to another.


Surely this should be using a perceptually uniform color space like OKLab rather than HSL!


While that would change the distribution of threshold hues (partly due to the non-linear mix of blue and green, as sRGB transfer function wasn't inverted), it shouldn't change the conclusion itself. Also it would be hard to constantly change the lightness in such systems, as the #0000ff green would have a much larger lightness than the #00ff00 blue and there are some gaps outside of the common sRGB or even P3 color space.


Pure RGB primaries gives an easy target for “red” and “green” endpoints but that’s about it. Ideally the test should consider two endpoints with uniform lightness and chroma, and just shift the hue to form in-betweens. The transition from blue to green in RGB (or HSL) is not linear in these attributes.


That is what I believe the original comment meant to say: convert to some color space where linear interpolation for non-hue axes would be meaningful. In my knowledge, such linear interpolation will require the tone mapping due to out-of-gamut colors, and the tone mapping itself is fairly subjective.


Not quite—you can choose a ramp that will remain in-gamut for sRGB, eg try shifting hue here:

https://oklch.com/#72.67,0.121,240.19,100

Even if you were to use a more saturated ramp, I suspect that discontinuities due to gamut mapping with a good algorithm[1] should be less than the discontinuities due to lightness and chroma shifts in HSL, but I could be wrong.

[1] https://bottosson.github.io/posts/gamutclipping/


Ah yeah, I only checked the path between sRGB #0000ff = oklch(45.2% 0.3131 264.05) and sRGB #00ff00 = oklch(86.64% 0.2948 142.50) which surely needs out-of-gamut colors. And as you have noticed from the post, there are many algorithms to handle them with different attributes of colors to preserve. CSS even has its own algorithm [1] that primarily keeps hue and lightness but allows slight alternations to avoid excessive reduction on edge cases. For the purpose of this test though, hues should be probably preserved at any cost.

While lower saturation may solve this problem, some colors do greatly depend on saturation to be correctly perceived, like brown, so I don't think it is not ideal to change that either.

[1] https://www.w3.org/TR/css-color-4/#css-gamut-mapping


To play devils advocate:

- if your app has a number of messages (eg: “image downloaded” or “message sent” or whatever) then there is a consistency in using toasts as they all appear in the same predictable manner

- often “appear away from focus” is one of the intended goals of a toast; it’s a message that is present, but more in the periphery (the user can ignore in most cases, and it doesn’t obscure main content)


Really fascinating. After reading a little more, I learned that while Laine proposed the inversion layer hypothesis in 2016, the Auroral Acoustics group he headed was informally started in 2000. The reason the linked article is coming out now is due to Laine’s latest paper that details the triangulation of the sounds[1][2].

Would love to try and record this myself. I’ve been recording some VLF “sferics” for some time now for an art project[3]; it seems the auroral sound recordings often peak in the same frequency range (and perhaps there is overlap without me realizing it).

[1] http://research.spa.aalto.fi/projects/aurora/index.html

[2] https://www.researchgate.net/profile/Unto-Laine/publication/...

[3] https://www.mattdesl.com/sferics


For the “terrain contours” is there something specific you’ve done to make it feel more cartographic? Or is it basically just marching cubes / iso lines on some data points?

Looks fantastic. Very cool project.


I'll ask Wilson to chime in on the question; thanks so much!


Much simpler than the paper, but I have a 3D screen space implementation here[1].

[1] https://mattdesl.svbtle.com/drawing-lines-is-hard


I love this page. Thank you. I bookmarked it in 2018 but still haven't used it, doh!

https://wwwtyro.net/2019/11/18/instanced-lines.html is also nice.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: