Thanks for your feedback Chris. It seems like I have not managed to convey my ideas that well. It was never my intention to argue that complex compilers create complex systems. Maybe you can help me locate the parts of the story that gives that impression.

My intention was to argue against complex programming languages. A simple programming language could in principle have a complex compiler. The complexity of the compiler and the language are somewhat independent although a complex language will naturally end up with a complex compiler.

I agree that the skill of the developer is important, which is why a skilled developer will be able to make the most out of simple tools. You don't necessarily need complex tools to be producitve, if you are clever about how you use the tools you have.

I think you are confusing termnology regarding typing. Loose typing is a bit of an inaccurate terminology. We usually use words like weak, strong, static and dynamic to describe type systems. E.g. C is a statically and weakly typed language. Perl and JavaScript are weakly typed dynamic languages. Python and Julia in contrast are strongly typed dynamic languages. Haskell is a strongly typed static language.

In your example, a statically compiled language could fail to catch the problem. E.g. the C programming language will not catch that you are using an integer where you should have been using a boolean type.

E.g. C is a statically typed language, and yet it failed to catch this bug both at compilation time and at runtime:

if (1) {

printf("Hello")

}

While a dynamically typed language such as Julia will catch this at runtime:

if 1

println("hello")

end

Also most dynamic languages today have linters and type annotations to help perform static code analysis. Python has MyPy which will do static code analysis using type annotations. Ruby has Sorbet type checker. Julia has JET.

In Objective-C, all of the object based code is dynamically typed but most people don't even think about that because using type annotations is common. People don't really differentiate between type errors from a compiler and type warnings from a linter.