My undstanding of Duck Typing

 　　 The definition of Duck Typing in wiki is ""When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck."    My understanding is behavior over type, now.  That is eazy to undstandin for the programmer who is using dynamic type programming such as ruby, python etc. But, maybe is not so eazy to understanding to someone like me who is never use dynamic type programming lanuage before.   When I started to learn ruby, i confused there is no interface syntax in ruby. As you know,  ruby is a OO programming language.  How do i do interface orintend programming in ruby.

     At first, we should know what is interface? Interface is a contract. If a class implments a specfic interface, we think the class statisfied the contract. Then we should know why do we need interface. Interface efficient decoupling a behavior, which dependence a specific implementation. After I knew the 2 points, i completely undstand. I unstand why there is no interface in ruby. Please take a look the below code.

 

ruby code:

 class Person

    def walk        
         puts 'Person is walking'    
    end
	
    def swim      
         puts 'Person is swimming'     
    end

    def quack
         puts "Person can't quack"
    end
end

class Duck
    def walk
        puts 'Duck is walking' 
    end
    
    def swim
        puts 'Duck is swimming'    
    end
    
    def quack
        puts "Duck is quacking"
    end
end

def detect_duck_behavior(duck)
   duck.walk()
   duck.swim()
   duck.quack()
end

detect_duck_behavior(Person.new)
detect_duck_behaviro(Duck.new)

C# code

    interface IDuckBehavior
    {
        void Walk();
        void Swim();
        void Quack();
    }

    class Person: IDuckBehavior
    {
        public void Walk()
        {
            Console.WriteLine("Person is walking");
        }

        public void Swim()
        {
            Console.WriteLine("Person is swimming");
        }

        public void Quack()
        {
            Console.WriteLine("Person can't quack");
        }
    }

    class Duck : IDuckBehavior
    {
        public void Walk()
        {
            Console.WriteLine("Duck is walking");
        }

        public void Swim()
        {
            Console.WriteLine("Duck is swimming");
        }

        public void Quack()
        {
           Console.WriteLine("Duck is quacking");
        }
    }

 class Program
    {
        static void Main(string[] args)
        {
            DetectDuckBehavior(new Person());
            DetectDuckBehavior(new Duck());
        }

        static void DetectDuckBehavior(IDuckBehavior duckBehavior)
        {
            duckBehavior.Walk();
            duckBehavior.Swim();
            duckBehavior.Quack();
        }
    }

Comparing the 2 code snippet, you will find ruby can do as same as c#, althought there is no interface in ruby. So, i think the dynamic type OO programming language is behavior over type. We care what behavior it have, not its type.