Most dynamic OOP languages don't have interfaces either, so that is kind of a poor argument. You cannot compare Julia to something like Java.

You got to compare it to Ruby, Python etc.

Also I have no idea what an interface definition would look like in Julia. A function in Julia isn't bound to one specific type like in an OOP language.

I think interfaces in Julia might go something like

    interface AnimalActions
        function walk(x::Animal) end
        function call(x::Animal, y::Animal) end
        function eat(x::Animal, z::Food) end
    end
    
    struct Dog <: Animal
        name::String
    end
    
    AnimalActions.walk(x::Dog) = true
    AnimalActions.call(x::Dog, y::Animal) = true
    AnimalActions.eat(x::Dog, z::Food) = true
    
    setinterface Dog AnimalActions end

and then I guess using it like

    using AnimalActions
    d = Dog("rufus")
    walk(d)

The below package implements something like that, but better imo: https://tk3369.github.io/BinaryTraits.jl/dev/

Regardless of what is a subset of what, I certainly agree with the OP that OOP feels "anemic" in comparison to the dispatch-based paradigm of Julia.

I can't tell you how many times I've seen disparate packages written by different authors with no explicit effort towards interoperability "just work" together in Julia (e.g., [1]), something I have never seen to a comparable degree in any other language.

[1] https://www.youtube.com/watch?v=kc9HwsxE1OY