Mostly this is a coincidence.
Programming languages have evolved over time, and the technology of compilers and interpreters has improved. The efficiency of the underlying processing (ie the compilation time, the interpreting overhead, the execution time etc) is also less important as mainstream computing platforms have grown in power.
The language syntax does have an impact - for example, Pascal was very carefully designed so it could use a single pass compiler - ie one pass over the source and you have excutable machine code. Ada on the other hand paid no attention to this, and Ada compilers are notoriously difficult to write - most require more than one pass. (One very good Ada compiler I used many years ago was an 8 pass compiler. As you might imagine, it was very slow.)
If you look at old languages like Fortran (compiled) and BASIC (interpreted or compiled) they have / had very strict syntax and semantic rules. [In the case of BASIC, thats not Bills old BASIC, you need to go back before that to the original.]
On the other hand, looking at other older things like APL (a bunch of fun) this had dynamic typing, of sorts. It was also generally interpreted but could be compiled too.
Lenient syntax is a difficult one - if that means you have things that are optional or can be inferred then it means the language has sufficient richness that it could be culled. Then again, BASIC had that many years ago when the "LET" statement became optional!
Many of the ideas you now see (for example, typeless or dynamic typing) are actually very old - first appearing in the 1970's or early 1980's. The way they are used, and the languages these ideas are used in has changed and grown. But fundamentally, much of whats new is actually old stuff dressed up in new clothes.
Here are some examples off the top of my head:
- APL: dynamic typing. Generally interpreted. Came from the 1960's / 1970's.
- BASIC: strong or dynamic typing. Interpreted or compiled. 1970's and many beyond.
- Fortran: strong typing. Compiled. 1960's or earlier.
- Algol68: strong typing. Compiled. 1960's.
- PL/1: strong typing. Compiled. 1960's.
- Pascal: strong typing. Compiled. 1970's. (But in the 1980s there were P-System compilers very similar to JIT compilers!)
- Some implementations of Fortran and others by DEC in the early days were partially compiled and partially interpreted.
- Smalltalk: dynamic typing. Compiled to bytecode which is interpreted. 1980's.
- Prolog: more strangeness. Functional. Compiled (Turbo Prolog, anybody?). 1980's.
- C: strong (ha ha) typing. Compiled. 1960's..today.
- Ada: uber-strong typing. Compiled. 1980's.
- Perl: dynamic typing. (Strong syntax). Interpreted. 1990's (?).
I could go on.
- Nitpickers corner: Many interpreted languages are tokenised or "byte compiled" at the time they the source is loaded / read-in. This makes the subsequent operation of the interpreter a lot simpler. Sometimes you can save the byte-compiled version of the code. Sometimes you can't. Its still interpreted.
Update: Because I was not clear enough.
Typing can vary widely.
Compile-time fixed static typing is common (eg, C, Ada, C++, Fortan, etc etc). This is where you declare a THING of a TYPE and it is that way forever.
It is also possible to have dynamic typing, where the thing picks up the type that is assigned to it. For example, PHP and some early BASIC, and APL, where you would assign an integer to a variable and from then on it was an integer type. If you later assigned a string to it, then it was a string type. And so on.
And then there is loose typing, for example PHP where you can do truly bizarre things like assign a numeric integer (quoted, so its a string) to a variable and then add a number to it. (eg '5' + 5 would result in 10). This is the land of the bizarre, but also at times the very very useful.
HOWEVER these are features designed into a language. The implementation just makes that happen.