I really don’t see the issue there, you’re only outputting highly specific data to a website, not dumping half the database.

Do you mean your typical CRUD structure? Like having a User object (AuthId, email, name, phone, …), the user has a Location (Country, zip, street, house number, …), possibly Roles or Permissions, related data and so on?

SQL handles those like a breeze and doesn’t care at all about having to resolve the User object to half a dozen other tables (it’s just a 1…1 relation, on 1…n, but with a foreign key on the user id it’s all indexed anyway). You also don’t just grab all this data, join it and throw it to the website (or rather the enduser API), you map the data to objects again (JSON in the end).

What does it matter there if you fetched the data from a NoSQL document or from a relational database?

The only thing SQL is not good at is if you have constantly changing fields. Then JSON in SQL or NoSQL makes more sense as you work with documents. For example if you offer the option to create user forms and save form entries. The rigid structure of SQL wouldn’t work for a dynamic use-case like that.

I mean in my case it’s for an international company where customers use this structure and the depth can basically be limitless. So trying to find the topmost parent of a child or getting all children and their children anywhere inside this structure becomes a performance bottleneck.

If you have a single level I really don’t understand the problem. SQL joins aren’t slow at all (as long as you don’t do anything stupid, or you start joining a table with a billion entries with another table with a billion entries without filtering it down to a smaller data subset).

If you only join on indexed columns and filter it down to a reasonable number of results it’s easily fast enough.

For true hierarchical structures there’s tricks. Like using an extra Path table, which consists of AncestorId, DescendentId and NumLevel.

If you have this structure:

A -> B -> C

Then you have:

A, A, 0

A, B, 1

A, C, 2

B, B, 0

B, C, 1

C, C, 0

That way you can easily find out all children below a node without any joins in simple queries.

My ISP doesn’t support IPv6, now what?

It’s really bullshit.

Well, there’s modern C++ and it looks reasonable, so you start to think: This isn’t so bad, I can work with that.

Then you join a company and you find out: They do have modern C++ code, but also half a million lines of older code that’s not in the same style. So there’s 5 different ways to do things and just getting a simple string suddenly has you casting classes and calling functions you have no clue about. And there’s a ton of different ways to shoot your foot off without warning.

After going to C# I haven’t looked back.

Mobile is an entirely different beast. Like sometimes my keyboard doesn’t show up. Or the text select refuses to work. And so on. It’s a mess. Even on a Galaxy S22.

No clue how people can exist without a proper computer at home and still do stuff online.

Ctrl + C literally doesn’t work at times, it drives me crazy. It might be due to some shitty applications and websites overriding it or adding complexity (Like copying not only the text but additional information).

I’m often 100% sure I copied the text, change the window and an old clipboard entry gets pasted.

There’s no Visual Studio for Linux, so yeah… especially as a .NET dev.

Visual Studio Code isn’t the same.

Yeah, I’ve worked with the leave it alone types. What do you get in return? Components of your system which haven’t been updated in the last 20 years and still run .NET 3.5. They obviously never stopped working, but you have security concerns, worse performance (didn’t matter much in that case) and when you actually need to touch them you’re fucked.

Why? Because updating takes a lot of time (as things break with every major revision) and on top of that if you then decide not to update (yeah, same coworker…) then you have to code around age old standards and run into bugs that you can’t even find on Stack Overflow, because people didn’t have to solve those in the last 20 years.

deleted by creator

Yes, but I was talking about the salary part, which is separate from the costs you mentioned.

It’s 19 million just for people.

Is it just me or is $19 million per year for 50 full-time employees insane?

Even for US salary standards.

I still haven’t found a proper command or tool to do a multi-commit git blame.

Like I want to know who changed the logic in this line. But the last commit was a format refactor. And the commit before that just changed a tiny detail. So now I’m digging through the entire file history just to find the spot where this one line was introduced or actually changed.

If you have any tips for that, I’m all ears.

That works for newer projects, but on older projects there’s a dozen commits for any given line and a handful of Jira tickets that have something to do with it, but none that say “Change exactly this”. A comment why you made an interesting design decision costs a lot less time than trying to unwrap the commit history… Especially when you can’t even find a clue on why this was done as the commit might simply be “Implemented feature XY”

The code shows what happens. But comments should explain why it was done this way.

Sometimes the code started simple and readable, till you ran into a weird edge case a year ago. Now the code no longer looks as obvious and another developer might scratch their head when they read over it. A small comment can help out there quite a bit.

Or you’re doing something stupid in code not because you want to, but because management forced you to. So you put a comment there that the code isn’t wrong, management wanted that behavior.

You’re comparing apples and oranges. Windows is the OS, One Drive is just a sync service (like Dropbox). They are not comparable in the least.

Or did you want to talk about Office365 or something?

Yeah… except for that tiny detail:

There are three conditions that must be satisfied for the defence to be applicable:

• You employer has made a statement of fact which made you believe that the money was your own;
• You acted in good faith and without knowledge of any claim for recovery from your employer and as a result, changed your position in terms of the money; and
• You were not involved in the cause of the overpayment.

So if you signed a contract for a sum of x and the employer never said they are going to pay you more, you’re already acting in bad faith based on the first point. The second point is tough to argue, literally the only way to win this is if you have a verbal “contract” only and claim you never watched your bank account and just didn’t notice the extra money (but then if your employer tells you about the wrong payments you have an issue again…).

In the real world you’ll probably pay the money back 99% of the time, except if you want to burn bridges and leave (going after you for smaller amounts is not worth the time in court). Your professional relationship will be ruined though, which you may or may not care about.

That’s not how it works in both Germany and Austria. If you have a contract you get paid based on it, if there is a bookkeeping error you have to pay the money back if the company accidentally gives you too much.

The only contracts that are invalid are when the number is very obviously wrong in the context. For example the contract says instead of $50k a year you get paid $500k a year or $5k a year, then the entire thing is void as it’s an obvious error.

If the contract says $55k and the company wanted to pay you $45k… their problem, contract counts. Your boss might be pissed if you keep insisting on the $55k and might fire you, especially if you verbally agreed on $45k. But oh well, that’s another topic.

Oh and in the UK? The employer is even allowed to deduct that money from your future wages. So much about knowing the law :)

That’s not how it works in both Germany and Austria. If you have a contract you get paid based on it, if there is a bookkeeping error you have to pay the money back if the company accidentally gives you too much.

The only contracts that are invalid are when the number is very obviously wrong in the context. For example the contract says instead of $50k a year you get paid $500k a year or $5k a year, then the entire thing is void as it’s an obvious error.

If the contract says $55k and the company wanted to pay you $45k… their problem, contract counts. Your boss might be pissed if you keep insisting on the $55k and might fire you, especially if you verbally agreed on $45k. But oh well, that’s another topic.

Oh and in the UK? The employer is even allowed to deduct that money from your future wages. So much about knowing the law :)

Depends on what’s in the contract, black on white. If the contract says x amount and they pay you y (and you don’t speak up), they can get that money back as it was a bookkeeping error.

If the contract says the higher amount then they can’t take it back, written contract always wins over verbal.