These are just different things. Dynamic types, as in Ruby, naturally make it quite impossible for the language compiler to be statically typed - it must be dynamically typed. If the types don’t even exist at compile time, the compiler has no chance of enforcing typing.

For example, VBScript is dynamically typed. There is no way to associate a specific type with a variable when it is declared. But all the possible types are known ahead of time.

JavaScript, on the other hand, allows you to build up a type at runtime, essentially adding your own properties to it. As I understand it, Ruby and Python are that way too.

So, do we have good terminology to distingush between dynamic typing and dynamic types?

The thing about dynamic typing is that it waits until runtime to see if such a conversion exists.

A = 5
B = new BankAccount()
C = A + B

Obviously there is no way to add a bank account to the number 5. With a statically typed language, that would usually be caught at compile time. With a dynamically typed langauge, you wouldn’t find out the mistake until the program was running.

Note that static typing isn’t perfect. Consider this code…

Number A = 5
Object B = new BankAccount()
Number C = A + (Integer)B

By making the cast on the third line, the programmer is saying “Yes, I know this might fail. But trust me, it will work.”. Of course if you give the compiler more info, errors are less likely…

Number A = 5
BankAccount B = new BankAccount()
Number C = A + (Integer)B

Here the compiler can tell the programmer, “No, you don’t know what you are doing. That will always fail.”

And lastly, the correct code…

Number A = 5
BankAccount B = new BankAccount()
Number C = A + B.Balance

By default, VB doesn’t require variable declaration, let alone types.

With Option Explicit, variables are required but you still don’t have to give them types. If you don’t, then they are dynamically bound.

With Option Strict (VB 7+), then VB requires types for all variables, essentially making them all statically typed.

On a side note, VB programmers tend to use the terms “Early Binding” and “Late Binding” rather than static and dynamic.

print “2″ + 4;

If this succeeds the types where in fact compatible and the language is strongly typed as per the definition you gave. If it fails they were incompatible. Looked at this way I can’t see a reason for a language to be weakly typed as that would simply be another way of stating that it is unsafe. Does strongly vs weakly typed simply mean that there exists some morphism between types which makes conversions possible?