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


Groups > comp.lang.c > #160147 > unrolled thread

Re: No, C is not a simple language

Started byManfred <noname@add.invalid>
First post2021-04-17 19:12 +0200
Last post2021-04-28 00:02 -0700
Articles 20 on this page of 89 — 20 participants

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

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.


Contents

  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 silas poulson <Silas8642@hotmail.co.uk> - 2021-04-17 18:33 -0700
      Re: No, C is not a simple language Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2021-04-18 02:10 +0000
        Re: No, C is not a simple language silas poulson <Silas8642@hotmail.co.uk> - 2021-04-17 22:35 -0700
      Re: No, C is not a simple language Real Troll <real.troll@trolls.com> - 2021-04-18 17:00 +0100
        Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-18 21:52 +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 Tim Rentsch <tr.17687@z991.linuxsc.com> - 2021-04-19 04:20 -0700
            Re: No, C is not a simple language Thiago Adams <thiago.adams@gmail.com> - 2021-04-19 08:29 -0700
              Re: No, C is not a simple language Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-04-19 13:21 -0700
                Re: No, C is not a simple language Richard Damon <Richard@Damon-Family.org> - 2021-04-19 18:03 -0400
                  Re: No, C is not a simple language Bart <bc@freeuk.com> - 2021-04-20 00:50 +0100
                    Re: No, C is not a simple language David Brown <david.brown@hesbynett.no> - 2021-04-20 08:32 +0200
                    Re: No, C is not a simple language Richard Damon <Richard@Damon-Family.org> - 2021-04-20 07:17 -0400
                      Re: No, C is not a simple language David Brown <david.brown@hesbynett.no> - 2021-04-20 14:25 +0200
                      Re: No, C is not a simple language Bart <bc@freeuk.com> - 2021-04-20 14:09 +0100
                        Re: No, C is not a simple language Richard Damon <Richard@Damon-Family.org> - 2021-04-20 10:19 -0400
                      Re: No, C is not a simple language James Kuyper <jameskuyper@alumni.caltech.edu> - 2021-04-20 11:50 -0400
                        Re: No, C is not a simple language Richard Damon <Richard@Damon-Family.org> - 2021-04-20 12:06 -0400
                          Re: No, C is not a simple language James Kuyper <jameskuyper@alumni.caltech.edu> - 2021-04-20 19:13 -0400
                    Re: No, C is not a simple language Tim Rentsch <tr.17687@z991.linuxsc.com> - 2021-05-11 05:29 -0700
                      Re: No, C is not a simple language David Brown <david.brown@hesbynett.no> - 2021-05-11 14:37 +0200
                  Re: No, C is not a simple language Tim Rentsch <tr.17687@z991.linuxsc.com> - 2021-05-11 05:18 -0700
                Re: No, C is not a simple language Tim Rentsch <tr.17687@z991.linuxsc.com> - 2021-05-11 05:14 -0700
        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 Thiago Adams <thiago.adams@gmail.com> - 2021-04-20 11:04 -0700
                      Re: No, C is not a simple language jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-20 20:23 +0200
                        Re: No, C is not a simple language Thiago Adams <thiago.adams@gmail.com> - 2021-04-20 12:22 -0700
                        Re: No, C is not a simple language Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-20 19:37 +0000
                    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 "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-21 15:26 -0700
                            Re: No, C is not a simple language Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-22 05:59 -0700
                              Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-22 11:58 -0700
                                Re: No, C is not a simple language Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-23 07:23 -0700
                                  Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-24 14:26 -0700
                                  Re: No, C is not a simple language "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-24 14:28 -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 Tim Rentsch <tr.17687@z991.linuxsc.com> - 2021-05-11 05:31 -0700
                    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 "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 Robert Latest <boblatest@yahoo.com> - 2021-04-26 09:30 +0000
                                  Re: No, C is not a simple language Ian Collins <ian-news@hotmail.com> - 2021-04-30 21:11 +1200
                            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 "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-24 12:48 -0700
                    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 jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-26 21:24 +0200
                        Re: No, C is not a simple language Robert Latest <boblatest@yahoo.com> - 2021-04-27 07:26 +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 Thiago Adams <thiago.adams@gmail.com> - 2021-04-20 11:04 -0700
                  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 Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-26 03:08 -0700
                      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:22 +0000
                              Re: No, C is not a simple language scott@slp53.sl.home (Scott Lurndal) - 2021-04-26 18:57 +0000
                          Re: No, C is not a simple language Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-26 06:55 -0700
                          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

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


#160272

FromJuha Nieminen <nospam@thanks.invalid>
Date2021-04-21 04:37 +0000
Message-ID<s5oa5u$1sgb$1@gioia.aioe.org>
In reply to#160252
In comp.lang.c++ jacobnavia <jacob@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.

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


#160274

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-21 15:26 -0700
Message-ID<s5q8rh$1rnd$1@gioia.aioe.org>
In reply to#160272
On 4/20/2021 9:37 PM, Juha Nieminen wrote:
> In comp.lang.c++ jacobnavia <jacob@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:

https://youtu.be/skGUAXAx6eg

https://youtu.be/R0v_1EBAOr4

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


#160276

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-04-22 05:59 -0700
Message-ID<ce6b26f7-bc7b-4a76-9147-f375e7f67fcbn@googlegroups.com>
In reply to#160274
On Wednesday, 21 April 2021 at 23:27:13 UTC+1, 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. ;^) 
> 
There are plenty of image format codecs in my Baby X resource compiler.

It's on github.
https://github.com/MalcolmMcLean/babyxrc

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


#160279

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-22 11:58 -0700
Message-ID<s5sh0i$t96$1@gioia.aioe.org>
In reply to#160276
On 4/22/2021 5:59 AM, Malcolm McLean wrote:
> On Wednesday, 21 April 2021 at 23:27:13 UTC+1, 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. ;^)
>>
> There are plenty of image format codecs in my Baby X resource compiler.
> 
> It's on github.
> https://github.com/MalcolmMcLean/babyxrc
> 

Thanks for the heads up Malcolm! :^)

For purely portable, for some reason, I tend toward PPM, perhaps because 
its so easy. If I need a png or something I have code that uses Cairo, 
which is a pretty nice C library.

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


#160285

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-04-23 07:23 -0700
Message-ID<763aaa03-bd03-4360-80d9-50a0ec76a4f2n@googlegroups.com>
In reply to#160279
On Thursday, 22 April 2021 at 19:58:38 UTC+1, Chris M. Thomasson wrote:
> On 4/22/2021 5:59 AM, Malcolm McLean wrote: 
> > On Wednesday, 21 April 2021 at 23:27:13 UTC+1, 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. ;^) 
> >> 
> > There are plenty of image format codecs in my Baby X resource compiler. 
> > 
> > It's on github. 
> > https://github.com/MalcolmMcLean/babyxrc 
> >
> Thanks for the heads up Malcolm! :^) 
> 
> For purely portable, for some reason, I tend toward PPM, perhaps because 
> its so easy. If I need a png or something I have code that uses Cairo, 
> which is a pretty nice C library.
>
Generally I use PNGs as a default image format. They have 24 bit plus alpha, so
they can be used for anything except really high end work where you need more
than 8 bits per channel. And they're lossless and reasonably well-compressed. 

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


#160326

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-24 14:26 -0700
Message-ID<s622e4$1o72$1@gioia.aioe.org>
In reply to#160285
On 4/23/2021 7:23 AM, Malcolm McLean wrote:
> On Thursday, 22 April 2021 at 19:58:38 UTC+1, Chris M. Thomasson wrote:
>> On 4/22/2021 5:59 AM, Malcolm McLean wrote:
>>> On Wednesday, 21 April 2021 at 23:27:13 UTC+1, 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. ;^)
>>>>
>>> There are plenty of image format codecs in my Baby X resource compiler.
>>>
>>> It's on github.
>>> https://github.com/MalcolmMcLean/babyxrc
>>>
>> Thanks for the heads up Malcolm! :^)
>>
>> For purely portable, for some reason, I tend toward PPM, perhaps because
>> its so easy. If I need a png or something I have code that uses Cairo,
>> which is a pretty nice C library.
>>
> Generally I use PNGs as a default image format. They have 24 bit plus alpha, so
> they can be used for anything except really high end work where you need more
> than 8 bits per channel. And they're lossless and reasonably well-compressed.
> 

Fwiw, here is the result of some older C code generate each frame for 
the following animation:

https://youtu.be/TLd64a4gdZQ

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


#160327

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-24 14:28 -0700
Message-ID<s622ik$1o72$2@gioia.aioe.org>
In reply to#160285
On 4/23/2021 7:23 AM, Malcolm McLean wrote:
> On Thursday, 22 April 2021 at 19:58:38 UTC+1, Chris M. Thomasson wrote:
>> On 4/22/2021 5:59 AM, Malcolm McLean wrote:
>>> On Wednesday, 21 April 2021 at 23:27:13 UTC+1, 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. ;^)
>>>>
>>> There are plenty of image format codecs in my Baby X resource compiler.
>>>
>>> It's on github.
>>> https://github.com/MalcolmMcLean/babyxrc
>>>
>> Thanks for the heads up Malcolm! :^)
>>
>> For purely portable, for some reason, I tend toward PPM, perhaps because
>> its so easy. If I need a png or something I have code that uses Cairo,
>> which is a pretty nice C library.
>>
> Generally I use PNGs as a default image format. They have 24 bit plus alpha, so
> they can be used for anything except really high end work where you need more
> than 8 bits per channel. And they're lossless and reasonably well-compressed.
> 

This one is an example of a special way I handle the result of a 
distance estimator for the Mandelbulb:

https://youtu.be/XpbPzrSXOgk

Also, a friend of mine put some of my work on his fractal page:

http://paulbourke.net/fractals/multijulia

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


#160251

FromRichard Damon <Richard@Damon-Family.org>
Date2021-04-20 14:46 -0400
Message-ID<RjFfI.8203$N%1.1971@fx28.iad>
In reply to#160245
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]


#160255

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-04-20 20:18 +0000
Message-ID<20210420130138.376@kylheku.com>
In reply to#160251
["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]


#160732

FromTim Rentsch <tr.17687@z991.linuxsc.com>
Date2021-05-11 05:31 -0700
Message-ID<86tun9fo3v.fsf@linuxsc.com>
In reply to#160251
Richard Damon <Richard@Damon-Family.org> writes:

> On 4/20/21 1:44 PM, jacobnavia wrote:
>
>> Le 20/04/2021 at 18:41, Juha Nieminen a ecrit:
>>
>>> 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.

Or some other resource management mechanism, not RAII necessarily.

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


#160256

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#160245
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]


#160257

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-04-20 20:29 +0000
Message-ID<20210420132757.260@kylheku.com>
In reply to#160256
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]


#160259

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#160257
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]


#160262

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#160259
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]


#160260

FromIan Collins <ian-news@hotmail.com>
Date2021-04-21 08:56 +1200
Message-ID<ie8tftFnts1U1@mid.individual.net>
In reply to#160245
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]


#160261

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#160245
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]


#160284

Fromjacobnavia <jacob@jacob.remcomp.fr>
Date2021-04-23 12:10 +0200
Message-ID<s5u6f0$9vc$1@dont-email.me>
In reply to#160261
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]


#160290

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#160284
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]


#160291

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#160290
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]


#160292

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-04-23 12:43 -0700
Message-ID<s5v81c$1ess$3@gioia.aioe.org>
In reply to#160290
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
> 

I used to cringe when I would see code that would allocate nodes all 
over the place, and never free them. Sometimes they would allocate nodes 
in loops! They would say, ahhh, that's for the GC. WOW!

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


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

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


csiph-web