> Please excuse me my theatricality. I'm not assaulting the author. I'm rather agravated that this post has this level of visibility and the potential damage it can do.
I thought it was a good post and provides a good overview of different methods along with a discussion why you should or shouldn't do some of these things.
I'm pretty certain that in the Linux kernel you can find each and every one of these methods used more than once and for a good reason.
Maybe in a normal user space app you have the luxury of being able to malloc/free everything and have nice high level containers, etc available but when writing C code, the assumption of normal user space apps is not necessarily true.
All of these methods - and when not to use them - is very useful knowledge.
It's amazing how much you can achieve without malloc and free if you're just careful to pass in the right output space and buffers as part of your function call. You rarely really need them for most functional code. (Non-trivial data structures may be different...)
And the OP is right - globals, especially if not encapsulated within a single code module, are a prime cause of opaque spaghetti code.
I've written plenty of embedded code where the first rule was "Thou shall not malloc." In just about every case it turns into setting aside static buffers and doing manual structure allocation. This is such a common idiom in embedded systems that most RTOS systems have this functionality built-in.
The embedded system I'm working right now doesn't have malloc as part of its platform SDK anyway, so it's not like there's a choice :)
I guess it depends on what exactly you're working on, but passing in a stack-declared for a function to fill with its results seems better to me anyway, as general practice. Preferable to allocating a new structure in the function and then returning it, that is. There are no ownership issues and nobody has to remember to free anything.
Heap emulation with static buffers comes with its own costs - either you end up writing an allocation engine or you just use a large buffer with an advancing pointer, free() does nothing and the whole thing has to be reset every so often, which means that you have to convince the other developers on the team that it's not to be used like normal malloc and please be careful and ... that's a whole other can of worms!
So I made once had the displeasure of doubling the performance of a fission reactor safety simulator by disabling win32's swap... 30 years and 2e7 LoC codebase. >.<. The working set was nowhere near smart, but it did work faster than AIX, HP-UX, SCO & Solaris/SunOS ports.
You are correct, discussion is always welcome. I agree that "All of these methods - and when not to use them - is very useful knowledge." would be a very valuable proposition.
Like I said, the presentation rubbed me the wrong way by first exposing antipatterns and then not taking a very strong position against them.
I thought it was a good post and provides a good overview of different methods along with a discussion why you should or shouldn't do some of these things.
I'm pretty certain that in the Linux kernel you can find each and every one of these methods used more than once and for a good reason.
Maybe in a normal user space app you have the luxury of being able to malloc/free everything and have nice high level containers, etc available but when writing C code, the assumption of normal user space apps is not necessarily true.
All of these methods - and when not to use them - is very useful knowledge.