There are 2 main camps in software development:
1. Turing computable computer scientists: All turing computable languages are equivalent. If something goes wrong, RTFM. If everyone RTFM, there would be less defects. This is the main driving factor in Unix and Linux.
2. Software engineers: Writing correct programs is almost impossible because defects are so pervasive, even if you read all manuals in the world. There is cognitive disonance between what the programmer thinks he is doing and what he is actually doing, mostly because every programming expression has limits based on the types of the variables he is using. There are other border conditions that produce the same problem. If the user misuses the system, it is because it is so hard to use. This is the main driving factor in Windows.
For example:
x + y
Is it a correct expression?
It depends.
If we assume that x and y are bytes, the sum will overflow if x + y > 255.
The same can occur with the expression:
x = 1/10.
What is the value of x * 10?
Most developers would expect 1, but a few selected ones would answer that it depends on the type of x, since if it is int, float or double, the result would be different. It would certainly be different from 1 in all those cases, which means languages are broken, from the point of view of what the language user expects.
Turing computable computer scientists would think it is irrelevant: Just hire smarter programmers and write down all requirements, so that if the requirement is not written, it is not the programmer's fault, but if the requirement is written and the program still fails, it is your fault because you didn't hire smart enough programmers. Programmers should be able to code using wires if they are required to, creating abstractions is such a waste of time, because it *derails* programmers from their real work.
Software engineers would rather think that languages need to evolve in order to avoid dumb programmers make idiotic mistakes. It is just the opposite of what turing computable computer scientists think. When it comes to languages, market economics agrees with software engineers in the long run (3 to 10 years), but in the short run (3 to 10 months) turing computable computer scientists are correct. Hire te smarter ones, write requirements down, work longer hours and ask users to RTFM.
When it comes to libraries, turing computable computer scientists are always wrong, because they avoid using and creating libraries. After a few months their projects flop because of the massive amount of copy and paste and the huge number of defects that go undetected and detected but not fixed. They may even try to fix those bugs, but for every 10 lines of code you touch, you introduce another bug.
Software engineers succeed only when using and creating libraries and abstraction layers. Language does matter because market economics is far more important than turing compatibility. Who cares if they are equivalent? The fact is that one of them is easier and therefore it reduces the amount of stress on the developer. The code looks correct when it is correct. There is a lot less code (since most code is in libraries anyway).
But there is a 3rd strain of the virus:
The OO camp.
It doesn't belong in the software engineering field nor in the computer science field, although it is closer to the software engineering field. While software engineering concentrates on software configuration management, Subversion, Jira and the like, the OO camp concentrates on JUnit (automated unit testing), Selenium (automated functional testing) and design patterns.
While the software engineering camp believes that specification is the key and believes strongly in waterfall (finishing the previous step before starting the new one), the OO camp believes you need to specify only what you are going to build in the next few weeks, it negates waterfall and believes in the spiral model, building functionality one step at a time.
The most vocal methodology when it comes to the OO camp is XP. Cynics declare XP to be programming without plans and without documentation. Although XP does not mandate documentation, it doesn't require that you don't write documentation. It just says not to write more documentation that is externally required by the client. All the rest should be explicitly stated in automated tests, so that you can know for sure you are complying after any change. No, "I know this is correct and doesn't affect the rest of the system" is not a valid response according to XP. Some critics argue that XP is too expensive because it requires you to write so many tests. At the beginnig that's true, it is expensive, because you need to get used to write tests. After a few months, though, the project is performing a lot faster. We run a project using XP for several months and we were improving our speed constantly until the project was simply finished. We could have been fed a new project twice the size and we would have finished it in just 2 months. We were coding 10 uses cases per day.