The original article describes scripting languages and makes some good points about how the use of them is an advantage when having novice programmers. In my opinion though, scripting languages are more often a dangerous tool in the hands of an inexperienced programmer rather than low level languages. Additionally, I would like to debate the advantages of compilation over interpretation as I think it is a very relevant and overlooked dimension to the topic of language choice in a project.
Scripting is easier right?
The author states that for a novice programmer is that it is easier to write efficient code in higher level scripting languages. However, I find the case to be that a programmer needs to have deep knowledge and understanding of a scripting language before he is able to produce any truly efficient code in one. In such languages a single line of code might raise complexity by an order of magnitude, but a programmer who doesn’t know how each command is implemented under the hood won’t know why his software suddenly became slow. In contrast lower-level languages, in which each line corresponds to a machine code instruction, are more straightforward to work with and thus harder to make such mistakes in.
In the article it is also argued that it is hard to write in a low level language because programmers need to have experience with manual memory allocation and pointers. This is indeed the case with C, but nowadays C is not the standard for system level languages. In fact most modern low level languages are quite different. Java and C# for example take care of memory allocation and garbage collection tasks automatically.
Scripting and not interpreted, how?
It is stated by the author that scripted languages are interpreted. While usually this is the case, the truth is that languages themselves are can be both compiled and interpreted. A great example of this is Java . We usually think of Java as a compiled language but can also be interpreted through the use of bsh (BeanShell). In fact, Java isn’t actually a compiled language, in the same sense that C or C++ are. It is compiled into what is called byte-code and then interpreted by a JVM which can do just-in-time (JIT) compilation to the native machine language. In fact, many modern compiled languages are not completely machine code based and most interpreted languages are actually compiled into byte-code forms before execution. My point here is that the landscape of programming languages has evolved to such an extent that the compiled/interpreted categorisation of a language starts to become irrelevant. That being said, there is a valid topic of whether compilation or interpretation, in general, is more suitable for a large scale task and I trust that this is a very relevant extension to the language choice debate.
But how is this interpretation – compilation thing relevant?
I do believe that the topic of compilation versus interpretation is important and especially when considering the case of large scale projects I believe there are significant advantages to having compiled code over interpreted. Firstly, native applications produced through compilation are more secure as it is usually impossible to generate source code from an executable . This is a security vulnerability of interpretation that one must take into account. Secondly, by using languages that are compiled we pay the cost of compilation only once and in turn get a fast and efficient executable. On the other hand, interpretation comes with a high cost  of execution because the program needs to be parsed and interpreted every time it is run. Another disadvantage is that in large complex projects identical code will surely exist and will have to be interpreted and optimised twice if an interpreted language is used. This might not make much difference in a small project, but might be what makes or break a product in a big project.
To conclude, there are cases where scripting languages are a better choice and other cases where system level programming is preferable. Since we are discussing large scale projects however, I believe there are more advantages to be gained with the use of lower level languages and compilation rather than scripted ones and interpretation. While it is true, that as languages evolve the differences between the 2 models have become smaller, I find that it is still safer to use a low level compiled language, even when having to deal with novice programmers on a given team. Moreover, in cases where a high level language must be used, using compilation should remain a priority. As for when the level of the team is high, then the combination of the two approaches would likely produce the best results and eliminate disadvantages  of either method.