[std-proposals] Can we have beginner friendly new line and deprecate std::endl?

[m***@gmail.com]

Wouldn't it be miles better to instead of un-teaching people from std::endl
and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?

The point is - '\n' is not in any way beginner friendly as it is not an std
or build in "command"/object, but some alien symbol (to a new comer) like,
literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple
letters, not rarely used symbols (double colon, is not rarely used a t all)

Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.

[Hyman Rosen]

'\n' has been the way to write newlines in C for half a century.
It's also the way to do it in C++, Java, Perl, Python, and other languages.
We don't need a beginner-friendly way to specify newlines,
because it's as easy to tell the beginners '\n' as to tell them anything
else.

Post by m***@gmail.com
Wouldn't it be miles better to instead of un-teaching people from
std::endl and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an
std or build in "command"/object, but some alien symbol (to a new comer)
like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple
letters, not rarely used symbols (double colon, is not rarely used a t all)
Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.
--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org?utm_medium=email&utm_source=footer>
.

[Ray Hamel]

I don't see any reason why '\n' or "string literal\n" is unintuitive or
would need to be replaced. I do think it's a good idea to rename std::endl
to something less misleading, and deprecate the old std::endl.

- Ray

Post by m***@gmail.com
Wouldn't it be miles better to instead of un-teaching people from
std::endl and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an
std or build in "command"/object, but some alien symbol (to a new comer)
like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple
letters, not rarely used symbols (double colon, is not rarely used a t all)
Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.

[g***@gmail.com]

Grumpy me says lets make endl not flush in C++20, since it surprises people.
And if people want flush they'll have to add a flush call explicitly.
Hopeful me says isn't someone going to produce a new faster API that will
replace that whole machinery anyway with something faster and better
designed so won't endl et al, all come to a sticky um, end, anyway sometime
"soon"?

Post by m***@gmail.com
Wouldn't it be miles better to instead of un-teaching people from
std::endl and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an
std or build in "command"/object, but some alien symbol (to a new comer)
like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple
letters, not rarely used symbols (double colon, is not rarely used a t all)
Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.

[Thiago Macieira]

Post by g***@gmail.com
Grumpy me says lets make endl not flush in C++20, since it surprises people.

Not flushing where it is flushing today would cause way more surprise than
what we have today. Plus, the C standard library does flush on newlines, if
the FILE* object is in line-buffered mode, so why should we deviate?
--
Thiago Macieira - thiago (AT) macieira.info - thiago (AT) kde.org
Software Architect - Intel Open Source Technology Center

[Brian Bi]

Post by m***@gmail.com
Wouldn't it be miles better to instead of un-teaching people from
std::endl and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an
std or build in "command"/object, but some alien symbol (to a new comer)
like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple
letters, not rarely used symbols (double colon, is not rarely used a t all)

I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.

Also, I think adding some hypothetical new "std::newline" constant in an
attempt to "seduce" novices does them a disservice by making them waste
keystrokes and tempting them to use "using namespace std" to save a few.

In other words, teaching people to use '\n' really is the best solution.

Post by m***@gmail.com
Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.
--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org?utm_medium=email&utm_source=footer>
.

[T. C.]

Post by Brian Bi

Post by m***@gmail.com
Wouldn't it be miles better to instead of un-teaching people from
std::endl and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an
std or build in "command"/object, but some alien symbol (to a new comer)
like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just
simple letters, not rarely used symbols (double colon, is not rarely used a
t all)

I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.
Also, I think adding some hypothetical new "std::newline" constant in an
attempt to "seduce" novices does them a disservice by making them waste
keystrokes and tempting them to use "using namespace std" to save a few.
In other words, teaching people to use '\n' really is the best solution.

I can see a manipulator that does endl-without-the-flush to be marginally
useful. It would be different from << '\n' in that it performs unformatted
output, i.e., no padding.

I'm not convinced that it's worth standardizing.

Post by Brian Bi

Post by m***@gmail.com
Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.
--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org?utm_medium=email&utm_source=footer>
.

--
*Brian Bi*

[W Brown]

Wouldn't it be miles better to instead of un-teaching people from std::endl and advertise '\n' <https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl> to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an std or build in "command"/object, but some alien symbol (to a new comer) like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple letters, not rarely used symbols (double colon, is not rarely used a t all)
I think the reason why novices use std::endl is that they're under the impression (no doubt perpetuated by incompetent educators) that std::endl is portable whereas '\n' isn't.
Also, I think adding some hypothetical new "std::newline" constant in an attempt to "seduce" novices does them a disservice by making them waste keystrokes and tempting them to use "using namespace std" to save a few.
In other words, teaching people to use '\n' really is the best solution.
I can see a manipulator that does endl-without-the-flush to be marginally useful. It would be different from << '\n' in that it performs unformatted output, i.e., no padding.
I'm not convinced that it's worth standardizing.
Also, if we have a friendly new line alternative we could deprecate endl and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org?utm_medium=email&utm_source=footer>.
--
Brian Bi
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/fff2c6b4-0f49-4151-bcf0-094e273cafa5%40isocpp.org <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/fff2c6b4-0f49-4151-bcf0-094e273cafa5%40isocpp.org?utm_medium=email&utm_source=footer>.

[Hyman Rosen]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.

[Peter Sommerlad]

So the better way is do better teaching. I show my students that they should not use endl, except when they need it.

Sent from Peter Sommerlad's iPad
[phone]

Post by Hyman Rosen

I think the reason why novices use std::endl is that they're under the impression (no doubt perpetuated by incompetent educators) that std::endl is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com.

[m***@gmail.com]

There are multiple problems with '\n'

First - it is ultimately C ("way")
Second, when we introduce simple output to beginners, for which cout is
actually good because of overloading,
when using '\n' we have to introduce additional topics
- the fact a char can be more the one, well, character
- special magic characters
We also create asymmetry b/w what is used to start the output std::cout (an
object), to modify it (hex) and what is used to end it ("magic").

This screams some design flaw - we should be able to insert a new lines the
same way we modify the stream!

On its own std::endl has the flaw that it does not obey the "do one thing"
rule.
Once we deprecate it, this will shut down all the naive tutorials/courses
still teaching it as the default!


As for std::newline, we have options -

std::nl //< even a beginner can "read" it
std::newl //< orthogonal to endl
std::br //< why not at this point!
std::brl
std::bl

Geeks can still use `\n`, but a beginner (and a teacher) will have a
simple, *correct, *go-to option that models the syntax already introduced
(std::cout)!

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.
Sent from Peter Sommerlad's iPad
[phone]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com?utm_medium=email&utm_source=footer>
.

[Brian Bi]

Post by m***@gmail.com
There are multiple problems with '\n'
First - it is ultimately C ("way")

This mailing list is about C++, not Java, Rust, Swift, etc.
This is not an argument.

Second, when we introduce simple output to beginners, for which cout is

Post by m***@gmail.com
actually good because of overloading,
when using '\n' we have to introduce additional topics
- the fact a char can be more the one, well, character
- special magic characters
We also create asymmetry b/w what is used to start the output std::cout
(an object), to modify it (hex) and what is used to end it ("magic").

What do you mean, "what is used to end it"? A semicolon?

Post by m***@gmail.com
This screams some design flaw - we should be able to insert a new lines
the same way we modify the stream!

Yes, the way to do that is with '\n'.

Post by m***@gmail.com
On its own std::endl has the flaw that it does not obey the "do one thing"
rule.
Once we deprecate it, this will shut down all the naive tutorials/courses
still teaching it as the default!
As for std::newline, we have options -
std::nl //< even a beginner can "read" it
std::newl //< orthogonal to endl
std::br //< why not at this point!
std::brl
std::bl
Geeks can still use `\n`, but a beginner (and a teacher) will have a
simple, *correct, *go-to option that models the syntax already introduced
(std::cout)!

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.
Sent from Peter Sommerlad's iPad
[phone]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
--

You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org?utm_medium=email&utm_source=footer>
.

[m***@gmail.com]

Post by Brian Bi

Post by m***@gmail.com
There are multiple problems with '\n'
First - it is ultimately C ("way")

This mailing list is about C++, not Java, Rust, Swift, etc.
This is not an argument.

There is some sort of miscommunication.
The fact there no C++ way to insert a new line (only a UNIX special
character way) is what I state an issue,
considering the rest of the API

Post by Brian Bi
Second, when we introduce simple output to beginners, for which cout is

Post by m***@gmail.com
actually good because of overloading,
when using '\n' we have to introduce additional topics
- the fact a char can be more the one, well, character
- special magic characters
We also create asymmetry b/w what is used to start the output std::cout
(an object), to modify it (hex) and what is used to end it ("magic").

What do you mean, "what is used to end it"? A semicolon?

std::cout //< start
<< 12.f
<< ' '
<< std::hex //< modify
<< 255
<< '\n'; //< finish (magic)

Note that printf (and other languages) already use special characters to
modify the output, so having an '\n' is not abrupt.

But C++ streams are different, having to spell out a special character is
odd and unintuitive for a beginner and a design deficiency in general.

Post by Brian Bi

Post by m***@gmail.com
This screams some design flaw - we should be able to insert a new lines
the same way we modify the stream!

Yes, the way to do that is with '\n'.

Post by m***@gmail.com
On its own std::endl has the flaw that it does not obey the "do one
thing" rule.
Once we deprecate it, this will shut down all the naive tutorials/courses
still teaching it as the default!
As for std::newline, we have options -
std::nl //< even a beginner can "read" it
std::newl //< orthogonal to endl
std::br //< why not at this point!
std::brl
std::bl
Geeks can still use `\n`, but a beginner (and a teacher) will have a
simple, *correct, *go-to option that models the syntax already
introduced (std::cout)!

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.
Sent from Peter Sommerlad's iPad
[phone]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
--

You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org?utm_medium=email&utm_source=footer>
.

--
*Brian Bi*

[Nicolas Lesser]

You're going to have a hard time because the committee doesn't like
iostreams and plans on replacing them with something else.

And I don't really see a problem with \n. Sure, it's a bit old-school, but
it's clear and almost every language uses it. If you're programming you'll
going to have to learn \n eventually.

Post by m***@gmail.com

Post by Brian Bi

Post by m***@gmail.com
There are multiple problems with '\n'
First - it is ultimately C ("way")

This mailing list is about C++, not Java, Rust, Swift, etc.
This is not an argument.

There is some sort of miscommunication.
The fact there no C++ way to insert a new line (only a UNIX special
character way) is what I state an issue,
considering the rest of the API

Post by Brian Bi
Second, when we introduce simple output to beginners, for which cout is

Post by m***@gmail.com
actually good because of overloading,
when using '\n' we have to introduce additional topics
- the fact a char can be more the one, well, character
- special magic characters
We also create asymmetry b/w what is used to start the output std::cout
(an object), to modify it (hex) and what is used to end it ("magic").

What do you mean, "what is used to end it"? A semicolon?

std::cout //< start
<< 12.f
<< ' '
<< std::hex //< modify
<< 255
<< '\n'; //< finish (magic)
Note that printf (and other languages) already use special characters to
modify the output, so having an '\n' is not abrupt.
But C++ streams are different, having to spell out a special character is
odd and unintuitive for a beginner and a design deficiency in general.

Post by Brian Bi

Post by m***@gmail.com
This screams some design flaw - we should be able to insert a new lines
the same way we modify the stream!

Yes, the way to do that is with '\n'.

Post by m***@gmail.com
On its own std::endl has the flaw that it does not obey the "do one
thing" rule.
Once we deprecate it, this will shut down all the naive
tutorials/courses still teaching it as the default!
As for std::newline, we have options -
std::nl //< even a beginner can "read" it
std::newl //< orthogonal to endl
std::br //< why not at this point!
std::brl
std::bl
Geeks can still use `\n`, but a beginner (and a teacher) will have a
simple, *correct, *go-to option that models the syntax already
introduced (std::cout)!

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.
Sent from Peter Sommerlad's iPad
[phone]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
--

You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org?utm_medium=email&utm_source=footer>
.

--
*Brian Bi*

--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org?utm_medium=email&utm_source=footer>
.

[m***@gmail.com]

Post by Nicolas Lesser
You're going to have a hard time because the committee doesn't like
iostreams and plans on replacing them with something else.

Are there any proposals in flight? I see Text Formating
<http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p0645r3.html>, but
it does not include I/O (AFAICT)

Post by Nicolas Lesser
And I don't really see a problem with \n. Sure, it's a bit old-school, but
it's clear and almost every language uses it. If you're programming you'll
going to have to learn \n eventually.

Post by m***@gmail.com

Post by Brian Bi

Post by m***@gmail.com
There are multiple problems with '\n'
First - it is ultimately C ("way")

This mailing list is about C++, not Java, Rust, Swift, etc.
This is not an argument.

There is some sort of miscommunication.
The fact there no C++ way to insert a new line (only a UNIX special
character way) is what I state an issue,
considering the rest of the API

Post by Brian Bi
Second, when we introduce simple output to beginners, for which cout is

Post by m***@gmail.com
actually good because of overloading,
when using '\n' we have to introduce additional topics
- the fact a char can be more the one, well, character
- special magic characters
We also create asymmetry b/w what is used to start the output std::cout
(an object), to modify it (hex) and what is used to end it ("magic").

What do you mean, "what is used to end it"? A semicolon?

std::cout //< start
<< 12.f
<< ' '
<< std::hex //< modify
<< 255
<< '\n'; //< finish (magic)
Note that printf (and other languages) already use special characters to
modify the output, so having an '\n' is not abrupt.
But C++ streams are different, having to spell out a special character is
odd and unintuitive for a beginner and a design deficiency in general.

Post by Brian Bi

Post by m***@gmail.com
This screams some design flaw - we should be able to insert a new lines
the same way we modify the stream!

Yes, the way to do that is with '\n'.

Post by m***@gmail.com
On its own std::endl has the flaw that it does not obey the "do one
thing" rule.
Once we deprecate it, this will shut down all the naive
tutorials/courses still teaching it as the default!
As for std::newline, we have options -
std::nl //< even a beginner can "read" it
std::newl //< orthogonal to endl
std::br //< why not at this point!
std::brl
std::bl
Geeks can still use `\n`, but a beginner (and a teacher) will have a
simple, *correct, *go-to option that models the syntax already
introduced (std::cout)!

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.
Sent from Peter Sommerlad's iPad
[phone]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under
the impression (no doubt perpetuated by incompetent educators) that
std::endl is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
--

You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org?utm_medium=email&utm_source=footer>
.

--
*Brian Bi*

--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org?utm_medium=email&utm_source=footer>
.

[Nicolas Lesser]

Post by m***@gmail.com

Post by Nicolas Lesser
You're going to have a hard time because the committee doesn't like
iostreams and plans on replacing them with something else.

Are there any proposals in flight? I see Text Formating
<http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p0645r3.html>,
but it does not include I/O (AFAICT)

I don't actually know. It's just what I've been hearing. Don't know how
accurate that is though...

Post by m***@gmail.com

Post by Nicolas Lesser
And I don't really see a problem with \n. Sure, it's a bit old-school,
but it's clear and almost every language uses it. If you're programming
you'll going to have to learn \n eventually.

Post by m***@gmail.com

Post by Brian Bi

Post by m***@gmail.com
There are multiple problems with '\n'
First - it is ultimately C ("way")

This mailing list is about C++, not Java, Rust, Swift, etc.
This is not an argument.

There is some sort of miscommunication.
The fact there no C++ way to insert a new line (only a UNIX special
character way) is what I state an issue,
considering the rest of the API

Post by Brian Bi
Second, when we introduce simple output to beginners, for which cout is

Post by m***@gmail.com
actually good because of overloading,
when using '\n' we have to introduce additional topics
- the fact a char can be more the one, well, character
- special magic characters
We also create asymmetry b/w what is used to start the output
std::cout (an object), to modify it (hex) and what is used to end it
("magic").

What do you mean, "what is used to end it"? A semicolon?

std::cout //< start
<< 12.f
<< ' '
<< std::hex //< modify
<< 255
<< '\n'; //< finish (magic)
Note that printf (and other languages) already use special characters to
modify the output, so having an '\n' is not abrupt.
But C++ streams are different, having to spell out a special character
is odd and unintuitive for a beginner and a design deficiency in general.

Post by Brian Bi

Post by m***@gmail.com
This screams some design flaw - we should be able to insert a new
lines the same way we modify the stream!

Yes, the way to do that is with '\n'.

Post by m***@gmail.com
On its own std::endl has the flaw that it does not obey the "do one
thing" rule.
Once we deprecate it, this will shut down all the naive
tutorials/courses still teaching it as the default!
As for std::newline, we have options -
std::nl //< even a beginner can "read" it
std::newl //< orthogonal to endl
std::br //< why not at this point!
std::brl
std::bl
Geeks can still use `\n`, but a beginner (and a teacher) will have a
simple, *correct, *go-to option that models the syntax already
introduced (std::cout)!

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.
Sent from Peter Sommerlad's iPad
[phone]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under
the impression (no doubt perpetuated by incompetent educators) that
std::endl is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it,
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
--

You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org?utm_medium=email&utm_source=footer>
.

--
*Brian Bi*

--
You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org?utm_medium=email&utm_source=footer>
.

--

You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/f7bd155a-bcbf-49f0-ac34-f0628ccf50e1%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/f7bd155a-bcbf-49f0-ac34-f0628ccf50e1%40isocpp.org?utm_medium=email&utm_source=footer>
.

[Brian Bi]

Post by m***@gmail.com

Post by Brian Bi

Post by m***@gmail.com
There are multiple problems with '\n'
First - it is ultimately C ("way")

This mailing list is about C++, not Java, Rust, Swift, etc.
This is not an argument.

There is some sort of miscommunication.
The fact there no C++ way to insert a new line (only a UNIX special
character way) is what I state an issue,
considering the rest of the API

'\n' is standard C, which became standard C++ about 20 years ago. I don't
see the issue.

Post by m***@gmail.com

Post by Brian Bi
Second, when we introduce simple output to beginners, for which cout is

Post by m***@gmail.com
actually good because of overloading,
when using '\n' we have to introduce additional topics
- the fact a char can be more the one, well, character
- special magic characters
We also create asymmetry b/w what is used to start the output std::cout
(an object), to modify it (hex) and what is used to end it ("magic").

What do you mean, "what is used to end it"? A semicolon?

std::cout //< start
<< 12.f
<< ' '
<< std::hex //< modify
<< 255
<< '\n'; //< finish (magic)

Note that printf (and other languages) already use special characters to

Post by m***@gmail.com
modify the output, so having an '\n' is not abrupt.
But C++ streams are different, having to spell out a special character is
odd and unintuitive for a beginner and a design deficiency in general.

It's only "magic" if you teach beginners that '\n' is a special magic
command, rather than the literal representation of the newline character.

Post by m***@gmail.com

Post by Brian Bi

Post by m***@gmail.com
This screams some design flaw - we should be able to insert a new lines
the same way we modify the stream!

Yes, the way to do that is with '\n'.

Post by m***@gmail.com
On its own std::endl has the flaw that it does not obey the "do one
thing" rule.
Once we deprecate it, this will shut down all the naive
tutorials/courses still teaching it as the default!
As for std::newline, we have options -
std::nl //< even a beginner can "read" it
std::newl //< orthogonal to endl
std::br //< why not at this point!
std::brl
std::bl
Geeks can still use `\n`, but a beginner (and a teacher) will have a
simple, *correct, *go-to option that models the syntax already
introduced (std::cout)!

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.
Sent from Peter Sommerlad's iPad
[phone]

Post by Brian Bi
I think the reason why novices use std::endl is that they're under the
impression (no doubt perpetuated by incompetent educators) that std::endl
is portable whereas '\n' isn't.

I think novices use std::endl because that's how C++ formatted I/O
was presented for ages. I have the feeling, completely unsupported
by evidence, that the iostreams designers thought manipulators were
really keen, and wanted to have one that would always get used.
--
You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAHSYqdYYZjeHHbRZ5bcHLYVsWfspwCeQ8oxEDRbuJ8dqAtsX5A%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
--

You received this message because you are subscribed to the Google
Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/b49f4c85-816b-4b35-851d-407061a8ef9f%40isocpp.org?utm_medium=email&utm_source=footer>
.

--
*Brian Bi*

--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7da1f33f-c2c1-482f-8fc2-c23a9767a5ec%40isocpp.org?utm_medium=email&utm_source=footer>
.

[Jake Arkinstall]

Post by Brian Bi
It's only "magic" if you teach beginners that '\n' is a special magic
command, rather than the literal representation of the newline character.

This. A thousand times this.

'\n' isn't magic in the same way that '\0' and '\t' aren't magic. They're
well known representations of special characters, and such ideas have been
in use in encodings in one form or another for well over a hundred years.
Avoiding them in any learning setting is fruitless in my opinion and,
perhaps, gives the opposite of the intended outcome - we replace a "magic"
that is consistent across dozens of languages with a "magic" command that
creates a newline.

I agree that endl is badly named, but it's one of those things where
deprecation (in terms of renaming) would cause a lot of friction. I'd
sooner just see a better (I.e. more efficient, better compile time support,
and less verbose - especially the disaster that is stream modifiers, that
make printf look user friendly) output approach and let std::endl die out -
not with a bang, but with a whimper.

[m***@gmail.com]

Post by Jake Arkinstall

Post by Brian Bi
It's only "magic" if you teach beginners that '\n' is a special magic
command, rather than the literal representation of the newline character.

This. A thousand times this.
'\n' isn't magic in the same way that '\0' and '\t' aren't magic. They're
well known representations of special characters, and such ideas have been
in use in encodings in one form or another for well over a hundred years.
Avoiding them in any learning setting is fruitless in my opinion and,
perhaps, gives the opposite of the intended outcome - we replace a "magic"
that is consistent across dozens of languages with a "magic" command that
creates a newline.

By no mean I suggest avoiding them altogether. I only point out that
- A beginner will have to be abruptly introduced to special characters in
his first day (in an API that does not used any special characters!)
- It is a glaring API inconsistency on its own

Post by Jake Arkinstall
I agree that endl is badly named, but it's one of those things where
deprecation (in terms of renaming) would cause a lot of friction. I'd
sooner just see a better (I.e. more efficient, better compile time support,
and less verbose - especially the disaster that is stream modifiers, that
make printf look user friendly) output approach and let std::endl die out -
not with a bang, but with a whimper.

We all do, but I don't see that coming anytime soon.

Maybe we could just deprecate endl and advocate using '\n' "until something
better comes along".
This will play nicely with format() as people will get used to adding it as
part of the formating string.

As mentioned, deprecating it will (hopefully) prevent teaching it.

[Brian Bi]

Post by m***@gmail.com

Post by Jake Arkinstall

Post by Brian Bi
It's only "magic" if you teach beginners that '\n' is a special magic
command, rather than the literal representation of the newline character.

This. A thousand times this.
'\n' isn't magic in the same way that '\0' and '\t' aren't magic. They're
well known representations of special characters, and such ideas have been
in use in encodings in one form or another for well over a hundred years.
Avoiding them in any learning setting is fruitless in my opinion and,
perhaps, gives the opposite of the intended outcome - we replace a "magic"
that is consistent across dozens of languages with a "magic" command that
creates a newline.

By no mean I suggest avoiding them altogether. I only point out that
- A beginner will have to be abruptly introduced to special characters in
his first day (in an API that does not used any special characters!)
- It is a glaring API inconsistency on its own

How is it an API inconsistency? The way the API works is that you pass it a
character, and it prints that character out. Escape sequences are entirely
orthogonal to the API.

Post by m***@gmail.com

Post by Jake Arkinstall
I agree that endl is badly named, but it's one of those things where
deprecation (in terms of renaming) would cause a lot of friction. I'd
sooner just see a better (I.e. more efficient, better compile time support,
and less verbose - especially the disaster that is stream modifiers, that
make printf look user friendly) output approach and let std::endl die out -
not with a bang, but with a whimper.

We all do, but I don't see that coming anytime soon.
Maybe we could just deprecate endl and advocate using '\n' "until
something better comes along".
This will play nicely with format() as people will get used to adding it
as part of the formating string.
As mentioned, deprecating it will (hopefully) prevent teaching it.
--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7ea647c8-9bfb-4cd9-b55f-4e8b83160451%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7ea647c8-9bfb-4cd9-b55f-4e8b83160451%40isocpp.org?utm_medium=email&utm_source=footer>
.

[Thiago Macieira]

Post by m***@gmail.com
- A beginner will have to be abruptly introduced to special characters in
his first day (in an API that does not used any special characters!)

A beginner needs to be taught the basics of the language. The difference
between "a" and 'a' is a lot more confusing than the presence of escape
sequences.
--
Thiago Macieira - thiago (AT) macieira.info - thiago (AT) kde.org
Software Architect - Intel Open Source Technology Center

[Matthew Woehlke]

Post by m***@gmail.com
By no mean I suggest avoiding them altogether. I only point out that
- A beginner will have to be abruptly introduced to special characters in
his first day (in an API that does not used any special characters!)
- It is a glaring API inconsistency on its own

It sounds like what you *really* want is the equivalent of Python's
print(), which prints a line of text and automatically adds the newline.

Maybe you could propose that?

BTW, Qt's QDebug also does that, and some other stuff:

qInfo() << "Hello" << "world";

...will print "Hello world\n", modulo any additional logging formatting
(e.g. prepending with the time) that is configured.

[Matthew Woehlke]

Post by m***@gmail.com
There is some sort of miscommunication.
The fact there no C++ way to insert a new line (only a UNIX special
character way) is what I state an issue,
considering the rest of the API

Huh?

'\n' is not "a UNIX special character". It is an escape sequence that
refers to the NEWLINE character.

Escape sequences are important. Not only should most programmers be
familiar with at least '\n', but also '\'', '\"' and of course '\\'.
Lacking this familiarity is just a recipe for getting into trouble when
needing to have these characters in a string.

As for NEWLINE, it is not UNIX specific. It is true that "UNIX" the the
line ending standard that uses '\n' by itself to mark the ends of lines
of files on disk, but it is *also* the standard for files being
processed in "text" mode. *On ALL platforms*. In fact, it is more
possible to be ignorant of the existence of other line ending
conventions than to be ignorant that at a code level, '\n' is *the*
correct way to end lines.

Post by m***@gmail.com
But C++ streams are different, having to spell out a special character is
odd and unintuitive for a beginner and a design deficiency in general.

So how do you print quote characters? Or backslashes? Or *any*
"non-printable" character?

Trying to avoid teaching escaped characters, which exist in virtually
EVERY computer language (not just "programming" languages, but markup
languages as well) is just dumb.

[o***@gmail.com]

Post by Peter Sommerlad
So the better way is do better teaching. I show my students that they
should not use endl, except when they need it.

When does one need std::endl?
AFAIK std::endl could / should be deprecated.
Write "\n" << std::flush; if that's what you need.

[Eyal Rozenberg]

Post by Brian Bi
Also, I think adding some hypothetical new "std::newline" constant in an
attempt to "seduce" novices does them a disservice by making them waste
keystrokes and tempting them to use "using namespace std" to save a few.

But it allows people (not only novices) to use literal strings with no
escapes; and that _is_ kind of useful, at least from an aesthetic
perspective. There is also the argument of a (slightly) reduced learning
curve for novices. Someone who has not programmed before will understand

"hello world" << std::newline << "goodbye world"

faster than

"hello world\ngoodbye world"


I'm not saying that's an important enough advantage, but still.

Eyal

[Edward Catmur]

Start them out with raw strings, then.

std::cout << R"(hello
world
)";

Escape characters can wait till a later lesson, once they're happy with getting a program to produce output.

[m***@gmail.com]

I think there's great value in teaching people about escape sequences
early, it's a useful cross-language concept that they'll run into forever.
I'm also not convinced it's harder to learn than std::endl, In fact I think
it's much simpler because it's part of the string meaning multi-line
strings are easy to work with instead of something magical that comes from
streaming in objects that come from elsewhere in the standard library.

Teaching someone 'put \n where you want a line break' seems easier to me
than 'if you want a line break, end your string, stream in std::endl, then
start streaming a new string'. The first says, 'this string has a line
break in it', the second is 'there are two strings, in the middle we're
doing the magical end-line operation.

Post by m***@gmail.com
Wouldn't it be miles better to instead of un-teaching people from
std::endl and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an
std or build in "command"/object, but some alien symbol (to a new comer)
like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple
letters, not rarely used symbols (double colon, is not rarely used a t all)
Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.

[m***@gmail.com]

Furthermore I think teaching \n naturally leads into curiosity about how
strings work, the fact that a 'char' is an integer holding an ASCII value,
that there are other special escape characters like \t, and that you can
escape integer literals for the other ones too.

Teaching people to use a separate std::endl doesn't teach people about
strings, it teaches them about iostreams.

[Bryce Adelstein Lelbach aka wash]

I'd rather just focus on providing a modern replacement for iostreams for
C++26, and aim to deprecate iostreams in the future.

Standard library dynamic constructors violate the zero cost abstraction
principle. std::cout and friends must go.

Post by m***@gmail.com
Wouldn't it be miles better to instead of un-teaching people from
std::endl and advertise '\n'
<https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#slio50-avoid-endl>
to have equally attractive alternative?
The point is - '\n' is not in any way beginner friendly as it is not an
std or build in "command"/object, but some alien symbol (to a new comer)
like, literally nothing else - it does not even look a single character.
Even for a non-beginner, some prefer typing std::endl as it is just simple
letters, not rarely used symbols (double colon, is not rarely used a t all)
Also, if we have a friendly new line alternative we could deprecate endl
and teach to new-line-and-flush-if-needed.
Without deprecating it, we might add confusion.
--
You received this message because you are subscribed to the Google Groups
"ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an
To view this discussion on the web visit
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org
<https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/e17189bf-51be-496d-845a-3707a516a210%40isocpp.org?utm_medium=email&utm_source=footer>
.

[a***@gmail.com]

If the purpose is on teaching, than for sure special characters have to be introduced sometime.
Maybe teach this?

const auto newline = '\n'; // constexpr maybe?

[FrankHB1989]

It seems to be the cost of omission of line buffered stream notion (as in
ISO C) in C++.

That said, I don't see it a big deal to teach newbies '\n' or std::endl as
long as they can know the difference.