# Golang - Facade Pattern

In software engineering, the Facade Pattern is a structural pattern that provides a simplified interface to a larger body of code. It's used to make a complex system more accessible, easier to use, and more understandable for end-users. The Facade Pattern is part of the "Gang of Four" design patterns that describe the best practices for object-oriented software development.

# How the Facade Pattern Works

The Facade Pattern provides a unified interface to a set of interfaces in a subsystem. It defines a higher-level interface that makes the subsystem easier to use. The subsystem can be a complex set of classes or a library that performs a specific task. The Facade Pattern is used to hide the complexities of the subsystem and provide a simplified interface to the end-user.

# Code Example

Here's an example of how the Facade Pattern can be used in Golang:

```go
package main

import (
    "fmt"
)

type CPU struct{}

func (*CPU) Freeze() {
    fmt.Println("CPU Freeze")
}

func (*CPU) Jump(position int) {
    fmt.Printf("CPU Jump to %d\n", position)
}

func (*CPU) Execute() {
    fmt.Println("CPU Execute")
}

type Memory struct{}

func (*Memory) Load(position int, data string) {
    fmt.Printf("Memory Load data '%s' to position %d\n", data, position)
}

type HardDrive struct{}

func (*HardDrive) Read(position int, size int) string {
    data := fmt.Sprintf("HardDrive Read data from position %d with size %d", position, size)
    fmt.Println(data)
    return data
}

type ComputerFacade struct {
    cpu       *CPU
    memory    *Memory
    hardDrive *HardDrive
}

func NewComputerFacade() *ComputerFacade {
    return &ComputerFacade{
        cpu:       &CPU{},
        memory:    &Memory{},
        hardDrive: &HardDrive{},
    }
}

func (c *ComputerFacade) Start() {
    c.cpu.Freeze()
    c.memory.Load(0, "boot_loader")
    c.cpu.Jump(0)
    c.cpu.Execute()
}

func main() {
    computer := NewComputerFacade()
    computer.Start()
}
```

In the example above, we have a `ComputerFacade` that provides a simplified interface to a set of subsystems such as `CPU`, `Memory`, and `HardDrive`. The `Start` method of the `ComputerFacade` performs a series of actions that are required to start a computer. The end-user only needs to call the `Start` method to start the computer, and the `ComputerFacade` takes care of the complexities of the subsystems.

# Conclusion

The Facade Pattern is a useful pattern for simplifying complex systems and making them more accessible to end-users. It provides a unified interface to a set of interfaces in a subsystem, making it easier to use and understand. In Golang, the Facade Pattern can be used to simplify the interaction with complex libraries or sets of classes.

---

# References

* [**“Design Patterns: Elements of Reusable Object-Oriented Software**](https://amzn.to/3SJenIZ)” by Erich Gamma, John Vlissides, Ralph Johnson, and Richard Helm