Kids nowadays. What’s wrong with the 8” floppies? You can even run CP/M 1.4 from them…

> after all, MS-DOS was basically an unlicensed clone of CP/M for the 8086.

Eh, not really. The file system was very different and these early operating systems were mostly a file system. The system calls were almost identical…

There was also The Plague of Justinian in the 6th century which may have been more devastating than the Black Death.

Context matters…

Not that I disagree, but this is nothing compared to the ".NET" craze in the early 2000s. Everything had to have ".NET" in its name even if it had absolutely nothing to do with the actual .NET technology.

There was also "Active" before that, but .NET was next level crazy...

I don't know, it seems comparable

Office.com is now "Welcome to Microsoft 365 Copilot"

You probably remember File Control Blocks which are briefly mentioned in the article…

I guess that was it.

I actually like Linux and use it exclusively for software development, but for most office and personal tasks it’s windows 11. Once you turn off the adds it’s really fine despite all the screaming online…

> auto main() -> int {

Dude…

In my opinion this syntax is super good, it allows to have all functions/method names starting at the same level, it’s way easier to read the code that way, huge readability improvement imo. Sadly nobody uses this and you still have the classic way so multiple ways to do the same thing…

This style is used in {fmt} and is great for documentation, especially on smaller screens: https://fmt.dev/12.0/api/#format_to_n

As someone who quit c++ over 15 years ago it's been comical to watch what this language has become.

This has been valid C++ since C++ 11

It's unusual. Some, unusual, style guides require it. It's useful in some cases, even necessary in some which is why it was introduced, but not for simple "int"

it's literally the exact same thing. We use trailing return types to be consistent across the language.

We use trigraphs to be consistent across the language.

It's like calling a Ford Mustang Mach-E the "Model T++."

> c++ threw pre-ansi argument type declarations out

they never were in C++.

And their code example doesn't actually return a value!

For main it's explicitly allowed by the standard, and no return is equal to return 0

which is super weird. If they can tell the compiler to allow no return, only for main, they can also tell it to pretend void return is int return of 0, only for main.

Go-to? I've never seen a project use it, I've only ever seen examples online.

It's still been the standard since c++11 and I've been using it every since in all teams I've worked in.

Same here

Now I haven't touched C++ in probably 15 years but the definition of main() looks confused:

> auto main() -> int

Isn't that declaring the return type twice, once as auto and the other as int?

No. The auto there is doing some lifting so that you can declare the type afterwards. The return type is only defined once.

There is, however, a return type auto-deduction in recent standards iirc, which is especially useful for lambdas.

https://en.cppreference.com/w/cpp/language/auto.html

auto f() -> int; // OK: f returns int

auto g() { return 0.0; } // OK since C++14: g returns double

auto h(); // OK since C++14: h’s return type will be deduced when it is defined

What about

auto g() -> auto { return 0.0; }

0.0 is a double, so I would assume the return type of g is deduced to be double, if that is what you're asking.

I was more pointing out that the syntax was dumb for that particular example!

I really wish they had used func instead, it would have saved this confusion and allowed for “auto type deduction” to be a smaller more self contained feature

the standard c++ committee is extremely resistant to introducing new keywords such as "func", so as not to break reams of existing code.

Indeed. I am a frequent critic of the c++ committee’s direction and decisions. There’s no direction other than “new stuff” and that new stuff pretty much has to be in the library otherwise it will require changes that may break existing code. That’s fine.

But on the flip side, there’s a theme of ignoring the actual state of the world to achieve the theoretical goals of the proposal when it suits. Modules are a perfect example of this - when I started programming professionally modules were the solution to compile times and to symbol visibility. Now that they’re here they are neither. But we got modules on part. The version that was standardised refused to accept the existence of the toolchain and build tools that exist, and as such refused to place any constraints that may make implementation viable or easier.

St the same time we can’t standardise Pragma once because some compiler may treat network shares or symlinks differently.

There’s a clear indication that the committee don’t want to address this, epochs are a solution that has been rejected. It’s clear the only real plan is shove awkward functional features into libraries using operator overloads - just like we all gave out to QT for doing 30 years ago. But at least it’s standardised this time?

People's life choices are their own, but if many people choose to live alone, that objectively affects housing situation in the society.

if so many people can afford to live alone, perhaps it means that housing situation isn't that bad? in cities like NYC where rents are high, it's very common to have roommates for instance.

And Atari…

I never saw Atari software for sale in the same magazines, but I'm sure it was available somewhere.