How do you perceive a situation when the use of an interface is not explicitly specified in the code?

In Go, interfaces are implemented implicitly: if a type implements all the methods of an interface, it is automatically considered to implement that interface, without the need to explicitly declare it.

If the code does not explicitly specify the use of an interface, it may mean:

• A concrete type is used directly, without abstractions.
• The interface may not be necessary for the current task, and the code is simpler without it.
• Or, the interface is used implicitly, for example, through assigning a value of a concrete type to a variable of an interface type.

This approach aligns with the philosophy of Go — simplicity and minimalism. The absence of explicit interface declarations reduces coupling and simplifies the code.

However, if flexibility and testability are important in the project, it is recommended to use interfaces explicitly so that implementations can be easily swapped.

Example of implicit interface implementation:

package main
import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct {}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var s Speaker
    s = Dog{} // Dog does not declare that it implements Speaker, but it does
    fmt.Println(s.Speak())
}

Here, Dog does not explicitly declare that it implements Speaker, but the compiler understands this automatically.