georgelyon

Docker already uses many of these frameworks on macOS (look in Docker settings to confirm).

Sure, “very infrequently recurring” may be a more accurate label than “one time”

Given recent research into using WiFi to “see” through walls or at the very least track what humans are doing in a space, I would argue we should go in the opposite direction. I’m pretty happy with my current house and adversarial-to-WiFi cement walls. Sure, I had to run some cable and buy enough access points for about 3x the amount of square feet of my house (if you go by the advertised specs) but this is a one-time investment that is pretty small in the grand scheme of home-related things.

- FoundationDB's testing philosophy: https://www.youtube.com/watch?v=4fFDFbi3toc

- VSCode devcontainers: https://code.visualstudio.com/docs/devcontainers/containers

The great thing about FDB is that they have a testing infrastructure that is unlike any other database: https://m.youtube.com/watch?v=4fFDFbi3toc If there is a Swift compiler bug that causes data loss I will bet money they will catch it (I will also bet they will find at least one Swift compiler bug)

Also, Rust does not have C++ interoperability the way Swift does and instead requires a binding layer. Some projects are choosing to completely replace C++ with Rust, but there isn’t a good way for the two to coexist, or to incrementally transition a codebase.

On Mobile Safari: A problem repeatedly occurred on "https://hu.ma.ne/aipin".

I guess they really do hate smartphones…

It seems kind of wild that "installing some binaries on my system" requires these sorts of crazy workarounds like Launch Deamons. I'd personally love something like nix that would live nicely in a low-privilege folder somewhere in my user directory, just to install the few tools I need for a particular project. Currently I can achieve this with VSCode devcontainers and Docker low-privilege install. For system-wide tools I just download prebuilt binaries...

Just to clarify, Chris hasn’t been working at SiFive for about two years now (he’s working on a new startup called Modular). CIRCT itself has a number of larger companies invested in it, but it’s true that FIRRTL (CIRCT’s replacement compiler back end for Chisel) is predominantly a SiFive joint. I’m cautiously optimistic that there will still be significant investment in this piece of technology.

Companion Swift forums thread: https://forums.swift.org/t/video-swift-as-c-successor-in-fou...

I didn’t find any mention of Lockdown Mode in the article, which is advertised as something a user in this position could use to decrease their attack surface. I find it surprising journalists covering high-risk stories don’t just all have this on by default. A lot of these no-user-interaction exploits are via vulnerabilities in decoders for images and such that run when a message is received, unless the phone has Lockdown Mode enabled (LM also disables other types of functionality). Has anyone seen evidence of a phone with Lockdown Mode enabled being compromised (not saying it’s impossible, just curious)?

Something finetuned to toolform on Shortcuts would be pretty neat and likely could run on iPhones with acceptable performance.

FoundationDB is a truly one-of-a-kind bit of technology. Others have already linked to the testing methodology that allows them to run orders of magnitude more database hours in test than have run in production: https://www.youtube.com/watch?v=4fFDFbi3toc

A less known but also great talk is the follow which talked about what the a few of the team worked on next, effectively trying to generalize the methodology to any computer program: https://www.youtube.com/watch?v=fFSPwJFXVlw

I liken the approach to being able to fuzz the execution space of the program, not just the inputs.

I am a proud owner of a top hat and tails. I also enjoy a somewhat direct mechanism for giving money to artists I admire, and having an attractive physical artifact of that transaction is a plus. For the (ahem) record, not all vinyl purchases are a somewhat-direct-to-artist transaction (though those at the merch table of a small-to-medium sized show probably are).

It seems like the output of this model is masks, but for cropping you really need to be able to pull partial color out of certain pixels (for example, pulling a translucent object out from of a colored background). I tried the demo, and it fails pretty miserably on a vase. Anyone know of a model that can do this well?

Something fitting about this story being reported on yahoo.

I’m intrigued by this. I wonder how well it functions as an HN discussion forum… let’s try to hug it? https://wavelength.app/invite/FtKfkbGbbbc#r9ji5_g_IA7UV23et1...

The app has an “@AI” user which needs to be mentioned for the data to be shared. Chef’s kiss emoji from me in terms of transparency. Also, if you DM @AI it calls out that the message will be shared with OpenAI and Wavelength.

I’ve brought this up in another thread, but we already have evidence that in certain cases it is desirable to trade off specificity for just “getting something done”, that evidence is Python. Python succeeds despite not having a serious type system, because often times you can get something that achieves your goal despite the 25 bugs in your program that would have been caught by a real type system.

On the other side of the coin, there’s C++, which is usually doing the heavy lifting underneath the underspecified-but-sufficient Python code.

My guess is that as LLMs evolve, they will more naturally fill this niche and you will have high-level, underspecified “code” (prompts) that then glued together more formal libraries (like OpenAI’s plugins).

This is not strictly true anymore as the low-level (FIRRTL) compilation is powered by CIRCT (http://GitHub.com/llvm/circt) which is built using MLIR (part of the LLVM project: https://GitHub.com/llvm/llvm-project)

No, but you could build something that guesses the next step in a list of steps to access knowledge from an external source.

Does anyone have any context as to how the image understanding works? From what I can gather they are simply using separate text-summarization step to generate some text like "and now we have an image of chicken nuggets" that it then feeds to the text-only network, but I wouldn't be surprised if there is some dialog I'm missing between the previous context and the image understanding mechanism.

I've always been curious, what happens if they just let these shares just expire? It wouldn't look great for Stripe, but presumably they would just get back for free (modulo taxes) any shares employees could not afford to exercise. The value of those shares alone could be pretty enticing to the people in charge.

I've long desired form my AirPods to operate in a "play any sound from any of my devices" mode. This seems like a no-brainer and such phantom connections would as a result have no user-visible impact and you could do things like listen to music coming from your phone while hearing sounds from your MacBook.

One thing this doesn't cover is that while we've gotten much better at making cars and TVs, but haven't really gotten all that much better at building houses. In fact, we seem to have only gotten better at using with cheaper, worse materials to build houses in ways that the average housing consumer doesn't really understand and thus can't properly price.

Am I correct in understanding that this doesn't actually generate answers based on HN, but instead finds semantically-near comments and sends them verbatim to GPT to summarize? Seems like a good enough hack, though I'd love a detailed writeup of how to actually specialize an existing LLM with additional training data (like HN).

Python proves that there is a use case for a tool with imprecise semantics (no meaningful type system) even if that tool has terrible performance compared to other options (GIL). That use case is gluing together C++.

Hottest take? In 5-10 years, ML advances will result in Python being mostly replaced by LLM based “programming glue” systems. Much Python doesn’t need to be “correct” the way statically typed languages are correct, it only needs to be correct for the few things you ask it to do (i.e. train this particular NN). LLMs are similarly imprecise, but more powerful. We will move from a world of Python gluing together C++, to LLMs gluing together some hopefully-better language (I bet $10 on Swift). Main delay will be from getting LLM based solutions to run performantly-enough on developer hardware.

The way Swift handles this is that you can’t do anything that involves the self pointer before calling super.

You could take a look a swift-nio (https://github.com/apple/swift-nio) which is a pretty high-throughput system. swift-nio does this using some reference-counted GC where it simplifies the code and doesn't affect performance. Otherwise, value-types are used which incur no GC overhead (unless they are copy-on-write, and backed by something that requires reference counting).

While the overall point is valid, this isn’t strictly true. A Swift string is frequently backed by a contiguous UTC8 buffer terminated with a \0, so passing to C is just a matter of passing the pointer and requires no copies.