C++26...wtf

This. C++17 is even better. I still think variant and optional should have been first class language constructs, though.

As should smart pointers.

I think i found it. Looks like some autistic bullshit for sure.

Attached: Screen Shot 2019-01-15 at 4.08.00 PM.png (706x859, 294K)

xabulglbl? Nigga::What::The::Fuck!!

God forbid we build our own abstractions using existing language features.

Sounds pretty useful, but also ripe for abuse by retards.

For a second I thought this was a C# thread

Basically a way to generate classes at compile time. But unlike templated classes, you can impose rules on the classes you generate from the metaclass. Things like that every method must be abstract (thus allowing you to create a metaclass that produces classes that work like "abstract" classes in another language). Or interfaces, too.

The metaclass also has compile time access to all sorts of properties of the classes derived from it, so C++ developers can use it for efficient reflection that happens at compile time.
Things like writing a json serializer will become a lot easier and won't require using shitty macros or redundantly describing the layout of your class and how to get its members.

That would be very useful.

Static reflection is sorely missing in C++.

>C++ requires you to be smart
>me brainlet
>....
>C++ bad!

en.wikipedia.org/wiki/Sunk_cost#Loss_aversion_and_the_sunk_cost_fallacy

Hey now. C# is fantastic. Change my mind.

Ok so this is basically like T4 generation that we've had in .NET languages for years.
>docs.microsoft.com/en-us/visualstudio/modeling/generating-code-from-a-domain-specific-language?view=vs-2017
Nice memes, C++ tards.

Just give us actual dynamic dispatch and patten matching Bjarne

something something split a string

Are C++ string literals still C strings or they finally made std::string behave like the other types?

concepts are actually pretty great

"need an s literal"s

What? C++ strings are their own thing and they always have.

I recommend watching youtube.com/watch?v=kPR8h4-qZdk for some insight on how they are implemented.

>4 major revisions in a decade
fucking hell those that touched the first version must have PTSD

>variant
might as well never declare your variable types, we're reaching a stage where simply naming and assigning will be the norm.

if you can stomach the presenter, that is

Sounds like free job security to me. Based Bjarne

Well, he is employed by Phizbook, so obviously that leaves some lasting damage.

>knows what the fuck they are doing
>C89
Oh the irony

>OCaml or Lisp until 2050 ...
Even Java will be way better in 7 years.

I don't follow what happens with C++ that closely, but don't all those updates heavily fragment everything surrounding the language?
People have to learn the new features -- a lot of them won't and will stick to older standards. The compilers have different levels of support for the latest standards. Some nerds start writing unreadable metaprogramming that no one wants to maintain or even look through. The standard library feels like a bunker (really, try writing a custom subclass of ostream or istream). Those new standards feel like commercial for 6 in 1 shampoos. Who really benefits from all those features except boost developers who can't find enough ways to flex their template gymnastics skills.

You'd think that but C++ has become much easier to write over the years. The C++ standard has increased in size but that's the compiler/library supporter's problem instead.

Real problems are bad debuggers and slow slow compiler times

okay what's wrong with the visual studio debugger

What happened to C++?
It started out as C with classes, and now its a fucking abomination of autistic features.

>autistic features
Read a book nigger. Nobody wants to use a crappy bare bones language like C

Just use Rust ;)

Imagine being mad about improving things.

uh no?

nobody wants anybody to write OS / kernels

You can write kernels and OSs in C++ with absolute ease.

>still no type-safe variants in syntax
>still no deprecation or outright removal of redundant and broken features
>still absurd compile times because of highly context-dependent grammar and nearly zero compile-time encapsulation
>after 35 fucking years

it's an admission that templates and concepts still somehow manage to be completely inadequate, even though C++'s implementation of both of them is the most complex and over-engineered of any modern programming language

>t. never written a kernel or operating system

I have worked on integrating android app store into car computers so that's close enough. They both compile to machine code and are Turing complete only c++ makes quality code.

>a lot of them won't and will stick to older standards
The main C++-using industries that are staying back on legacy C++ are embedded and gamedev. Finance, HPC, and Goog/FB-type companies are either already C++11/14 shops, or in the process of migrating towards modern C++.

forgot to mention: as new standards get published more and more learning resources become deprecated. now anyone who wants to pick up C++ will likely start with an old resource and after some time realize they have to learn how to write C++ in the newer standard.

It is, if you keep yourself to the bits that make it easier to write (and read). I remember getting excited about auto and lambdas when they were announced. But you have more power now to write monstrous, incomprehension code.

Herb's deterministic exceptions are utter wank and they don't belong in C++. C++ is not bad because it's large, but it is bad because it's very context sensitive - which this proposal will make worse.
I'm happy to say that C++14 through C++20 are good improvements to the language because their new features add clarity rather than reduce it.

C++20 will add modules which remove the biggest hurdles in compile times..
Also templates and macros are orthogonal, I don't know why you'd get the idea you should only have one or the other.

>process of migrating towards modern C++
*with guidelines that make it literally C98

It's my favorite language alongside C and I hate seeing it getting bloated year after year.
Default interface methods are the newest hot garbage.

The whole notion of C# is just Java with bloat.

>I made some shitty android app run on elinux so that's basically the same as writing a kernel or operating system
mfw

Attached: 1473629685819.jpg (431x450, 70K)

And what guidelines would they be, presumably wherever you work?

google.github.io/styleguide/cppguide.html

ok kid

I never said you shouldn't have both. What I DID say is that C++'s implementations of templates and macros are horrendous.
When I referred to redundant, non-orthogonal, and/or contradictory features, I was referring primarily to
>struct/class
>half a dozen different initialization syntaxes for most things in the language
>const functions/mutable
>the 'explicit' keyword as a "feature" instead of just fixing the fucking type system

At some point it was Java made right. With things like operator overloading and events it's less verbose than java and removed a need for unnecessary design patterns. Also 1 class per file is a shitty idea. Also namespaces don't require me to have 8 nested folders just to place 1 source file. Exceptions, etc...
Now C# 8.0 is just C# with bloat.
Java 10 is just Java with bloat.
In 4-5 years prepare to use "sane subset of C#/Java"
tpbp. This guy gets it.

>sane subset of C#/Java
The sane subset of C# and Java is using neither, and using literally anything else instead (except C++)

I'm seeing nothing that makes Google's subset of C++ "C98-style C++." No exceptions/RTTI is a pretty common ban, and the only other thing they mention is "don't use TMP."
Apart from that, lambdas, move semantics, smart pointers and STL all are okay to use.

As I described in that post, I don't mind feature bloat if it doesn't add to the mental overhead. struct/class is easy to understand because the difference is so small but the differences with initialisation syntax and semantics are hard even when you're very familiar with the language.

they should have stopped riding the coattails of C a long time ago and done their own thing.

backwards compatibility is pointless when people are still just using C.

I use auto everywhere right now.

>its just java with bloat
no, its a wrapper for asp

>interpreting posts literally on a japanese coloring book symposium

>people
*morgan stanley

Absolutely true. And slightly more comfortable than C in my opinion

that's reasonable. I guess it just bothers me because it fragments the language into multiple dialects. struct/class would be bearable if not for the countless other dialect-dependent things in the language. The end result is that nobody can read anybody else's code, because C++ is actually 10-15 different languages.
I'm fine with features as long as they can be used together and they don't make the language so complex that nobody actually bothers to learn all of it. I know it's a bit of a meme, but I look to Nim as an example of a language that is every bit as feature-packed as C++, yet is much more consistent.

has anyone ever seen a program written by bolgna ketchup?

he doesn't program there.
he's a director of tech division
has he ever programmed anything?

I don't know anything about Nim. I only hear about it on Jow Forums so I can't tell if it has enough presence to be usable for actual work. C++ is desperately in need of a replacement, after all.

I think you will find that the style of using partial classes is really nice in C# land these days. I cant stand having a business service or other tight coupling class with a bunch of methods all cramed into one source file. I standardized us on one method per file in extreme cases and other groupings as logical.

Nim has been around for ages and nobody uses it
there's probably a reason for that

The absolute state of micro-sepple-atics

Man. You're dumb

>has he ever programmed anything
Weak bait

Yes, my point is that it's nice but gets lots of unnecessary bloat with each revision much like c++.

While I can understand that sentiment I'm not sure it is 100% correct. I feel like C++ mostly gained traction because it started off riding the coat tails of C. Hell, when C++ was being created it had an explicit goal making sure C code was valid C++ code.

And as much as I love C, it is not a perfect language and made a few screw ups, mostly with its pointer syntax and its somewhat excessive undefined behavior. Even though its strengths may outshine its weaknesses in my opinion, I don't think that is why it became so popular and wide spread over the last several decades. It mostly likely picked up traction because its development was heavily intertwined with the development of Unix. I think this gave it enough presence and leg up on other competing languages at the time to have a snowballing effect. I don't think it would have become as widespread or popular if the development of Unix hadn't leveraged it. I think the same can be said of languages like Java, C#, or Go. However good or bad one might feel about these languages, they probably wouldn't have taken off if they didn't have some form of corporate backing to give them that little bit of boost early on to gain track. I feel like C++

Metaclasses are beautiful and anyone who is against them is a complete brainlet, who thinks shit like Q_OBJECT is a good idea. C++ needs a decent meta programming model already.

A decent metaprogramming model in general is direct AST manipulation but C++ has such a heinous AST I don't think anyone wants that.

nice quads
Nim spent the first 80% of its life being a toy side project by some random German guy. In reality, Nim has only truly been a serious, professional project (that is, one with money at stake and people being paid to work on it) for a couple years.
Unlike Rust (Mozilla) and Go (Google), Nim doesn't have some gigantic sponsor throwing money or people at it. A large fraction of its funding comes from individual community members, and a handful of small corporate donations.
In essence, Nim does just about everything C++ does (e.g. templates, macros, concepts, etc) but has been designed with each of those features in mind at the outset. It's a lot more terse than C++ and its feature set is more practical (less hand-wavey bullshit like "metaclasses").
It is primarily designed as a GC'd language, but a large subset of the standard library can actually still be used without the GC, giving it potential for use in embedded. Its garbage collector is designed with soft real-time systems in mind, and can be adjusted to allow for sufficiently deterministic behavior so that it can be used in those applications.
Unit testing framework and async are built into the standard library. Young but powerful package manager.
It can be compiled to C and JS, so it is a suitable replacement for Node, but unlike Node, Nim doesn't make performance sacrifices on the server side. There are transpilers that allow you to quickly translate your C and Python code directly into Nim.

Attached: openbsd.gif (420x247, 2M)

People have hated C++ for years now
if Nim was such a great alternative I think it would have more traction

>the absolute state of sepples
>literally just copy-pasting rust

>trusting devs so inbred they think aFunction, AFunction, and a_function should resolve to the same symbol
lol
Bonus points:
>>>>>>>>>>>>> significant whitespace

I've used to work with c++
> define abstraction on everything
> look at the type and know what's going on
> switch seamlessly between different programming methodologies depending on need
> create DSL on the flight
> make clever constructs to solve problems

Now I work in Java
> changing anything requires touching 300+ lines and 20 classes of mind numbing boringness
> set/get
> final considered harmful
> IntSet is preferred over Set
> throw UnsupportedOperationException(), because interfaces are a joke
> Code repetition everywhere.
> 4 weeks spent tuning GC

Just wake me up.

>direct AST manipulation
name one (1!) language that does this

>proceeds to create bloated sluggish Windows clone

I don't know what you meant to type instead of C++ but it definitely wasn't C++.

Both rust and ocaml do it as far as I know.

Rust? Really?

Probably some really bare bones LISP from the 80s

Lisp macros are the example most often given.
I'm not so sure if it's direct AST manipulation but given that lisp code is in nested lists (trees) anyways the effect is the same. You can cons programs together just fine.

Lisp doesn't fucking count. Give me a C like language with full compiletime AST manipulation. I'm waiting.

>C++20 will add modules
Oh shit, I thought that was supposed to be in C++17. I just don't want to deal with half the linker shit anymore. That was one of the better features they were stealing from C#.

Attached: 1409023774529.gif (293x238, 8K)

Yes, just double-checked and it turned out I was remembering right.

Link to the documentation please. Can I do shit like add new keywords?

Modern lisp doesn't really expose the AST, but an "enriched" version of it so it will be less annoying to program. Like it as pretty much the same structure and all, so it's pretty close.