Dynamically typed languages associate all values with types in the language, and do not permit operations on values of inappropriate types (for example, adding an integer to a string). However, in contrast to StaticallyTypedLanguages, these types are not (fully) verified at compile time. Rather, run-time checks in the compiled program will verify that the values being operated on are of the appropriate type, and an error is raised if a type check fails. As a conseqence of dynamic typing, it is often necessary for values to "carry" their types with them (such a carried type is sometimes referred to as a tag).
Dynamic typing carries the penalty of reduced efficiency because of these checks, and the possibility of runtime type errors must be taken into consideration when writing a program. However, these languages are generally better for rapid prototyping because the programmer is not constrained by a compile-time typechecker. Some of these languages also have features which are not compatible with static typing; the typechecking needed for these features might have exponential runtime, be ambiguous, or even be undecidable (examples: concurrency issues, inline code in regular expressions, side effects, mobile code).
(There are also UntypedLanguages, which have either incomplete type verification or none at all.)
Programmers often feel strongly about the merits of one category or the other. Ultimately, it will depend on the needs of the project at hand.
Some examples of dynamically typed languages: