Does any error correction code still work in such situation? I'm looking for a kind of error correction code or solution that can correct my codeword in this case:

My message holds $k$ bits, and $2k$ bits codeword (rate is $1/2$) is produced by the generator matrix, e.g. $k=5$, so it yields $10$ bits codeword $\rm 1001100111$. If the codeword is erased for some reason and it becomes $\rm 1xx1x00xx1$ (similar to the codeword transmitted through Binary Erasure Channel, and $\rm x$ is unknown, either '$0$' or '$1$'), can I still correct all the "$\rm x$ bits" in such situation as bit error rate is $1/2$?

I have read about some error correction code, such as block code, convolutional code and LDPC and got the following questions:


All these ECC have pratical application in communication, so do they still work when BER is close to $1/2$ (I think BER is impossible so high)?
Are there any feasible solution to my case? In fact, my message is $30$ bits and I can introduce another $30$ bits redundancy as parity bits. Can I still correct my codeword even if its half bits are erased where the recipient knows which bits he didn't receive properly?
What's the limit of ECC? If it can't correct half bits of codeword that are erased, how many bits can it correct at most?


Any guides or suggestions are appreciated!
I'm afraid that this will be an incomplete answer, but I'm giving it in the hopes that it is better than nothing.

It is impossible to recover any information with a BER of 50% because, as information theory tells us, no information is getting through such a channel.  You can see this intuitively if you realize that no matter what bit you send, 0 or 1, it has equal chance of arriving at the receiver as a 0 or 1, so what you receive tells you nothing about what was actually sent.  In such a case it is theoretically impossible to create an ECC that will help at all.

Erasures are, in some situations, better than errors though.  Reed-Solomon decoders often use erasures to increase their error correction capability.  The reason why it works is because with RS codes you have two sets of unknowns: the error locations and the error magnitudes (the number of errors is also an implicit unknown).  Erasures give the decoder the error location so it only needs to figure out the magnitude.

Talking about "erasures" in the context of bits, though, makes little sense because with bit-based codes there is only one set of unknowns: the error locations.  The error magnitudes are always 1.  So if you have a bit "erasure" you are trading one unknown (error location) for another (error magnitude).

With bit-based codes like Viterbi codes the analog to erasures is using soft-decisions.  Soft-decisions contain "confidence" information- i.e. how sure the receiver is that the bit is really a 1 or really a 0.  That information can be used to greatly improve decoder performance.

All that being said, though, if your error/erasure rate is really that high you will probably not get good performance out of any ECC.