Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.c++ > #78998 > unrolled thread

No, C is not a simple language

Started byJuha Nieminen <nospam@thanks.invalid>
First post2021-04-17 05:56 +0000
Last post2021-04-26 08:49 +0000
Articles 20 on this page of 143 — 32 participants

Back to article view | Back to comp.lang.c++


Contents

  No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-17 05:56 +0000
    Re: No, C is not a simple language Christian Gollwitzer <auriocus@gmx.de> - 2021-04-17 08:42 +0200
    Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-16 23:49 -0700
      Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-18 16:25 +0000
        Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-19 06:43 -0700
          Re: No, C is not a simple language Bo Persson <bo@bo-persson.se> - 2021-04-19 20:19 +0200
            Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-19 13:04 -0700
          Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-20 04:02 +0000
            Re: No, C is not a simple language Chris Vine <chris@cvine--nospam--.freeserve.co.uk> - 2021-04-21 18:30 +0100
              Re: No, C is not a simple language scott@slp53.sl.home (Scott Lurndal) - 2021-04-21 18:33 +0000
                Re: No, C is not a simple language Chris Vine <chris@cvine--nospam--.freeserve.co.uk> - 2021-04-21 21:14 +0100
                  Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-21 22:38 -0700
                Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-21 15:37 -0700
                Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-22 10:14 -0700
              Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-22 08:45 +0000
                Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-22 01:48 -0700
                Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-22 01:51 -0700
                  Re: No, C is not a simple language MrSpook_l0xjKyc@b3jtfv70fxckzmak.net - 2021-04-22 09:40 +0000
                    Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-22 12:38 -0700
                    Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-23 07:12 +0000
                      Re: No, C is not a simple language MrSpook_l0c6dv@66h4_0ccefudc0u8w.gov - 2021-04-23 09:14 +0000
                        Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 04:47 +0000
                          Re: No, C is not a simple language MrSpook_531q@dr4t0dkj168m4ml.tv - 2021-04-26 08:13 +0000
                            Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-26 01:22 -0700
                              Re: No, C is not a simple language MrSpook_9p05k3C69@xr34.gov.uk - 2021-04-26 09:03 +0000
                                Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-26 02:17 -0700
                                  Re: No, C is not a simple language MrSpook_i4zl8mHy@0tr9r.eu - 2021-04-26 09:23 +0000
                                Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-26 02:22 -0700
                            Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 09:37 +0000
                              Re: No, C is not a simple language MrSpook_gbzt63zc@83jpfr9ry9f55a.tv - 2021-04-26 10:22 +0000
                                Re: No, C is not a simple language Bo Persson <bo@bo-persson.se> - 2021-04-26 13:05 +0200
                                Re: No, C is not a simple language David Brown <david.brown@hesbynett.no> - 2021-04-26 13:10 +0200
                            Re: No, C is not a simple language Paavo Helde <myfirstname@osa.pri.ee> - 2021-04-26 14:38 +0300
                              Re: No, C is not a simple language MrSpook_mD_r@g72w8ixztm106rprqnby.tv - 2021-04-26 13:49 +0000
                Re: No, C is not a simple language MrSpook_lxrj1vfhmw@qdgb.org - 2021-04-22 09:37 +0000
                  Re: No, C is not a simple language Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 11:32 +0100
                    Re: No, C is not a simple language MrSpook_f0mj9r@d6g.gov.uk - 2021-04-22 10:38 +0000
                      Re: No, C is not a simple language Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 12:35 +0100
                Re: No, C is not a simple language Chris Vine <chris@cvine--nospam--.freeserve.co.uk> - 2021-04-22 13:35 +0100
                  Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-23 07:20 +0000
                    Re: No, C is not a simple language Chris Vine <chris@cvine--nospam--.freeserve.co.uk> - 2021-04-23 11:01 +0100
                      Re: No, C is not a simple language Paavo Helde <myfirstname@osa.pri.ee> - 2021-04-23 15:44 +0300
                        Re: No, C is not a simple language Chris Vine <chris@cvine--nospam--.freeserve.co.uk> - 2021-04-23 17:52 +0100
                          Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 04:55 +0000
                            Re: No, C is not a simple language Chris Vine <chris@cvine--nospam--.freeserve.co.uk> - 2021-04-26 22:16 +0100
                Re: No, C is not a simple language Manfred <noname@add.invalid> - 2021-04-22 16:30 +0200
                  Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-23 07:32 +0000
                    Re: No, C is not a simple language Manfred <noname@add.invalid> - 2021-04-23 20:35 +0200
                      Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 05:01 +0000
          Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-20 04:56 +0000
            Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-20 05:22 -0700
    Re: No, C is not a simple language MrSpook_wb@g9b2a_ex9aicgvs04.net - 2021-04-17 10:27 +0000
      Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-18 16:30 +0000
        Re: No, C is not a simple language MrSpook_wyzaq1485z@solbi8e3oaumg9.gov.uk - 2021-04-19 07:42 +0000
    Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-17 17:43 +0200
      Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-18 16:39 +0000
        Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-18 20:48 +0200
    Re: No, C is not a simple language Manfred <noname@add.invalid> - 2021-04-17 19:12 +0200
      Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-18 16:46 +0000
        Re: No, C is not a simple language Manfred <noname@add.invalid> - 2021-04-18 20:30 +0200
          Re: No, C is not a simple language Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-04-18 12:46 -0700
            Re: No, C is not a simple language Manfred <noname@add.invalid> - 2021-04-18 22:53 +0200
          Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-19 07:18 +0000
            Re: No, C is not a simple language Manfred <noname@add.invalid> - 2021-04-19 17:15 +0200
              Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-20 04:05 +0000
                Re: No, C is not a simple language Manfred <noname@add.invalid> - 2021-04-20 18:27 +0200
                  Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-20 16:41 +0000
                    Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-20 19:44 +0200
                      Re: No, C is not a simple language Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-20 18:30 +0000
                        Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-20 20:47 +0200
                          Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-20 13:29 -0700
                          Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-21 04:37 +0000
                            Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-20 22:02 -0700
                              Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-20 22:35 -0700
                            Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-21 15:26 -0700
                              Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-21 22:06 -0700
                                Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-22 08:52 +0000
                                  Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-22 09:41 -0700
                                    Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-23 07:34 +0000
                                      Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-23 04:58 -0700
                                        Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 05:04 +0000
                                        Re: No, C is not a simple language Paavo Helde <myfirstname@osa.pri.ee> - 2021-04-26 09:41 +0300
                                        Re: No, C is not a simple language James Kuyper <jameskuyper@alumni.caltech.edu> - 2021-04-26 10:25 -0400
                                          Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-26 12:07 -0700
                                            Re: No, C is not a simple language Christian Gollwitzer <auriocus@gmx.de> - 2021-04-28 08:03 +0200
                                Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-22 09:26 -0700
                      Re: No, C is not a simple language Richard Damon <Richard@Damon-Family.org> - 2021-04-20 14:46 -0400
                        Re: No, C is not a simple language Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-20 20:18 +0000
                      Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-20 13:19 -0700
                        Re: No, C is not a simple language Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-20 20:29 +0000
                          Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-20 13:39 -0700
                            Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-20 14:29 -0700
                      Re: No, C is not a simple language Ian Collins <ian-news@hotmail.com> - 2021-04-21 08:56 +1200
                      Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-20 14:07 -0700
                        Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-23 12:10 +0200
                          Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-23 04:10 -0700
                            Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-28 00:32 -0700
                              Re: No, C is not a simple language wij <wyniijj@gmail.com> - 2021-04-28 11:04 -0700
                          Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 12:37 -0700
                            Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 12:38 -0700
                            Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 12:43 -0700
                              Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-23 22:38 +0200
                                Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 13:44 -0700
                                Re: No, C is not a simple language Ian Collins <ian-news@hotmail.com> - 2021-04-24 10:56 +1200
                                  Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 16:09 -0700
                              Re: No, C is not a simple language Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-24 03:51 +0000
                      Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-26 09:24 +0000
                      Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-26 09:27 +0000
                    Re: No, C is not a simple language "Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com> - 2021-04-20 19:53 +0200
                    Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-26 09:02 +0000
                      Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 09:43 +0000
                        Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-26 10:35 +0000
                          Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 13:08 +0000
                            Re: No, C is not a simple language Richard Damon <Richard@Damon-Family.org> - 2021-04-26 09:30 -0400
                            Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-26 14:15 +0000
                              Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-27 04:37 +0000
                                Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-27 07:22 +0000
      Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-19 21:42 -0700
        Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-22 00:26 -0700
      Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-28 00:02 -0700
    Re: No, C is not a simple language Bonita Montero <Bonita.Montero@gmail.com> - 2021-04-17 21:36 +0200
      Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-18 16:49 +0000
        Re: No, C is not a simple language Bonita Montero <Bonita.Montero@gmail.com> - 2021-04-18 23:31 +0200
        Re: No, C is not a simple language Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 01:36 +0100
          Re: No, C is not a simple language Juha Nieminen <nospam@thanks.invalid> - 2021-04-19 07:19 +0000
            Re: No, C is not a simple language Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 11:36 +0100
            Re: No, C is not a simple language Bonita Montero <Bonita.Montero@gmail.com> - 2021-04-19 16:54 +0200
    Re: No, C is not a simple language Paavo Helde <myfirstname@osa.pri.ee> - 2021-04-18 00:48 +0300
    Re: No, C is not a simple language (PLO) olcott <NoOne@NoWhere.com> - 2021-04-18 16:04 -0500
      Re: No, C is not a simple language (PLO) Juha Nieminen <nospam@thanks.invalid> - 2021-04-19 07:22 +0000
        Re: No, C is not a simple language (PLO) olcott <NoOne@NoWhere.com> - 2021-04-19 09:50 -0500
          Re: No, C is not a simple language (PLO) jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-19 19:05 +0200
            Re: No, C is not a simple language (PLO) olcott <NoOne@NoWhere.com> - 2021-04-19 12:23 -0500
            Re: No, C is not a simple language (PLO) scott@slp53.sl.home (Scott Lurndal) - 2021-04-19 18:02 +0000
            Re: No, C is not a simple language (PLO) jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-19 21:03 +0200
              Re: No, C is not a simple language (PLO) olcott <NoOne@NoWhere.com> - 2021-04-19 15:14 -0500
            Re: No, C is not a simple language (PLO) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-19 17:16 -0700
              Re: No, C is not a simple language (PLO) jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-20 07:32 +0200
                Re: No, C is not a simple language (PLO) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-19 23:47 -0700
            Re: No, C is not a simple language (PLO) Juha Nieminen <nospam@thanks.invalid> - 2021-04-20 10:29 +0000
              Re: No, C is not a simple language (PLO) jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-20 14:14 +0200
                Re: No, C is not a simple language (PLO) Juha Nieminen <nospam@thanks.invalid> - 2021-04-20 16:44 +0000
    Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-26 08:49 +0000

Page 5 of 8 — ← Prev page 1 2 3 4 [5] 6 7 8  Next page →


#79263

FromJuha Nieminen <nospam@thanks.invalid>
Date2021-04-26 05:04 +0000
Message-ID<s65hln$1qla$1@gioia.aioe.org>
In reply to#79197
wij <wyniijj@gmail.com> wrote:
> You cannot use memcpy/memmove in 'pure' C++.

Why not? They are standard C++ library functions.

> As to the memory allocation issue, in extreme cases (real programs will encounter),
> e.g. many string objects, or one long string, one might even need to use zero-terminate
> c-string directly and RAII becomes a hinder.

That doesn't make any sense. RAII becomes a hinder for zero-terminating C strings?
What are you talking about?

[toc] | [prev] | [next] | [standalone]


#79266

FromPaavo Helde <myfirstname@osa.pri.ee>
Date2021-04-26 09:41 +0300
Message-ID<s65nb5$fd5$1@dont-email.me>
In reply to#79197
23.04.2021 14:58 wij kirjutas:
> 
> std::string provides "helper functions" to manipulate "C-string"
> (precisely speaking, this was an error of 'pure' C++, we are now actually
> talking about an erroneous feature of C++), does not mean C is ugly.

What? Making a C++ feature interoperable with C is an error?

One might argue that std::string class is too large and attempts to do 
too many things, and there might be a bit truth in it. That's why we now 
have other classes like std::string_view. On the other hand, all this 
large interface is sometimes needed, I think the only member function I 
have never used is std::string::at().

> 
> Helper functions(or macro/template) come with cost (user usually do not care,
> but note that it can accumulate) and can not cover all cases. 

I have no idea what you mean here. Arguably the whole C string 
manipulation is done by helper functions like strcat().

> You cannot use
> memcpy/memmove in 'pure' C++.

What? Technically memcpy() is the most correct way to do type punning in 
C++, for example. How come the most correct way to do something cannot 
be used?

I guess you wanted to say that memcpy() may not be used with non-trivial 
C++ objects. That's true, but what is the point? In C you may not call 
free() with an address of a local variable, this does not make free() 
unusable.

And what's the relation to the string processing? The std::string move 
operator will easily beat any memcpy() or memmove() of string contents, 
with the extra bonus that it is much less error prone.

> 
> As to the memory allocation issue, in extreme cases (real programs will encounter),
> e.g. many string objects, or one long string, one might even need to use zero-terminate
> c-string directly and RAII becomes a hinder.

Here I can not even guess what crossed your mind when writing these 
sentences. In case you are a not aware, all strings hold be std::string 
are already automatically zero-terminated nowadays.

If you want to really attack C++ over C you should express yourself more 
coherently. And choose some other topic, string processing is not an 
area where you can win, or even look credible.

[toc] | [prev] | [next] | [standalone]


#79296

FromJames Kuyper <jameskuyper@alumni.caltech.edu>
Date2021-04-26 10:25 -0400
Message-ID<s66ih1$onb$1@dont-email.me>
In reply to#79197
On 4/23/21 7:58 AM, wij wrote:
...
> ... You cannot use memcpy/memmove in 'pure' C++.

You can use them in well-formed C++ code. "well-formed" is a term
defined precisely by the C++ standard. "pure C++" not a term defined by
the standard. I suppose that it may be defined by you - but if so, the
truth of your statement depends upon how you define that term. The
importance of your statement also depends upon that definition. I can't
come up with a plausible definition for "pure C++" that makes your
statement both true and important. Could you provide one?

[toc] | [prev] | [next] | [standalone]


#79302

Fromwij <wyniijj@gmail.com>
Date2021-04-26 12:07 -0700
Message-ID<1ac34ba3-738c-4d35-bf2a-3edcc848e8bdn@googlegroups.com>
In reply to#79296
On Monday, 26 April 2021 at 22:25:48 UTC+8, james...@alumni.caltech.edu wrote:
> On 4/23/21 7:58 AM, wij wrote: 
> ... 
> > ... You cannot use memcpy/memmove in 'pure' C++. 
> 
> You can use them in well-formed C++ code. "well-formed" is a term 
> defined precisely by the C++ standard. "pure C++" not a term defined by 
> the standard. I suppose that it may be defined by you - but if so, the 
> truth of your statement depends upon how you define that term. The 
> importance of your statement also depends upon that definition. I can't 
> come up with a plausible definition for "pure C++" that makes your 
> statement both true and important. Could you provide one?

Forget about those snippet phrases that easily mislead occasional readers.
My mind was all about the development of C++ from its initial ideal and implement
to the real effect practiced and evaluated from the real world.
Obviously, I know little about the standard and you also understand I was not
referring to the standard.

The "slogan" of C++ started from system programming, changed latter to generic
programming, and settled down to multi-paradigm language.
Then, "my problem" is the concept of multi-paradigm and C++ standard practiced
by usual programmers contradict each other if C++ standard library dictates its
usage only a bit more. Other practices/implements, like mine (or Qt,..), are
easily classified as "non-standard" (multi-paradigm?).
Another one is about optimization. Procedural language (informal term) and
optimization, these two are also contraditory concepts. C++ stresses a lot about
optimization.

I guess all these things emerge from "No, C is not a simple language" we do
not really want to talk about. I may have written many seemingly unrelated
words, but to ruminate myself and for others who can understand.

[toc] | [prev] | [next] | [standalone]


#79345

FromChristian Gollwitzer <auriocus@gmx.de>
Date2021-04-28 08:03 +0200
Message-ID<s6atrs$eun$1@dont-email.me>
In reply to#79302
Am 26.04.21 um 21:07 schrieb wij:
> Forget about those snippet phrases that easily mislead occasional readers.
> My mind was all about the development of C++ from its initial ideal and implement
> to the real effect practiced and evaluated from the real world.
> Obviously, I know little about the standard and you also understand I was not
> referring to the standard.
> 
> The "slogan" of C++ started from system programming, changed latter to generic
> programming, and settled down to multi-paradigm language.
> Then, "my problem" is the concept of multi-paradigm and C++ standard practiced
> by usual programmers contradict each other if C++ standard library dictates its
> usage only a bit more. [...]

I think, you simply do not like C++ and like C more - and that is OK, it 
is your opinion. De gustibus non est disputandum.

Most people in this group simply have another opinion.

	Christian

[toc] | [prev] | [next] | [standalone]


#79173

Fromwij <wyniijj@gmail.com>
Date2021-04-22 09:26 -0700
Message-ID<b006ca17-1234-4acd-88e9-730f9bdc5ea4n@googlegroups.com>
In reply to#79150
On Thursday, 22 April 2021 at 13:06:43 UTC+8, wij wrote:
> On Thursday, 22 April 2021 at 06:27:16 UTC+8, Chris M. Thomasson wrote: 
> > On 4/20/2021 9:37 PM, Juha Nieminen wrote: 
> > > In comp.lang.c++ jacobnavia <ja...@jacob.remcomp.fr> wrote: 
> > >> See above. In small spaces GC is not that good. But we were talking 
> > >> about a TEXT EDITOR for learning C, so that is probably a PC environment 
> > >> where GC SHINES! 
> > > 
> > > If that's the case, then just use a language like Java or Python. 
> > > 
> > > Or, you know, C++. 
> > > 
> > > At least you won't be needing to use non-standard third-party extensions. 
> > > 
> > Fwiw, using an "extension" in C is nothing new. Want to create a server, 
> > better learn how to use sockets. If you want to go deep, create your own 
> > TCP stack. Is creating a driver in C to use a 3d party device "cheating" 
> > by using third-party extensions? third-party API's? 
> > 
> > Luckily for me a lot of my recent work is 100% workable with pure C and 
> > graphics. Pure C generating a PPM image is absolutely perfect. 100% 
> > portable and no 3d party code used in any way, shape or form. :^) 
> > 
> > If the user wants to view the result of my C code, they can choose any 
> > PPM viewer they want to. There, pure C code generating fractals, vector 
> > fields, abstract art, ect. ;^) 
> > 
> > Way back in the day I would be forced to use "extensions" to C. Things 
> > like POSIX, Pthreads, my own externally assembled atomic's libs for 
> > various archs using MASM and GAS, ect... I still have a bunch of code 
> > that uses the good ol' Pthreads for win32 lib here: 
> > 
> > https://sourceware.org/pthreads-win32 
> > 
> > When C/C++ 11 made atomic's and threading standard, it was really nice, 
> > but made me want to port all of my older code from Pthreads and assembly 
> > language to the new stuff. 
> > 
> > Here is a result of some of my C code generating a single file for 
> > another program, PovRay, to raytrace for me: 
> >
> When thread was introduced in C++11, I needed to consider using it or not, too. 
> But after weighing the gains and losses, I decided that RAII feature outweigh 
> the efficiency. Thus, not using it. 

Checked again from https://en.cppreference.com/w/cpp/thread/thread, along with
my document and email. Woo, I could have read a premature version of
std::thread (I do not use C++ standard library). I have been so wrong for these years.
Sorry about this part.

> C++ has several places violated its original OO principle, this is just one example. 
> For instance, the added keyword override/final/delete (good, but it reflects the 
> half-true "object model" crap) violated the C++ author's ideal (or guideline) about a 
> a good language "...not add a new feature and then add another to disable it..." 
> 
> > https://youtu.be/skGUAXAx6eg 
> > 
> > https://youtu.be/R0v_1EBAOr4

[toc] | [prev] | [next] | [standalone]


#79117

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-20 14:46 -0400
Message-ID<RjFfI.8203$N%1.1971@fx28.iad>
In reply to#79114
On 4/20/21 1:44 PM, jacobnavia wrote:
> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>> The problem with C is that anything that requires manual construction and
>> destruction will "contaminate" (can't think of a better word) anything
>> that
>> uses that first thing, with the same requirements. All the way down.
>>
>> If you have this kind of "string" object that requires manual
>> construction
>> and destruction, and you put it as a member of a struct, suddenly that
>> struct "inherits" the same requirement. Use that struct in yet another
>> struct and that, too, will "inherit" the same requirement.
> 
> No.
> 
> Just have a constructotr and never free anything. Then link with Boehm's
> GARBAGE COLLECTOR and be done with it!
> 
> I have already said this in this thread but people will go on arguing
> about how difficult is to keep the accounting of memory pieces right.
> 
> And they are right but refuse to see the right tool for theirpurpose:
> just use a garbage collector and BE DONE WITH IT.
> 
> I use an automatic car, no passing of gears. Recently I spoke with a
> taxi driver... "Don't you get bored passing gears all day?"
> 
> And he acknowledged: yes, My arm hurts at the end of the day. Maybe you
> are right, should get an automatic...
> 
> Use an automatic garbage collector and BE DONE WITH IT. And please, do
> not start with performance problems, in most string applications the gc
> is completely transparent.
> 
> 
But that only works for a fungible resource like memory. If you really
need to release the resource right away (like a lock on something) you
really want RAII.

[toc] | [prev] | [next] | [standalone]


#79119

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-04-20 20:18 +0000
Message-ID<20210420130138.376@kylheku.com>
In reply to#79117
["Followup-To:" header set to comp.lang.c.]
On 2021-04-20, Richard Damon <Richard@Damon-Family.org> wrote:
> On 4/20/21 1:44 PM, jacobnavia wrote:
>> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>>> The problem with C is that anything that requires manual construction and
>>> destruction will "contaminate" (can't think of a better word) anything
>>> that
>>> uses that first thing, with the same requirements. All the way down.
>>>
>>> If you have this kind of "string" object that requires manual
>>> construction
>>> and destruction, and you put it as a member of a struct, suddenly that
>>> struct "inherits" the same requirement. Use that struct in yet another
>>> struct and that, too, will "inherit" the same requirement.
>> 
>> No.
>> 
>> Just have a constructotr and never free anything. Then link with Boehm's
>> GARBAGE COLLECTOR and be done with it!
>> 
>> I have already said this in this thread but people will go on arguing
>> about how difficult is to keep the accounting of memory pieces right.
>> 
>> And they are right but refuse to see the right tool for theirpurpose:
>> just use a garbage collector and BE DONE WITH IT.
>> 
>> I use an automatic car, no passing of gears. Recently I spoke with a
>> taxi driver... "Don't you get bored passing gears all day?"
>> 
>> And he acknowledged: yes, My arm hurts at the end of the day. Maybe you
>> are right, should get an automatic...
>> 
>> Use an automatic garbage collector and BE DONE WITH IT. And please, do
>> not start with performance problems, in most string applications the gc
>> is completely transparent.
>> 
>> 
> But that only works for a fungible resource like memory. If you really
> need to release the resource right away (like a lock on something) you
> really want RAII.

RAII can be entirely separated from memory allocation. RAII can unlock
mutexes and close handles without invalidating memory.

I implemented a form of RAII in TXR Lisp.

  This is the TXR Lisp interactive listener of TXR 256.
  Quit with :quit or Ctrl-D on an empty line. Ctrl-X ? for cheatsheet.
  If unwanted side effects persist, discontinue imperative programming.
  1> (defstruct obj ()
       (:init (me) (put-line `@me constructed`))
       (:fini (me) (put-line `@me finalized`)))
  #<struct-type obj>
  2> (with-objects ((x (new obj)))
       (put-line "inside with-objects"))
  #S(obj) constructed
  inside with-objects
  #S(obj) finalized
  t

The object has not gone away; just its finalizer was prematurely
invoked. When the object becomes garbage, that finalizer will not be
called any more; it is no longer registered for finalization.

If an exception goes off while an object is being initialized,
a similar thing happens:

  TXR's no-spray organic production means every bug is carefully removed by hand.
  1> (defstruct obj ()
       (:init (me)
         (put-line `@me constructed ... almost`)
         (throw 'error))
       (:fini (me) (put-line `@me finalized`)))
  #<struct-type obj>
  2> (new obj)
  #S(obj) constructed ... almost
  #S(obj) finalized
  ** exception args: nil
  ** during evaluation at expr-1:4 of form (throw 'error)
  ** run with --backtrace to enable backtraces

Struct objects have multiple finalizers at different levels of the
inheritance hierarchy; these get called in well-defined, documented
orders.

You can invoke an object's finalizers directly at any time with
(call-finalizers obj). Using that, and unwind-protect, you can
build your own scoping macros.

For something like acquiring and releasing a lock, we wouldn't
be constructing an object.

This is the problem in C++: RAII is strictly based on constructing and
destroying something, and always requires an object, and that must be a
class.

TXR Lisp offers a standard macro (based on unwind-protect under the hood)
for managing resources that can be allocated with expressions that
produce a value, and then disposed of by passing that value to another
expression. The value can be anything:

  Use TXR only as directed. Unless you are intelligent, curious and creative.
  1> (defun make-widget (arg)
     (put-line `make-widget: @arg`)
     arg)
  make-widget
  2> (defun break-widget (arg)
       (put-line `break-widget: @arg`))
  break-widget
  3> (with-resources ((x (make-widget 42) (break-widget x))
                      (y (make-widget 'foo) (break-widget y)))
       (put-line "inside with-resources"))
  make-widget: 42
  make-widget: foo
  inside with-resources
  break-widget: foo
  break-widget: 42

[toc] | [prev] | [next] | [standalone]


#79120

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-20 13:19 -0700
Message-ID<s5nd0k$2po$1@gioia.aioe.org>
In reply to#79114
On 4/20/2021 10:44 AM, jacobnavia wrote:
> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>> The problem with C is that anything that requires manual construction and
>> destruction will "contaminate" (can't think of a better word) anything 
>> that
>> uses that first thing, with the same requirements. All the way down.
>>
>> If you have this kind of "string" object that requires manual 
>> construction
>> and destruction, and you put it as a member of a struct, suddenly that
>> struct "inherits" the same requirement. Use that struct in yet another
>> struct and that, too, will "inherit" the same requirement.
> 
> No.
> 
> Just have a constructotr and never free anything. Then link with Boehm's 
> GARBAGE COLLECTOR and be done with it!

Wow! Really? Did you know that manual memory management can actually 
help a GC'ed environment run more efficiently? I have had to deal with 
questions about performance issues wrt using a garbage collector to act 
as a memory reclamation scheme for lock-free algorithms for almost two 
decades. GC can become a rather nasty, unpredictable, bottleneck.


> 
> I have already said this in this thread but people will go on arguing 
> about how difficult is to keep the accounting of memory pieces right.
> 
> And they are right but refuse to see the right tool for theirpurpose: 
> just use a garbage collector and BE DONE WITH IT.
> 
> I use an automatic car, no passing of gears. Recently I spoke with a 
> taxi driver... "Don't you get bored passing gears all day?"
> 
> And he acknowledged: yes, My arm hurts at the end of the day. Maybe you 
> are right, should get an automatic...
> 
> Use an automatic garbage collector and BE DONE WITH IT. And please, do 
> not start with performance problems, in most string applications the gc 
> is completely transparent.
> 
> 

[toc] | [prev] | [next] | [standalone]


#79121

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-04-20 20:29 +0000
Message-ID<20210420132757.260@kylheku.com>
In reply to#79120
On 2021-04-20, Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
> On 4/20/2021 10:44 AM, jacobnavia wrote:
>> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>>> The problem with C is that anything that requires manual construction and
>>> destruction will "contaminate" (can't think of a better word) anything 
>>> that
>>> uses that first thing, with the same requirements. All the way down.
>>>
>>> If you have this kind of "string" object that requires manual 
>>> construction
>>> and destruction, and you put it as a member of a struct, suddenly that
>>> struct "inherits" the same requirement. Use that struct in yet another
>>> struct and that, too, will "inherit" the same requirement.
>> 
>> No.
>> 
>> Just have a constructotr and never free anything. Then link with Boehm's 
>> GARBAGE COLLECTOR and be done with it!
>
> Wow! Really? Did you know that manual memory management can actually 
> help a GC'ed environment run more efficiently? I have had to deal with 
> questions about performance issues wrt using a garbage collector to act 
> as a memory reclamation scheme for lock-free algorithms for almost two 
> decades. GC can become a rather nasty, unpredictable, bottleneck.

Snip of a recent commit of mine:

  commit 174182a29c785493ed41231caff36f35c56819cf
  Author: Kaz Kylheku <kaz@kylheku.com>
  Date:   Tue Apr 6 20:06:18 2021 -0700

      gc: fix astonishing bug in weak hash processing.

      This is a flaw that has been in the code since the initial
      implementation in 2009.

:)

[toc] | [prev] | [next] | [standalone]


#79123

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-20 13:39 -0700
Message-ID<s5ne5l$jms$1@gioia.aioe.org>
In reply to#79121
On 4/20/2021 1:29 PM, Kaz Kylheku wrote:
> On 2021-04-20, Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
>> On 4/20/2021 10:44 AM, jacobnavia wrote:
>>> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>>>> The problem with C is that anything that requires manual construction and
>>>> destruction will "contaminate" (can't think of a better word) anything
>>>> that
>>>> uses that first thing, with the same requirements. All the way down.
>>>>
>>>> If you have this kind of "string" object that requires manual
>>>> construction
>>>> and destruction, and you put it as a member of a struct, suddenly that
>>>> struct "inherits" the same requirement. Use that struct in yet another
>>>> struct and that, too, will "inherit" the same requirement.
>>>
>>> No.
>>>
>>> Just have a constructotr and never free anything. Then link with Boehm's
>>> GARBAGE COLLECTOR and be done with it!
>>
>> Wow! Really? Did you know that manual memory management can actually
>> help a GC'ed environment run more efficiently? I have had to deal with
>> questions about performance issues wrt using a garbage collector to act
>> as a memory reclamation scheme for lock-free algorithms for almost two
>> decades. GC can become a rather nasty, unpredictable, bottleneck.
> 
> Snip of a recent commit of mine:
> 
>    commit 174182a29c785493ed41231caff36f35c56819cf
>    Author: Kaz Kylheku <kaz@kylheku.com>
>    Date:   Tue Apr 6 20:06:18 2021 -0700
> 
>        gc: fix astonishing bug in weak hash processing.
> 
>        This is a flaw that has been in the code since the initial
>        implementation in 2009.
> 
> :)
> 

Wow! I remember somebody asking me why the GC is under so much pressure. 
They showed me their code where most of the allocations were coming 
from. Of course they were allocating a new node for every push into a 
lock-free stack! I said the simplest thing I could think of, just to see 
if it made a difference... It was: Create a LIFO node cache, and create 
a layered approach for allocating nodes. Try the cache first, then 
resort to allocating a new node for now. The response was well, then we 
have to use manual memory management for the node cache. I said, indeed 
you do! So, they did it. Guess what? They were able to increase 
performance by orders of magnitude! The GC had a lot less pressure on 
it. Iirc, this was in Java. All due to good ol' manual memory management 
even in a GC system.

[toc] | [prev] | [next] | [standalone]


#79126

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-20 14:29 -0700
Message-ID<s5nh3v$1skh$1@gioia.aioe.org>
In reply to#79123
On 4/20/2021 1:39 PM, Chris M. Thomasson wrote:
> On 4/20/2021 1:29 PM, Kaz Kylheku wrote:
>> On 2021-04-20, Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
>>> On 4/20/2021 10:44 AM, jacobnavia wrote:
>>>> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>>>>> The problem with C is that anything that requires manual 
>>>>> construction and
>>>>> destruction will "contaminate" (can't think of a better word) anything
>>>>> that
>>>>> uses that first thing, with the same requirements. All the way down.
>>>>>
>>>>> If you have this kind of "string" object that requires manual
>>>>> construction
>>>>> and destruction, and you put it as a member of a struct, suddenly that
>>>>> struct "inherits" the same requirement. Use that struct in yet another
>>>>> struct and that, too, will "inherit" the same requirement.
>>>>
>>>> No.
>>>>
>>>> Just have a constructotr and never free anything. Then link with 
>>>> Boehm's
>>>> GARBAGE COLLECTOR and be done with it!
>>>
>>> Wow! Really? Did you know that manual memory management can actually
>>> help a GC'ed environment run more efficiently? I have had to deal with
>>> questions about performance issues wrt using a garbage collector to act
>>> as a memory reclamation scheme for lock-free algorithms for almost two
>>> decades. GC can become a rather nasty, unpredictable, bottleneck.
>>
>> Snip of a recent commit of mine:
>>
>>    commit 174182a29c785493ed41231caff36f35c56819cf
>>    Author: Kaz Kylheku <kaz@kylheku.com>
>>    Date:   Tue Apr 6 20:06:18 2021 -0700
>>
>>        gc: fix astonishing bug in weak hash processing.
>>
>>        This is a flaw that has been in the code since the initial
>>        implementation in 2009.
>>
>> :)
>>
> 
> Wow! I remember somebody asking me why the GC is under so much pressure. 
> They showed me their code where most of the allocations were coming 
> from. Of course they were allocating a new node for every push into a 
> lock-free stack! I said the simplest thing I could think of, just to see 
> if it made a difference... It was: Create a LIFO node cache, and create 
> a layered approach for allocating nodes. Try the cache first, then 
> resort to allocating a new node for now. The response was well, then we 
> have to use manual memory management for the node cache. I said, indeed 
> you do! So, they did it. Guess what? They were able to increase 
> performance by orders of magnitude! The GC had a lot less pressure on 
> it. Iirc, this was in Java. All due to good ol' manual memory management 
> even in a GC system.

For the life of me I cannot remember if this was using Java or C with 
the Bohem collector.

[toc] | [prev] | [next] | [standalone]


#79124

FromIan Collins <ian-news@hotmail.com>
Date2021-04-21 08:56 +1200
Message-ID<ie8tftFnts1U1@mid.individual.net>
In reply to#79114
On 21/04/2021 05:44, jacobnavia wrote:
> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>> The problem with C is that anything that requires manual construction and
>> destruction will "contaminate" (can't think of a better word) anything that
>> uses that first thing, with the same requirements. All the way down.
>>
>> If you have this kind of "string" object that requires manual construction
>> and destruction, and you put it as a member of a struct, suddenly that
>> struct "inherits" the same requirement. Use that struct in yet another
>> struct and that, too, will "inherit" the same requirement.
> 
> No.
> 
> Just have a constructotr and never free anything. Then link with Boehm's
> GARBAGE COLLECTOR and be done with it!

Let's not forget that memory isn't the only resource that a program has 
to manage.

-- 
Ian.

[toc] | [prev] | [next] | [standalone]


#79125

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-20 14:07 -0700
Message-ID<s5nfpu$1ato$1@gioia.aioe.org>
In reply to#79114
On 4/20/2021 10:44 AM, jacobnavia wrote:
> Le 20/04/2021 à 18:41, Juha Nieminen a écrit :
>> The problem with C is that anything that requires manual construction and
>> destruction will "contaminate" (can't think of a better word) anything 
>> that
>> uses that first thing, with the same requirements. All the way down.
>>
>> If you have this kind of "string" object that requires manual 
>> construction
>> and destruction, and you put it as a member of a struct, suddenly that
>> struct "inherits" the same requirement. Use that struct in yet another
>> struct and that, too, will "inherit" the same requirement.
> 
> No.
> 
> Just have a constructotr and never free anything. Then link with Boehm's 
> GARBAGE COLLECTOR and be done with it!
> 
> I have already said this in this thread but people will go on arguing 
> about how difficult is to keep the accounting of memory pieces right.
> 
> And they are right but refuse to see the right tool for theirpurpose: 
> just use a garbage collector and BE DONE WITH IT.
> 
> I use an automatic car, no passing of gears. Recently I spoke with a 
> taxi driver... "Don't you get bored passing gears all day?"
> 
> And he acknowledged: yes, My arm hurts at the end of the day. Maybe you 
> are right, should get an automatic...
> 
> Use an automatic garbage collector and BE DONE WITH IT. And please, do 
> not start with performance problems, in most string applications the gc 
> is completely transparent.
> 
> 

For some reason, anytime I hear somebody go, just use a GC... Well, it 
makes think of this song:

https://youtu.be/WJabPYimznY

Or the following scene in Disney's Dragonslayer from 1981:

https://youtu.be/TJRaLnLDMWg

[toc] | [prev] | [next] | [standalone]


#79195

Fromjacobnavia <jacob@jacob.remcomp.fr>
Date2021-04-23 12:10 +0200
Message-ID<s5u6f0$9vc$1@dont-email.me>
In reply to#79125
Le 20/04/2021 à 23:07, Chris M. Thomasson a écrit :

> 
> For some reason, anytime I hear somebody go, just use a GC... Well, it 
> makes think of this song:
> 
> https://youtu.be/WJabPYimznY
> 
> Or the following scene in Disney's Dragonslayer from 1981:
> 
> https://youtu.be/TJRaLnLDMWg

Great arguments!

Technically sound, I am convinced now...


... that you have nothing to say

[toc] | [prev] | [next] | [standalone]


#79196

Fromwij <wyniijj@gmail.com>
Date2021-04-23 04:10 -0700
Message-ID<ce771f8d-a676-4637-8017-0d88f4b9d37fn@googlegroups.com>
In reply to#79195
On Friday, 23 April 2021 at 18:10:51 UTC+8, jacobnavia wrote:
> Le 20/04/2021 à 23:07, Chris M. Thomasson a écrit : 
> 
> > 
> > For some reason, anytime I hear somebody go, just use a GC... Well, it 
> > makes think of this song: 
> > 
> > https://youtu.be/WJabPYimznY 
> > 
> > Or the following scene in Disney's Dragonslayer from 1981: 
> > 
> > https://youtu.be/TJRaLnLDMWg 
> 
> Great arguments! 
> 
> Technically sound, I am convinced now... 
> 
> 
> ... that you have nothing to say

Let it burn. I like to play fire, safely.

This is not the exact one in my memory, but close. 
https://www.youtube.com/watch?v=ajNieXqs8XE

[toc] | [prev] | [next] | [standalone]


#79348

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-28 00:32 -0700
Message-ID<s6b331$1vjh$1@gioia.aioe.org>
In reply to#79196
On 4/23/2021 4:10 AM, wij wrote:
> On Friday, 23 April 2021 at 18:10:51 UTC+8, jacobnavia wrote:
>> Le 20/04/2021 à 23:07, Chris M. Thomasson a écrit :
>>
>>>
>>> For some reason, anytime I hear somebody go, just use a GC... Well, it
>>> makes think of this song:
>>>
>>> https://youtu.be/WJabPYimznY
>>>
>>> Or the following scene in Disney's Dragonslayer from 1981:
>>>
>>> https://youtu.be/TJRaLnLDMWg
>>
>> Great arguments!
>>
>> Technically sound, I am convinced now...
>>
>>
>> ... that you have nothing to say
> 
> Let it burn. I like to play fire, safely.

;^)

The dragon in the clip I posted is pretty damn pissed off! ;^)

> 
> This is not the exact one in my memory, but close.
> https://www.youtube.com/watch?v=ajNieXqs8XE
> 

[toc] | [prev] | [next] | [standalone]


#79354

Fromwij <wyniijj@gmail.com>
Date2021-04-28 11:04 -0700
Message-ID<61e08dc7-0f38-4af9-b4bb-940f8ded67b2n@googlegroups.com>
In reply to#79348
On Wednesday, 28 April 2021 at 15:33:05 UTC+8, Chris M. Thomasson wrote:
> On 4/23/2021 4:10 AM, wij wrote: 
> > On Friday, 23 April 2021 at 18:10:51 UTC+8, jacobnavia wrote: 
> >> Le 20/04/2021 à 23:07, Chris M. Thomasson a écrit : 
> >> 
> >>> 
> >>> For some reason, anytime I hear somebody go, just use a GC... Well, it 
> >>> makes think of this song: 
> >>> 
> >>> https://youtu.be/WJabPYimznY 
> >>> 
> >>> Or the following scene in Disney's Dragonslayer from 1981: 
> >>> 
> >>> https://youtu.be/TJRaLnLDMWg 
> >> 
> >> Great arguments! 
> >> 
> >> Technically sound, I am convinced now... 
> >> 
> >> 
> >> ... that you have nothing to say 
> > 
> > Let it burn. I like to play fire, safely. 
> 
> ;^) 
> 
> The dragon in the clip I posted is pretty damn pissed off! ;^) 
> 

Yop, that's what the director want audience to see.

This song (lyrics, at least) is from Book of Songs (very old)
https://www.youtube.com/watch?v=9QVTcv6geHQ

"Book of Songs"==Classic_of Poetry==Lyrics 
https://en.wikipedia.org/wiki/Classic_of_Poetry

> > 
> > This is not the exact one in my memory, but close. 
> > https://www.youtube.com/watch?v=ajNieXqs8XE 
> >

[toc] | [prev] | [next] | [standalone]


#79207

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-23 12:37 -0700
Message-ID<s5v7m4$1ess$1@gioia.aioe.org>
In reply to#79195
On 4/23/2021 3:10 AM, jacobnavia wrote:
> Le 20/04/2021 à 23:07, Chris M. Thomasson a écrit :
> 
>>
>> For some reason, anytime I hear somebody go, just use a GC... Well, it 
>> makes think of this song:
>>
>> https://youtu.be/WJabPYimznY
>>
>> Or the following scene in Disney's Dragonslayer from 1981:
>>
>> https://youtu.be/TJRaLnLDMWg
> 
> Great arguments!
> 
> Technically sound, I am convinced now...
> 
> 
> ... that you have nothing to say

Have you ever had to deal with GC issues? I have... Unfortunately, some 
people seem to think that a full blown GC is okay to use for reclaiming 
memory in lock-free algorithms. It works, but can become a massive, 
nasty, unpredictable bottleneck. Only then do they complain. I warned 
some of them...

https://youtu.be/XcxKIJTb3Hg

[toc] | [prev] | [next] | [standalone]


#79208

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-23 12:38 -0700
Message-ID<s5v7ni$1ess$2@gioia.aioe.org>
In reply to#79207
On 4/23/2021 12:37 PM, Chris M. Thomasson wrote:
> On 4/23/2021 3:10 AM, jacobnavia wrote:
>> Le 20/04/2021 à 23:07, Chris M. Thomasson a écrit :
>>
>>>
>>> For some reason, anytime I hear somebody go, just use a GC... Well, 
>>> it makes think of this song:
>>>
>>> https://youtu.be/WJabPYimznY
>>>
>>> Or the following scene in Disney's Dragonslayer from 1981:
>>>
>>> https://youtu.be/TJRaLnLDMWg
>>
>> Great arguments!
>>
>> Technically sound, I am convinced now...
>>
>>
>> ... that you have nothing to say
> 
> Have you ever had to deal with GC issues? I have... Unfortunately, some 
> people seem to think that a full blown GC is okay to use for reclaiming 
> memory in lock-free algorithms. It works, but can become a massive, 
> nasty, unpredictable bottleneck. Only then do they complain. I warned 
> some of them...
> 
> https://youtu.be/XcxKIJTb3Hg
> 

The bunny is the GC when you expose your lock-free system to high levels 
of sustained load.

[toc] | [prev] | [next] | [standalone]


Page 5 of 8 — ← Prev page 1 2 3 4 [5] 6 7 8  Next page →

Back to top | Article view | comp.lang.c++


csiph-web