“Section 3 seems out-of-place. You're switching from a conservative critique of Herb's existing proposal, to an even wilder proposal of your own?  Flying cars will never work, but let me tell you my ideas on personal jetpacks?”


What is the point of criticizing other people’s works without providing solution? Complaining for no reason?


Well, you should be able to deal with the merits (or lack thereof) of Herb's proposal completely orthogonally to your own "solution."
Your paper has two different things going on:
(1) a critique of Herb's proposal, which I think makes some valid points and some invalid points;
(2) a promotion of your own proposal [Java-style checked exceptions + noexcept(auto)], which I think is much more flawed than Herb's.
Right now you're tying those two orthogonal issues together. In my opinion, the naivete of (2) reduces your credibility in re (1). Someone else might disagree with (1), and then view (2) as irrelevant.

 

“Your `dynamic_exception` type sounds exactly isomorphic to C++11 `std::exception_ptr`. Have you seen `exception_ptr` before? After looking at `exception_ptr`, what differences do you see between `exception_ptr` and your ideas about `dynamic_exception`?” 

 

I agree dynamic_exception is a fault. I have a new solution to that which is throws exception should not be allowed to be bound to a pointer or virtual function, just like constexpr. If people want that, they need to use current exception. I will provide a revised version of my proposal in the next few days.


Please, take a look at std::exception_ptr on cppreference. See if it does what you're looking for.


In general, variant-based exception works and it is the only real zero-overhead exception proposal.


When you use phrases like "real zero-overhead", it makes me think that you're exaggerating or naïve.
C++ exceptions are "zero-overhead" in the sense that you don't pay for test-and-branch at each level of a successful call stack; but they are "non-zero overhead" in many other ways. Your proposed exception mechanism, like Herbceptions, is "zero-overhead" in the sense that you don't need any auxiliary data tables to tell you how to perform stack unwinding; but it is "non-zero overhead" in the sense that it inserts test-and-branch instructions at each level of the call stack, slowing down your code's happy path.


- "Sutter thinks exceptions and RTTI are the only two violators of the zero-overhead principle."
That is true. Herb Sutter did say that in his video and his paper. 

“RTTI is the other C++ language feature that violates the zero-overhead principle. [...]"


Good. Cite this in your paper.
Don't just claim or assert it; provide evidence for your claim. If that means linking to YouTube, or to another committee paper, do so!


- "Introducing a new keyword is a problem." Introducing a new contextual keyword `throws`, in the same place as `override` and `final`, is actually not troubling at all. By pretending that it is a problem, you cast doubt on the rest of your arguments.

 

False. As Bjrane demoed in the previous cppcons Even introducing nullptr would cause problem since it is possible some people are using nullptr as variable name. Same thing with why coroutine keywords are called co_yield, co_return instad of yield or resume


`override`, `final`, and Herb's `throws` keyword are not a problem for C++'s grammar in the way that e.g. `yield` is.
For more information on the grammar of contextual keywords, see N3163.


- "The prototype has not completed yet." (by which you mean "there is no implementation of std::error available") Quite possibly true, but I would like to see a link to a GitHub or something. I bet someone has at least tried to implement it, right? No?

 

14ned’s implementation is horrible and not freestanding.


So, someone has tried to implement it?  I'd like to see your paper offer a link to that implementation.
It would also be interesting to see why you think that implementation is "horrible."
Maybe you could come up with a code snippet (on Compiler Explorer, for example) that shows a significant difference in performance between that implementation and the optimal one.

- "A lot of middle school algorithm competition like NOIP is banning containers or not enabling optimization toggle." Citation wanted.

 

Evidence?


Yes. Again, in the form of a link, in the paper.
http://www.noi.cn/newsview.html?id=67&hash=2DA1FD&type=6 counts as evidence. Put it in the paper.
(Although, uncharitably, I wonder why these rules are 10 years old and exist only in Chinese. The rules for the 2019 International Olympiad in Informatics are here, and they don't mention any banned headers.)


- "C++ code still cannot run on a lot of platforms with no ABIs of dynamic exceptions, web assembly, for example." Is this saying that C++ compilers targeting WebAssembly can't use try/throw/catch? Citation wanted.

 

It just aborts. Why do you not even watch Cppcon 2019?

https://youtu.be/5N4b-rU-OAA?t=4690


I've watched it now, thanks! I had not watched that link before you sent it because I'm not a mind-reader. Put it in your paper.

–Arthur