I mean that's obviously the best outcome for the Chinese government. Same thing that happens/ed to Hongkong. War is bad for everybody.

Definitely. My friend group consists of gen-z and millenials and we met irl but have a shared interest of gaming that gets us together on weekends.

What Discord does so well is that you start using it for gaming but then it also becomes the space for all kinds of things. We discuss news there, music/popculture, organize events etc

Whatsapp is more for the "formal" stuff and when it's time critical since not everybody has Discord notifications enabled.

I'd say Discord is definitely more popular among gen-z (or even younger) and gamers but it's kinda become reddit 2.0 where every niche has its discord.

> So, what are the forces that have determined the current state of C++?

I'm very confident that the main driving factors are:

1. "performance" (not wanting to do more allocations than necessary)

2. abi compatibility

3. adding features without caring how well they integrate

Example for 1:

"emplace", you normally have "append" but emplace directly constructs the object in the container instead of having to be constructed first and then moved into the container. This nice and all but breaks when using pairs (for reasons you can google but I don't wanna explain here). So now you have these obscure classes like https://en.cppreference.com/w/cpp/utility/piecewise_construc... which solve this.

Example for 2:

Basically they never break the ABI and this leads to tons of old stuff hanging around and never being changed and just more stuff being added on top. std::iostream is famously slow and a big reason is because you can't fix it without breaking the abi which they don't wanna do.

Example for 3:

The whole template thing adds so much complexity it's bonkers, I think c++ without templates would be pretty manageable comparatively. For example because C++ has constructors and they don't quite mix well with templates you suddenly end up in the situation that you have 2 concepts: "normal" template argument deduction and constructor template argument deduction (CTAD). Because of this asymmetry you need a custom language feature called "deduction guides" to maneuver yourself out of the problems that come from this.

Or another short one: std::expected without something like the "!" that rust has. You end up with endless "if(result.has_value()) { return result; }" cascades and it's horribly unergonomic. So now we have a Result class but it's practically unusable that it will only fragment the ecosystem even more.

>Example for 1: ...breaks when using pairs

No, it doesn't. But sometimes you want to construct pair's elements in-place too and that's what piecewise_construct is for.

Yes because users don't appreciate this enough to pay for the time this takes.

In my opinion it's the 'correct' design, I don't see any advantage from not doing this.

Because from my experience using codex in a decently complex c++ environment at work, it works REALLY well when it has things to copy. Refactorings, documentation, code review etc. all work great. But those things only help actual humans and they also take time. I estimate that in a good case I save ~50% of time, in a bad case it's negative and costs time.

But what I generally found, it's not that great at writing new code. Obviously an LLM can't think and you notice that quite quickly, it doesn't create abstractions, use abstractions or try to find general solution to problems.

People who get replaced by Codex are those who do repetitive tasks in a well understood field. For example, making basic websites, very simple crud applications etc..

I think it's also not layoffs but rather companies will hire less freelancers or people to manage small IT projects.

In my opinion you must have function coloring, it's impossible to do async (in the common sense) without it. If you break it down one function has a dependency on the async execution engine, the other one doesn't, and that alone colors them. Most languages just change the way that dependency is expressed and that can have impacts on the ergonomics.

Not necessarily! If you have a language with stackful coroutines and some scheduler, you can await promises anywhere in the call stack, as long as the top level function is executed as a coroutine.

Take this hypothetical example in Lua:

  function getData()
    -- downloadFileAsync() yields back to the scheduler. When its work
    -- has finished, the calling function is resumed.
    local file = downloadFileAsync("http://foo.com/data.json"):await()
    local data = parseFile(file)
    return data
  end

  -- main function
  function main()
    -- main is suspended until getData() returns
    local data = getData()
    -- do something with it
  end
    
  -- run takes a function and runs it as a coroutine
  run(main)

Note how none of the functions are colored in any way!

For whatever reason, most modern languages decided to do async/await with stackless coroutines. I totally understand the reasoning for "system languages" like C++ (stackless coroutines are more efficient and can be optimized by the compiler), but why C#, Python and JS?

Look at Go or Java virtual threads. Async I/O doesn't need function coloring.

Here is an example Zig code:

    defer stream.close(io);

    var read_buffer: [1024]u8 = undefined;
    var reader = stream.reader(io, &read_buffer);

    var write_buffer: [1024]u8 = undefined;
    var writer = stream.writer(io, &write_buffer);

    while (true) {
        const line = reader.interface.takeDelimiterInclusive('\n') catch |err| switch (err) {
            error.EndOfStream => break,
            else => return err,
        };
        try writer.interface.writeAll(line);
        try writer.interface.flush();
    }

The actual loop using reader/writer isn't aware of being used in async context at all. It can even live in a different library and it will work just fine.

Uncoloured async is possible, but it involves making everything async. Crossing the sync/async boundary is never trivial, so languages like go just never cross it. Everything is coroutines.

I don't think unions are the right thing here, you just need to get together as a team and talk with your higher ups, that's a far smaller scope than where unions normally come in.

But I totally agree, I think people are too compliant and fear banding together to have influence on higher ups. I'd argue in most places the engineers have far more power than they realize since they are in high demand due to shortages of qualified personnel. (at least in many countries in Europe)

There are tons of factors in play though that I believe contribute to this like some employees being friends with their higher ups not wanting to hurt their careers, not wanting the tough discussions, the repercussions if management says "no" etc..

> you just need to get together as a team

"Just". Come on, man, you know better than that. I too like my sci-fi to be over the top unrealistic.

Truth is, nobody ever thinks about their rights before it's too late. The paycheck shows up on time every month and people just don't want to rock the boat. Not to mention all the opportunists that will tell on you immediately to gain the favor of the upper class.

These things are well-known and apparently nothing ever changes before the guillotines start working. I don't think anything will ever improve in our area. Nobody is bothered. The people who are have zero power. And so it goes.

Absolutely not, barely anyone is okay with it -- only the most naive and fresh of young workforce, and then not even half of them by my observations chatting with many people 20+ years younger than me. It's just that people have too much at stake to risk it. Families, mortgage, basic respectful existence even. Nobody wants to live under a bridge.

It's extremely sad. I did not want to live in such times but oh well, good thing anyone asked us, right?

You don't have to fire "low performers" you just have to be realistic about their skillsets and use them that way.

If you see an engineer is out of his depth then change his position, no need to fire them since like others have pointed out, that can have severe consequences in their personal lives and most of the time they can still be useful if they get more adequate work.

> I don't like unions because one bad hire can destroy a whole team, and the option to remove that hire is worth more than any benefit a union can give me.

In MANY other countries there is already WAY more regulations regarding layoffs and firing employees that has nothing to do with unions.

In Germany there is a probationary period in which you can just fire somebody for no reason basically. That time can be like half a year (in my case) and in most cases it becomes clear if the new hire fits your team or doesn't.

All unrelated to unions though. The big unions in Germany for example have a lot of power and if you are just a simple welder for example you'd have no chance getting anything done without a union.

And this is one of the key reasons why Germany is economically stagnant, especially in the software industry.

> In MANY other countries...

When your scope is Europe ... The US is not the exception in the world, it's Europe which is.

The US has a dynamic job market where it's easy to lose your job, but easy to find another one. In Europe, and that's true for most EU countries, it's really hard to lose your job, but it's also really hard to get one for the very reason it's hard to get fired - and when you get a job, you will have to compromise on compensation and other benefits. It's not black and white here. While the European market is appealing to some people, the US market is preferable to others.

> It's not black and white here. While the European market is appealing to some people, the US market is preferable to others.

I agree with that, it's a very individual topic. I'd say for high paying "high performance" jobs the US model definitely has an advantage but for low-wage jobs it's quite the opposite.

No need to go as far as "low wage". Having strong labour protections is great if you are middle class and below.

Counterpoint: Denmark has something called Flexcurity: "flexible" + "security". Basically, it means you can hire and fire more easily than traditional socialist market economies. There is a good social safety net, but it is (somewhat) time constrained to pressure people to return to work quickly.

Good insight. Let's see whether Denmark remains competitive.

To be clear, the modern programme started in the 1990s. That makes it about 30 years old. If it had major problems, I assume they would be fixed by now.

Re-reading your comment again, I'm not sure that I understand it: "Let's see whether Denmark remains competitive." What do you mean?

Yeah and denmark finally voted left because they are finally getting tired of all this right wing shit that brings no benefit to workers.

Did they vote left? And that's the same left pushing over and over the Chat Control? That's an interesting twist if it turns out it's not always the right wing trying to undermine privacy rights.

You think Ursula von der Leyen is left wing? Like Lenin, Stalin and Ursula von der Leyen are in the same political party?

She is the European Commission president, that's unrelated.

But that made me curious, and answering my own question, it's this guy https://en.wikipedia.org/wiki/Peter_Hummelgaard who is indeed a Social Democrat .. So much about workers rights, funny ...

Well the proposal came from the european commission, doesn't seem that unrelated to me.