Login / Register |
+91-9764326834
TechElliptica > All Latest Blogs

GoLang, Go Fast - Digitalizing Faster World

Pallavi Gaikwad
Posted on 13th Dec 2024 5:20 PM | 10 min Read | 60 min Implementation

#Golang

Exploring Go Lang: The Power of Simplicity and Efficiency in Programming


Go, also called Golang, has become more popular in software development since it was created in 2007. Made by Google, Go was built to make the development process simpler while keeping performance and scalability high, especially for large, modern systems. If you're a developer looking for a language that’s fast, easy to learn, and highly efficient, Go might be the right choice for you.


What is Go Lang?


Go is an open-source programming language focused on simplicity, concurrency, and performance. It was created by Google engineers Rob Pike, Ken Thompson, and Robert Griesemer to improve on existing languages, making development easier, faster, and more productive. With its clean syntax and strong features, Go is a great choice for building scalable applications and microservices.


Why Google Created Go Lang?


1) Compile Time:

Google has historically struggled with long compile times for its project having large codebases.

Go is designed for faster compilation without the need for dependency checking.


2) String processing:

Google frequently processes and analyzes large amounts of text data in the form of web pages, requiring efficient manipulation of string.


Go Programming languages has a comprehensive set of string functions. which also uses garbage collection to make working with strings more efficient compared to some other language like C++.


3) Concurrency:

Concurrency in Go refers to the ability of a program to execute multiple tasks independently but no necessarily simultaneously. It's about structuring your program in a way that allows different parts of it to run independently, making efficient use of available resources.


While concurrency is about managing tasks, parallelism is about executing tasks simultaneously


In Go, a goroutine is a lightweight thread managed by the Go runtime.


4) Learning curve:

Go is a relatively simple language with a straightforward syntax and a small set of core features. This makes it easy for a programmers to learn and use , even if they are new to programming.



GO= C + Stings + Garbage collection + Concurrency.


Key Features of GOLang:


1) Concurrency: Go is designed to handle multiple tasks at once and makes it easy to write code that does this.

a. It means different tasks can be done independently and at the same time.

b. Each task can start without waiting for the others to finish.


2) Garbage Collection: Go has a garbage collector that automatically takes care of memory management, so developers don’t have to worry about it while coding.


3) Static Typing: Go is a statically typed language, meaning that variables must be declared with a specific type, and this type cannot change. This helps catch mistakes early and makes the code more reliable.


4) Lightweight: Goroutines use only 8 kilobytes of memory, so you can run thousands of them at once.


5) Fast Compilation: Go has a fast compiler that quickly builds large programs, making it great for creating scalable applications.


6) Zero Dependencies: Go doesn’t depend on external libraries or frameworks, so you don’t need to install extra dependencies on the target machine. This makes deployment easier and reduces the risk of problems from missing or incompatible dependencies. It's especially useful for apps that need to run in different environments.


7) Built-in support for testing: Go includes built-in Support for writing and running tests, making it easy to test and verify code.


8) Strong Community: Go has a Strong and active community of developers who contribute to the language and its ecosystem , including libraries and tools.



Overall, Go is a versatile and powerful programming language that can be used in a wide range of projects. whether you're building a web application, a network server, or command line tool, Go is a good language to consider.


Install GoLang:


A) Go to https://go.dev/

B) Normally Google : "Download Go language" you will get a link.

C) Open Command Prompt and run this command -> go version



Now, verify that Go is installed and begin writing your first program.


Some important features of Golang


1) Structs


In Go (Golang), a struct is a composite data type that groups together variables (called fields) under a single name. Each field can be of any data type, including other structs. Structs are used to represent real-world entities with various properties, such as a Person with fields like Name, Age, and Address.


Here’s a simple example to show how structs work in Go:


Defining a Struct

To define a struct, you use the type keyword followed by the struct name and the struct keyword. Here is an example of a struct definition:

package main

import "fmt"

// Defining a struct called "Person"
type Person struct {
Name string
Age int
Address string
}

func main() {
// Creating an instance of the struct
p := Person{
Name: "John",
Age: 30,
Address: "123 Main St",
}

// Accessing fields of the struct
fmt.Println("Name:", p.Name)
fmt.Println("Age:", p.Age)
fmt.Println("Address:", p.Address)
}


Output:


Struct with Methods

You can also define methods on structs.

package main

import "fmt"

// Defining a struct called "Person"
type Person struct {
Name string
Age int
Address string
}

// Method to display person's info
func (p Person) DisplayInfo() {
fmt.Println("Name:", p.Name)
fmt.Println("Age:", p.Age)
fmt.Println("Address:", p.Address)
}

func main() {
p := Person{
Name: "Alice",
Age: 28,
Address: "456 Elm St",
}

// Calling the method on the struct
p.DisplayInfo()
}


Output:


Struct with Pointer Receiver

In Go, methods can also have pointer receivers, which allow you to modify the original struct.

package main

import "fmt"

// Defining a struct called "Person"
type Person struct {
Name string
Age int
Address string
}

// Method to change the person's age
func (p *Person) IncreaseAge() {
p.Age++
}

func main() {
p := Person{
Name: "Bob",
Age: 25,
Address: "789 Oak St",
}

fmt.Println("Before:", p.Age)

// Calling the method with pointer receiver
p.IncreaseAge()

fmt.Println("After:", p.Age)
}


Output:


Structs in Arrays and Slices:

You can also store structs in arrays or slices.

package main

import "fmt"

// Defining a struct called "Person"
type Person struct {
Name string
Age int
}

func main() {
// Creating a slice of Person structs
people := []Person{
{"John", 30},
{"Alice", 28},
{"Bob", 35},
}

// Looping through the slice of structs
for _, p := range people {
fmt.Println("Name:", p.Name, "Age:", p.Age)
}
}


Output:


Note: 1) Structs are used to group related data into a single unit.

2) You can define methods for structs and work with them like any other data type.

3) Go supports both value and pointer receivers, which makes structs versatile in how you manipulate and pass them around.



2) Pointers


In Go, pointers are variables that store the memory address of another variable. Pointers are useful when you want to modify the original value of a variable or pass large data structures to functions without making a copy.


Example of Pointers in Go:

package main

import "fmt"

func main() {
// Declare a variable
a := 58

// Declare a pointer that holds the address of variable 'a'
var p *int = &a

// Print the address of 'a'
fmt.Println("Address of a:", p)

// Dereferencing the pointer to get the value stored at that address
fmt.Println("Value at the address stored in p:", *p)
// Modifying the value of 'a' using the pointer
*p = 100
fmt.Println("New value of a:", a) // The value of 'a' is modified via the pointer
}


Output:



3) nil, error, and multiple return values


Go offers efficient methods for handling errors and nil values. Both `error` and `nil` are built-in types in Go, which can be used for validation before executing operations. Additionally, Go allows functions to return multiple values, which can be achieved by specifying the types within parentheses instead of a single return type.


Nil: Represents an uninitialized state for pointers, slices, maps, channels, and function types. It is often used to check whether a variable has been initialized.


Examples:

1) Nil Pointers: A pointer without an assigned value is nil.

var ptr *int
fmt.Println(ptr) // Output: <nil>


2) Nil Slice: A slice that has been declared but not initialized is nil.

var s []int
fmt.Println(s) // Output: [] (empty slice, but not nil)


3)Nil Channel: A channel that has been declared but not initialized is nil.

var ch chan int
fmt.Println(ch) // Output: <nil>


Error: Go uses the error type to handle errors explicitly. Functions typically return a result and an error, and you check for nil to determine if the operation was successful.

Example:

package main

import "fmt"

// Custom error type
type MyError struct {
Msg string
}

func (e *MyError) Error() string {
return e.Msg
}

// Function that returns an error
func doSomething(flag bool) (string, error) {
if flag {
return "Success", nil
} else {
return "", &MyError{Msg: "Something went wrong!"}
}
}

func main() {
result, err := doSomething(false)

if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}


Output:


4) Multiple Return Values


Go allows functions to return multiple values, which is commonly used for returning both a result and an error. You can also choose to ignore some return values if necessary.


Example:

package main

import "fmt"

// Function that returns two values: the result and error
func divide(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("cannot divide by zero")
}
return a / b, nil
}

func main() {
// Example 1: Successful division
result, err := divide(10, 2)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}

// Example 2: Division by zero
result, err = divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}


Output:


5) Goroutine:

Goroutines are managed by the Go runtime, and they are lighter and more efficient than threads in many other programming languages. You can create thousands of goroutines in a Go program without consuming a lot of system resources.


How to Create a Goroutine:

package main

import (
"fmt"
"time"
)

// Function to be executed as a goroutine
func printHello() {
fmt.Println("Hello from Goroutine!")
}

func main() {
// Starting a goroutine
go printHello()

// Sleep to ensure the goroutine has time to execute
time.Sleep(time.Second)

fmt.Println("Hello from Main!")
}


Output:


6) Testing in Go


Testing in Go is an essential part of writing reliable and maintainable code. Go provides a simple, built-in testing framework that makes it easy to write unit tests for your functions and ensure they behave correctly.


Some concepts of Testing in Go:

A) Testing Package: Go provides a built-in package called testing to help you write tests.

B) Test Functions: A test function in Go must start with the keyword Test and take a pointer to testing.T as its argument.

C) Running Tests: You use the go test command to run your tests.

D) Test Output: The Go testing framework automatically reports the success or failure of your tests.


Example of Testing in GO:

package main

import (
"testing"
)

// Function to test
func Add(a, b int) int {
return a + b
}

// Test function for Add
func TestAdd(t *testing.T) {
result := Add(2, 3)
if result != 5 {
t.Errorf("Add(2, 3) = %d; want 5", result)
}
}


Output:




Conclusion


In summary, Go is an excellent language for modern software development, combining simplicity, performance, and scalability. Whether you’re building high-performance backends, network servers, or cloud-native applications, Go provides the tools and features you need to succeed.

Related Articles

Decorator in Python

Understanding Python Collection Symbols: A Simple Memory Technique

Python - Constant is a myth. We all are adults here

Verification and Validation

Reading files effectively in Java

Scrum vs Kanban: The Battle of Agile Methodologies

Canary Trap - information security and detecting leaks

Manage Competing Work Demand Prioritization Framework - MoSCoW and Eisenhower

Returning Multiple Values from Functions: A Comparison of Java, Python, and GoLang

Emulators and Simulators

Introduction of Keys in DBMS

A Step-by-Step Guide to Creating Service Accounts in Google APIs

Unlocking Database Power: A Comprehensive Guide to JDBC in Java

Implement Logger in your java framework

Baking Up Quality: The Test Pyramid for Software Success

Selenium 4 Architecture

Git Command - best cheat sheet

Reading Excel files in Java

Understanding Java's Substring Method in Java

Read Data From Google-Sheet
All Comments ()
Do You want to add Comment in this Blog? Please Login ?


Posted By Pallavi Gaikwad at 24th Dec 2024 10:55 AM
Follow Us
Course
Copyright
Services