kune

I support this. I wrote a Sqlite plugin for KSUIDs, but at the end I never used them, since all I do can be handled by integer primary keys, which sqlite maps to the rowid automatically. Autoincrement is only required, if you want to prevent the reuse of ids in deleted rows.

They had a comparable problem in europe-west9 in 2023. Apparently they actually run into trouble if they lose a whole zone through a physical event. It's either thundering herd or simply insufficient capacity in the other two zones to take over all the load from the third zone.

Imagine that would be a biotech startup, experimenting with viruses. I'm pretty sure they would have already been shutdown. If you are not able to implement proper sandboxes and airgaps, you cannot be trusted with AI agents.

In Go you would methods for that: my_list.Clear(), my_queue.Clear() and my_map.Clear(). Now you can define a Clearer interface, which has only the Clear method. That allows you to write a function clearAndLog(item Clearer) and it will work with the list, queue and map.

Humboldt University Berlin had officially licensed a UNIX System III as a research institute. They run it on a K1600 series Robotron system, which was a PDP-11 clone. I had a few sessions on it ca. 1985 as a 16-year old kid as a member of the Mathematical Student Society of Humboldt University.

I remember being challenged to learn about the file system. All I was told was, use the man command. I knew CP/M, or better the East-German clone SCP, but that OS didn't know directories. I had to learn the concept from the man pages. There were no UNIX books in libraries or book stores. But it was fun, I managed to write a simple compression program doing run-length encoding on that system.

Theoretically you can use channels to simulate a mutex, but I agree with you there are use cases where a mutex makes more sense. They are even used in the standard library, for instance to implement sync.Once.

But generally I would agree that if you need to code parallel execution, channels are a good way to do it, because you can avoid race conditions if you share data only over channels. The biggest problem is that a lot of people don't understand, that channels with a buffer larger than 1 are a sign of problems in the architecture.

There is a type of parallel programming with workers for specific functions, that always leads to performance issues. The problem is you need to right-guess the distribution of work, when you have to define the amount of workers for a specific function. At least one go routine for one request is a much better approach than function-specific workers.

The RST (Reset) is sent to inform the client that the data it sent was not read by the server. The RST avoids here the 4-way handshake for the TCP connection closure and the long wait times, if the client doesn't behave normal.

For the case here the server should call shutdown with SHUT_WR after sending the data and then drain the incoming data before closing the socket.

The interesting aspect of the Cloudflare support, which is not clarified, is how they came to the risk assessment that it is ok to roll out a change non-gradual globally without testing the procedure first. The only justification I can see is that the React/Next.js remote command execution vulnerabilities are actively exploited. But if this is the case they should say so.

This thing crashes on Ubuntu LTS 24.04 during start. Apparently all these agents are not able to ensure that a desktop app starts on a popular Linux distribution.

If Google has forgotten how to do Software, than the future doesn't look bright.

In my org nobody has admin rights with the exception of emergencies, but we are ending up with a directory full of Github workflows and nobody knows, which of them are currently supposed to work.

Nothing beats people knowing what they are doing and cleaning up behind them.

Palm2 tells me that it is most powerful LLM in the world, but it isn't Gemini yet. LOL! I don't need AIs that are parroting marketing crap.

The statement "An interface type A is assignable to interface type B if A’s methods are a subset of B’s." is wrong. It is not in the current language specification of Go. The author misunderstood the term type set from the Go language specification. The type set of an interface is the set of types implementing the interface and not the set of methods of an interface. If you use the right meaning of type set, the subset makes sense again.