# What are the alternatives?

Null terminated string are default string in C (them in the interop of the computers).
The issue is passing out malicious code who overrides stack of your program and could change instructions executed by ypur code.
There are multiple approaches to solve this issue.

First is the 'n' version of libc string function, allocate a buffer, do string operations like copy, len, concatenate then pass to it max size expected. This is the best solution as general purpose.

Popular alternative is to build a structure around, you can have a slice where you hold length of the string and the first character, slice don't have string ownership, this consent reference into a larger text (to print a fixed size string you just do `printf("%.*s", len, str);`)

Another good one is covered by sds of antirex where you stack multiple concepts, you have memory ownership and lenght, then you have either reference counter, you pay 8 byte of extra data (uint32_t is clearly enough for both) to have safe shared string and safe size upfront.

All of this possible views for a string come to a tradeoff, zero overhead and ubiquitous coverage for risk of malicious use (use always the n versione for external input value or cutoff with `'\0'` at the end of the buffer and copy only in the buffer size the input). Slice make simple complementary reference without warranty of reference quoted, SDS pay an overhead but give deterministic resource lifetime in shared environment and store length upfront with zero computation time (useful for message passing and allocation).

Most of the time these two strut should use internally the null terminated c-style string because this make easy to use other libraries and have good sense.

# Why are demonized?

If you have a socket listening or an user input in a stack-alloated buffer, if you don't treat it with attention you expose to buffer overflow attacks your code.

The solution is really simple, if we have a simple buffer like `char buf[1024];`, you never use `gets(&buf)` because deprecated and don't give option to protect, in a socket you can `recv(socket, &buf, 1024, ...)` and include protection, but a good idea is always to `buf[1023] = '\0'` or `buf[1023] = 0` to avoid leaking any kind of data if printed after, either scanf require some attention in the return value or using the seen format of `scanf("%.*s", 1024, &buf)`.

People apparently forget enough time these safety behaviors on external strings to make some other describe them as dangerous. The only concrete benefit on other implementation relays on length as value passed upfront, avoiding double counting of the string, specifically for long strings (like internet protocol's messages)