eddd-ddde

Personally, any of the flash options is my default most times because it tends to perform tasks faster and with the same level of success.

Do people actually rely on their chat groups as a knowledge base? If tomorrow I come to work and all my chats are wiped I wouldn't even budge .

I see chats purely as an ephemeral way of coordination.

I think the terms are usability Vs usefulness.

Effort is not a good signal for value. Never has been. Just because someone took 10 more hours to finish a task doesn't mean they did a better job or they care more about the result.

Not sure why this is down voted.

You cannot support FOSS and then get mad when people use those freedoms to create a service that matches their ideas and philosophies.

For what reason would grammar influence whether something is true or not...

Zig is always _less_ robust than rust. Even if you have a single allocation you can always forget to free it.

Ideally websites just respect the existing media queries so you don't even have to switch!

Because making segfaults impossible is simply a better solution to playing a game of whack a mole of "crash, root cause, fix and add test for that very specific bug"?

Your macros are not implementing features, fixing bugs, and writing test cases.

This is very similar to my recent experience!

LLMs are surprisingly effective at helping you learn the "vibes" of making music and understanding various concepts.

I can run away from a knife holding psycho or fight back, a drone can fly into my bedroom. Same argument for guns really.

My flow state with AI is having 5 different conversations at the same time making good progress on all of them by giving key insight and feedback at the right times.

You can actually go super fast with the right setup and focusing only on the important details like ensuring the shape of the APIs make sense and that test quality is good.

The main benefits you get are transformations. You can leverage tooling to automate include remapping and things like that.

But it's definitely not geared towards forks, but rather mirrors with deterministic and invertible transforms.

The "supported" workflow is you keep your source of truth in either the monorepo or the external repo. Then you export the current state of the source of truth to keep the mirrors up to date. Then, since we can assume the mirrors are up to date, the inverse transform can be applied to import change requests from the mirrors.

It works well when the assumptions hold, that there isn't large divergence on either side. It can actually be largely automated.

It's a good day to work in a monorepo :)

My favorite:

> This report was reviewed by Legal, who have asked us to clarify that the fox was depicted as over eighteen.

> I like being able to memorise IP addresses, it really helps testing.

This is even easier with IPv6. At work we have a bunch of test devices, and you calculate the IPv6 from the device's serial number. Simple as that, no memorization at all.

I don't think these kind of features belong in a compiler. If you want a stamp then pass it in to your compiler invocation via explicit defines.

You might accidentally end up including it transitively and suddenly your binary is nondeterministic.

So? That's literally how language works. The importance is not in the writing style, but in the content of the words.

What about battery life? I bought a cheap Chinese MP3 player online and it works wonders. I use it with some regular wired headphones as well.

The internal version at least is heavily based on a global commit cloud.

If you give me your commit ID I can immediately print it on my workspace without you having to upload a formal change request.

But parent is right, you have to cast it anyways before reading from it, so might as well take the right type from the beginning.

What about "go see an agent in person and use your fingerprint to prove it is you"?

That's still orders of magnitude more complexity for no real benefit. A migration from sqlite to postgres, if really required, is not that hard.

It's more like comparing assembly against the same program but with comments.

The pattern I notice more frequently at work now is:

"I'm working on X problem, I tried Y solution, AI thinks Z is wrong and W could be better, human opinion?"

This way there's never space for ambiguity, you showed you did your homework to the best of your extent, you already asked AI, all that's left is explicit request for human input.

It works quite well, and I appreciate it from both ends, as it saves everyone time.

This is obviously massively understating what an IDE does.

Do you never use language server features? Showing git blame on files? Doing regex search and replace? Doing multi-cursor editing? Run test?

If you genuinely never do, then that's ok, you don't need an IDE.

I actually think these constraints _help_ the average project as well. By enforcing remote builds and execution you completely remove the need for something like docker. You also get cloud backups for your code automatically.

This is not a complete answer.

There are many open source projects that are developed in google3.