Forem: Bharat Makwana

[Boost]

Bharat Makwana — Wed, 25 Jun 2025 09:12:26 +0000

Aurélie Vache

Aug 3 '20

Understanding Docker: part 1 – Retrieve & Pull images

#docker #devops #beginners #cloud

415

Comments 4

1 min read

Introduction to Golang: A Comprehensive Guide for Beginners

Bharat Makwana — Wed, 16 Apr 2025 11:54:37 +0000

What is Go?

Go, also known as Golang, is a powerful programming language developed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. As a statically typed and compiled language, it combines performance with type safety. Go is celebrated for its simplicity, readability, and efficiency, featuring fast compilation and execution. Its built-in concurrency model, robust standard library, and garbage collection make it a favorite for modern software development.

Key Characteristics

Simplicity & Readability: Minimal syntax for easy comprehension.
Efficiency: Fast compilation and execution speeds.
Built-in Concurrency: Simplifies parallel task management.
Strong Standard Library: Comprehensive tools for diverse applications.
Garbage Collected: Automatic memory management.

Why Learn Go?

Go’s clean and minimal syntax makes it approachable for beginners, while its high performance suits it for systems programming, web backends, and more. Its concurrency model, powered by goroutines and channels, simplifies complex tasks. Go’s growing ecosystem powers cloud-native technologies like Docker and Kubernetes, command-line tools, and microservices. Fast compile times and excellent tooling boost developer productivity.

Benefits of Learning Go

Easy to Learn: Intuitive syntax reduces the learning curve.
High Performance: Ideal for performance-critical applications.
Concurrency Support: Goroutines and channels streamline concurrent programming.
Growing Ecosystem: Widely used in modern tech stacks.
Productivity: Rapid compilation and robust tools.

Setting Up Your Go Environment

Getting started with Go is straightforward:

Download Go: Visit https://go.dev/dl/ to download the installer for your operating system (Windows, macOS, or Linux).
Install: Follow the OS-specific installation instructions.
Verify Installation: Open a terminal and run go version to confirm Go is installed correctly.
Workspace (Optional): Understand the $HOME/go structure (src, pkg, bin). Note that Go Modules are now the standard for dependency management.

Your First Go Program: "Hello, World!"

Let’s write a simple Go program to print "Hello, Bootcamp!" to the console:

package main // Executable program package
import "fmt" // Import standard Formatted I/O library

func main() { // Entry point of the program
    fmt.Println("Hello, Bootcamp!") // Print to console
}

Run the Program: Save this as hello.go and run go run hello.go in your terminal.
Key Components:
- package main: Defines an executable program.
- import "fmt": Imports the formatted I/O library.
- func main(): The program’s entry point.

Basic Syntax

Packages & Variables

Go organizes code into packages. The main package creates executable programs, while other packages (e.g., package mylib) organize reusable code. Use import to include external packages like fmt or math.

Variables are declared using var or the short declaration operator := (inside functions only):

var age int = 30
var name string // Defaults to ""
var count int // Defaults to 0
message := "Hello" // Inferred string
score := 95 // Inferred int

Constants & Basic Types

Constants are immutable values defined with const:

const Pi = 3.14159
const AppName = "BootcampApp"

Go supports basic data types:

Integers: int, int64
Floating-point: float32, float64
Boolean: bool (true, false)
String: string (immutable UTF-8 text)
Byte: byte (alias for uint8)

Control Flow: if/else

Go’s if/else statements require braces {} but omit parentheses around conditions. An optional initialization statement can precede the condition:

if score >= 60 {
    fmt.Println("Passed")
} else {
    fmt.Println("Failed")
}
if num := getValue(); num < 0 {
    fmt.Println("Negative")
}

Control Flow: for Loop

The for loop is Go’s only looping construct, supporting multiple styles:

C-style:

   for i := 0; i < 10; i++ {
       // ...
   }

Condition-only (while-like):

   for count < 5 {
       // ...
   }

Infinite:

   for {
       // ... (use break to exit)
   }

For-range (collections):

   items := []string{"a", "b", "c"}
   for index, value := range items {
       // ...
   }
   for _, value := range items { // Ignore index
       // ...
   }

Control Flow: switch

Go’s switch statement is a cleaner alternative to multiple if/else statements. It doesn’t fall through by default and supports multiple case values:

switch day {
case "Saturday", "Sunday":
    fmt.Println("Weekend")
default:
    fmt.Println("Weekday")
}
switch { // Expressionless switch
case hour < 12:
    fmt.Println("Morning")
default:
    fmt.Println("Afternoon/Evening")
}

Composite Types

Arrays

Arrays are fixed-size sequences of elements of the same type. Their size is part of the type:

var nums [5]int // Array of 5 zeros
nums[0] = 100
primes := [3]int{2, 3, 5} // Array literal

Slices

Slices are dynamic, flexible views of arrays and are more commonly used. They support len(), cap(), and append():

letters := []string{"a", "b", "c"} // Slice literal
s := make([]int, 3, 5) // make(type, length, capacity)
s = append(s, 10, 20)
sub := letters[1:3] // Slicing: ["b", "c"]

Maps

Maps store unordered key-value pairs, created with make() or literals:

ages := make(map[string]int)
ages["Bob"] = 25
scores := map[string]int{"Math": 95}
val, ok := ages["Alice"] // Check existence
if ok {
    // ...
}
delete(ages, "Bob") // Remove key
for key, value := range ages { // Iterate
    // ...
}

Structs

Structs group related fields to define custom data types:

type Person struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    p1 := Person{FirstName: "Ada", LastName: "Lovelace", Age: 36}
    fmt.Println(p1.FirstName) // Output: Ada
    p2 := &Person{FirstName: "Alan"} // Pointer to struct
    fmt.Println(p2.FirstName) // Auto-dereferenced
}

Functions

Functions in Go support parameters, return types, multiple return values, and variadic arguments:

func add(a, b int) int {
    return a + b
}
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a/b, nil
}
func sumAll(nums ...int) int { // Variadic
    // nums is a slice
}

Pointers

Pointers store memory addresses, using & to get an address and * to dereference:

x := 10
p := &x // p holds address of x
fmt.Println(*p) // Output: 10
*p = 20 // Changes x
fmt.Println(x) // Output: 20

Pointers are useful for modifying function arguments or passing large structs efficiently.

Methods

Methods are functions tied to a specific type (the receiver). Value receivers operate on copies, while pointer receivers modify the original:

type Rect struct {
    width, height float64
}

func (r Rect) Area() float64 { // Value receiver
    return r.width * r.height
}

func (r *Rect) Scale(factor float64) { // Pointer receiver
    r.width *= factor
    r.height *= factor
}

Interfaces

Interfaces define method signatures, enabling polymorphism without explicit implementation declarations:

type Shape interface {
    Area() float64
}

func printArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

Types like Rect or Circle implicitly implement Shape if they define Area(). The empty interface interface{} can hold any value.

Concurrency

Goroutines

Goroutines are lightweight, concurrent functions managed by the Go runtime:

import "time"

func say(s string) {
    fmt.Println(s)
    time.Sleep(100 * time.Millisecond)
}

func main() {
    go say("World") // Runs concurrently
    say("Hello")    // Runs in main goroutine
    time.Sleep(500 * time.Millisecond) // Wait
}

Channels

Channels enable communication and synchronization between goroutines:

messages := make(chan string) // Unbuffered channel
go func() {
    messages <- "ping" // Send
}()
msg := <-messages // Receive
fmt.Println(msg) // Output: ping
close(messages) // Close channel

Error Handling

Go uses explicit error return values, with nil indicating success:

import "os"

file, err := os.Open("filename.txt")
if err != nil {
    log.Fatal("Error opening file:", err)
}
defer file.Close() // Close when function returns

The defer statement schedules cleanup tasks for when the surrounding function exits.

Standard Library Highlights

Go’s standard library is rich and versatile, including:

fmt: Formatted I/O
net/http: Web servers and clients
encoding/json: JSON processing
os: File and system operations
io: I/O primitives
strings, strconv: String manipulation
time: Time-related functions
sync: Concurrency synchronization
errors: Error creation

Explore the full library at https://pkg.go.dev/std.

Building and Running Go Programs

go run <file>.go: Compiles and runs without saving a binary.
go build: Creates an executable binary in the current directory.
go install: Compiles and installs the binary to $GOPATH/bin or $GOBIN.

Next Steps & Resources

To deepen your Go knowledge:

Go Modules: Manage dependencies with go mod init and go get.
Testing: Write tests using the testing package and go test.
Advanced Concurrency: Explore select, sync.Mutex, and sync.WaitGroup.
Context Package: Handle cancellations and deadlines.
Build Projects: Create a web service, CLI tool, or microservice.

Recommended Resources

Official Go Tour: https://go.dev/tour/
Effective Go: https://go.dev/doc/effective_go
Go Documentation: https://pkg.go.dev/std

Conclusion

Go is a versatile, efficient, and beginner-friendly language with a thriving ecosystem. Its simplicity, performance, and concurrency features make it ideal for modern applications. Start experimenting with Go today, and join the growing community of developers building the future!

Using VIM as your Flutter IDE

Bharat Makwana — Fri, 30 Jul 2021 13:27:13 +0000

Today we are going to setup vim as your Flutter IDE

If you have not installed Vim, consider installing NeoVim in your machine.

Once you have installed Vim in your machine you need to have plugin manager for vim

I Use Vim plug:

https://github.com/junegunn/vim-plug

Once you have Vim plug installed you have to created .vimrc file (If you are on neo vim you have to create init.vim)

After that you have to install plugin inside VIM via Vim plug

In your .vimrc add these 2 lines

Plug 'dart-lang/dart-vim-plugin'
Plug 'thosakwe/vim-flutter'

Once you added these 2 lines run:

:source %
:PlugInstall

Done: you have installed Flutter in Your Vim setup now you can run flutter app via:

:FlutterRun <args>

For more you can find more commands here: https://github.com/thosakwe/vim-flutter

VIM cheatsheet

Bharat Makwana — Fri, 26 Feb 2021 06:57:31 +0000

Exiting:

:qa ⇒ close alll file
:qa! ⇒ close all files, abadon changes
:w ⇒ save
:wq / :x ⇒ Save and close file
:q ⇒ close file
:q! ⇒ close files, abadon changes
ZZ ⇒ save and quit
ZQ ⇒ quit without checking changes

Navigation:

h, j, k, l ⇒ arrow keys
/ ⇒ Half-page up / down
/ ⇒ page up / down

words

b / w ⇒ previus / next word
ge / e ⇒ previus / next end of word

line

0 (zero) ⇒ start of line
^ ⇒ start of line (after white space)
$ ⇒ end of line

character

fc ⇒ go forward to character c
FC ⇒ go backword to character c

document

gg ⇒ first line
G ⇒ last line
:n ⇒ go to line n
nG ⇒ go to line n

window

zz ⇒ center this line
zt ⇒ top this line
zb ⇒ bottom this line
H ⇒ move to top of the screen
M ⇒ move to middle of the screen
L ⇒ move to bottom of screen

n ⇒ next matching search pattern
N ⇒ pervius match
*⇒ next whole word under cursor
# ⇒ pervius whole word under cursor

tab pages

:tabedit [file] ⇒ edit file in new tab
:tabfind [file] ⇒ open file if exist in new tab
:tabclose ⇒ close current tab
:tabs ⇒ list all tabs
:tabfirst ⇒ go to first tab
:tablast ⇒ go to last tab
:tabn ⇒ go to next tab
:tabp ⇒ go to previus tab

Editing:

a ⇒ append
A ⇒ append from end of line
i ⇒ insert
o ⇒ next line
O ⇒ previus line
s ⇒ delete char and insert
S ⇒ delete line and insert
C ⇒ delete until end of line and insert
r ⇒ replace one character
R ⇒ enter replace mode
u ⇒ undo changes
⇒ redo changes

Clipbord:

x ⇒ delete character
dd ⇒ delete line (cut)
yy ⇒ yank line (copy)
p ⇒ paste
P ⇒ paster before
"+p / "*p ⇒ paste from system clipborad
"+y / "*y ⇒ copy to system clipborad

Exiting insert mode:

Esc / ⇒ exit insert mode
⇒ exit insert mode and abort current command

Visual mode:

v ⇒ enter visual mode
V ⇒ enter visual line mode
⇒ enter visual block mode

in visual mode

d / x ⇒ delete selection
s ⇒ replace selection
y ⇒ yank selection (copy)

Creating New/Old Flutter project with web support

Bharat Makwana — Tue, 03 Dec 2019 13:53:46 +0000

Today I will be guiding you to how to create flutter project with web support

There will be 2 portions of this article

1: Creating a project from scratch

2: Adding web support on an old project

Creating project from scratch

Before starting Make sure you are on flutter Dev channel if you are not

You need to switch to Dev or Master channel by hitting this command on your terminal

flutter channel dev

flutter channel master

Currently, I am on Dev channel

Enabling web support

To enable web support you have to write

flutter config — enable-web

It will enable experimental web support

Creating a Project

Now create a project as we usually do

You can see there is a web folder available

And we can run it on Google Chrome and Android emulator

Adding web support on existing project

(Create a backup of your project before doing anything)

As you know you need to switch to dev/master channel (if you are not)

flutter channel dev

flutter channel master

And Enable web support

flutter config — enable-web

Now open a terminal in your old flutter project directory and write

flutter create.

You can see web/index.html (created)

All done…

p.s - ”not all library is supported in flutter web so you might get some errors so take a backup of your project before performing these tasks”