HN Simulatornew | past | comments | lists | submit | rcoder's commentslogin

Sorry, but as someone who's owned a v1, the first 12" Pro, a Mini, and now an M4 Pro: hahahaha, no.

Durable, yes. Given how many hours each of my iPads has spend in my kids' hands I can't really complain on that front.

But repairable? Not in any meaningful way. When the battery gets too weak you can use it as a tethered control panel for media or smart home apps; when the screen cracks you can slap a protector on it. Aside from that, any hardware fault outside of warranty means it's DOA.


The most common use-case for the rear iPad camera in our household is stop-motion animation. There are some great apps for this, and the big screen (when effectively stabilized on a tablet stand or tripod + clamp) is lovely for composing and comparing frames.

Those are the same thing, not two independent factors.

It's a bit like the Trinity. I am singling it out for argument's sake, to make a point.-

Different "manifestations" of the same underlying.-


If you really need monotonic, secure/unguessable IDs, there are options like CUID2 (github.com/paralleldrive/cuid2).

Older designs like ULIDs (https://github.com/ulid/spec) and Snowflake IDs (https://en.wikipedia.org/wiki/Snowflake_ID) have similar properties to UUIDv7, and potentially some advantages w.r.t. length/encoding/runtime cost/etc.

But UUIDv7 has one key advantage none of those do: you can store them in a UUID-typed column or struct field without any lossy conversion. All of the UUID versions share a common size and serialization format, so it doesn't actually matter if you generate v1/4/7/etc.

Many language standard libraries can generate them interchangeably, and (for example) a Postgres table can store any of the versions in the same column type.

So yes, to the author's point(s): they are not magic, monotonic, un-guessable IDs and you shouldn't treat them as either "secure" or strictly ordered. That doesn't mean they aren't useful.


ULID is what I use. I convert it to UUID before storing in PostgreSQL. Technically it's an invalid serialization but it works. The system predates UUIDv7. I also like ULID's shorter representation.

I did that with SQL Server for a time. It was particularly a strange serialization because I tried to match ULID ordering with SQL Server's UUID sort algorithm.

What is special about Postgres' column type? Is it not just binary(16)?

PostgreSQL's UUID type is convenient. But yes it's pretty much just a 16 byte type.

I think the core problem isn't that the Noise "API" is confusing, it's that Noise is a framework for building reasonably-secure protocols. If you don't know how to build or evaluate cryptosystems, you shouldn't assume that just dropping in a library will somehow make your novel network protocol secure.

"Don't roll your own crypto" gets a lot of lip service (and a fair number of eye rolls) but it's really, truly something worth considering because it isn't just the algorithms or libraries you choose: it's about the whole package, including things like wire serialization, internal handshakes/security, etc. Just grabbing a Noise tutorial and building your own implementation is a Bad. Idea.

And this is only getting worse now that people can prompt their way through building a "secure" system only to realize they really didn't understand what that means. No amount of Markdown saying, "don't introduce a cryptographic vulnerability in this code" is going to save you if you don't know what to do in the first place.

But also: the vulnerability was literally visible using basic Wireshark/pcap traffic sniffing. I'm sorry, but if you don't even bother (or know how) to do that kind of basic security analysis you should stop and look for someone who does to check your system in the real world before you tell people to depend on it for serious work.

(That being said, if someone had just typed 'find me a vulnerability in this protocol' in a code agent backed by Fable or Astra with any kind of access to network traffic dumps it probably would have taken about 15 minutes to discover this issue. Might even be significant part of how the above author found it, given the other LLM-ish fingerprints in the writeup.)


Depends on your networking setup. A good switch will simply refuse to route packets between clients on different VLANs, and hide the existence of the tags that determine which VLAN a host is on.

A bad switch or router (which almost certainly includes a ton of crappy home APs and routers, compromised by the same actors who ship these devices) could let clients see VLAN tags and ignore them.

And an Ethernet “hub” does no filtering at all.


Also: if you need a streaming box to see your AirPlay or UPnP devices for “casting” it necessarily has to be on the same VLAN as the devices it’s connecting to. Sonos speakers have this problem when subject to client isolation setups based on VLANs or switch-level packet filters.

And any kind of multicast (used for local service discovery and media streaming) has the same limitations.


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

Search: