To me 16 is long haha.

I usually end up running with 16 characters since a lot of services reject longer than 20 and as a programmer I just like it when things are a power of two. Back in the Dark Times of remembering passwords my longest was 13 characters so when I started using a password manager setting them that long felt wild to me.

I do have my bank accounts under a 64 character password purely because monkey brain like seeing big security rating in keepass. Entropy go brrrrrrrrrrrr

I’ve used cloud based services for password managers for work and “self host” my personal stuff. I barely consider it self hosting since I use Keepass and on every machine it’s configured to keep a local cached copy of the database but primarily to pull from the database file on my in-home NAS.

Two issues I’ve had:

Logging into an account on a device currently not on my home network is brutal. I often resort to simply viewing the needed password and painstakingly type it in (and I run with loooooong passwords)

If I add or change a password on a desktop and don’t sync my phone before I leave, I get locked out of accounts. Two years rocking this setup it’s happened three times, twice I just said meh I don’t really need to do this now, a third time I went through account recovery and set a new password from my phone.

Minor complaint:

Sometimes Keepass2Android gets stuck trying to open the remote database and I have to let it sit and timeout (5 minutes!!!) which gets really annoying but happens very infrequently which is why I say just minor complaint

All in all, I find the inconvenience of doing the personal setup so low that to me even a $10 annual subscription is not worth it

Combination of anti large company sentiment + people feeling entitled to get things for free if I had to guess. It also usually feels wrong when a corporation threatens a lawsuit over a single person since the US court system heavily favors the person with more money and it’s probably a true statement to say that Nintendo has more resources than the lead dev.

Modern Vintage Gamer on YouTube had an interesting take in that by stifling emulator development now it will hurt the industry in the long run because Switch exclusives will become increasingly difficult to play once support ends (an argument I myself don’t find all that compelling)

Nerrel on YouTube has a well put together and researched video on emulation where at least in the US it’s been tested in court several times that emulators are legal, but obtaining the code for the emulators to run is almost always not since you usually have to make a copy and that violates the publisher’s right to copy

Embedded systems run into this a lot, especially on low level communication busses. It’s pretty common to have a comm bus architecture where there is just one device that is supposed to be in control of both the communication happening on the bus and what the other devices are actually doing. SPI and I2C are both examples of this, but both of those busses have architectures where there isn’t one single controller or that the devices have some other way to arbitrate who is talking on the bus. It’s functionally useful to have a term to differentiate between the two.

I’ve seen Master/Servant used before which in my experience just trips people up and doesn’t really address the cultural reason for not using the terms.

Personally I’m a fan of MIL-STD-1553 terminology, Bus Controller and Remote Terminal, but the letters M and S are heavily baked into so much literature and designs at this point (eg MISO and MOSI) that entirely swapping them out will be costly and so few people will do it, so it sticks around

Ada

It has a lot of really nice features for creating data types and has amazing static analysis during compile time.

But all the tooling around it is absolute crap making using the language unbearable and truly awful. If it had better tooling I could see that it would have taken a decent chunk of development away from C and C++

As someone who is in the aerospace industry and has dealt with safety critical code with NASA oversight, it’s a little disingenuous to pin NASA’s coding standards entirely on attempting to make things memory safe. It’s part of it, yeah, but it’s a very small part. There are a ton of other things that NASA is trying to protect for.

Plus, Rust doesn’t solve the underlying problem that NASA is looking to prevent in banning the C++ standard library. Part of it is DO-178 compliance (or lack thereof) the other part is that dynamic memory has the potential to cause all sorts of problems on resource constrained embedded systems. Statically analyzing dynamic memory usage is virtually impossible, testing for it gets cost prohibitive real quick, it’s just easier to blanket statement ban the STL.

Also, writing memory safe code honestly isn’t that hard. It just requires a different approach to problem solving, that just like any other design pattern, once you learn and get used to it, is easy.

I’m genuinely curious how saying that Linux GUI desktop has issues equates to gargling Microsoft’s balls?

So many people forget that while they understand how to use a Linux terminal and how Linux on a high level works, not everyone does. Plus, learning all of that takes time, effort, and tenacity, which not everyone is willing to do. Linus’s whole conclusion was that as long as that learning curve exists and as long as it’s that easy to shoot yourself in the foot, Linux desktop just isn’t viable for a lot of people.

But Linus has done a lot of public fuck ups therefore everything he says must be inherently wrong.

Whenever I replay OOT I never have a problem with Navi. She rarely hard interrupts, usually just a short tone and flashing C button that goes away after a few seconds. The voice lines only trigger if you press the button to call her, in most cases the hints she gives are genuinely helpful, and stays out of your way for the vast majority of the game.

Fi from skyward sword though… Far worse because she does interrupt gameplay, often repeats what the last dialogue box just fucking told you, and takes several dialogue boxes to tell you what Navi would have taken one to do. I’m glad they significantly overhauled her interactions in the HD release but I’m still going to be hesitant to play that game again

Oh yeah I pulled 20 years out of my ass. I could see some manager there saying to plan for it even though all the engineers expect a much shorter lifetime

The issue is that with ongoing service across time, the longer the service is being used the more it costs Kia. The larger the time boxes Kia uses the bigger the number is and the more you’re going to scare off customers.

Using Kias online build and price, looks like the most expensive Telluride you can get right now is $60k MSRP, cheapest at 30k

Let’s assume Kia estimates average lifetime of a Telluride to be 20 years so they create an option to purchase this service one time for the “lifetime” of the vehicle. Taking in good faith the pricing Kia has listed, using that $150 annual package, and assuming that price goes up every year at a rate of 10% (what Netflix, YouTube, etc have been doing) across those twenty years you’re looking at around $8.5k option. At the top trim thats still 14% extra that is going to make some buyers hesitant, at the base model that’s 28% more expensive.

Enough buyers will scoff at that so Kia can either ditch the idea entirely as they’ll lose money on having to pay for the initial development and never make their money back, or they find some way to repackage that cost and make it look like something that buyers are willing to deal with.

To me the bigger issue is the cost of the service vs what you’re getting. Server time + dev team + mobile data link cannot be costing Kia more than a few million annually, mid to upper hundred K is more likely so they must not be expecting that many people to actually be paying for any of this

In pure C things are a bit different from what you describe.

Declaration has (annoyingly) multiple definitions depending on the context. The most basic one is when you are creating an instance of a variable, you are telling the compiler that you want a variable with symbol name X, data type Y, and qualifiers A,B and C. During compilation the compiler will read that and start reserving memory for the linker to assign later. These statements are always in the form of “qualifiers data_type symbol;”

Function declaration is a bit different, here you’re telling the compiler “hey you’re going to see this function show up later. Here are the types for arguments and return. I pinky swear promise you’ll get a definition somewhere else”. You can compile without the definition but the linker will get real unhappy if you don’t have the definition when it’s trying to run. Here you’re looking at a statement of “qualifiers return_data_type symbol(arg_1_data_type arg_1_symbol,…);” Technically in function declarations you don’t need argument symbols, just the types, but it’s better to just have them for readability.

Structs are different still. Here you’re telling the compiler that you’re going to have this struct definition somewhere else in the same translation unit, but the data type symbol will show up before the definition. So whenever the compiler sees that data type show up in a variable instance declaration it won’t reserve space right away but it has to have the struct definition before compilation ends. This is pretty straightforward syntax wise, “struct struct_name;” (Typedefs throw a syntax wrench into this that I won’t get into, it’s functionally the same though)

One more thing you can do with variables during declaration is to “extern” them. This is more similar to function declaration, where you’re telling the compiler “hey you’re gonna see this symbol pop up, here’s how you use it, but it actually lives somewhere else k thx bye”. I personally don’t like calling this declaration since it behaves differently than normal declaration. This is the same as a normal variable declaration syntax with “extern” tossed in the front of the qualifiers.

Definitions have two types: Function definitions contain the actual code that gets translated into instructions, Enum, struct, typedef definitions all describe memory requirements when they get used.

Structs and enums will have syntax like “struct struct_name {blah,blah,blah};”, typedefs are just “typedef new_name old_name;”, and function definition “qualifiers return_data_type symbol(arg_1_data_type arg_1_symbol,…) {Blah,blah,blah}” (note that function definitions don’t need a ; at the end and here you do need argument symbols)

Lastly, when you create a variable instance, if you say that you want that symbol to have value X all in one statement, by the standard that’s initialization. So “int foo = 5;” is declaration and initialization. Structs and arrays have special initialization syntax, “struct foo bar = {5, 6, 7};” where the numbers you write out in the list gets applied in order of the element names in the struct definition. You can also use named initialization for structs where it would look like “struct foo bar = {. element_one = 5, .e_two = 6, .e_three = 7};” This style syntax is only available for initialization, you cannot use that syntax for any other assignment. In other words you can’t change elements in bulk, you have to do it one at a time.

C lets you get real wild and combine struct definition, struct instance declaration and initialization all into one! Though if I was your code reviewer I’d reject that for readability.

<\wall-o-text>