Lesson 5
Backward Compatibility in Go: Practical Applications
Backward Compatibility: Practice

Welcome back! Today, we'll master what we learned about backward compatibility in practice. Prepare to apply all the knowledge to practical tasks, but first, let's look at two examples and analyze them.

Task 1: Enhancing a Complex Data Processing Function with Flexible Function Use

Let's say that initially, we have a complex data processing function designed to operate on a slice of maps map[string]interface{}, applying a transformation that converts all string values within the map to uppercase. Here's the initial version:

Go
1package main
2
3import (
4    "fmt"
5    "strings"
6)
7
8type DataProcessor struct{}
9
10func (d DataProcessor) ProcessData(items []map[string]interface{}) {
11    processedItems := make([]map[string]interface{}, 0)
12    for _, item := range items {
13        processedItem := make(map[string]interface{})
14        for k, v := range item {
15            if strVal, ok := v.(string); ok {
16                processedItem[k] = strings.ToUpper(strVal)
17            } else {
18                processedItem[k] = v
19            }
20        }
21        processedItems = append(processedItems, processedItem)
22    }
23    for i := 0; i < min(3, len(processedItems)); i++ {
24        fmt.Println("Processed Item:", processedItems[i])
25    }
26}
27
28func min(a, b int) int {
29    if a < b {
30        return a
31    }
32    return b
33}

We intend to expand this functionality by adding capabilities to filter the items based on a condition and to allow for custom transformations. The aim is to retain backward compatibility while introducing these enhancements. Here's the updated approach using flexible function signatures and closures:

Go
1package main
2
3import (
4    "fmt"
5    "strings"
6)
7
8type DataProcessor struct{}
9
10/*
11    List of data items to be processed,
12    Function to transform each item,
13    Function to determine if the item meets a condition
14*/
15func (d DataProcessor) ProcessData(
16        items []map[string]interface{},
17        transform func(map[string]interface{}) map[string]interface{},
18        condition func(map[string]interface{}) bool) {
19    if condition == nil {
20        condition = func(item map[string]interface{}) bool { return true }
21    }
22
23    if transform == nil {
24        transform = func(item map[string]interface{}) map[string]interface{} {
25            transformed := make(map[string]interface{})
26            for k, v := range item {
27                if strVal, ok := v.(string); ok {
28                    transformed[k] = strings.ToUpper(strVal)
29                } else {
30                    transformed[k] = v
31                }
32            }
33            return transformed
34        }
35    }
36
37    processedItems := make([]map[string]interface{}, 0)
38    for _, item := range items {
39        if condition(item) {
40            processedItems = append(processedItems, transform(item))
41        }
42    }
43
44    for i := 0; i < min(3, len(processedItems)); i++ {
45        fmt.Println("Processed Item:", processedItems[i])
46    }
47}
48
49// Usage examples:
50func main() {
51    data := []map[string]interface{}{
52        {"name": "apple", "quantity": 10},
53        {"name": "orange", "quantity": 5},
54    }
55
56    processor := DataProcessor{}
57
58    // Default behavior - convert string values to uppercase
59    processor.ProcessData(data, nil, nil)
60
61    // Custom filter - select items with a quantity greater than 5
62    processor.ProcessData(data, nil, func(item map[string]interface{}) bool {
63        return item["quantity"].(int) > 5
64    })
65
66    // Custom transformation - convert names to uppercase and multiply the quantity by 2
67    processor.ProcessData(data, func(item map[string]interface{}) map[string]interface{} {
68        transformed := make(map[string]interface{})
69        for k, v := range item {
70            if k == "name" {
71                transformed[k] = strings.ToUpper(v.(string))
72            } else if k == "quantity" {
73                transformed[k] = v.(int) * 2
74            } else {
75                transformed[k] = v
76            }
77        }
78        return transformed
79    }, nil)
80}

In this evolved version, we've introduced flexible function signatures that allow users to provide transformation and filtering functions as needed. The default behavior processes all items, converting string values to uppercase, ensuring that the original functionality's behavior is maintained for existing code paths. This robust enhancement strategy facilitates adding new features to a function with significant complexity while preserving backward compatibility, showcasing an advanced application of evolving software capabilities responsively and responsibly.

Task 2: Using the Adapter Design Pattern for Backward Compatibility

Imagine now that we are building a music player, and recently, market demands have grown. Now, users expect support not just for MP3 and WAV but also for FLAC files within our music player system. This development poses a unique challenge: How do we extend our music player's capabilities to embrace this new format without altering its established interface or the adapter we've already implemented for WAV support?

Let's say that we currently have a MusicPlayer struct that can only play MP3 files:

Go
1package main
2
3import (
4    "fmt"
5    "strings"
6)
7
8type MusicPlayer struct{}
9
10func (mp MusicPlayer) Play(file string) {
11    if strings.HasSuffix(file, ".mp3") {
12        fmt.Println("Playing", file, "as mp3.")
13    } else {
14        fmt.Println("File format not supported.")
15    }
16}

Let's approach this challenge by introducing a composite adapter, a design that encapsulates multiple strategies to extend functionality in a modular and maintainable manner.

Go
1package main
2
3import (
4    "fmt"
5    "strings"
6)
7
8type MusicPlayerAdapter struct {
9    player        *MusicPlayer
10    formatAdapters map[string]func(string)
11}
12
13func NewMusicPlayerAdapter(player *MusicPlayer) *MusicPlayerAdapter {
14    a := &MusicPlayerAdapter{
15        player: player,
16        formatAdapters: map[string]func(string){
17            ".wav":  ConvertAndPlayWav,
18            ".flac": ConvertAndPlayFlac,
19        },
20    }
21    return a
22}
23
24func (a *MusicPlayerAdapter) Play(file string) {
25    // Extract the file extension by finding the last dot.
26    extensionIndex := strings.LastIndex(file, ".")
27    if extensionIndex != -1 {
28        extension := strings.ToLower(file[extensionIndex:])
29        if adapterFunc, exists := a.formatAdapters[extension]; exists {
30            adapterFunc(file)
31        } else {
32            a.player.Play(file)
33        }
34    } else {
35        a.player.Play(file)  // No extension found
36    }
37}
38
39func ConvertAndPlayWav(file string) {
40    // Simulate conversion
41    convertedFile := strings.Replace(file, ".wav", ".mp3", 1)
42    fmt.Println("Converting", file, "to", convertedFile, "and playing as mp3...")
43}
44
45func ConvertAndPlayFlac(file string) {
46    // Simulate conversion
47    convertedFile := strings.Replace(file, ".flac", ".mp3", 1)
48    fmt.Println("Converting", file, "to", convertedFile, "and playing as mp3...")
49}
50
51// Upgraded music player with enhanced functionality through the composite adapter
52func main() {
53    legacyPlayer := &MusicPlayer{}
54    enhancedPlayer := NewMusicPlayerAdapter(legacyPlayer)
55    enhancedPlayer.Play("song.mp3")  // Supported directly
56    enhancedPlayer.Play("song.wav")  // Supported through adaptation
57    enhancedPlayer.Play("song.flac") // Newly supported through additional adaptation
58}

This sophisticated adaptation strategy ensures that we can extend the MusicPlayer to include support for additional file formats without disturbing its original code or the initial adapter pattern's implementation. The MusicPlayerAdapter thus acts as a unified interface to the legacy MusicPlayer, capable of handling various formats by determining the appropriate conversion strategy based on the file type.

Lesson Summary

Great job! You've delved into backward compatibility while learning how to utilize interfaces, closures, and the Adapter Design Pattern in Go. Get ready for some hands-on practice to consolidate these concepts! Remember, practice makes perfect. Happy Coding!

Enjoy this lesson? Now it's time to practice with Cosmo!
Practice is how you turn knowledge into actual skills.