Go, also referred to as Golang, is an open-source programming language developed by a team at Google and made available to the public in 2009. The design of Go is influenced by its renowned creators: Rob Pike, Ken Thompson, and Robert Griesemer.

The language aimed to address specific challenges experienced by Google developers, and also sought to amalgamate the best features from different languages.

• Simplicity: Go was designed with a minimalistic approach to minimize complexity. Its design steers clear of excessive abstractions and programmer 'magic'.

• Efficiency: It was crucial for Go to be efficient and expressive in both time and space.

• Safety: The creators aimed to make Go a safe, statically-typed language.

• Concurrent Programming: Go's design intends to make concurrent programming pragmatic and straightforward.

  This was achieved, to a great extent, through features such as goroutines and channels.

• Being a System Language: Go was envisioned as a language suitable for system-level programming. This means it is feasible to use Go to create operating systems, write device drivers, or handle system operations.

• Open Source: Go is open source, which means its source code is openly available. You can view, modify, and distribute it under the license's terms.

• Statically Typed: Like Java and C++, Go requires you to specify types of variables and function return values explicitly. These types are checked at compile-time for safety and accuracy.

• Memory Management: Go developers don't have to deal with low-level memory operations like in C/C++. Instead, Go uses a garbage collector to release memory from objects that aren't in use.

• Concurrent Programming: Go directly supports concurrent operations through the use of goroutines and channels.

• In-Built Toolset: Go comes with numerous tools, such as the go command-line tool, that automates many development tasks. For instance, you can use go build to compile your program and go test to run your tests.

• Portability: Go was designed to be compatible with multiple systems and architectures.

• Unicode Support: Go is thoroughly Unicode-compliant.

• Support for Networking: Go comes with libraries to handle network operations efficiently, making it an optimum language for developing network systems.

Several prominent companies make extensive use of Go in critical, performance-driven systems, such as:

• Google: Go is often used in internal systems, and many cloud services like YouTube, Google Search, and others heavily rely on Go for their backend tasks.

• Dropbox: Dropbox has employed Go to enhance performance in software components that require synchronization and other tasks.

• Docker: Go plays a key part in enabling Docker to achieve cross-platform compatibility and resource efficiency.

• SoundCloud: SoundCloud has utilized Go for deploying and managing their infrastructure.

• BBC Worldwide: Go is instrumental in enabling real-time data processing for BBC Worldwide, ensuring viewers receive the most current content.

Beyond these, Go is increasingly favored for cloud-native applications and microservices due to its performance, efficiency in resource management, and robust standard library. This popularity is forecasted to grow as more companies recognize the advantages Go brings to the table.

The Go Language uses a simplified workspace architecture that sets it apart from many other programming languages.

The workspace essentially consists of three directories:

• src: This is where the source code resides.
• pkg: The pkg directory houses the package objects created during the build process. This segregation helps establish a clear distinction between the code and the build output.
• bin: The directory where the compiled application will be located, once it's been built.

The leader in the Go Distribution "Golang", Google clarifies that these are not just suggestions but are observed standards by the Go tool.

The GOPATH environment variable plays a pivotal role. It is the starting point for finding Go code, and all the mentioned directories reside within it.

Under the $GOPATH/src directory, the Go tool expects to see your application source packages.

This command is a critical tool for Golang developers. You can use it to fetch and manage dependencies from remote repositories like GitHub. For instance, if you run go get github.com/gorilla/mux, it will fetch the mux package from GitHub and save it in your $GOPATH.

Following the Go community's best practices, ensure that you have "go.mod" and "go.sum" files at the root of your project. The "go.mod" file maintains module registration and dependency requirements, while the "go.sum" file records the version of the dependencies.

The tool will expect your code under a relevant folder in src. If your version control system is Git, the folder may be in line with Git-conventions: for instance, github.com/username/project. Without Git, you can think of it like this: all code should reside in a directory somewhat influenced by its import URL.

Assume your GOPATH is ~/go. For a personal project, with a URL of bob.com/project, your source code would be found at ~/go/src/bob.com/project.

If, say, a Git repository houses a project with an import URL of gitlab.com/team/project, the code would be located at ~/go/src/gitlab.com/team/project.

• Isolation: Having one GOPATH per project ensures a clean slate and avoids conflicts arising from different project dependencies.

• Loose Configuration: Avoid setting GOPATH in your shell configuration profile, which may lead to unwanted interference in other projects.

• Multiple Workspaces: For different language versions or distinct environments, consider having separate workspaces and their accompanying GOPATHs. This segregation prevents projects built in older versions from updating to the new tooling.

For version control systems:

• GitHub & Co: The import path is often linked to the repository URL.
• Local Repositories: If your repository is local and not connected to a remote VCS service, you could use any import path structure.

• Combine all your codebases under a version control system for easy management and deployment.
• Keep external dependencies outside the $GOPATH, possibly using a package manager.

$ go get github.com/gorilla/mux

This command will oversee downloading the GitHub repository for the "mux" package and storing it locally for you as a requirement.

$ go get -v github.com/gorilla/mux

Adding the verbose option here makes the command more communicative, providing details about the actions being taken.

Upon executing the go get command, the mux package from the gorilla repository will be obtained, and it shall be located in the following path:

~/go/src/github.com/gorilla/mux

In Go, the GOPATH environmental variable is crucial, serving as the root for both package management and your code repository, and separating your development area from your installed packages.

1. Source Files Location:

   • Your Go source files likely reside in the bin, pkg, and src directories inside your GOPATH directory.
   • Inside the src directory, you generally organize your code using your module path.

2. Installing Packages:

   • The go get command is responsible for fetching and installing packages. For example, running go get <package-name> from anywhere in your workspace installs the package to the global package cache.

3. Building and Running Code:

   • When you build or run your programs, Go looks for imported packages in your workspace first (in GOPATH/src) before checking in the global package cache. For commands and tools, Go expects to find their source files directly in GOPATH/src.

Using GOPATH led to a specific structure and workflow, which sometimes isolated your projects and workspace.

Now let's focus on improved workflows with Modules.

1. Module Awareness: Starting with Go 1.11, Go is more modular by design. If your code is in a directory with a go.mod file, it's a module. No need for a GOPATH.

2. Central Module Cache: In module-aware mode, all the dependencies are stored in a central cache, eliminating the need for repeated downloads.

3. Version Control: Go modules encourage clear versioning for project dependencies, offering enhanced development reliability, reproducibility, and portability.

4. Clean Independence: Each module gets its isolated space, enforcing a clear boundary between dependencies.

5. Code Sharing: Unlike the previous setup, where all codes resided under a single directory, Go modules let you work on and track your modules in any suitable location.

6. Global Visibility: Your modules, defined by a go.mod file, are accessible across systems, aiding in easy sharing and collaboration.

7. VCS Integration: Go allows direct interaction with various version control systems, such as Git, by recognizing URLs for modules.

8. Dependency Report: Go now ensures you have visibility over your project's dependencies by adding a go.mod file, avoiding the potentially overwhelming directory structure under GOPATH.

9. Graceful Transition: Go supports the gradual shift to the new module-aware mode, letting users choose their migration pace.

Let's consider the newer go mod workflow in Go.

1. Self-Contained: Code can reside anywhere on your system, making it independent from a central location like GOPATH.
2. Versioning Control: Libraries get versioned with precision, ensuring a consistent and stable build environment.
3. Module Cache: This efficient central cache eliminates the repetitive download headache.
4. Reduced Pitfalls: No system-wide changes and global caches to manage—each module is in a reliable, separate state.
5. Mechanism for Isolation: Go doesn't halt on its usual package structure; you still get a self-contained module, therefore keeping your environment predictable and manageable.
6. Effortless Setup: New users or contributors can promptly set up the workspace without worrying about GOPATH correctness.

You can invoke modules by initializing a go.mod file in your project root:

# Initialize a go.mod file
go mod init <module-path>

This action automatically activates module-aware mode, rendering GOPATH irrelevant.

Go (Golang) offers several features that set it apart from other programming languages:

1. Concurrently Using Goroutines and Channels: Go excels in multi-threading and concurrency management through goroutines (lightweight threads) and channels (communication mechanism between goroutines).

2. Simplicity in Syntax: Go employs C-like syntax with a subtle touch of its own design. While the language sets clear style guidelines, it's more lenient compared to others, such as Python.

3. Goroutines: These lightweight threads serve for concurrent execution. Go's run-time scheduler maps them to OS threads, optimizing performance.

4. Robust Standard Library: Go's standard library is extensive and maintains a consistent design, making it more developer-friendly.

5. Integrated Tooling: Go's built-in tools provide package management, code formatting, and ease in testing, leading to streamlined development processes.

6. Speed and Performance: Golang's compilation, execution, and resource utilization often outperform interpreted languages, such as Python or Ruby.

7. Automatic Memory Management: Go's garbage collector efficiently manages memory, freeing developers from the burden of memory allocation/deallocation.

8. Native Compilation: Go programs compile directly into machine code, ensuring portability across hardware without any external runtime dependencies.

9. Structural Typing and Interfaces: Go offers a distinctive approach to object-oriented programming through interfaces and structural typing.

10. Statically Linked Binaries: Go's binaries bundle the necessary libraries, simplifying deployment and reducing the risk of library conflicts compared to languages like C.

11. Language Stability: Go follows a "minimal versioning" policy for its standard library, ensuring code stability and backward compatibility. It also leads to fewer surprises during upgrades.

12. Implicit Interface Implementation: Types can implement interfaces implicitly, reducing the need for boilerplate code.

13. Package Management with go mod: Starting with Go 1.11, go mod provides dependency management at the package level while offering versioning control and module encapsulation.

14. Concise Error Handling: Go's single error return value, supplemented by its errors package, makes error handling compact and straightforward.

15. Code Generation Efficiency: The Go compiler generates optimized machine code, resulting in faster executables.

16. Web Servers with Standard Library: Go's standard library includes an HTTP package, simplifying web server development without relying on third-party frameworks.

17. GoDoc for Documentation: GoDoc automates code documentation, enhancing code maintainability and developer collaboration.

18. Goroutines and Concurrency Primitives: Go's 'select' statement and the 'context' package provide powerful mechanisms for coordination and time-outs in concurrent applications.

19. Full Support for Unicode: Go treats text as Unicode by default, ensuring internationalization and text processing are seamless.

20. Permissive for Loop: Go's for loop accommodates various styles, fostering code adaptability.

In Go, all code resides within Packages. Each package has its designated role, with clear specifications on visibility, accessibility, and its place in the broader program.

• Visibility: Elements starting with a lowercase letter are only visible within their package (package-private in other languages). Exported elements, starting with an uppercase letter, are accessible outside the package (similar to public in other languages).

• Organization: Code is organized at three levels - main program, packages, and individual files.

• Package Naming: Most Go developers use lowercase, single-word package names.

• .package file: Denotes an importable package.

Go uses a module system to manage dependencies and ensure package versioning and compatibility. Modules allow developers to designate a directory as a package root, containing a go.mod file facilitating dependency resolution.

Here is the Go code:

package geometry

import "math"

// A Point represents a point in the 2D plane.
type Point struct {
    X, Y float64
}

// Distance calculates the Euclidean distance between two points.
func Distance(p1, p2 Point) float64 {
    return math.Sqrt(math.Pow(p2.X-p1.X, 2) + math.Pow(p2.Y-p1.Y, 2))
}

• Packages help to compartmentalize code, making it more manageable.
• Following Go's conventions in file organization and package naming is crucial for maintainability and clarity.
• Proper usage of the module system ensures that a program is self-contained and encapsulated.

Slices in Go are dynamic, flexible and reference-based data structures that enable efficient list management. They are built on top of arrays and offer features such as automatic resizing and ease of use.

• Dynamic Sizing: Slices are resizable, ensuring adaptability as elements are added or removed.
• Reference Semantics: Underneath, slices reference an array, meaning any modifications to the slice apply to the referred array.
• Bounds Checking: Slices automatically handle out-of-bounds errors, offering an added layer of safety during indexing.
• Reslice Efficiency: Operations like slicing a slice are highly efficient and do not involve element copying.
• Append-Optimized: The append function allows slices to smartly manage capacity, optimizing their resizing behavior.
• Built-in Methods: Golang provides versatile built-in methods for slices, including append, copy, and sub- and sub-sub-slicing.

• Structural Difference: Arrays have a fixed size, defined at the point of declaration, while slices can dynamically expand or contract.
• Directness of Data: Arrays stash data directly, but slices act as abstractions, referencing arrays.
• Memory Management: The Go runtime governs the memory of slices, yet the size of arrays is static and set in stone at the outset.
• Pointer-Level Reference: Slices, as dynamic arrays of a kind, can be likened to pointers to the backing array.

You can declare a slice without any initial contents:

var s []int // creates an empty slice, equivalent to "nil"

Or initialize it with elements:

s := []int{1, 2, 3}  // creates and initializes a slice with {1, 2, 3}

Go, following the "less is more" philosophy, integrates slicing straightforwardly. Both slices and arrays can be sliced using the same syntax:

arr := [5]int{1, 2, 3, 4, 5}
slice1 := arr[1:3]  // creates a slice from arr with elements {2, 3}

otherSlice := slice1[1:2]  // creates a slice from slice1 with element {3}

The append function amplifies the flexibility of slices when it comes to growing or joining.

Here is the go code:

package main

import "fmt"

func main() {
   s1 := []int{1, 2, 3}
   s2 := []int{4, 5}

   s1 = append(s1, 4, 5, 6)   // Result: s1 = [1, 2, 3, 4, 5, 6]
   s1 = append(s1, s2...)     // Merging two slices: s1 = [1, 2, 3, 4, 5, 6, 4, 5]
}

Goroutines are lightweight threads or, more accurately, cooperative concurrent functions in Golang that manage their execution. They allow for independent code segments to execute concurrently.

• Efficiency: Goroutines are more memory and processing efficient than traditional threads because they're multiplexed over a small number of OS threads.

• Go Select-Weile: Concurrency and communication between Goroutines are elemental in Go, often achieved through channel communication and the select statement.

Goroutines are created using the go keyword, which precedes a function call. The process involves the Go runtime, making Goroutines distinct from typical functions.

• Simplicity: The process of creating and controlling Goroutines is streamlined.

• Use in Moderation: Goroutines provide useful concurrency but avoid exceeding practical limits.

• Responsible Interaction: Goroutines should communicate and share memory using predefined structures like channels.

Now, let's look at the Go code example:

Here is the Go code:

package main

import (
  "fmt"
  "time"
)

func task(message string) {
  for i := 0; i < 5; i++ {
    fmt.Println(message)
    time.Sleep(time.Millisecond * 100)
  }
}

func main() {
  go task("goroutine")
  task("normal function")
  time.Sleep(time.Second)
}

In this program, task("normal function") is called as a regular function, and go task("goroutine") is called as a Go routine. The output will show concurrent execution.

Go provides automatic memory management through a garbage collector. This ensures developers do not need to manage memory allocation or deallocation explicitly.

• Garbage Collection (GC): Go uses GC to identify and reclaim memory that is no longer in use, preventing memory leaks.

• Concurrency-Awareness: Go's GC is designed to work efficiently in concurrent environments, affecting production real-time applications.

Pros: Go's garbage collector simplifies memory management, reducing the likelihood of common issues like dangling pointers or memory leaks.

Cons: While it generally has minimal impact, the GC process can cause slight performance fluctuations, which real-time applications need to account for.

Policy Customization: Go allows developers to influence the GC's behavior using environment variables and runtime functions. Some commands all programmers to tune GOGC for memory efficiency. Nonetheless, these aren't guarantees but heuristics for the GC.

Here is Go code:

package main

import "fmt"
import "runtime"

func main() {
    // Create lots of memory-consuming objects
    for i := 0; i < 100000000; i++ {
        _ = make([]byte, 100)
        if i%10000000 == 0 {
            fmt.Printf("Allocated %d bytes\n", i*100)
        }
    }

    // Request garbage collection
    runtime.GC()
    var ms runtime.MemStats
    runtime.ReadMemStats(&ms)
    fmt.Println("Memory allocated, not yet garbage collected:", ms.Alloc)
    
    // It would be a rare use case to invoke manual GC in production
}

Go provides a robust set of data types, addressing various data needs efficiently.

• Numeric Types: Integers (int and byte), Floating-Points (float32 and float64).

• String: Unicode characters encoded in UTF-8.

• Boolean: Represents true/false states.

• Arrays: Fixed-size sequences of elements of the same type.

• Slices: Similar to arrays but with dynamic sizing.

• Maps: Key-value pairs suitable for quick lookups.

• Structs: Encapsulation of various data types inside a single entity.

• Pointers: Holds the memory address of a value.

• Constants: Immutable values known at compile time.

• Functions: First-class citizens, enabling higher-order functionality.

• Channels: Facilitates communication among goroutines in concurrent programs.

• Interfaces: Defines behavior by prescribing a set of method signatures.

• Errors: A built-in interface type to represent error conditions.

• Type aliases: Allows for type redefinition without direct inheritance or subclassing.

• User-Defined Types:

  • Named Types: Enhanced readability and type compatibility through custom, user-defined type names.

  • Underlying Types: Primarily one of the built-in types.

Here is the Go code:

package main

import (
	"fmt"
)

func main() {
	// Basic types
	var myInt int = 42
	var myFloating float64 = 3.1415
	var myStr string = "Hello, Go!"
	var isTrue bool = true 

	// Derived and composite types
	var myArray [3]int = [3]int{1, 2, 3}
	mySlice := []int{2, 3, 4, 5} // Type inference
	myMap := map[string]int{"one": 1, "two": 2}
	myStruct := struct {
		Name string
		Age  int
	}{Name: "Alice", Age: 30}

	var myPointer *int = &myInt
	const myConstant = 100
	// function type
	var myFunction func(string) string
	myFunction = func(str string) string {
		return "Hello, " + str
	}

	var myChannel = make(chan int)
	var myInterface interface{} = myStr

	var myAlias int32 = 42
  var myUserDefinedType MyCustomType = 100 // User defined type

	fmt.Printf("Output: %v %v %v %v\n", myInt, myFloating, myStr, isTrue)
	fmt.Printf("Arrays/Slices: %v %v\n", myArray, mySlice)
	fmt.Println("Maps: ", myMap)
	fmt.Println("Struct: ", myStruct)
	fmt.Println("Pointer: ", *myPointer)
	fmt.Printf("Constant: %v\n", myConstant)
	fmt.Println("Function: ", myFunction("Go!"))
  fmt.Println("Type Aliases: ", myAlias)
	fmt.Println("User Defined Type: ", myUserDefinedType)
	// Other types
	fmt.Println("Channel: ", myChannel)
	fmt.Println("Interface: ", myInterface)
}

In Go, variables automatically initialize to their zero values if not explicitly set. Zero values provide sensible defaults, especially when dealing with dynamically allocated variables like pointers.

• Uninitialized Variables: Variables declared but left unassigned will take on their zero values.
• Slices and Maps: Their zero values are nil, indicating that no underlying data is assigned.
• Pointers: Their zero value is also nil.
• Interfaces: Their state is nil unless initialized to a specific type with a non-nil value.

• Bool: false
• Numeric Types (int, float, and their variations): 0
• Complex: 0 + 0i
• String: ""

package main

import "fmt"

func main() {
    var (
        b bool
        i int
        f float64
        c complex128
        s string
    )

    fmt.Println(b, i, f, c, s)
}

• Slice: nil
• Map: nil

package main

import "fmt"

func main() {
    var (
        slice []int
        dmap  map[string]int
    )
    
    fmt.Println(slice, dmap)
}

• Pointer: nil
• Interface: nil

package main

import "fmt"

type dataStruct struct {
    value int
}

func main() {
    var (
        pDataStruct *dataStruct
        any         interface{}
    )

    fmt.Println(pDataStruct, any)
}

Go has a unique approach to error handling compared to other languages. It uses explicit error return types. This design choice reduces ambiguity about functions that can potentially fail and obviates the need for try-catch blocks.

The Go philosophy stresses transparency and early reporting of issues. To adhere to these principles, the language offers a set of built-in tools and techniques.

• Minimize. panic(): Use it for exceptional conditions like unrecoverable internal state

• Log Smartly: Specify logging levels selectively. Avoid logging the same message multiple times.

• Wrap Errors to Retain Context: Use fmt.Errorf() and errors.New() or the errors package for this.

• Validate and Handle Returned Errors: Don't ignore them without validation.

• Custom Error Types Over string: Custom types are expressive and can provide tailored behaviors.

Go offers a rich set of methods for efficiently managing and transforming data types.

• Type Conversions: Used to convert a value explicitly from one type to another within related types, like converting an integer to a float.
• Type Assertions: Applied to interface types, they are used to extract the actual data from the interface to a specified type.

• Numeric: int, uint, float, complex.
• Textual: string, rune (integer type representing a Unicode code point).

Here is the Golang code:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Numeric to String
	num := 42
	str := strconv.Itoa(num)

	// String to Numeric
	str2 := "42"
	num2, err := strconv.Atoi(str2)
	if err != nil {
		panic(err)
	}

	// Interface with Asserted Types
	var myData interface{} = "Golang"
	val, ok := myData.(string)
	if ok {
		fmt.Println("The data is a string:", val)
	} else {
		fmt.Println("The data is not a string")
	}

	// Type Switch
	myFunc(47)

}

func myFunc(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Println("It's an int!")
	case string:
		fmt.Println("It's a string!")
	default:
		fmt.Printf("Don't know the type %T!\n", v)
	}
}

In Go, a channel is a way to safely and efficiently share data among Goroutines. Its primary design goal is to streamline concurrent communication and data transfer.

• First-In-First-Out (FIFO) Order: Data enqueued to the channel is sent out in the same order.
• Type Safety: Channels are type-specific to ensure clear data communication.
• Blocking Synchronization: When the data is sent or received, the sending or receiving Goroutine is blocked until the operation is complete, promoting synchronization.

1. Goroutine Coordination: Establish communication and synchronization among concurrent Goroutines.

2. Resource Sharing Among Goroutines: Use channels to manage shared resources, such as a fixed number of database connections between Goroutines.

3. Error Handling: Send possible errors to a central Goroutine for unified handling.

4. Stream Data Communication: Facilitate streaming of data, such as real-time updates, using channels.

5. Batch Data Transfer: Channels can be effective in grouping and sending data in batches. This is especially helpful if the receiving end is designed to work with data in batches, which might help to optimize the computational operations. It can be useful in scenarios like financial tickers where you might have multiple ticks in a second but will only process data once in a while.

6. Graceful Shutdown: Use a channel to signal Goroutines to gracefully terminate or suspend tasks, like in a server that should start processing requests only after a certain setup is complete.

Here is the Java code:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BatchDataTransfer {
    public static void main(String[] args) {
        BlockingQueue<Integer> channel = new ArrayBlockingQueue<>(5);
        
        // Producer
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    channel.put(i);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
        
        // Consumer
        new Thread(() -> {
            while (true) {
                try {
                    System.out.println(channel.take());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
    }
}

Goroutines enable concurrent execution in Go by running functions independently. Tasks are handled through a unicast communication model where a sender can reach multiple receivers, commonly through channels. This stands in contrast to a bidirectional approach characteristic of shared memory systems.

• Memory Model: Go follows a "Share by Communicating" philosophy. In contrast, traditional systems like Java or C# adopt a shared memory model.
• Concurrency Style: Go leverages the "Do not communicate by sharing memory; instead, share memory by communicating" paradigm. Languages like Python or Ruby often rely on shared memory for communication.

Go employs the go keyword to launch routines, with efficient scheduling through its runtime. Multiple cores bring about parallelism, with the system handling the distribution.

• Ease of Use: The go keyword and straightforward synchronization schemes simplify concurrent programming.
• Memory Safety: Go runtime provides automatic memory garbage collection, reducing the likelihood of memory leaks.
• Improved Responsiveness: Multiple tasks are handled independently, enhancing application performance.
• Potential for Greater Speed: By utilizing multiple cores, efficient code guarantees faster execution.

In Go, range is a versatile loop construct that simplifies iterating over data structures like arrays, slices, maps, strings, and channels. It efficiently handles different data types and abstracts away the underlying indexing or iteration mechanisms.

• Clarity: It makes the code more readable by focusing on elements rather than indices.
• Safety: Range loops guard against index out-of-bounds errors and ensure element synchronization in concurrent contexts.
• Efficiency: They eliminate the need for manual index management.

• Slice/Array: It yields both the current element and its index.
• Map: It produces key-value pairs.
• Channel: When used in a for loop with a channel, range retrieves data from the channel until it's closed.

Here is the Go code:

package main
	
import (
	"fmt"
)

func main() {
	// Slice/Array
	numbers := []int{2, 3, 5, 7, 11, 13}
	for index, value := range numbers {
		fmt.Printf("Index: %d, Value: %d\n", index, value)
	}

	// Map
	person := map[string]string{"name": "Alice", "age": "30"}
	for key, value := range person {
		fmt.Printf("Key: %s, Value: %s\n", key, value)
	}

	// Channel
	ch := make(chan int)
	go func() {
		defer close(ch)
		for i := 0; i < 5; i++ {
			ch <- i
		}
	}()
	
	for val := range ch {
		fmt.Println("Channel value:", val)
	}
}