Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c++ > #78998 > unrolled thread
| Started by | Juha Nieminen <nospam@thanks.invalid> |
|---|---|
| First post | 2021-04-17 05:56 +0000 |
| Last post | 2021-04-26 08:49 +0000 |
| Articles | 20 on this page of 143 — 32 participants |
Back to article view | Back to comp.lang.c++
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 →
| From | Juha Nieminen <nospam@thanks.invalid> |
|---|---|
| Date | 2021-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]
| From | Paavo Helde <myfirstname@osa.pri.ee> |
|---|---|
| Date | 2021-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]
| From | James Kuyper <jameskuyper@alumni.caltech.edu> |
|---|---|
| Date | 2021-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]
| From | wij <wyniijj@gmail.com> |
|---|---|
| Date | 2021-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]
| From | Christian Gollwitzer <auriocus@gmx.de> |
|---|---|
| Date | 2021-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]
| From | wij <wyniijj@gmail.com> |
|---|---|
| Date | 2021-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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2021-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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2021-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2021-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]
| From | Ian Collins <ian-news@hotmail.com> |
|---|---|
| Date | 2021-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2021-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]
| From | jacobnavia <jacob@jacob.remcomp.fr> |
|---|---|
| Date | 2021-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]
| From | wij <wyniijj@gmail.com> |
|---|---|
| Date | 2021-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2021-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]
| From | wij <wyniijj@gmail.com> |
|---|---|
| Date | 2021-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2021-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2021-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