Can C++ be 10x Simpler and Safer?
youtube.com
youtube.com
The goal is nothing more than fulfilling these B. Stroustrup quotes:
"Inside C++, there is a much smaller and cleaner language struggling to get out." (1994)
"Say 10% of size of C++ in definition and front-end compiler size. ... Most of the simplification would come from generalization." (2007)
There's a summarization at 1:14:39[0] where concepts are listed on the left, and C++ syntax for handling these concepts in different contexts are on the right. The point of this effort is reduce the accidental complexity syntax on the right by refactoring it into concise uniform syntax. This effort is broad and much more than sugar, e.g. eliminating forward declarations. The talk up to that time is giving examples of the work that has been done in many of those areas, with remaining to-do's listed.
Basically the language that is being extracted is the actual language that current C++ programmers really think in, but don't have a more concise way of writing than C++.
It reminds me of what Google did with AngularJS and Angular. It is dishonest on its face and turns me off toward listening further.
C++ has this issue of every few years looking entirely different. There's no long-lasting thought about how changes or additions to the language will echo into perpetuity.
I do not know the totality of what issues we face when working with C++ (or C) outside of say, bounds safety, optimization issues that cause undefined behavior, and implicit conversion problems, but I do have a feeling that every time I see safety issues in C++ (or C) they can almost always be addressed by using an already existing safe alternative, asking whether or not a supposed "valid" optimization should be considered valid if in combination with another optimization it causes undefined behavior, or creating library functions which assist with converting what would otherwise be implicit type conversions to explicit with error checking.
I mean, the almost-simplest abstraction possible the std::vector has potential UB right in its [] operator. Sure, you could theoretically always do "at(...)", but good luck convincing anybody else on to use this safer, yet more verbose and "slower" alternative to [].
There are lots of these things in the STL. (For trickier things, see iterator invalidation, etc.)
A lot of the unsafety is also baked into basic language primitives, e.g. dangling references/pointers because of confusion around lifetime, etc., etc.
There's just sooooo much that you have to get 100% right as a programmer and adding abstractions (while a definite improvement in many cases, e.g. smart pointers) hasn't proven to be nearly enough.
It's your responsibility to pass the allowed range of value to a function. It a function description tells you to e.g. pass only non-null pointers or only even integers then it's your fault if you don't do it. Inside the function there may me asserts but there is no need to such checks in general.
> There's just sooooo much that you have to get 100% right as a programmer
It's simply the job of the programmer to get it 100% right. No language can do this job for you.
EDIT: The fundamental problem with the "attitude" of C++ I see is that fast-and-potentially-UB by default is a bad default (as almost all defaults in C++ are). It would be far saner to have slow-but-guaranteed-behavior by default[0]... but the C++ committee has repeatedly demonstrated that they're not willing to do that. Well, it's either that or require the compiler to prove that the fast behavior is safe (an example of which is Rust), but that's likely not feasible in C++... unless you turn it into Rust with even more obscure and verbose annotation.
[0] At least you can stay safe and then optimize as needed from there.
Sure we all don't get it right 100% on the first write. For this reason we test and iterate. Equally you could say that it is pure hubris that a language will enable you to make your code right 100% of the time.
You mean the vector::operator[] is an example of fast-and-potentially-UB ? I don't see any UB if the constraints are met (keeping the index within valid range).
If they are not willing in a specific case they for sure had specific reasons not to be.
> You mean the vector::operator[] is an example of fast-and-potentially-UB ? I don't see any UB if the constraints are met (keeping the index within valid range).
I don't understand this line of reasoning when it's plain that the contraints are not met. Routinely. It happens all the time. Again, see the CVEs.
This. It looks like a blatant attempt to ride the coattails of C++, which oddly enough is not the first case coming from Redmond (see C++/CX).
If the concept is able to fly on its own without these marketing crutches then it would be more credible to just claim it's a successor.
> C++ has this issue of every few years looking entirely different So what. The style you have been using does the job then just keep it. There is no obligation switch to use new stuff. You should stick with that what proved to be successful.
Modern languages use a type of syntax where all declarations start with an introducer, something along the lines of "let", "fn", "class", etc... in order to eliminate ambiguities as well as avoid the need for the parser to have potentially unbounded look-ahead.
int x = 5;
auto x = 5;
let x: i32 = 5;
let x = 5;
If I read e.g. "Why build Carbon?" on https://github.com/carbon-language/carbon-lang I dont find any concrete reasons or proves that show why C++ should be abandoned for something completely new but somehow very similar. There are so many question around the actual language definition like who maintains it, how is the standardization process. Who will adapt to it or to something else. ... This seems all so utopic.
I have been using C++ for many years with fantastic success. It allows me to create all I want/need from embedded to high performance projects. That you may shot you in the foot is in fact not bad. It compels you to be careful and think deeply about the design and only use what you completely understand.
With other languages your program might not crash but probably will do wrong things like eat up memory or access still references outdated data. You will find error much later in the process when it costs multiple magnitudes more.
We could call it c+++
The exact opposite was all the function/lambda syntax forms in Swift.