procaryote

What kind of scalability issues have you had with git?

Is it because of a monorepo?

The most frustrating thing with the "Atomic architecture" bit with tiny packages is how obviously stupid it is. Any borderline sane person should look at isOdd/isEven and see that it's an awful idea

Instead they've elevated it to a cultural pillar and think they've come up with a great innovation. It's like talking to antivaxers

That will be after it broke, which costs money

Also: no

Bose QuietComfort Ultra 2 at least just allows varying levels of passthrough. You can have noise cancelling or noise cancelling + sound from the outside mike. You cannot have noise-cancelling off for better battery life or to cope with windy conditions

They're awful in several other ways too, which is sad for what should be their flagship model

every headphone and phone had a 3.5mm connection, why did phone manufacturers fuck it up?

Headphone jacks.

Sony experia, Asus zenphone, Motorola Moto G, and a few others

They're rare nowadays, but they're inherently superior when it comes to audio just working

This is why I use wired for longer calls or video conferences. I've tried so many wireless in-ear things and all of them are more sensitive to surrounding noise and I have to repeat myself more due to dropouts or spotty quality.

It's just much harder to get good sound quality when the mikes are by your ear rather than on a wire near your mouth

Not to mention that it completely removes the risk of running low on headphone battery mid-call

The options were never ASCII or unicode though. Before unicode we had ASCII + lots of different incompatible encodings that relied on metadata to be properly rendered. That's what unicode fixed

Besides I like being able to put things like →, €, ∞ or ∆ into text. With ascii a lot of things that are nowadays trivial would need markup languages

Adding lots of code for the common case to support consumers of the code not recompiling for some uncommon potential future corner-cases seems like a bad deal.

Recompiling isn't that hard usually.

Yeah, I feel singletons are mostly a result of people learning globals are bad and wanting to pretend their global isn't a global.

A bit like how java people insisted on making naive getFoo() and setFoo() to pretend that was different from making foo public

It was a mess back then though. Unicode fixed that.

You're still relying on sites fulfilling what they promise in a world where facebook has been blatantly violating gdpr from day one and enforcement just isn't happening

Set your browser to block 3rd party cookies, add privacy badger and ublock origin. It will have more effect than clicking "reject"

I click "don't send me mail" every time I buy something. Every place I buy from still sends me spam at some point. There are no negative repercussions for them beyond whatever infinitessimal thing me clicking the "report as spam" button does

This is a useful tip!

but also... who has a dir with 777 permissions? Is that something people do nowadays?

check further down this discussion for immediately downvoted comments

https://news.ycombinator.com/item?id=47191837 https://news.ycombinator.com/item?id=47191619

Post anything negative about rust, or anything about a severe bug in some non-rust code, for examples of your own

I have nothing against rust, although the learning curve is too steep and development in rust is too slow to be a practical general purpose language for a regular company.

The culture around dependencies also means you pay for your memory safety by increased supply chain risk.

Golang or Java gets you memory safety, faster compilation, easy hiring and have better standard libraries

> You may have never written a memory bug in your life, but I have, and that renders me completely incompetent.

This feels overly binary. Memory management bugs is just one class of bugs, and there have been many other bugs leading to security issues or defects.

If you apply the standard "has ever written a bug" → "completely incompetent" you will have to stop using software, and if you think about it most other technology too

Memory safety is a very useful trait for a language though, and as you say provided by a whole bunch of different languages nowadays

Arguably, calling it a key while insisting it's a non-sensitive ID was a mistake to start with

Changing the semantics of existing non-key keys, making them actually keys is horrendous

> Because walking away from it all isn't the right answer. Why? Because we leave behind all those people addicted to it.

Don't start drinking or smoking, because with this logic you'll have a really hard time quitting

Hydrogen ions are edible, although usually dissolved in water. Hydrogen ions existed before oxygen or water

It's a staple food in some cultures. It needs preprocessing, but people have been doing that for a while

You can build a mergetool (https://git-scm.com/docs/git-mergetool)

One fundamental deal-breaking problem with structure aware version control is that your vcs now needs to know all the versions of all the languages you're writing in. It gets non-trivial fast.

Markdown is readable as plain text, that's kind of the point of it

There's also a pretty large jump between "I can ask the system to open this link in the default browser" and "I have built my own link handling in a memory-unsafe language to support some really fringe features, and oops it's exploitable"

And even if they reserved a core, that would be a waste of a perfectly good core

Second gen butterfly keyboard broke a lot too. And then there was the no-esc touch bar, and the removal of inverted-T arrow keys... It took a few years of no good mac laptops before they backpedalled enough to get back to where they started

I wanted to love berkeley db; it was available everywhere, seemed simple, was fast when tested. In practice it never worked well though, with pretty frequent corruption under load, and license confusion from oracle. It has a lot of features you're never going to use, and if you try, you'll be disappointed

There's no shortage of embeddable key-value stores with C bindings like leveldb, rocksdb, or even gdbm, and all of them have worked better for me.

A lower tech version would be to pick a very long recovery passphrase, cut it in two or three and give it to two or three friends. It doesn't give you N out of M, but it will be good enough for a lot of real world scenarios

OVH is awful. The UI is slow and buggy, operations often fail and you need slow contact with support.

Worse, closing an OVH account is very hard. Every domain you host there they sign you up to several services, and you need to manually disable each one before they let you close the account. This then often gets stuck, because of the broken UI, and you end up needing to badger support over and over until they'll fix it

Never again

An AR-glass assistant is very different from the metaverse Zuck blew tens of billions on, which was a shittier version of Second Life in VR, with a side of blockchain

He wasn't early with a good thing; he was unfathomably disconnected from reality with a bad thing

Even if the code might not end up requiring it, if you write it with the assumption that bytes are 8 bits, it's good to document that with a static assert so someone porting things knows there will be dragons

It's a pretty neat way to drop some corner cases from your mental load without building subtle traps

Arguably, 1993's C has survived better than 1993's C++.