Re: Top 10 Worst C# Features

[Nicholas Collin Paul de Gloucester <Gloucester@nicht.at>]

On October 14th, 2015, Maciej Sobczak sent:
|-------------------------------------------------------------------------|
|"> One of the bugs which I detected in Crap-Poo-Poo code which I referred|
|> to in the paper referred to below involved two functions like these,   |
|> but they accidentally did not return values compatible with each       |
|> other. I explained this to Crap-Poo-Poo advocates involved, but they   |
|> lacked sufficient intelligence to comprehend a reason as to code       |
|> cloning producing a bug.                                               |
|                                                                         |
|Apparently you have talked to wrong advocates.                           |
|For the sake of discussion I will play that role in this post.           |
|                                                                         |
|Yes, we understand that it is possible to have incompatible              |
|implementations of operator== and operator!= in C++ (assuming that       |
|this is the language you are referring to), but we are willing to        |
|take this risk (and address it by other means) as it allows us to        |
|implement these operators more efficiently.                              |
|[. . .]"                                                                 |
|-------------------------------------------------------------------------|

This Crap-Poo-Poo code was inefficient. The idea of an operator which
is a complement of another operator being implemented in terms of a
complementary operator had not occurred to these idiots.

|-------------------------------------------------------------------------|
|"> I also advised that Ada does not do                                   |
|> this.                                                                  |
|                                                                         |
|Yes, we know that Ada prevents some [. . .]. This is not the only one."  |
|-------------------------------------------------------------------------|

Ada prevents bugs.

|-------------------------------------------------------------------------|
|"> They persisted with Crap Poo Poo.                                     |
|                                                                         |
|Yes, we prefer to get better performance at the expense of higher        |
|verification effort."                                                    |
|-------------------------------------------------------------------------|

Actually, they untruthfully boasted about both being faster and being
verified.

|-------------------------------------------------------------------------|
|"If you are willing to address the above, please use the actual name     |
|of the programming language that you are referring to.                   |
|                                                                         |
|--                                                                       |
|Maciej Sobczak * http://www.inspirel.com "                               |
|-------------------------------------------------------------------------|

Why? It was supposedly in C++ (which one of the aforementioned idiots
frequently used to accidentally call C then) and supposedly SystemC(R)
code. Note that persons who impose a requirement on how to use the
SystemC(R) name do not even adhere to this requirement themselves.

Regards,
Nicholas Collin Paul de Gloucester