"Duck typing" is a programming concept that is used in dynamically typed languages, where the semantics of an object is determined by its current set of methods and properties, not by its inheritance from a particular class or its implementation of a specific interface. The name comes from the phrase "If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck."

In other words, an object's suitability is determined by the presence of certain methods and properties (its shape), rather than the actual type of the object. This allows for greater flexibility in a dynamically typed language, since you can call methods or access properties on an object if they exist, without worrying about the object's type.

For example, consider a function that takes an object and calls its "quack" method. In a statically typed language, you might require that the object be of type "Duck", and it would be a compile-time error to pass in an object of a different type. However, in a dynamically typed language with duck typing, any object that has a "quack" method can be passed to the function, regardless of its type. If the "quack" method doesn't exist on the object, then it would be a runtime error when the method is actually called.

JavaScript and Python are examples of languages that utilize duck typing. TypeScript also has a form of duck typing because of its structural type system, even though TypeScript is statically typed. In TypeScript, an object's type is determined by the shape that the object takes, i.e., what properties and methods it has. This allows for a lot of flexibility while still providing type safety.