Categorisation of type systems (strong/weak, dynamic/static)
Historically, the term "strongly typed programming language" came into use in the 70's in reaction to the existing widely used programming languages, most of which had type holes.  Some examples:


In Fortran, there were things called "COMMON" storage areas, which could be shared across modules, but there were no checks to see if each module was declaring the contents of the COMMON storage with the same types.  So, one module could declare that a particular COMMON storage block had an integer and another a floating point number, and the data would get corrupted as a result.  Fortran also had "EQUIVALENCE" statements, whereby the same storage could be declared to contain two different objects of different types.
In Algol 60, the type of procedure parameters was declared as just "procedure", without specifying the types of the parameters of the procedure.  So, one could assume that a procedure parameter was an integer-accepting procedure, but pass in a real-accepting procedure as the argument.  This would result in the same kind of corruption as the COMMON and EQUIVALENCE statements.  (However, Algol 60 did eliminate the older problems.)
In Pascal, "variant records" were added which were almost exactly like the old EQUIVALENCE statements.
In C, "type casts" were added whereby any type of data could be reinterpreted as data of a different type.  This was a rather deliberate type hole meant for programmers who supposedly know what they are doing.


The strongly typed languages designed in the 70's were meant to eliminate all such type holes.  If you drill down into what this means, it means essentially that data representations are protected.  It is not possible to view data object of one type as an object of another type which happens to have the same bit pattern as its internal representation.  Theoreticians began to use the term "representation independence" to characterize this property instead of the vague idea of "strong typing".

Note that dynamically typed languages like Lisp which perform complete run-time type checking are "strongly typed" in the sense of protecting representations.  At the same time, statically typed languages would lose representation independence unless they did array bounds checking.  So, they are not "strongly typed" in the strict sense of the term.  Due to these anomalous consequences, the term "strongly typed" fell into disuse after the 70's.
When the US Department of Defence developed rigorous requirements for the design of Ada, they included the requirement that the language should be "strongly typed".  (It seems to have been believed at that time that the idea of "strongly typed" was self-evident.  No definition was offered.)  All the language proposals submitted in response claimed to be "strongly typed".  When Dijkstra analysed all the language proposals, he found that none of them were strongly typed and, in fact, it wasn't even clear what the term meant.  See the report EWD663.  However, I see that the term is coming back into use now, through a younger generation of researchers who don't know the checkered history of the term.

The term "statically typed" means that all type-checking is done statically and no type errors will arise at run-time.  If the language is also strongly typed, that means that there are really no type errors during execution.  If, on the other hand, there are type holes in the type system, the absence of run-time type errors means nothing.  The results could be completely corrupt.

The new debate about "strong vs weak typing" seems to be about whether certain type conversions should be allowed.  Allowing a string where an integer is required is "weak typing" according to these folks.  There is some sense to that because attempting to convert a string to an integer may fail, if the string doesn't happen to represent an integer.  However, converting an integer to a string doesn't have that problem.  Would that be an instance of "weak typing" according to these folks?  I have no idea.  I notice that the Wikipedia discussions on "weak typing" don't cite any refereed publications.  I don't believe that it is a coherent idea.

Note added: The basic point is that the term "strong typing" did not come into use as a technical term with a rigorous definition.  It was more like some language designers felt: "our type system is strong; it catches all type errors; it doesn't have type holes" and, so, when they published their language design, they claimed that it was "strongly typed".  It was a buzz word that sounded good and people started using it.  The Cardelli-Wegner paper was the first one that I have seen where some analysis was provided into what it means.  My post here should be thought of as an elaboration of their position.