Building Scalable Backend Services in Go.png

backend_development_with_go.tar.gz

Lesson 1

Testing

Scalable backend services refer to the ability of a system’s backend to cope with changing workloads. A developer must build applications that can handle increased user demands without sacrificing performance, reliability, and responsiveness.

You’ll start by learning the fundamentals of a server and how to test a backend service. You’ll also design RESTful APIs and build a self-sufficient network package to interact with APIs efficiently. Next, you’ll learn different caching strategies and the necessary interfaces to handle databases using MongoDB, an example of a NoSQL database. Finally, you will learn about different creational design patterns to ensure the system’s components are scalable.

Irrespective of whether you’re a seasoned developer or completely new to the backend world, you will confidently build high-performance systems that can handle increasing user demands, equipped with the skills to excel in modern backend development using Go after taking this course.

Building Scalable Backend Services in Go

Interfaces only allow us to define methods that manipulate data entities.

Interfaces make code more tightly coupled to the external dependency.

Interfaces allow us to decouple the implementation details of a struct from the code that interacts with it.

Interfaces are only used for abstract use cases where the API signature is not known.

Which option is *true* regarding interfaces in Go?

Which option is true regarding interfaces in Go?

Queues are only used in synchronous communication.

Queues are only used in asynchronous communication.

Queues cause low performance due to added latency.

Queues are always implemented inside your codebase as an in-memory structure.

Which option is true about queues?

Which method will update existing data or create a new entity if *not* present? 

Which method will update existing data or create a new entity if not present?

**(Select all that apply.)** What is an example of an external dependency in back-end development?

(Select all that apply.) What is an example of an external dependency in back-end development?

```go
type Service struct {
    db *sql.DB
}

func NewService() *Service {
    return &Service{}
}
```

```go
type Service struct {
    db *sql.DB
}

func NewService() *Service {
    db, _ := sql.Open("mysql", "user:password@tcp(localhost:3306)/db")
    return &Service{db: db}
}
```

```go
type Service struct {
    db *sql.DB
}

func (s *Service) SetDB(db *sql.DB) {
    s.db = db
}

func NewService() *Service {
    return &Service{}
}
```

```go
type Service struct {
    db *sql.DB
}

func (s *Service) SetDB(db *sql.DB) {
    s.db = db
}

func NewService(db *sql.DB) *Service {
    s := &Service{}
    s.SetDB(db)
    return s
}
```

John is trying to implement a service that connects to and fetches data from a database. He knows he can only interact with the SQL databases for his needs, but his team might need to swap out the actual database later from Oracle to Amazon RDS or use both simultaneously. Therefore, he wants to use a dependency injection so that his service code initializes only an SQL DB in the constructor. Go through the four options below to pick the correct approach for John. 

John is trying to implement a service that connects to and fetches data from a database. He knows he can only interact with the SQL databases for his needs, but his team might need to swap out the actual database later from Oracle to Amazon RDS or use both simultaneously. Therefore, he wants to use a dependency injection so that his service code initializes only an SQL DB in the constructor. Go through the four options below to pick the correct approach for John.

Test your knowledge of interfaces, databases, and queues.

Before We Get Started

Server Fundamentals

Parking Lot Server

Networking and Interfaces

E-commerce Compare Products API

Dealing with Databases and Queues

Design Patterns

Conclusion

Quiz: Interfaces, Databases, and Queues