deorder

You should know that people who are against one of the following are called "pro-life" (and therefore Trump-supporters, racists, alt-right and nazi...) as well:

- 3rd-trimester / late term abortion without physical-health reasons.

- The selling of body parts instead of freely giving it away for research. See: https://en.m.wikipedia.org/wiki/Planned_Parenthood_2015_unde... (later said to only be the cost of transportation)

- The idea of post-birth termination. See: http://jme.bmj.com/content/39/5/261

It is not "wrong", but it is being "overused". I had been fixing people their broken OOP code for about 10 years (diamond problem, spaghetti code, too much coupling etc.). People seem to abuse it in every way they can. I personally do not like how code is often not separate from the data as well.

That is why i like C. I can have my data structure and just add functions that can operate on those data structures outside of the data structure itself without worrying about coupling code to the data. Extra functions that can operate on the data may as well be inside a dynamically loaded plugin. Not feeling forced to put everything that can operate on a single instance of the data inside the same class. Not feeling forced to create a separate class to add methods that can operate on multiple instances of the data and hardcoding multicore support inside of it.

The new C++ (and Nim) have the notion of concepts which can mostly replace the many ways OOP was being abused. It is similar to type classes in Haskell. I advice you to read Alexander Stepanov's books.

You can have a data structure in a class, add certain concepts that the data structure supports and then create separate functions which can operate on these concepts outside of the class / object.

I was not sure about the use of the word "program" as well. Just wanted to make it clear I am talking about something created by intelligent / sentient beings capable of autonomously making certain decisions.

Depending on its adaptability that something may outgrow what supports and created it (nature, energy sources, their intelligent / sentient creators etc.).

That is what makes that kind of AI dangerous. It just does not care and / or need a reason we could understand. It may decide to visit us in 250 years and reach us ~250 years later.

Other possibilities:

- The sentient / strong AI may have (developed) FTL travel / signalling capabilities which from our current understanding does not seem to be possible.

- The AI may have sent out scouts millions of years ago into multiple directions. The closest scout only needs to decide to conquer / harvest our planet.

- A combination of the above, for example: FTL signalling and activating scouts where needed.

At minimum: Something working according to a program created by another species capable of autonomously making a decision to visit us if we tip it off.

If intelligent life got as far to have the technology to be able to visit us they at least did not kill themselves off which already reduces the chance of them being aggressive against others.

Tipping off a rogue sentient AI that killed off their own creators is what I am more afraid of.

I usually first start reading or glance over papers (and non-story books) from the end to the beginning before I read it the other way around. This has the following benefits for me:

- By knowing about the conclusion first I will better understand the motivation and why certain steps are being taken.

- I find out sooner if the paper (or book) is something I am looking for.

I like to read papers unrelated to my field to learn new thing to apply. To be honest, some papers still take me a long time to understand because they usually assume you already are researching the topic (for ex. certain terms, symbols and/or variables that are not being defined).

I am aware that all of this is possible in C++ as well and for many things C++ might be the better choice (more standardized compiler hints instead of using pragmas, generics and templates etc.).

What I meant is that C++ does not add anything for me personally.

POD-structures are all I need and the way I fetch/store the data may require the struct layout to be interleaved or non-interleaved (depending on the platform / architecture I am targeting for a specific build) requiring different code to be generated to access them.

I do not need to disable name mangling or add 'extern "C"' everywhere (I still do in case the code will be used from C++) when I just use plain C.

I like the many new features added to C++ like concepts, lambdas etc. but for these I prefer to use Nim (they just added complete concept support as well).

“If you’re arguing, you’re losing.”. That is a quick way to stop any discussion. The reason I am not using C++ is because C already does everything I need:

- Easier to write code generators for: I use libclang to read in annotations that will generate new code according to where the annotations are being used. If I have to take care of every edge case and new features added to the latest C++ standard it would make the code generator more complex.

- Using plain old data structures: My code generator generates new code to be able to work with the plain old data structures which data can be interleaved or non-interleaved using data-oriented design. Classes will not add that much value.

- C compilers are easier to write: I integrated the tiny C compiler inside my program to be able to compile C code on demand. The C code can then use the code I've already written.

- No name mangling by default: I dynamically load a lot of plugins and do not want to bother with binary incompatibilities all the time (if compiled by different compilers like the tiny C compiler for ex.).

- I mostly use libraries written in C

- Low-level access

If I need concepts or meta-programming etc. I can already use Nim or write my own code generator, else I would rather choose something different than C++.

To be more on-topic. Confirmation bias. On The Internet you can find confirmation of something being true about almost every topic. Whatever people believe is the truth, it will not change the reality. Which programming languages are better is a very difficult thing to measure because there are many factors to consider. Being used to a certain programming language can be a good reason not to change.

https://en.wikipedia.org/wiki/Confirmation_bias

Update: added some explanations, and more on-topic