jjnoakes

But... does the whole page scroll at once, and can I tap and drag "between" two rows (slightly above one, slightly below the other) to scroll the whole page? Or does each row scroll independently, and only taps on the row scroll? I habitually don't tap on anything that looks like an icon if I want to scroll around, because I'm afraid I'll activate the icon in a poorly written program (or if I tap too lightly and it is picked up as a tap and not a hold and drag event). So visual cues as to what's scrollable makes it easier for folks like me to know where to tap to scroll things properly.

Last writer wins may be sufficient for some folks but for me, any potential data loss in an app like this is a deal breaker. I hope you'll consider some kind of merge conflict detection and surfacing that to the user. Even keeping a list of deleted items and showing that can be a good start.

The same way you know that your browser session secrets, bank account information, crypto private keys, and other sensitive information is never uploaded. That is to say, you don't, really - you have to partially trust Microsoft and partially rely on folks that do black-box testing, network analysis, decompilation, and other investigative techniques on closed-source software.

I view code in many contexts though - diffs in emails, code snippets on web pages, in github's web UI, there are countless ways in which I need to read a piece of code outside of my preferred editor. And it is nicer, in my opinion, to read languages that have visually distinct parts to them. I'm sure it is because I'm used to it, but it really makes it hard to switch to a language that looks so uniform and requires additional tools outside of my brain to take a look at it.

Safe pockets in ambient unsafety does have benefits though. For example, some code has a higher likelihood of containing undefined behavior (code that manipulates pointers and offsets directly, parsing code, code that deals with complex lifetimes and interconnected graphs, etc), so converting just that code to safe code would have a high ROI.

And once you get to the point where a large chunk of code is in safe pockets, any bugs that smell of undefined behavior only require you to look at the code outside of the safe pockets, which hopefully decreases over time.

There are also studies that show that newly written code tends to have more undefined behavior due to its age, so writing new code in safe pockets has a lot of benefit there too.

An article like this would be better if it didn't gloss over the different bash startup files and when they get loaded.

Many times when I help someone debug their shell, the root cause is not understanding what each of those files is for.

Adding an echo to the wrong one and not having it check if the shell is interactive can break all sorts of things like scp for example. And in weird and non-obvious ways.

I like digital board games for quick setup and cleanup too. It lets us play more games in a session.

If someone is locked out of their password vault, they are likely also locked out of their email...

Fill-in-the-middle. If your cursor is in the middle of a file instead of at the end, then the LLM will consider text after the cursor in addition to the text before the cursor. Some LLMs can only look before the cursor; for coding,.ones that can FIM work better (for me at least).

I use fly.io. I pre-paid for credits and if they run out, things shut down.

No affiliation, just happy to use a provider with actual caps.

I take a slightly different approach - I usually have AI assist in writing a script that does the task I want to do, instead of AI doing the task directly. I find it is much easier for me to verify the script does what I want and then run it myself to get guaranteed good output, vs verifying the AI output if it did the task directly.

I mean if I'm going to proof-read the full task output from the AI, I might as well do the task by hand... but proof-reading a script is much quicker and easier.

I'm pretty sure all of the common areas in HOAs that I used to live in were equally owned by all members.

> Security: Compiler binaries can contain malware and backdoors that insert viruses into programs they compile. Malicious code in a compiler can even recognize its own source code and propagate itself. Recompiling a compiler with itself therefore does not eliminate the threat. The only compiler that can truly be trusted is one that you've bootstrapped from scratch.

It is a laudable goal, but without using from-scratch hardware and either running the bootstrap on bare metal or on a from-scratch OS, I think "truly be trusted" isn't quite reachable with an approach that only handles user-space program execution.

Memory safety and the borrow checker are useful even in the absence of dynamic memory allocation. This still doesn't bring rust and ada to the same place, but it is important to clarify that piece.

I have a self-imposed goal of not using third-party libraries for any of the solve logic. It feels more satisfying to do it myself, even if it takes longer.