What arguments are there in favor of weak typing?

Question

This came up in a discussion with a friend, and I found myself hard-pressed to think up an any good arguments. What benefits do weak typing confer?

Answer 1

The problem with this kind of discussion is simply that the terms "weak typing" and "strong typing" are undefined, unlike for example the terms "static typing", "dynamic typing", "explicit typing", "implicit typing", "duck typing", "structural typing" or "nominal typing". Heck, even the terms "manifest typing" and "latent typing", which are still open areas of research and discussion are probably better defined.

So, until your friend provides a definition of the term "weak typing" that is stable enough to serve as the basis of a discussion, it doesn't even make sense to answer this question.

Unfortunately, apart from Nick's answer, nobody of the answerers bothered to provide their definition either, and you can see the confusion that generates in some of the comments. It's hard to tell, since nobody actually provides their definitions, but I think I count at least three different ones, just on this very page.

Some of the more commonly used definitions are (and yes, I know that pretty much none of them makes any sense, but those are the definitions I've seen people actually use):

• weak typing = unsafe typing / strong typing = safe typing
• weak typing = dynamic typing / strong typing = static typing
• weak typing = duck typing / strong typing = nominal typing
• weak typing = structural typing / strong typing = nominal typing
• weak typing = implicit typing / strong typing = explicit typing
• weak typing = latent typing / strong typing = manifest typing
• weak typing = no typing / strong typing = typing
• weak typing = implicit casts / strong typing = only explicit casts
• weak typing = implicit or explicit casts / strong typing = no casts at all
• weak typing = implicit conversions / strong typing = only explicit conversions
• weak typing = implicit or explicit conversions / strong typing = no conversions at all
• weak typing = interpretation / strong typing = compilation
• weak typing = slow / strong typing = fast
• weak typing = garbage collection / strong typing = manual memory management
• weak typing = manual memory management / strong typing = garbage collection
• … and many others

The three definitions that seem to be used most widely, however, are

• weak typing = your stupid crappy programming language / strong typing = my super-awesome programming language
• weak typing = every other programming language / strong typing = the only programming language I ever bothered to learn (usually either Java, C# or C++; strangely, people who learn e.g. Haskell or Scheme as their first and only language don't seem to share this worldview)
• weak typing = every language I don't understand / strong typing = Java (substitute with C# or C++ at will)

Unless everybody agrees on a definition of what "weak typing" even is, it doesn't even make sense to think about what its advantages might be. Advantages of what? Even worse, if there is no definition at all, then everybody can just shift their definitions to fit their arguments, and every discussion is pretty much guaranteed to devolve into a flamewar.

I myself have personally changed my own definition several times over the years and have now reached the point where I don't even consider the terms useful any more. I also used to think that weak typing (in its various definitions) has a place in shell scripting, but whenever I have to solve the same problem in Bash and PowerShell, I am painfully reminded how wrong I was.

Answer 2

Remember there are two major concepts that are commonly confused:

Dynamic typing

A programming language is said to be dynamically typed when the majority of its type checking is performed at run-time as opposed to at compile-time. In dynamic typing, values have types but variables do not; that is, a variable can refer to a value of any type.

The advantages here are often dismissed as just for "new" programmers, but can also be convenient for any programmer:

if (!(arr is Array)) arr = [arr]; // is, instanceof, .constructor ==, whatever

Less code in any case where you'd otherwise have to cast or assign a new value:

if (data is Array)) {
    i = data.length; // no i = ((Array)data).length or Array myArr=(Array)data;
}

Loose or weak typing

Weak typing means that a language implicitly converts (or casts) types when used.

Benefits:

• Pass any type value as a parameter to a function. Useful for callbacks, flexible APIs, and makes for a simpler implementation of closures.

• Implicit boolean evaluation. Any type can be evaluated as a boolean. This also has side benefits such as a part of an || can be used in assignment without conversion to boolean:

  var a = param || defaultValue;
  

• Again, less code:

  var num = 5;
  var str = "Hello";
  input.innerHTML = input.value = num;
  for (var i=0; i < input.value; i++) { ... }
  

  Even Java had to go partway, with the implicit call to .toString() when combining objects with a String; otherwise Java programmers would be cursing it all day long (log statements would be out of control).

---

^{Both definitions are from http://en.wikipedia.org/wiki/Type_system. It said it better than I could.}

Answer 3

The main argument for weak typing is one of performance. (this is to answer the OPs question as stated). There's a lot of good discussion about dynamic vs. static, implicit vs. explicit. etc.

C is the most famous weakly typed language, and it does not perform any run time checking or compile time checking of the variables type. In essence you can cast a char * to an int * and the language wouldn't care. So why would you do this?

C programming is pretty close to the way you would do things with assembly, so there are times where you only care about an address. It's not uncommon to cast or pass a void * reference for that very reason. If you know how the memory is organized (again a C and assembly concern), you can do some pretty cool calculations based on the address in the void * to get at the information you need. This can let you short-circuit the process you would have to go through in Java for instance.

While run-time type checking doesn't have an extraordinary bit of overhead, there are times when it is just enough to cause a critical section to be too slow. I'm thinking mostly about embedded programming and real time systems in this case.

That said, in most cases having a strong type system that is either compile time checked or runtime checked helps more often than it hurts.

Answer 4

Weak typing is typically easier for newbies to grasp, for instance in things like excel,javascript and vbscript. You also trade some development speed for potential errors.

Good article on the subject: Strong typing vs Strong testing