React Suspense is a powerful feature introduced in React 16.6 that allows components to pause rendering while they wait for asynchronous operations to complete.

React Suspense for Mastering Asynchronous Data Fetching | Relia Software

React Suspense for Mastering Asynchronous Data Fetching

large_react-suspense.webp

medium_react-suspense.webp

small_react-suspense.webp

thumbnail_react-suspense.webp

react-suspense.webp

React Error Boundaries are specialized components that can catch errors anywhere within their child components, acting as guardians in the component tree.

In-Depth Tutorial for Mastering React Error Boundaries | Relia Software

React Error Boundaries are specialized components that can catch errors anywhere within their child components

large_react-error-boundary.webp

medium_react-error-boundary.webp

small_react-error-boundary.webp

thumbnail_react-error-boundary.webp

react-error-boundary.webp

In-Depth Tutorial for Mastering React Error Boundaries

Tailwind CSS is a utility-first CSS tool for building custom web interfaces quickly. The integration of Tailwind CSS with React simplify the development process.

Tailwind CSS for React UI Components: Practical Code Examples | Relia Software

Tailwind CSS for React UI Components: Practical Coding Examples

large_tailwind-css-react.webp

medium_tailwind-css-react.webp

small_tailwind-css-react.webp

thumbnail_tailwind-css-react.webp

tailwind-css-react.webp

Tailwind CSS for React UI Components: Practical Code Examples

The React Context API is a feature provided by React that enables you to pass data through the component tree without having to pass props manually at every level.

Mastering React Context API for Streamlined Data Sharing | Relia Software

Mastering React Context API for Streamlined Data Sharing

large_react-context-api.webp

medium_react-context-api.webp

small_react-context-api.webp

thumbnail_react-context-api.webp

react-context-api.webp

React Test Renderer is a library for rendering React components into pure JavaScript objects. It&rsquo;s primarily used for writing tests for your components.

Mastering React Test Renderer for Streamlined Testing | Relia Software

Mastering React Test Renderer for Streamlined Testing

large_react-test-renderer.webp

medium_react-test-renderer.webp

small_react-test-renderer.webp

thumbnail_react-test-renderer.webp

react-test-renderer.webp

React Server Components (RSCs) revolutionize front-end development by enabling server-side rendering of UI components. How to incorporate RSCs into React projects?

A Comprehensive Guide for React Server Components | Relia Software

A Comprehensive Guide for React Server Components

large_react-server-components.webp

medium_react-server-components.webp

small_react-server-components.webp

thumbnail_react-server-components.webp

react-server-components.webp

Redux serves as a universal state management library for single-page apps, facilitating the synchronization and easy access of your app&rsquo;s state across various components.

Demystifying React Redux for Centralized State Management | Relia Software

Demystifying React Redux for Centralized State Management

large_react-redux.webp

medium_react-redux.webp

small_react-redux.webp

thumbnail_react-redux.webp

react-redux.webp

React is a JavaScript library for building user interfaces, while Next.js is a production framework for React. This means that Next.js is used on top of React.

Next.js vs React: How to Choose the Right Framework? | Relia Software

Next.js vs React: How to Choose the Right Framework?

large_next-js-vs-react.webp

medium_next-js-vs-react.webp

small_next-js-vs-react.webp

thumbnail_next-js-vs-react.webp

next-js-vs-react.webp

React Query is a data synchronization library for React that simplifies fetching, caching, and state management of server state in React applications.

Mastering React Query: Simplify Your React Data Flow | Relia Software

Mastering React Query: Simplify Your React Data Flow

large_react-query.webp

medium_react-query.webp

small_react-query.webp

thumbnail_react-query.webp

react-query.webp

In React, a higher-order component (HOC) is a function that takes an existing component and returns a new component. Explore further about React HOCs via this blog!

Mastering React Higher-Order Components (HOCs) | Relia Software

Mastering React Higher-Order Components (HOCs)

large_react-higher-order-components.webp

medium_react-higher-order-components.webp

small_react-higher-order-components.webp

thumbnail_react-higher-order-components.webp

react-higher-order-components.webp

React Hooks are a new feature in React 16.8 that allows you to use state and other React features without writing classes. Let's explore further here!

Mastering React Hooks: Fundamentals for Beginners | Relia Software

large_react-hooks.webp

medium_react-hooks.webp

small_react-hooks.webp

thumbnail_react-hooks.webp

react-hooks.webp

Mastering React Hooks: Fundamentals for Beginners

4 React design patterns are: Higher-order Components, Providers, Compound Components, and Hooks. Otherwise, let's discover other general design patterns in React here!

The Best React Design Patterns with Code Examples | Relia Software

The Best React Design Patterns with Code Examples

large_react-design-patterns.webp

medium_react-design-patterns.webp

small_react-design-patterns.webp

thumbnail_react-design-patterns.webp

react-design-patterns.webp

Air is a command-line utility designed for live-reloading Go applications during development. It serves as a tool that enables Go applications to reload in real-time.

Guide for Implementing Live Reload Using Golang Air | Relia Software

Guide for Implementing Live Reload Using Golang Air 

large_live-reload-using-golang-air.webp

medium_live-reload-using-golang-air.webp

small_live-reload-using-golang-air.webp

thumbnail_live-reload-using-golang-air.webp

live-reload-using-golang-air.webp

Guide for Implementing Live Reload Using Golang Air

React is a JavaScript library with more history than Angular. Angular is a comprehensive framework. React and Angular can both create single-page applications.

React vs Angular: A Comprehensive Side-by-Side Comparison | Relia Software

React vs Angular: A Comprehensive Side-by-Side Comparision

large_react-vs-angular.jpg

medium_react-vs-angular.jpg

small_react-vs-angular.jpg

thumbnail_react-vs-angular.jpg

react-vs-angular.jpg

React vs Angular: A Comprehensive Side-by-Side Comparison

Suppose you have some initialization code that should only be executed once, regardless of how many times it's called from different parts of your program or by different goroutines. If you don't have a mechanism to control this, you might end up with race conditions where multiple goroutines are attempting to initialize the same resource concurrently, leading to unpredictable and potentially incorrect behavior.
<a href="https://reliasoftware.com/blog/what-is-golang">The Go language</a> provides a simple and efficient way to guarantee that a given function is executed only once. It uses a combination of a boolean flag and a mutex to ensure that only one goroutine executes the specified function, while other goroutines that attempt to execute the same function will wait until the initialization is complete. It call <code>Sync.Once</code>.
&gt;&gt;&nbsp;Read more about Golang:
<ul>
<li>Go Tutorial:&nbsp;<a href="https://reliasoftware.com/blog/golang-basics-of-knowledge">Golang Basics of Knowledge for Beginners</a></li>
<li style="font-style: italic;"><a class="seoquake-params-link" href="https://reliasoftware.com/blog/gin-gonic-api-development" rel="443ddb94 x_url" data-ved="2ahUKEwj1xLbT6syDAxUvhlYBHfYRCvQQFnoECBwQAQ">API Development in Go with Gin Framework</a></li>
<li style="font-style: italic;"><a class="seoquake-params-link" href="https://reliasoftware.com/blog/dockerize-golang-application" rel="7d8d0f37 x_url" data-ved="2ahUKEwi1w73m68yDAxWxrlYBHf9CBdA4ChAWegQICRAB">A Comprehensive Guide To Dockerize A Golang Application</a></li>
<li style="font-style: italic;"><a class="seoquake-params-link" href="https://reliasoftware.com/blog/simplifying-testing-with-golang-testify" rel="0af20f22 x_url" data-ved="2ahUKEwi1w73m68yDAxWxrlYBHf9CBdA4ChAWegQIChAB">Detailed Guide for Simplifying Testing with Golang Testify</a></li>
<li style="font-style: italic;"><a class="seoquake-params-link" href="https://reliasoftware.com/blog/type-conversion-in-golang" rel="971309eb x_url" data-ved="2ahUKEwi1w73m68yDAxWxrlYBHf9CBdA4ChAWegQICxAB">Type Conversion in Golang</a></li>
<li style="font-style: italic;"><a href="https://reliasoftware.com/blog/golang-ordered-map">Understanding Golang Ordered Map with Code Examples</a></li>
</ul>
<h2 dir="ltr">What is sync.Once?</h2>
sync.Once is a synchronization primitive provided by the Golang sync package. It is used to perform a certain operation exactly once, regardless of how many times the Once instance is consulted.
<h2 dir="ltr">3 Common Scenarios for Using sync.Once</h2>
sync.Once is particularly useful in scenarios where you want to perform a certain initialization or setup operation only once, regardless of how many times that operation is requested. It's commonly used in scenarios like this:
<h3 dir="ltr">Lazy Initialization&nbsp;</h3>
When you want to initialize a resource or perform a setup operation only when it is first needed, and you want to avoid the overhead of repeated initialization.
<pre class="language-clike"><code>var once sync.Once
var expensiveResource *SomeType

func getExpensiveResource() *SomeType {
 once.Do(func() {
 expensiveResource = initializeExpensiveResource()
 })
 return expensiveResource
}</code></pre>
<h3>Singleton Pattern</h3>
Ensuring that a certain operation, like creating a singleton instance, is performed only once, even in a concurrent environment.
<pre class="language-clike"><code>var once sync.Once
var instance *Singleton

func GetInstance() *Singleton {
 once.Do(func() {
 instance = createSingletonInstance()
 })
 return instance
}</code></pre>
<h3>Package-Level Initialization</h3>
In package-level variables or initialization functions, where you want to ensure that certain setup code is executed only once when the package is used.
<pre class="language-clike"><code>package mypackage

import (
 "sync"
)

var (
 once sync.Once
 initialized bool
)

func initialize() {
 // Initialization code here
 initialized = true
}

func MyFunction() {
 once.Do(initialize)
 // Rest of the code
}</code></pre>
In these cases, <code>sync.Once</code> provides a clean and efficient way to handle the one-time initialization, and it ensures that the initialization is safe for concurrent use. It helps avoid race conditions and guarantees that the initialization code is executed exactly once.
<h2>3 New Features of sync.Once in Go 1.21</h2>
The recently introduced <code>OnceFunc</code>, <code>OnceValue</code>, and <code>OnceValues</code> functions encapsulate a common usage of Once, designed for the deferred initialization of a value upon its initial use.
<h3>OnceFunc</h3>
<pre class="language-clike"><code>func OnceFunc(f func()) func()</code></pre>
<code>OnceFunc</code>&nbsp;return a function that supports concurrent calls and can be invoked multiple times.
The following code,&nbsp;<code>onceVoid</code>, is only executed once.
<pre class="language-clike"><code>package main

import (
	"log"
	"sync"
)

func main() {
	onceVoid := func() {
		log.Println("Only once")
	}
	call := sync.OnceFunc(onceVoid)
	for i := 0; i &lt; 10; i++ {
		call()
	}
}</code></pre>
Result:
<pre class="language-clike"><code>2023/12/18 22:45:01 Only once</code></pre>
<h3>OnceValue</h3>
<pre class="language-clike"><code>func OnceValue[T any](f func() T) func() T</code></pre>
<code>OnceValue</code> the returned function retrieves the result of the initial function call, ensuring that subsequent invocations yield the same value.
In the code below,&nbsp;<code>randNum</code> only be executed once, returning the result as&nbsp;<code>n</code>, and each call to the bar function will return&nbsp;<code>n</code>. bar can be called concurrently.

<pre class="language-clike"><code>package main

import (
	"log"
	"math/rand"
	"sync"
)

func main() {
	randNum := func() int {
		return rand.Int() % 10
	}
	getNum := sync.OnceValue(randNum)
	for i := 0; i &lt; 10; i++ {
		log.Println(getNum())
	}
}</code></pre>
Result:
<pre class="language-clike"><code>2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4</code></pre>
<code>randNum</code> return one random value no matter how many <code>getNum</code> called that the reason why call many time but still receive value 4.
<h3>OnceValues</h3>
<pre class="language-clike"><code>func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2)</code></pre>
In the case of <code>OnceValues</code> and <code>OnceValue</code>, they serve a comparable purpose, with the distinction that the former returns two parameters.
To summarise:
<ul>
<li>The three functions yield 0, 1, and 2 return values, respectively, upon invocation of the associated function.</li>
<li>The returned functions can be called concurrently.</li>
<li>Should the execution of function f result in a panic, the returned function will also panic upon subsequent calls, preserving the same panic value as encountered during the execution of f.</li>
</ul>

<pre class="language-clike"><code>package main

import (
	"log"
	"math/rand"
	"sync"
)

func main() {
	randTwoNum := func() (int, int) {
		return rand.Int() % 10, rand.Int() % 10
	}
	getTwoNum := sync.OnceValues(randTwoNum)
	for i := 0; i &lt; 10; i++ {
		log.Println(getTwoNum())
	}
}</code></pre>
Result:
<pre class="language-clike"><code>2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6</code></pre>
Same result with <code>OnceValue</code> but the different is that return two value only once.
Keep going with <code>OnceValues</code> we can receive once more than two value
<pre class="language-clike"><code>package main

import (
	"log"
	"math/rand"
	"sync"
)

func main() {
	getThreeNum := sync.OnceValues(func() (int, func() (int, int)) {
		return rand.Int() % 10, sync.OnceValues(func() (int, int) {
			return rand.Int() % 10, rand.Int() % 10
		})
	})

	for i := 0; i &lt; 10; i++ {
		v1, f1 := getThreeNum()
		v2, v3 := f1()
		log.Println(v1, v2, v3)
	}
}</code></pre>
Result:
<pre class="language-clike"><code>2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9</code></pre>
<code>OnceValues</code> returns a function that invokes <code>f</code> only once and returns the values returned by <code>f</code>. The returned function may be called concurrently. If&nbsp;<code>f</code> panics, the returned function will panic with the same value on every call.
&gt;&gt;&nbsp;You may be interested in these Golang-related blogs:
<ul>
<li><a href="https://reliasoftware.com/blog/best-practices-for-dependency-inversion-in-golang" data-ved="2ahUKEwidmui-2_-CAxUWz2EKHdyWDgcQFnoECAwQAQ">Best Practices For Dependency Inversion in Golang</a></li>
<li><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle">Detailed Code Examples of Dependency Inversion in Golang</a></li>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation">Hands-On Implementation for Dependency Injection in Go</a></li>
<li><a class="seoquake-params-link" href="https://reliasoftware.com/blog/single-responsibility-principle-in-golang" rel="ec585c4b x_url" data-ved="2ahUKEwi1w73m68yDAxWxrlYBHf9CBdA4ChAWegQICBAB">Practical SOLID in Golang: Single Responsibility Principle</a></li>
</ul>
<h2>Conclusion</h2>
In conclusion, the introduction of the new functions, <code>OnceFunc</code>, <code>OnceValue</code>, and <code>OnceValues</code>, in Go's <code>sync.Once</code> package is a significant enhancement that adds valuable flexibility and convenience to the already powerful synchronization primitive. Understanding and leveraging these new functions is crucial for <a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Go developers</a>, as they provide elegant solutions for deferred initialization scenarios with varying degrees of complexity.
<ul>
<li>The ability to use <code>OnceFunc</code> enables developers to encapsulate operations that need to be executed only once, creating a function that supports concurrent calls and can be invoked multiple times. This feature is particularly useful in scenarios where an operation should be performed exactly once, but the result is not needed immediately.</li>
<li>With <code>OnceValue</code>, the Go language introduces a mechanism that not only ensures a function is executed only once but also caches and returns the result upon subsequent invocations. This is especially beneficial for scenarios where the cost of computation is high, and the result can be reused multiple times.</li>
<li>The introduction of <code>OnceValues</code> extends this capability further, allowing developers to handle functions that return multiple values. This function provides a clean and concise way to deal with scenarios where initialization involves multiple results or configurations.</li>
</ul>
In essence, mastering these new <code>sync.Once</code> functions is a must for any Go developer, as they address common challenges in concurrent programming, enhance code readability, and provide a more expressive and efficient way to handle deferred initialization. As the Go language evolves, staying informed and adopting these improvements will contribute to writing more robust, scalable, and maintainable Go code.
<div id="article_content" class="inner_article__entries__XvNcf">
<div>
&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!
</div>
</div>

sync.Once is a synchronization primitive provided by the Golang sync package. 3 new features of Go sync.Once are: OnceFunc, OnceValue, and OnceValues.

Sync Package: What Are New Features in Golang sync.Once? | Relia Software

What Are New Features in Golang sync.Once

large_golang-sync-once.jpg

medium_golang-sync-once.jpg

small_golang-sync-once.jpg

thumbnail_golang-sync-once.jpg

golang-sync-once.jpg

Sync Package: What Are New Features in Golang sync.Once?

A Golang ordered map (linked map or ordered dictionary) is a data structure that combines the properties of a map and maintains the order of insertion of elements.

Understanding Golang Ordered Map with Code Examples | Relia Software

Understanding Golang OrderedMap with Code Examples

large_go-ordered-map.jpg

medium_go-ordered-map.jpg

small_go-ordered-map.jpg

thumbnail_go-ordered-map.jpg

go-ordered-map.jpg

Understanding Golang Ordered Map with Code Examples

With version 1.18, Golang Generics, long-awaited, is finally available. It's exciting to examine generics implementation in the <a href="https://reliasoftware.com/blog/what-is-golang">Go programming language</a> and this new language innovation. Let's explore Golang Generics' inner workings and their effects on code via this article!
&gt;&gt;&nbsp;You may consider:
<ul>
<li>Top 10&nbsp;<a href="https://reliasoftware.com/blog/10-best-ides-for-go-lang">Best IDEs for Golang Web Development</a></li>
<li>Top 10 Best <a href="https://reliasoftware.com/blog/top-10-best-golang-web-frameworks">Golang Web Frameworks</a>&nbsp;in 2023</li>
</ul>
<h2>Why Generics in Go?</h2>
Go's introduction of generics addresses several limitations and challenges in the language:
<ul>
<li>Code Reusability: Generics enable the creation of functions and data structures that can work with different types, leading to more reusable and flexible code. Without generics, <a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Go developers</a> often resort to code duplication or the use of interfaces, which may result in less efficient or more verbose code.</li>
<li>Type Safety: Generics provide a way to achieve type safety while still writing generic code. Before generics, developers often relied on interface and type assertions, which could lead to runtime errors if types were not handled correctly. Generics allow developers to write type-safe code without sacrificing flexibility.</li>
<li>Performance: Generics can improve performance by eliminating the need for type assertions and interfaces in certain situations. The generated code can be specialized for specific types at compile time, resulting in more efficient execution.</li>
<li>Cleaner Code: With generics, code becomes more readable and concise. It eliminates the need for repetitive type-specific code and reduces the cognitive load on developers.</li>
<li>Compatibility with Data Structures: Generics make it easier to implement generic data structures, such as containers and algorithms, that can operate on different types. This is especially important for building libraries and frameworks.</li>
</ul>
Other <a href="https://reliasoftware.com/blog/which-web-development-language-should-you-learn">programming languages</a>, such as Java, C++, and C#, have long supported generics, and their absence in Go was a notable feature gap. Adding generics to Go brings it more in line with modern programming language features.
<h2>Golang Generic Types</h2>
Go 1.17 was the latest stable version, and it did not include support for generics. Support for generics was planned for Go 1.18, and it was expected to be a major addition to the language.
<table style="border-collapse: collapse; border-color: rgb(0, 0, 0); border-style: solid; width: 99.5483%; height: 313.6px;" border="1">
<thead>
<tr style="height: 19.6px;">
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 19.6px;">Feature</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 19.6px;">Go Generics</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 19.6px;">Java Generics</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 19.6px;">C++ Templates</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 19.6px;">C# Generics</th>
</tr>
</thead>
<tbody>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 39.2px;">Syntax</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 39.2px;">Type parameter before name</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 39.2px;">Type parameter before name</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 39.2px;">Type parameter after name</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 39.2px;">Type parameter before name</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 39.2px;">Constraint Support</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 39.2px;">Yes</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 39.2px;">Type Erasure</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 39.2px;">No (Reified Types)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 39.2px;">Yes (Type Erasure)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 39.2px;">Yes (Template Instantiation)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 39.2px;">No (Reified Types)</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 39.2px;">Code Bloat</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 39.2px;">Minimal</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 39.2px;">Possible (Code is generated per type)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 39.2px;">Minimal</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 39.2px;">Default Values</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 39.2px;">No</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 39.2px;">Generic Methods</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 39.2px;">Yes</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 39.2px;">Wildcard Types</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 39.2px;">No</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.9035%; height: 19.6px;">Variance</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.5736%; height: 19.6px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.4462%; height: 19.6px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.0701%; height: 19.6px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.7969%; height: 19.6px;">Yes</td>
</tr>
</tbody>
</table>
In Go, generic types are introduced using type parameters. A type parameter is a placeholder for a specific type that will be determined when the generic code is instantiated. Here are some key aspects of generic types in Go:
<ul>
<li>Type Parameters: Type parameters are denoted by a type identifier within square brackets. For example, <code>func Print[T any](value T) { fmt.Println(value) }</code> has a type parameter <code>T</code>.</li>
<li>Type Constraints: Type constraints specify requirements on the type parameter. For instance, <code>T any</code> means that <code>T</code> can be any type. Constraints can also be more specific, such as requiring <code>T</code> to be comparable (<code>T comparable</code>).</li>
<li>Generic Functions and Data Structures: Generics allow you to write functions and data structures that work with any type. Examples include generic sorting functions, containers (like slices and maps), and more.</li>
<li>Compile-Time Type Safety: The type parameter is determined at compile time, ensuring type safety without sacrificing flexibility.</li>
<li>Implicit Specialization: The Go compiler implicitly generates specialized code for each type used with generic functions or data structures. This helps avoid the performance overhead associated with runtime type checks.</li>
</ul>
&gt;&gt;&nbsp;Read more about Golang:
<ul>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation">Hands-On Implementation for Dependency Injection in Go</a></li>
<li><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle">Detailed Code Examples of Dependency Inversion Principle in Go</a></li>
</ul>
<h2>Golang Generics Example</h2>
Here's a simple example to illustrate generic types in Go:
<pre class="language-clike"><code>package main

import (
	"fmt"
	"log"
)

type PrintInterface interface {
	print()
}
type PrintNum int

func (p PrintNum) print() {
	log.Println("Num:", p)
}

type PrintText string

func (p PrintText) print() {
	log.Println("Text:", p)
}

// PrintSlice prints elements of a slice of any type
func PrintSlice[T PrintInterface](s []T) {
	for _, value := range s {
		value.print()
	}
}

func main() {
	// Example with PrintSlice
	stringSlice := []PrintText{"apple", "banana", "orange"}
	intSlice := []PrintNum{5, 2, 9, 1, 7}

	fmt.Println("String slice:")
	PrintSlice(stringSlice)

	fmt.Println("\nInteger slice:")
	PrintSlice(intSlice)
}</code></pre>
This Go code defines an interface, <code>PrintInterface</code>, and two types (<code>PrintNum</code> and <code>PrintText</code>) that implement this interface. It also includes a generic function, <code>PrintSlice</code>, which takes a slice of any type that satisfies the <code>PrintInterface</code> interface and prints each element using the <code>print</code> method.
Here's a breakdown of the code:
Interface and Types:

<pre class="language-clike"><code>type PrintInterface interface {
 print()
}</code></pre>
This declares an interface named <code>PrintInterface</code> with a single method <code>print()</code>.
<pre class="language-clike"><code>type PrintNum int

func (p PrintNum) print() {
 log.Println("Num:", p)
}

</code></pre>
Here, <code>PrintNum</code> is a type that represents an integer. It implements the <code>PrintInterface</code> interface by providing a <code>print</code> method that logs the value of the integer.
<pre class="language-clike"><code>type PrintText string

func (p PrintText) print() {
 log.Println("Text:", p)
}</code></pre>
<code>PrintText</code> is another type, representing a string. Like <code>PrintNum</code>, it implements the <code>PrintInterface</code> interface with a <code>print</code> method that logs the value of the string.
Generic Function:

<pre class="language-clike"><code>// PrintSlice prints elements of a slice of any type
func PrintSlice[T PrintInterface](s []T) {
 for _, value := range s {
 value.print()
 }
}</code></pre>
The <code>PrintSlice</code> function is a generic function that takes a slice of any type <code>T</code> that satisfies the <code>PrintInterface</code> interface. It iterates over the elements of the slice and calls the <code>print</code> method on each element.
Main Function:

<pre class="language-clike"><code>func main() {
 // Example with PrintSlice
 stringSlice := []PrintText{"apple", "banana", "orange"}
 intSlice := []PrintNum{5, 2, 9, 1, 7}

 fmt.Println("String slice:")
 PrintSlice(stringSlice)

 fmt.Println("\nInteger slice:")
 PrintSlice(intSlice)
}</code></pre>
In the <code>main</code> function, two slices (<code>stringSlice</code> and <code>intSlice</code>) are created with elements of types <code>PrintText</code> and <code>PrintNum</code>, respectively. The <code>PrintSlice</code> function is then called on each slice, demonstrating the use of the generic function with different types.
The output of this program will be log messages showing the values of the elements in the slices, as logged by the <code>print</code> methods of <code>PrintNum</code> and <code>PrintText</code>.

<pre class="language-clike"><code>String slice:
2023/12/17 23:28:53 Text: apple
2023/12/17 23:28:53 Text: banana
2023/12/17 23:28:53 Text: orange

Integer slice:
2023/12/17 23:28:53 Num: 5
2023/12/17 23:28:53 Num: 2
2023/12/17 23:28:53 Num: 9
2023/12/17 23:28:53 Num: 1
2023/12/17 23:28:53 Num: 7</code></pre>
<h2>Stack</h2>
<pre class="language-clike"><code>package main

import "fmt"

// Stack is a generic stack data structure.
type Stack[T any] struct {
	items []T
}

// Push adds an element to the top of the stack.
func (s *Stack[T]) Push(item T) {
	s.items = append(s.items, item)
}

// Pop removes and returns the element from the top of the stack.
func (s *Stack[T]) Pop() (T, error) {
	if len(s.items) == 0 {
		var zeroValue T
		return zeroValue, fmt.Errorf("stack is empty")
	}
	item := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return item, nil
}

// Size returns the number of elements in the stack.
func (s *Stack[T]) Size() int {
	return len(s.items)
}

func main() {
	// Example with integers
	intStack := Stack[int]{}
	intStack.Push(1)
	intStack.Push(2)
	intStack.Push(3)

	fmt.Println("Int Stack Size:", intStack.Size())

	poppedInt, err := intStack.Pop()
	if err == nil {
		fmt.Println("Popped Int:", poppedInt)
	}

	// Example with strings
	stringStack := Stack[string]{}
	stringStack.Push("apple")
	stringStack.Push("banana")
	stringStack.Push("cherry")

	fmt.Println("String Stack Size:", stringStack.Size())

	poppedString, err := stringStack.Pop()
	if err == nil {
		fmt.Println("Popped String:", poppedString)
	}
}</code></pre>
Here's the breakdown:
<ul>
<li><code>Stack[T any]</code>: Defines a generic stack data structure using the new generics feature introduced in Go 1.18. The type parameter <code>T</code> is used to represent the type of elements the stack will hold.</li>
<li><code>Push(item T)</code>: Method of the <code>Stack</code> type that adds an element to the top of the stack.</li>
<li><code>Pop() (T, error)</code>: Method of the <code>Stack</code> type that removes and returns the element from the top of the stack. It returns an error if the stack is empty.</li>
<li><code>Size() int</code>: Method of the <code>Stack</code> type that returns the number of elements in the stack.</li>
<li><code>main()</code>: Demonstrates using the generic stack with both integers and strings. It creates two instances of the <code>Stack</code> type, one for integers and one for strings, pushes elements onto the stacks, prints the size of the stacks, and pops elements off the stacks. The popped elements and stack sizes are then printed to the console.</li>
</ul>
This example showcases the flexibility and reusability of the generic stack data structure, allowing you to work with different types while maintaining type safety.
&gt;&gt;&nbsp;Read more:&nbsp;
<ul>
<li>Gin-Gonic Tutorial:&nbsp;<a href="https://reliasoftware.com/blog/gin-gonic-api-development">API Development in Go with Gin Framework</a>&nbsp;</li>
<li>Type Conversion in Golang:&nbsp;<a href="https://reliasoftware.com/blog/type-conversion-in-golang">How To Convert Data Types in Go</a>?</li>
<li>Go Tutorial:&nbsp;<a href="https://reliasoftware.com/blog/golang-basics-of-knowledge">Golang Basics of Knowledge for Beginners</a></li>
</ul>
<h2>Conclusion</h2>
Generics promote code abstraction and reusability. It is crucial to identify the right use cases where these might be used to boost efficiency. Golang generics are relatively new, so it will be fascinating to observe how they perform.
<div id="article_content" class="inner_article__entries__XvNcf">
<div>
<div id="article_content" class="inner_article__entries__XvNcf">
<div>
&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!
</div>
</div>
</div>
</div>

Golang Generics promotes code abstraction and reusability. Let's get insights about golang generic types parameter, constraints, etc. with generic coding examples.

Instruction For Using Golang Generics With Code Examples | Relia Software

Instruction For Using Golang Generics With Code Examples

large_golang-generics.jpg

medium_golang-generics.jpg

small_golang-generics.jpg

thumbnail_golang-generics.jpg

golang-generics.jpg

Testify is like a handy toolbox specifically designed for Golang testing. It offers a bunch of useful tools that make your Go app testing easier and more effective.

Detailed Guide for Simplifying Testing with Golang Testify | Relia Software

large_golang-testify.webp

medium_golang-testify.webp

small_golang-testify.webp

thumbnail_golang-testify.webp

golang-testify.webp

Detailed Guide for Simplifying Testing with Golang Testify

<div class="notion-selectable notion-text-block" data-block-id="2e1f407e-5674-4cfe-96a8-6617e6d256f6">
<div>Go 1.21 has landed six months after 1.20. Let's discover sigificant changes in its features via this article!</div>
<div>
&gt;&gt;&nbsp;Read more:
<ul>
<li>Top 10 Best&nbsp;<a href="https://reliasoftware.com/blog/top-10-best-golang-web-frameworks">Golang Web Frameworks</a>&nbsp;in 2023</li>
<li><a class="seoquake-params-link" href="https://reliasoftware.com/blog/golang-basics-of-knowledge" rel="0f416e20 x_url" data-ved="2ahUKEwj20uKmt5iDAxVgs1YBHeNPA0MQFnoECA0QAQ">Go Tutorial: Golang Basics of Knowledge for Beginners</a></li>
<li>Top 10 Best&nbsp;<a href="https://reliasoftware.com/blog/10-best-ides-for-go-lang">IDEs for Golang Web Development</a></li>
</ul>
</div>
<div>
<h2>Introduction To Go 1.21</h2>
Go 1.21, the latest release in the <a href="https://reliasoftware.com/blog/what-is-golang">Go programming language</a> series, brings a myriad of improvements in toolchain implementation, runtime, and libraries. Released six months after Go 1.20, this version maintains and enhances the Go 1 promise of compatibility. In this blog post, we'll delve into the key features and changes introduced in Go 1.21.

</div>
</div>
<div class="notion-selectable notion-sub_header-block" data-block-id="71c8d5f9-c8dc-4d46-a7c4-1ef0fdb1eefd">
<h2>Changes to Release Numbering</h2>
</div>
<div class="notion-selectable notion-text-block" data-block-id="62dcd06b-ba5a-47db-aace-d5cf4acf425f">
<div>
<div>A small but notable change has been introduced in the numbering of releases. In Go 1.21, the first release is now labeled as Go 1.N.0. This release includes the Go 1.21 language and its initial implementation, known as the Go 1.21.0 release.&nbsp;This blog will refer to it as "Go 1.21," while tools like&nbsp;<code>go version</code> will display "go1.21.0" until an upgrade to Go 1.21.1. Refer to the "Go Toolchains" documentation for a detailed explanation of the new version numbering.</div>
<h2>Changes to the Language</h2>
<h3>New Built-ins</h3>
Go 1.21 introduces three new built-in functions:
min and max: Compute the smallest or largest value from a fixed number of given arguments.

</div>
</div>
<div class="notion-selectable notion-text-block" data-block-id="ae9cdab8-6411-4916-92eb-2a9e17a8d85c">
<pre class="language-clike"><code>// Max
num := max(1, 2, 3)
fmt.Println("Max =", num)

// Min
minNum := min(1, 2, 3)
fmt.Println("Min =", minNum)</code></pre>
<pre class="language-clike"><code>myList := []int{1, 2, 3}

// Max in Slice
max := slices.Max(myList)
fmt.Println("Max in Slice =", max)

// Min in Slice
min := slices.Min(myList)
fmt.Println("Min in Slice =", min)</code></pre>
clear: Delete all elements from a map or zero all elements of a slice.
<pre class="language-clike"><code>m := map[string]int{"x": 1, "y": 2, "z": 3}
clear(m)
fmt.Println(m) // Outputs: map[]</code></pre>
New log/slog package: provides structured logging, in which log records include a message, a severity level, and various other attributes expressed as key-value pairs.
<pre class="language-clike"><code>slog.Info("hello", "count", 3)
// output is
// 2022/11/08 15:28:26 INFO hello count=3


logger := slog.New(slog.NewTextHandler(os.Stderr, nil))
logger.Info("hello", "count", 3)
// output is
// time=2022-11-08T15:28:26.000-05:00 level=INFO msg=hello count=3


logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
logger.Info("hello", "count", 3)
// output is
// {"time":"2022-11-08T15:28:26.000000000-05:00","level":"INFO","msg":"hello","count":3}


slog.Group("request", "method", r.Method, "url", r.URL)
request.method=GET 
request.url=http://example.com
// output is
// "request":{"method":"GET","url":"http://example.com"}</code></pre>
<h3>Package Initialization Order</h3>
The package initialization order is now precisely specified. The new algorithm involves sorting all packages by import path and initializing them in a defined order. This change may impact programs relying on specific initialization orders, providing a more unambiguous definition.
<h3>Type Inference Improvements</h3>
Several improvements have been made to type inference, enhancing its power and precision:
<ul>
<li>A generic function can now be called with arguments that are themselves generic functions.</li>
<li>Type inference considers methods when a value is assigned to an interface.</li>
<li>Multiple enhancements in type inference accuracy.</li>
</ul>
<h3>Preview of Language Change</h3>
Go 1.21 includes a preview of a language change for loop variables, aiming to make them per-iteration rather than per-loop. This change helps avoid accidental sharing bugs. Check the LoopvarExperiment wiki page for details on trying out this language change.
<h3>Panicking and Recover</h3>
In Go 1.21, if a goroutine is panicking and <code>recover</code> was called directly by a deferred function, the return value of <code>recover</code> is guaranteed not to be nil. A runtime panic of type <code>*runtime.PanicNilError</code> will occur if panic is called with a nil interface value or an untyped nil. To support older Go versions, nil panics can be re-enabled by setting <code>GODEBUG=panicnil=1</code>.
&gt;&gt; You may consider:
<ul>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation">Hands-On Implementation for Dependency Injection in Go</a></li>
<li><a href="https://reliasoftware.com/blog/best-practices-for-dependency-inversion-in-golang" data-ved="2ahUKEwidmui-2_-CAxUWz2EKHdyWDgcQFnoECAwQAQ">Best Practices For Dependency Inversion in Golang</a></li>
<li><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle">Detailed Code Examples of Dependency Inversion in Golang</a></li>
</ul>

</div>
<div class="notion-selectable notion-text-block" data-block-id="4a139828-2846-471d-bad2-7d2cdc6bcab9">
<div>
<div>
<h2>Tools</h2>
Go 1.21 enhances support for both backward and forward compatibility in the Go toolchain.
<h3>Backward Compatibility</h3>
To handle changes that are non-breaking but may impact existing programs, Go 1.21 formalizes the use of the <code>GODEBUG</code> environment variable. The toolchain now chooses between old and new behaviors based on the <code>go</code> line in the workspace's <code>go.work</code> file or the main module's <code>go.mod</code> file.
<h3>Forward Compatibility</h3>
Go 1.21 reads the <code>go</code> line in a <code>go.work</code> or <code>go.mod</code> file as a strict minimum requirement. If a workspace or module specifies <code>go 1.21.0</code>, it cannot be used with Go 1.20 or Go 1.21rc1. The <code>go</code> command can now invoke other Go toolchain versions found in the <code>PATH</code> or downloaded on demand based on the version specified in <code>go.mod</code> or <code>go.work</code>.
<h3>Go Command Changes</h3>
<ul>
<li>The <code>pgo</code> build flag defaults to <code>pgo=auto</code>.</li>
<li>The <code>C dir</code> flag must be the first flag on the command line.</li>
<li>New options for <code>go test</code>: <code>fullpath</code>, <code>c</code>, and <code>o</code>.</li>
</ul>
</div>
</div>
</div>
<div class="notion-selectable notion-code-block" data-block-id="c128cb2b-139a-4dea-ace8-d1027347f744">
<div>
<h2>Cgo</h2>
In files that import <code>"C"</code>, the Go toolchain now correctly reports errors for attempts to declare Go methods on C types.
<h2>Runtime</h2>
Several enhancements and optimizations have been introduced in the runtime:
<ul>
<li>Improved stack trace printing for better debugging.</li>
<li>Transparent huge page management on Linux platforms for better memory utilization.</li>
<li>Garbage collection tuning for up to 40% reduction in application tail latency.</li>
<li>Reduced overhead of subsequent C to Go calls on Unix platforms.</li>
</ul>

<h2>Compiler</h2>
Profile-guided optimization (PGO) is now ready for general use, providing performance improvements of up to 7% for a representative set of Go programs. Assembler improvements and better build speed (up to 6%) have also been implemented.

<h2>Linker</h2>
On Windows/amd64, the linker emits SEH unwinding data by default, improving integration with Windows debuggers. The linker is now capable of deleting dead global map variables and offers better performance.

<h2>Core Library</h2>
<h3>New Packages</h3>
<ul>
<li>log/slog: <a href="https://reliasoftware.com/blog/structured-logging-with-golang-slog">Provides structured logging with levels</a>.</li>
<li>testing/slogtest: A package to validate <code>slog.Handler</code> implementations.</li>
<li>slices: Offers common operations on slices using generic functions.</li>
<li>maps: Provides common operations on maps using generic functions.</li>
<li>cmp: Defines the type constraint <code>Ordered</code> and two new generic functions <code>Less</code> and <code>Compare</code> for ordered types.</li>
</ul>
<h3>Minor Changes</h3>
Various minor changes and updates have been made to the library, adhering to the Go 1 promise of compatibility. Performance improvements are included, though not explicitly detailed.
<h2>Archive and Compression Packages</h2>
Several improvements and additions have been made to packages such as <code>archive/tar</code>, <code>archive/zip</code>, and <code>bytes</code>.

<h2>Crypto Packages</h2>
<ul>
<li>crypto/ecdsa: Improvements in execution time for <code>PublicKey.Equal</code> and <code>PrivateKey.Equal</code>.</li>
<li>crypto/elliptic: Deprecated methods and recommendations for ECDH operations.</li>
<li>crypto/rand: Usage of <code>getrandom</code> system call on NetBSD 10.0 and later.</li>
</ul>

<h2>TLS Package</h2>
The <code>net/http</code> package introduces several new features and improvements, including enhanced support for errors, content control of session tickets, and improved handling of TLS alert codes for client authentication failures.

<h2>X.509 Package</h2>
The <code>crypto/x509</code> package deprecates <code>RevocationList.RevokedCertificates</code> in favor of <code>RevokedCertificateEntries</code> for improved revocation list management.

<h2>Debugging and Profiling</h2>
Improvements have been made in various packages related to debugging and profiling, such as <code>runtime/trace</code>, offering a smaller CPU cost and explicit stop-the-world events in traces.
<h2>Other Packages</h2>
Numerous other packages, including <code>unicode</code>, <code>syscall</code>, and <code>errors</code>, have undergone enhancements and improvements. The <code>unicode</code> package, in particular, has been upgraded to Unicode 15.0.0.

<h2>Platform-Specific Changes</h2>
<ul>
<li>Darwin: Requires macOS 10.15 Catalina or later.</li>
<li>Windows: Support for Windows Server 2019.</li>
<li>Linux: Improved support for cgroups v2.</li>
</ul>
&gt;&gt;&nbsp;You may be interested in:&nbsp;
<ul>
<li><a href="https://reliasoftware.com/blog/arrays-and-slices-in-go">Comprehending Arrays and Slices in Go Programming Language</a></li>
<li>Gin-Gonic Tutorial: <a href="https://reliasoftware.com/blog/gin-gonic-api-development">API Development in Go with Gin Famework</a></li>
<li>Type Conversion in Golang: <a href="https://reliasoftware.com/blog/type-conversion-in-golang">How To Convert Data Types in Go</a>?</li>
</ul>

<h2>Conclusion</h2>
Go 1.21 packs a punch with its array of features, optimizations, and improvements across the language, toolchain, runtime, compiler, linker, core library, and various packages. <a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Go developers</a> are encouraged to explore the release notes and upgrade their projects to leverage the benefits of Go 1.21.
To download and get started with Go 1.21, visit the official <a href="https://go.dev/dl/">Go download page</a>.
<div id="article_content" class="inner_article__entries__XvNcf">
<div>
&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!
</div>
</div>



</div>
</div>

Go 1.21, the latest release in the Go programming language series, brings a myriad of improvements in toolchain implementation, runtime, and libraries.

What's New in Go 1.21 Release? Exploring 3 Handy Functions | Relia Software

Exploring 3 Handy Functions in Go 1.21 Release

large_go-1-21.jpg

medium_go-1-21.jpg

small_go-1-21.jpg

thumbnail_go-1-21.jpg

go-1-21.jpg

What's New in Go 1.21 Release? Exploring Three Handy Functions

Type conversion is the process of converting a value from one data type to another. Explicit type conversion in Go ensure compatibility between different data types.

Type Conversion in Golang: How To Convert Data Types in Go? | Relia Software

large_type-conversion-in-golang.jpg

medium_type-conversion-in-golang.jpg

small_type-conversion-in-golang.jpg

thumbnail_type-conversion-in-golang.jpg

type-conversion-in-golang.jpg

Type Conversion in Golang: How To Convert Data Types in Go?

Arrays and Slices is fundamental to working effectively in <a href="https://reliasoftware.com/blog/what-is-golang">the Go programming language</a>. They are key data structures used for organizing and manipulating collections of data. In this explanation, I'll describe what arrays and slices are, how they differ, and when to use one over the other.
&gt;&gt; Read more: <a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle">Detailed Code Examples of Dependency Inversion Principle in Go</a>
<h2>Understanding Golang Arrays</h2>
<h3>Definition</h3>
An array is a fixed-size, ordered collection of elements of the same <a href="https://reliasoftware.com/blog/type-conversion-in-golang">data type</a>. The size of an array is determined at the time of declaration, and it cannot be changed during the program's execution.
<h3>Declaration</h3>
In Go, you declare an array like this:
<pre class="language-clike"><code>var arr [5]int</code></pre>
This creates an integer array of size 5.
<h3>Access</h3>
You can access elements of an array using index notation, starting at 0. For example:
<pre class="language-clike"><code>arr[0] = 1
element := arr[2]</code></pre>
Size: The size of an array is fixed and cannot be changed.
<h2>Understanding Golang Slices</h2>
<h3>Definition</h3>
A slice is a dynamic and flexible view on an underlying array. Slices are like references to an array, and they can grow or shrink as needed. They are more versatile than arrays.
<h3>Declaration</h3>
Slices are often created by slicing an existing array, or you can create them directly using the&nbsp;<code>make</code> function. For example:
<pre class="language-clike"><code>var slice []int // A slice with no specific length or underlying array.
slice := make([]int, 5) // A slice with a specific length.</code></pre>
<h3>Access</h3>
Slices are accessed in the same way as arrays, using index notation. Slices can also be sliced further, and you can append new elements to them.
<h3>Size</h3>
Slices have a dynamic size, and they can grow or shrink by creating a new slice based on the original slice.
&gt;&gt;&nbsp;Read more about the Go programming language:
<ul>
<li><a href="https://reliasoftware.com/blog/cloud-success-blueprint-why-go-is-a-perfect-match">Cloud Success Blueprint</a>: Why Go Is A Perfect Match?</li>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation">Practical Guide to Dependency Injection in Go</a>: Hands-On Implementation</li>
<li><a href="https://reliasoftware.com/blog/go-for-web-development">Go for Web Development</a>: How Top Companies Achieve Powerful Business Results with Golang?</li>
</ul>
<h2>Comparison Between Arrays and Slices</h2>
Here's a comparison of slices and arrays in a tabular format:
<table style="border-collapse: collapse; border-color: rgb(0, 0, 0); border-style: solid; width: 100.069%;" border="1">
<thead>
<tr>
<th style="border-color: rgb(0, 0, 0); width: 22.4272%; text-align: center;">Aspect</th>
<th style="border-color: rgb(0, 0, 0); width: 39.4659%; text-align: center;">Slice</th>
<th style="border-color: rgb(0, 0, 0); width: 38.0732%; text-align: center;">Array</th>
</tr>
</thead>
<tbody>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Dynamic Sizing</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Yes, dynamic and can grow or shrink.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">No, fixed size at declaration.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Capacity Growth Strategy</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Doubles capacity as needed.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">Fixed size; cannot change.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Efficient Appends</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Yes, amortized O(1) time complexity.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">No appends; fixed size.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Bounds Checking</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Built-in bounds checking for safety.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">No bounds checking; may result in errors.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Resizing</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Auto-managed by Go's runtime.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">Not applicable; fixed size.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Pass by Value</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Passes a reference (pointer).</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">Passes a copy of the data.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Copying Data</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Copy-on-write (only if necessary).</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">Not applicable; fixed size.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Initial Declaration</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">make([]T, len, cap) or slicing.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">[len]T.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Length</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Dynamic and changes with append operations.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">Fixed and set at declaration.</td>
</tr>
<tr>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 22.4272%;">Common Use Cases</td>
<td style="border-color: rgb(0, 0, 0); width: 39.4659%;">Dynamic collections, slices of arrays.</td>
<td style="border-color: rgb(0, 0, 0); width: 38.0732%;">Fixed-size data, more memory-efficient.</td>
</tr>
</tbody>
</table>
Dynamic Size: Arrays have a fixed size, while slices are dynamic and can grow or shrink.
Underlying Array: Slices are built on top of arrays. They reference an underlying array. If you modify a slice, it can affect the array it's based on. Arrays do not have an underlying array concept.
Passing by Reference: Slices are reference types, so when you pass a slice to a function, you're passing a reference to the underlying data. Arrays, on the other hand, are passed by value, which means the entire array is copied when passed to a function.
Flexibility: Slices are more flexible and versatile for most use cases because of their dynamic nature. Arrays are mainly used when you need a fixed-size collection of elements.
&gt;&gt;&nbsp;Read more: <a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Tips For Hiring The Best Golang Developers</a>
In Go, arrays have a fixed size, and their capacity doesn't grow or change. Slices, on the other hand, have dynamic sizing and can grow as elements are appended to them. To compare the behavior of arrays and slices, you can create an array and a slice and observe how they behave differently. Here's an example:
<pre class="language-clike"><code>package main

import (
	"fmt"
)

func main() {
	// Create an array with a fixed size of 5
	array := [5]int{1, 2, 3, 4, 5}

	// Create a slice with an initial length of 5 and capacity of 5
	slice := make([]int, 5)

	// Function to print the array and slice properties
	printArrayAndSlice := func(arr [5]int, slc []int) {
		fmt.Printf("Array: %v, Length: %d\\n", arr, len(arr))
		fmt.Printf("Slice: %v, Length: %d, Capacity: %d\\n", slc, len(slc), cap(slc))
	}

	// Print the initial state of the array and slice
	printArrayAndSlice(array, slice)

	// Try to append to the array (which is not possible)
	// Uncommenting this line will result in a compilation error:
	// array[5] = 6

	// Append elements to the slice
	for i := 6; i &lt;= 10; i++ {
		slice = append(slice, i)
		printArrayAndSlice(array, slice)
	}
}</code></pre>
<pre class="language-clike"><code>Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0], Length: 5, Capacity: 5
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6], Length: 6, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7], Length: 7, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7 8], Length: 8, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7 8 9], Length: 9, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7 8 9 10], Length: 10, Capacity: 10</code></pre>
Go's slice resizing strategy involves the following key aspects:
Initial Capacity: When you create a slice using the <code>make</code> function or by slicing an existing array, it's assigned an initial capacity. The capacity is determined by the size of the underlying array. The initial capacity of the slice may be greater than or equal to its length, but it can never be less than the length.
Doubling Capacity: When you append an element to a slice, Go checks if there is enough capacity to accommodate the new element. If the current capacity is insufficient, Go automatically doubles the capacity by creating a new underlying array with double the size of the old array and copying the elements from the old array to the new one. This ensures amortized constant-time append operations.
Copy-On-Write: Slices in Go are designed to minimize the need for copying. When you append an element to a slice, Go creates a new underlying array only if necessary. Otherwise, it appends the element to the existing array. This means that slices share their underlying array until a change is made.
Growing Beyond Doubling: Slices continue to double in capacity as they grow, but it's important to note that the actual resizing behavior may be more complex than simple doubling. Go's runtime may optimize this process by considering factors such as available memory, locality, and other system-specific considerations.
Efficient Appends: Go's slice resizing strategy aims to provide efficient append operations while <a href="https://reliasoftware.com/blog/golang-memory-leak">managing memory effectively</a>. The use of doubling capacity helps ensure that the amortized time complexity for append operations is O(1).
Here's an example that demonstrates how the capacity of a slice changes as elements are appended:
<pre class="language-clike"><code>package main

import (
	"fmt"
)

func main() {
	slice := make([]int, 0, 1) // Create an empty slice with an initial capacity of 1

	// Function to print the slice and its length and capacity
	printSlice := func(s []int) {
		log.Printf("Length: %d, Capacity: %d, Data: %v\n", len(s), cap(s), s)
	}

	// Initial state
	printSlice(slice)

	// Append elements to the slice
	for i := 0; i &lt; 10; i++ {
		slice = append(slice, i)
		printSlice(slice)
	}
}</code></pre>
<pre class="language-clike"><code>Length: 0, Capacity: 1, Data: []
Length: 1, Capacity: 1, Data: [0]
Length: 2, Capacity: 2, Data: [0 1]
Length: 3, Capacity: 4, Data: [0 1 2]
Length: 4, Capacity: 4, Data: [0 1 2 3]
Length: 5, Capacity: 8, Data: [0 1 2 3 4]
Length: 6, Capacity: 8, Data: [0 1 2 3 4 5]
Length: 7, Capacity: 8, Data: [0 1 2 3 4 5 6]
Length: 8, Capacity: 8, Data: [0 1 2 3 4 5 6 7]
Length: 9, Capacity: 16, Data: [0 1 2 3 4 5 6 7 8]
Length: 10, Capacity: 16, Data: [0 1 2 3 4 5 6 7 8 9]</code></pre>
In this example, we explicitly set the initial capacity of the slice to 1. As elements are appended to the slice, you can observe how the capacity changes, and the slice is dynamically resized to accommodate the new elements. The resizing strategy, involving doubling capacity when needed, helps maintain efficient and predictable performance characteristics for slices in Go.
The code example provided demonstrates the growth of a slice's capacity as elements are appended. Here's a more detailed breakdown of the results you can expect from that code:
<pre class="language-clike"><code>package main

import (
 "fmt"
)

func main() {
 slice := make([]int, 0, 1) // Create an empty slice with an initial capacity of 1

 // Function to print the slice and its length and capacity
 printSlice := func(s []int) {
 fmt.Printf("Length: %d, Capacity: %d, Data: %v\\n", len(s), cap(s), s)
 }

 // Initial state
 printSlice(slice)
}</code></pre>
We start with an empty slice <code>slice</code> with an initial capacity of 1. The initial capacity is specified as the second argument to the <code>make</code> function. This means the slice can initially hold one element without needing to allocate a new underlying array.
We use the <code>printSlice</code> function to print the length, capacity, and content of the slice. At this point, the slice is empty, so its length is 0.
<pre class="language-clike"><code> // Append elements to the slice
 for i := 0; i &lt; 10; i++ {
 slice = append(slice, i)
 printSlice(slice)
 }
}</code></pre>
Inside a loop, we append elements to the slice by using the <code>append</code> function. As elements are appended, you'll see the following behavior:
<ul>
<li>Initially, the capacity is 1, so the first element can be added without allocating a new array. The length and capacity both increase to 1, and the data is [0].</li>
<li>When you attempt to add the second element, the capacity is exceeded (1 &lt; 2). The slice is automatically resized by creating a new underlying array with double the capacity (2). The elements are copied to the new array, and the old array is released. The length and capacity both increase to 2, and the data is [0, 1].</li>
<li>This process continues as elements are appended, doubling the capacity as needed. You'll see the capacity grow to 4, 8, and so on.</li>
</ul>
As you run the code, you'll observe the growth of the slice's capacity to accommodate the increasing number of elements. Go's automatic resizing strategy ensures that, in practice, the amortized time complexity for append operations remains close to O(1), making slices efficient for dynamic data collections.
<figure class="image align-center"><img src="../../../../uploads/arrays_slices_in_golang_ff9829f68e.webp" alt="Comparison Between Arrays and Slices " width="662" height="331">
<figcaption>Comparison Between Arrays and Slices (Source: Internet)</figcaption>
</figure>
<h2>When to Use Arrays vs. Slices?</h2>
<ul>
<li>Use arrays when you know the size of your data in advance and it won't change during the program's execution.</li>
<li>Use slices when you need a dynamic collection that can grow or shrink. Slices are more commonly used in Go for handling data structures and collections.</li>
</ul>
Slices and arrays serve different purposes and are chosen based on your specific needs. Slices are more versatile and are commonly used for dynamic collections of data, whereas arrays are used when a fixed-size, compact data structure is required. Slices provide dynamic sizing, bounds checking, and automatic resizing, making them safer and more flexible for many use cases.
&gt;&gt;&nbsp;You may consider:
<ul>
<li>Top 10 <a href="https://reliasoftware.com/blog/top-10-best-golang-web-frameworks">Best Golang Web Frameworks</a></li>
<li>The 10 <a href="https://reliasoftware.com/blog/10-best-ides-for-go-lang">Best IDEs for GoLang Web Development</a></li>
</ul>

<h2>Conclusion</h2>
In this article, you learnt Go array and slice basics. Multiple exercises showed how arrays are fixed in length while slices are flexible, and how this impacts their situational usage. Hope this will helpul for you!&nbsp;
&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!

An Array is a fixed-size, ordered collection of elements of the same data type. A Slice is a dynamic and flexible view on an underlying array. Read more here!

Comprehending Arrays and Slices in Go Programming Language | Relia Software

Comprehending Arrays and Slices in the Go Programming Language

large_arrays-and-slices-in-go.webp

medium_arrays-and-slices-in-go.webp

small_arrays-and-slices-in-go.webp

thumbnail_arrays-and-slices-in-go.webp

arrays-and-slices-in-go.webp

What is cloud-native applications? Let's discover benefits of cloud native architecture and cloud native application characteristics via this article.

Cloud Success Blueprint: Why Go Is A Perfect Match? | Relia Software

Cloud Success Blueprint: Why Go is a Perfect Match

large_cloud-success-blueprint-go.png

medium_cloud-success-blueprint-go.png

small_cloud-success-blueprint-go.png

thumbnail_cloud-success-blueprint-go.png

cloud-success-blueprint-go.png

Cloud Success Blueprint: Why Go is a Perfect Match?

Dependency Injection in Golang involves furnishing a component - typically a struct - with its required dependencies through constructors or methods.

Solutions We Provide

Articles by Huy Nguyen