REST stands for "Representational State Transfer." It is not a protocol but rather an architectural style that defines a set of constraints for creating scalable and maintainable web services. RESTful APIs use HTTP as a communication protocol and adhere to these constraints, making it easier to develop and consume APIs in a consistent and efficient manner. Understanding these constraints is essential for designing RESTful APIs effectively.

Custom errors provide a way to "encapsulate" more information about the error conditions. By encapsulating errors, you can wrap the original error with additional context and information, making it easier to handle and communicate the error's details to other parts of the application or to external systems. This helps improve error reporting, debugging, and overall system resilience.

A race condition is a critical concurrency issue where two or more goroutines access shared data without proper synchronization, leading to unpredictable and erroneous behavior. The -race flag in Go is a powerful tool for detecting race conditions. When you compile your Go program with the -race flag, the Go runtime will instrument your code to track all accesses to shared variables. If it detects a race condition during runtime, it will report it, helping you identify and fix the issue. The -race flag is a vital tool for ensuring the correctness of concurrent Go programs.

In Go testing, the t.Fatal function is used to terminate the current test immediately and report it as a failure. This function is typically used when a critical condition is not met during the test execution, and you want to indicate that the test cannot proceed successfully. It helps in identifying and diagnosing issues more precisely by stopping the test as soon as a problem is encountered, rather than continuing to execute the subsequent test code.

In Go, the defer statement schedules a function to be called after the surrounding function returns. This is often used for tasks like closing files, releasing resources, or ensuring cleanup operations happen even in the presence of errors. When defer is used, the function call is deferred until the end of the enclosing function's scope, ensuring it runs just before that function returns.

In this scenario, you would prefer to use a Struct in Go to store information about each book. A Struct allows you to define a custom data type with fields to represent attributes of a book (e.g., title, author, ISBN). It provides a way to encapsulate related data and behaviors into a single unit, making it ideal for representing individual books in the library's inventory. Using a Struct allows you to access book properties using dot notation, making your code more organized and readable.

The correct answer is uppercase. In Go, when you encode a data structure into JSON using the encoding/json package, the fields in the data structure need to be exported, which means they need to start with an uppercase letter. Exported fields are those that are accessible from outside the package, and they are the only fields that the encoding/json package can encode into JSON. This convention is important for proper JSON encoding and decoding in Go.

Shadowing in Go refers to declaring a variable with the same name in an inner scope, which temporarily hides a variable of the same name in an outer scope. While not inherently problematic, it can lead to confusion and potential bugs. When shadowing occurs, it can be challenging to determine which variable is being accessed or modified. It's essential to be aware of shadowing to write clean and maintainable Go code and avoid unexpected behavior caused by variable conflicts.

When a Go interface becomes large and has many methods, it's often beneficial to split it into smaller interfaces for easier mocking and testing. This practice aligns with the SOLID principles, particularly the "Interface Segregation Principle" (ISP), which recommends that you should have many client-specific interfaces rather than a single, large, general-purpose one. Smaller interfaces make it easier to create focused mocks and test specific interactions.

In Go, to read from a file line by line, you typically use the os.Open function to open the file, creating a *os.File object. Then, you create a Scanner using bufio.NewScanner(file) and use a loop to iterate over the lines using the scanner.Scan() method. This method reads one line at a time, and you can access the text of the line using scanner.Text(). This approach is memory-efficient as it doesn't load the entire file into memory.