sgammon

people have catalogued and tracked physical items for centuries without issue; a 1TB SD card is now $75 and can store perhaps a year worth of photos

convenience is nearly always a tradeoff with security

> an authenticator code is NOT a 2nd factor, if that user is using Google Authenticator.

it is still a second factor, because it is something you have instead of something you know; it's just that you converted it to something you know when you read it and transmitted it to someone else

all that being said, yeah, legal@google.com (as a homograph attack) should probably be blocked.

why were you synchronizing your 2fa codes? that requires opt in, even in the form of a signed in google account combined with google authenticator as a choice of 2FA code storage

why were your coins not in a cold wallet? that is how you stop this permanently

why did you acknowledge any kind of inbound communication? ignore it. always. or call outbound to a confirmed number to make sure.

btw you were scammed out of $80k, as you admit in your article, the headline is misleading for seemingly no reason except the larger number

thats great matt. i still wont ever use wordpress because of your choices

of course one can simply monkey patch `toString`, or provide a symbol such that an object stringifies to that value, but sure

> Contrast this behavior against message types. While scalar fields are dumb, the behavior for message fields is outright insane.

The reason messages are initialized is that you can easily set a deep property path:

```

message SomeY { string example = 1; }

message SomeX { SomeY y = 1; }

```

later, in java:

```

SomeX some = SomeX.newBuilder();

some.getY().setExample("hello"); // does not produce npe

```

in kotlin this syntax makes even more sense:

```

some {

  y.example = "hello". // does not produce npe

}

```

> It’s impossible to differentiate a field that was missing in a protobuffer from one that was assigned to the default value.

This is purportedly fixed in proto3 and latest SDK copies (IIRC)

> Your guess is as good as mine for why an enum can’t be used as a map key.

I filed an issue requesting this and it was denied with an explanation:

https://github.com/protocolbuffers/protobuf/issues/7791#issu...

yeah it says that in the docs

This is great, but you should post it to: https://github.com/oracle/graalvm-reachability-metadata

... as a PR, so that, when merged, other users can pull it into their build automatically, merely by looking up from the relevant dependency's maven coordinates.

You can also ship this metadata as part of the library artifact itself[1], by placing configurations at the JAR resource path `META-INF/native-image/<group-id>/<artifact-id>/reachability-metadata.json`, etc

[1]: https://www.graalvm.org/latest/reference-manual/native-image...

swing, and miss

Removing the button from the DOM after click is maybe the worst advice I’ve ever heard for web UX

Your point about URL encoding defeats your own other point about these characters being safely parsable as surrounding delimiters

Cool, thanks! I'd like to try it

Bun uses JSC from Apple, not Spidermonkey.

The application for the copyright predates GraalJs.

Hey LMCache team! Saw you guys at OSS N.A. but wasn’t able to set aside time to say hello. We’d love to chat about collaborating. Is there an email we can reach out to?

Sometimes people are just talking. There's no deliberate attempt to mislead built inherently into saying you "dropped a new feature."

In other words, "Tell HN poster: No, and, by the way, language is not yours to control"

Slang is the free expression of thought and no, there are no rules, and no, nothing is sacred. That is the only way language works while avoiding dehumanization for the people employing it to express themselves.

Pay it forward!

one of the best talks of all time, and absolutely a part of who I am now as a person. Bret Victor is a hero.

however it does look like the link has a mid-video timestamp, may want to fix, the intro is too good to miss.

I guess it’s worse than I realized. They are using result counts, not activity.

There is a generation of graphics cards under the name "Ada." For example: https://www.bhphotovideo.com/c/product/1811918-REG/nvidia_90...

I believe TIOBE counts by search activity for a given token. I.e. large search volume of the token "Ada" would show up in TIOBE, whether it is for the line of graphics cards from NVIDIA or the programming language.

> The underlying Elide tool looks amazing

Thank you!

> Does the Kotlin compiler support plugins, e.g. serialization?

We don't support Kotlin Serialization yet, but KotlinX is fully embedded and ready. You can reach for things like KotlinX Coroutines without installing a single JAR.

Bring-and-use-your-own-plugins might be challenging, yeah, but we plan to at least build in the KotlinX plugins you would want by default (serialization included). So thank you for this note, it's helpful and I'll add a notch next to that feature :)

Benchmarking a toy case (hello world) shows a 20x performance difference; this is true for both kotlinc and javac, when benchmarked through hyperfine. YMMV, but benchmarks of different build styles show native converging with JIT at about 10k classes[1]

So, if your project is 10k classes or less, you are looking at "up to" a 20x improvement in compile time vs. stock javac.

On the dependency fetching side, we haven't benchmarked yet. It definitely feels like 100x+ though on a wall-clock basis.

[1]: https://github.com/simonis/LeydenVsGraalNative

Not yet, but we are working on a Maven plugin :) if you join our Discord or file an issue, I can update you when its out.

Elide is licensed under MIT https://github.com/elide-dev/elide

There are some JARs we must commit to source because they are built with patches from upstream GraalVM components. That's probably the big weight there.

We have an issue in our repo tracking those upstream PRs. Once merged, we won't need to do this anymore. We should probably publish them in our own Maven repo to avoid this kind of experience. Thanks for the push to take care of that cruft :P

You can find them in `third_party/oracle`. You also don't need to build from source -- Elide ships as a binary for Linux amd64/macOS arm64. You are totally welcome to though, and if you encounter issues, hop in our discord and we'd be glad to help: https://elide.dev/discord

Elide's resolver is just Maven's, and we use Maven's own components to read poms. Native-imaging Gradle itself is really challenging because Gradle relies so much on reflection, and really is architected to account for the JIT case (i.e. emphases on the daemon).

I haven't found a way to do it yet so this plugin is the best alternative so far.