All computer science is about abstraction as everything is binary, and that's why its sometimes hard to learn, let's break down this terminology.

Abstract data types

Also known as ADT, let's start our discussion about the primitives or scalar types.

• Abstract data types are abstracting away 0 and 1 from us,

• Representation and operations, each data type, is represented in some specific way and can have a set of operations to it.

  • 16 bit integer is 15 bits of 1 and 0, and the leftmost bit is whether its a signed or unsigned integer.

  • Arithmetic Operations can be done on integers addition, subtraction, multiplication division modulos

    • Relational operations, less than greater than, increment than decrement..etc

• Primitives or scalar types, is the programming language provided types, like integers, strings, floats..ect

• We dont concern our selves too much how internally this operations are performed.

When we learn programming languages, we mostly learn about representation of data, mostly scalar types, or primitive types and the operations we can do to them.

So the concept of representation and definition of data, and operations on the. while hiding the internal details is in essence abstract data types

For example in programming languages, we define classes, which has objects, and we give those special behaviours and different details, this is how we define them and there operations. for example we can create a class of linkedlists, with different operations

• Add(element, index) or inserrt(element, index)

• Append(element)

• Remove(element)

• Set(element)

• Get(index)

• Search(key)

• Sort()

• ….

This is how we create our own abstract data types, but the thing is, there is some very known and efficient data types, we call them data structure, they allow us to efficiently utilize the resources, the main memory in the most ideal way, and we extend the programming languages to perform what we want us, us developers.

Physical data structure

Data structure is collection of data structure, so multiple data stored together.

This data structure defines how memory is allocated, they define how the memory will be organized in order for them to store the data.

Arrays

• Most programming languages supports arrays

• its a collection of memory allocation, side by side, back to back.

• Arrays are fixed size, or arrays size is static, we cannot increase or decrease an array size after its creation, we can only assign to it, or desctruct it (deallocate the memory)

• Arrays can be created in the stack or the heap, we use a pointer to allocate arrays in the heap.

• We use arrays when we know the maximum number of elements we need

Linedlist

• Lined lists are dynamic by nature, you can add more elements or delete them.

• its a collceiton of data, where each piece is called a node

• Each node holds data, and a pointer to the next node.

• Lined lists live in the heap, the head pointer can be in the stack.

Logical data structure

This data structure, are an abstraction over the physical datastructure, Physical data structure store the data in memory, physically, but the logical data strucutre is the protocol, the discipline or the set of rules and policies we use to use the physical data structures in way we want for better organiztion of our data.

All operations we do to this data structure are defined also by the logic we set. the API.

This data structure can be split into two types, linear data structure, and non linear data structure.

Linear data sturcture

linear data structure include

• Stack (LIFO)

• Queue (FIFO)

Non linear data structure

• Tree

• Graph

Tabluar

• Hash tables

Big O notatian

Its how we analyse algorithms and operations on them, how efficient they are specially when we approach infinity. in respect of N input.

Time complexity

To measure the performance of our data structure, our job is to find out how much work we do per N elements, means for example if to find a word in a dictionary takes you iterating through every single word, means thats Order of N, if you can find the word by just looking at a fraction of the book or a subset, there is high chances, its a log to the two of N, so time complexity is always in respect of our input, or how much element exists in the data we are working with, the job is not to find the exact time it takes, because that varies from machine to machine or from buzy processors to another..ect Our job is to find the least amount of time we need to process N elements, we analyse the behaviour, how much more time we need to get the task done. a behaviour not an exact time.

Space complexity

Many times, when we do something, we need extra memory than what we are working with, so in that case, we would have to consider that, because we dont always have extra memory, so thats the memory complexity it can be order of N or less or more, depends on the data type or algorithm we are working with.

• https://www.bigocheatsheet.com/

• https://www-cs-faculty.stanford.edu/~knuth/taocp.html

• https://en.wikipedia.org/wiki/Big_O_notation

Trees types and use cases

Whats a tree

A tree is a collection of nodes, each node holds some data, one of the nodes is the root node, and other nodes. are disjoints subsets and each subset is a tree or a sub tree.

Each node has exactly one parent, and can have one or more children, no single node has more than one parent.

Trees are everywhere:

• If you wrote any switch statement but didnt knew why its more efficient than a bunch of if-else statements, the answer is Look up tables (LUT) which may use BST
• Operating systems use trees for File system.
• The syntactic representation of a programming language is Abstract syntax tree. AST
• Browser Document object model (DOM)
• Databases use Log structured merge tree. LSM tree
• SQL index use b-tree.
• Dynamic memory management uses heap. which is a type of a tree.
• A trie for dictionaries or auto complete algorithms.
• Priority queues as well use heap.
• Garbage collectors also use trees.

https://en.wikipedia.org/wiki/Tree_(graph_theory)

https://en.wikipedia.org/wiki/Tree_(data_structure)

Nodes or vertices

Nodes is every unit of data

Edges or paths (links)

Its the connection between each two nodes, if we have N nodes we would have N-1 edges, because each node as parent, except the root node.

Root

Is the upmost node, who has no parent, and have only children, for the children nodes this is their most parent node, generally in the top of the tree.

Parent-Children

A node is a parent to its very next descendants. the descendants are the children to whom its connected with one single edge.

Siblings

Are the children connected to the same node.

Descendants

When we want to talk about children and their children, and the children of their children..etc we would say descendants.

It means the set of nodes we can reach from a particular node going to its children. so all the subtree.

Ansestors

From that node to the root node, all this nodes are considered anscestors.

Degree of nodes

Is the number of children a node has, so the direct children.

A degree of a tree cannot be told from a tree, but its predefined, we can say its a binary tree. but if its unbalanced, we would see it in a form of a linkedlist.

Leaf nodes, external or terminal

All nodes who has no children. so with nodes with degree 0

Levels

Levels starting from first level 1, the root, as we categorize each level by all the nodes who take the same number of edges to get to the root node.

Height

Hight of nodes, is the same as the levels but it starts from 0, its very useful for analysis.

Forest

A collection of a tree is called a forest. which at least has a root node.

To convert a forest to a tree, we attach the roots of the present trees, to one single root.

Types of trees

There is many types of trees, and they are extremely useful and popular. for example

Binary tree

One of the most popular trees, is the binary tree,

Its tree of degree 2, means every node can have 0,1 or 2 children, but not more than 2.

$deg(T)=2$

$children={{0,1,2}}$

• Because the nodes can have only 2 nodes, we call them left child and right child. or left node and right node.
• If we come across a tree that is unbalanced, means it forms something like a linked list, but to the left side, we call it left skewed binary tree. or right skewed binary tree

Binary search tree

The binary search tree or BST , is a derivate of binary tree, but with a constraint in the data, Its a rooted binary tree, where every node (data) on the left side is grater than nodes on the right side.

$deg(T)=2$

AVL Tree

Another tree named after inventors Adelson-Velsky and Landis, is a self balancing binary search tree.

Decision Tree

Its one of the popular ones for classification and prediction.

Fenwich Tree

A Fenwick tree or binary indexed tree is a data structure that can efficiently update elements and calculate prefix sums in a table of numbers.

Link to wiki

Log structured Merge Tree

Or LSM tree one of the trees used in databases like influxDB.

It compiles to an executable file, runs it, and makes sure there is no errors, its also used for other tests in the same main package.

func TestMain(m *testing.M) {
    fmt.Println("-> Building...")
    // checking if Microsoft Windows OS
    // if so, we append .exe to make it excutable by Go
    if runtime.GOOS == "windows" {
        appName += ".exe"
    }
    // We run a command to build the code
    // we are using appName string as tthe name of the excutable
    build := exec.Command("go", "build", "-o", appName)
    if err := build.Run(); err != nil {
        fmt.Fprintf(os.Stderr, "Error building %s: %s", appName, err)
        os.Exit(1)
    }
    fmt.Println("-> Running...")
    // Running the
    result := m.Run()
    fmt.Println("-> Getting done...")
    os.Remove(appName)
    os.Remove(fileName)
    os.Exit(result)
}

This is the list of operating systems and architectures, Golang supports out of the box:g

aix/ppc64
android/386
android/amd64
android/arm
android/arm64
darwin/amd64
darwin/arm64
dragonfly/amd64
freebsd/386
freebsd/amd64
freebsd/arm
freebsd/arm64
illumos/amd64
ios/amd64
ios/arm64
js/wasm
linux/386
linux/amd64
linux/arm
linux/arm64
linux/loong64
linux/mips
linux/mips64
linux/mips64le
linux/mipsle
linux/ppc64
linux/ppc64le
linux/riscv64
linux/s390x
netbsd/386
netbsd/amd64
netbsd/arm
netbsd/arm64
openbsd/386
openbsd/amd64
openbsd/arm
openbsd/arm64
openbsd/mips64
plan9/386
plan9/amd64
plan9/arm
solaris/amd64
windows/386
windows/amd64
windows/arm
windows/arm64

In this article, we are going to speak of the Go built-in function, make

How to use it, when, the parameters it does accept and more.

Make

In Go, make is a special built-in function, there is a similar one called new but that one is fairly different and has a different purpose.

The make function signature is as follows, it has 3 arguments, the first one is the type, the second is the length and the last is its capacity.

// package builtin
func make(t Type, size ...IntegerType) Type

According to the official documentation:

The make built-in function allocates and initializes an object of type slice, map, or chan (only). Like new, the first argument is a type, not a value. Unlike new, make's return type is the same as the type of its argument, not a pointer to it. The specification of the result depends on the type:

Slice: The size specifies the length. The capacity of the slice is equal to its length. A second integer argument may be provided to specify a different capacity; it must be no smaller than the length. For example, make([]int, 0, 10) allocates an underlying array of size 10 and returns a slice of length 0 and capacity 10 that is backed by this underlying array.

Map: An empty map is allocated with enough space to hold the specified number of elements. The size may be omitted, in which case a small starting size is allocated.

Channel: The channel's buffer is initialized with the specified buffer capacity. If zero, or the size is omitted, the channel is unbuffered.

At Glance

make function can take 3 parameters, but the first parameter is the only required one, which is the type, that we would return out of the function.

The make function, creates an underlying array for this type, and enables you to optionally define the starting length of the array, and the starting capacity.

• A type

  • slice

  • map

  • channel

• length

• capacity

Lets break it down

Type

The first argument in the make function, is the type we intend to create, So it applies only to the 3 built-in reference types: slices, maps and channels.
It's a function that allocates and initializes the specified object type, as discussed, So that's the variable type we return.

Unlike new, which returns a pointer to the data it has created and allocated space for you.

Length

The optional second argument has to be of type integer, which is the length of the type we want to initialize. if we don’t specify anything it's initialized to 0, as for channel type, it would be an unbuffered channel.

Capacity

The capacity is optional, it would be the underlying array we allocate for this type, the array should be of size bigger than the length, otherwise, it would throw an error.

invalid argument: length and capacity swapped

Testing the terminal output

// save copy of std out
old := os.Stdout
//create read and write pupe
r, w, _ := os.Pipe()
// set the stdout to the pipe
os.Stdout = w
// we excute the function
someFunctionCall()
// close the resource
w.Close()
// reset the stdout back to the orignal
os.Stdout = old
// read from the read pipe we create
got, _ := io.ReadAll(r)
// check if out is what you want
// want := something you want
//if got != want {
    // throw an error.
//}

Example

SayHello function

Given we have this example function, saying Hello World!, and we want to test this out, whether the terminal is properly printing it out.

func sayHello() {
    fmt.Printf("Hello World!")
}

The test we function

To test we apply the same method, and we test for strings equality.

func Test_SayHello(t *testing.T) {
    // save copy of std out
    old := os.Stdout
    //create read and write pupe
    r, w, _ := os.Pipe()
    // set the stdout to the pipe
    os.Stdout = w
    // we excuted
    sayHello()
    // close the resource
    w.Close()
    // reset the stdout back to the orignal
    os.Stdout = old
    // read from the read output we create
    out, _ := io.ReadAll(r)
    // convert to string
    got := string(out)
    // what we expect
    want := "Hello World!"
    if strings.Compare(got, want) != 0 {
        t.Errorf("incorrect hello got: %v", string(out))
    }
    if got != want {
        t.Errorf("incorrect hello got: %v", string(out))
    }
}

I started learning Go, and I found plenty books and I didnt knew where to start from, so my first step was to collect them, I figured many others would need to do the same, or at least search for Go books to filter through and make their choice, so I hope this makes there journey easier.

The books are in no particular order

Writing an interpreter in Go

By Thorsten Ball

Released 23 November 2016

ISBN: 3982016118

https://interpreterbook.com/

Writing a compiler in Go

By Thorsten Ball

Released 31 July 2018

ISBN: 398201610X

https://compilerbook.com/

Go fundamentals: Gopher Guides

By Mark Bates, Cory LaNou

Released November 2022

ISBN: 9780137918416

https://www.oreilly.com/library/view/go-fundamentals-gopher/9780137918416/

Efficient Go

By Bartlomiej Plotka

Released November 2022

ISBN: 9781098105716

https://www.oreilly.com/library/view/efficient-go/9781098105709/

Learning Go

By Jon Bodner

Released March 2021

ISBN: 9781492077213

https://www.oreilly.com/library/view/learning-go/9781492077206/

Mastering Go - Third Edition

By Mihalis Tsoukalos

Released August 2021

ISBN: 9781801079310

https://www.oreilly.com/library/view/mastering-go/9781801079310/

Mastering Go - Second Edition

By Mihalis Tsoukalos

Released August 2021

ISBN: 9781838559335

https://www.oreilly.com/library/view/mastering-go/9781838559335/

Head First Go

By Jay McGavren

Released April 2019

ISBN: 9781491969557

https://www.oreilly.com/library/view/head-first-go/9781491969540/

The Go Programming Language

By Alan A. A. Donovan, Brian W. Kernighan

Released October 2015

ISBN: 9780134190570

https://www.oreilly.com/library/view/the-go-programming/9780134190570/

Cloud Native Go

By Matthew A. Titmus

Released April 2021

ISBN: 9781492076339

https://www.oreilly.com/library/view/cloud-native-go/9781492076322/

Pro Go: The Complete Guide to Programming Reliable and Efficient Software Using Golang

By Adam Freeman

Released January 2022

ISBN: 9781484273555

https://www.oreilly.com/library/view/pro-go-the/9781484273555/

Concurrency in Go

By Katherine Cox-Buday

Released August 2017

ISBN: 9781491941195

https://www.oreilly.com/library/view/concurrency-in-go/9781491941294/

Powerful Command-Line Applications in Go

by Ricardo Gerardi

Released December 2021

ISBN: 9781680509328

https://www.oreilly.com/library/view/powerful-command-line-applications/9781680509311/

Go in 24 Hours Sams Teach Yourself: Next Generation Systems Programming with Golang, First Edition

By George Ornbo

Released December 2017

ISBN: 9780134771922

https://www.oreilly.com/library/view/go-in-24/9780134771922/

Network Programming with Go

By Adam Woodbeck

Released March 2021

ISBN: 9781718500884

https://www.oreilly.com/library/view/network-programming-with/9781098128890/

Hands-On Software Engineering with Golang

By Achilleas Anagnostopoulos

Released January 2020

ISBN: 9781838554491

https://www.oreilly.com/library/view/hands-on-software-engineering/9781838554491/

Black Hat Go

by Tom Steele, Chris Patten, Dan Kottmann

Released January 2020

ISBN: 9781593278656

https://www.oreilly.com/library/view/black-hat-go/9781098122645/

Introducing Go

by Caleb Doxsey

Released January 2016

ISBN: 9781491941959

https://www.oreilly.com/library/view/introducing-go/9781491941997/

Go in Action

by Brian Ketelsen, Erik St. Martin, and William Kennedy

Released November 2015

ISBN: 9781617291784

https://www.oreilly.com/library/view/go-in-action/9781617291784/

Go Web Programming

By Sau Sheong Chang

Released July 2016

ISBN: 9781617292569

https://www.oreilly.com/library/view/go-web-programming/9781617292569/

Go for Java Programmers

by Barry Feigenbaum Ph.D.

Released October 2021

ISBN: 9781484271995

https://www.oreilly.com/library/view/go-for-java/9781484271995/

Get Programming with Go

by Nathan Youngman and Roger Peppé

Released September 2018

ISBN: 9781617293092

https://www.oreilly.com/library/view/get-programming-with/9781617293092/

Go in Practice

by Matt Butcher, Matt Farina

Released August 2016

ISBN: 9781633430075

https://www.oreilly.com/library/view/go-in-practice/9781633430075/

Hands-On RESTful Web Services with Go - Second Edition

by Naren Yellavula

Released February 2020

ISBN: 9781838643577

https://www.oreilly.com/library/view/hands-on-restful-web/9781838643577/

Building RESTful Web services with Go

by Naren Yellavula

Released December 2017

ISBN: 9781788294287

https://www.oreilly.com/library/view/building-restful-web/9781788294287/

Hands-On Dependency Injection in Go

by Corey Scott

Released November 2018

ISBN: 9781789132762

https://www.oreilly.com/library/view/hands-on-dependency-injection/9781789132762/

Go Programming Blueprints - Second Edition

by Mat Ryer

Released October 2016

ISBN: 9781786468949

https://www.oreilly.com/library/view/go-programming-blueprints/9781786468949/

Go Programming Blueprints

by Mat Ryer

Released January 2015

ISBN: 9781783988020

https://www.oreilly.com/library/view/go-programming-blueprints/9781783988020/

Hands-On Full Stack Development with Go

by Mina Andrawos

Released March 2019

ISBN: 9781789130751

https://www.oreilly.com/library/view/hands-on-full-stack/9781789130751/

Go Programming Cookbook - Second Edition

by Aaron Torres

Released July 2019

ISBN: 9781789800982

https://www.oreilly.com/library/view/go-programming-cookbook/9781789800982/

Cloud Native Go

by Kevin Hoffman, Dan Nemeth

Released December 2016

ISBN: 9780134505787

Building Web Applications and Microservices for the Cloud with Go and React

https://www.oreilly.com/library/view/cloud-native-go/9780134505787/

Go Standard Library Cookbook

by Radomir Sohlich

Released February 2018

ISBN: 9781788475273

https://www.oreilly.com/library/view/go-standard-library/9781788475273/

Go Systems Programming

by Mihalis Tsoukalos

Released September 2017

ISBN: 9781787125643

https://www.oreilly.com/library/view/go-systems-programming/9781787125643/

The Go Workshop

by Delio D'Anna, Andrew Hayes, Sam Hennessy, Jeremy Leasor, Gobin Sougrakpam, Daniel Szabo

Released December 2019

ISBN: 9781838647940

https://www.oreilly.com/library/view/the-go-workshop/9781838647940/

Hands-On System Programming with Go

by Alex Guerrieri

Released July 2019

ISBN: 9781789804072

https://www.oreilly.com/library/view/hands-on-system-programming/9781789804072/

Hands-On High Performance with Go

by Bob Strecansky

Released March 2020

ISBN: 9781789805789

https://www.oreilly.com/library/view/hands-on-high-performance/9781789805789/

The Go Programming Language Phrasebook

by David Chisnall

Released April 2012

ISBN: 9780132918961

https://www.oreilly.com/library/view/the-go-programming/9780132918961/

Learning Go Programming

by Vladimir Vivien

Released October 2016

ISBN: 9781784395438

https://oreilly.com/library/view/learning-go-programming/9781784395438/

Go: Building Web Applications

by Nathan Kozyra, Mat Ryer

Released August 2016

ISBN: 9781787123496

https://www.oreilly.com/library/view/go-building-web/9781787123496/

Go Cookbook

by Aaron Torres

Released June 2017

ISBN: 9781783286836

https://www.oreilly.com/library/view/go-cookbook/9781783286836/

Machine Learning With Go

by Daniel Whitenack

Released September 2017

ISBN: 9781785882104

https://www.oreilly.com/library/view/machine-learning-with/9781785882104/

Distributed Computing with Go

by V.N. Nikhil Anurag

Released February 2018

ISBN: 9781787125384

https://www.oreilly.com/library/view/distributed-computing-with/9781787125384/

Tanmay Teaches Go The Ideal Language for Backend Developers

by Tanmay Bakshi, Baheer Kamal

Released May 2021

ISBN: 9781264258154

https://www.oreilly.com/library/view/tanmay-teaches-go/9781264258154/

Building Microservices with Go

by Nic Jackson

Released July 2017

ISBN: 9781786468666

https://www.oreilly.com/library/view/building-microservices-with/9781786468666/

Distributed Services with Go

by Travis Jeffery

Released March 2021

ISBN: 9781680507607

https://www.oreilly.com/library/view/distributed-services-with/9781680508376/

Go Brain Teasers

by Miki Tebeka

Released August 2021

ISBN: 9781680508994

https://www.oreilly.com/library/view/go-brain-teasers/9781680509144

Go Design Patterns

by Mario Castro Contreras

Released February 2017

ISBN: 9781786466204

https://www.oreilly.com/library/view/go-design-patterns/9781786466204/

Security with Go

by John Daniel Leon

Released January 2018

ISBN: 9781788627917

https://www.oreilly.com/library/view/security-with-go/9781788627917/

Hands-On Serverless Applications with Go

by Mohamed Labouardy

Released August 2018

ISBN: 9781789134612

https://www.oreilly.com/library/view/hands-on-serverless-applications/9781789134612/

Cloud Native programming with Golang

by Mina Andrawos, Martin Helmich

Released December 2017

ISBN: 9781787125988

https://www.oreilly.com/library/view/cloud-native-programming/9781787125988/

Go: Design Patterns for Real-World Projects

by Vladimir Vivien, Mario Castro Contreras, Mat Ryer

Released June 2017

ISBN: 9781788390552

https://www.oreilly.com/library/view/go-design-patterns/9781788390552/

Learn Data Structures and Algorithms with Golang

by Bhagvan Kommadi

Released March 2019

ISBN: 9781789618501

https://www.oreilly.com/library/view/learn-data-structures/9781789618501/

Programming in Go: Creating Applications for the 21st Century

by Mark Summerfield

Released May 2012

ISBN: 9780132764094

https://www.oreilly.com/library/view/programming-in-go/9780132764100/

Hands-On Software Architecture with Golang

by Jyotiswarup Raiturkar

Released December 2018

ISBN: 9781788622592

https://www.oreilly.com/library/view/hands-on-software-architecture/9781788622592/

Level Up Your Web Apps With Go

By Mal Curtis

Released April 2015

ISBN: 9780992461294

https://www.oreilly.com/library/view/level-up-your/9781457192845/

100 Go Mistakes and How to Avoid Them

by Teiva Harsanyi

Released September 2022

ISBN: 9781617299599

https://www.oreilly.com/library/view/100-go-mistakes/9781617299599

Hands-On Deep Learning with Go

by Gareth Seneque, Darrell Chua

Released August 2019

ISBN: 9781789340990

https://www.oreilly.com/library/view/hands-on-deep-learning/9781789340990/

Go Web Scraping Quick Start Guide

by Vincent Smith

Released January 2019

ISBN: 9781789615708

https://www.oreilly.com/library/view/go-web-scraping/9781789615708/

Learning Functional Programming in Go

by Lex Sheehan

Released November 2017

ISBN: 9781787281394

https://www.oreilly.com/library/view/learning-functional-programming/9781787281394/

Hands-On GUI Application Development in Go

by Andrew Williams

Released February 2019

ISBN: 9781789138412

https://www.oreilly.com/library/view/hands-on-gui-application/9781789138412/

Go Machine Learning Projects

by Xuanyi Chew

Released November 2018

ISBN: 9781788993401

https://www.oreilly.com/library/view/go-machine-learning/9781788993401/

Go for DevOps

by John Doak, David Justice

Released July 2022

ISBN: 9781801818896

https://www.oreilly.com/library/view/go-for-devops/9781801818896/

Hands-On Software Architecture with Golang

by Jyotiswarup Raiturkar

Released December 2018

ISBN: 9781788622592

https://www.oreilly.com/library/view/hands-on-software-architecture/9781788622592/

Manipulating filename paths in a way that is compatible with the any target operating system-defined file paths.

Path joining

When you start changing directories, you have to work with both forward slash and backward slash, depending on the operating system, Unix or Windows, Go takes care of that using path.FilePath.Join function, to use Join, you have to provide the name of the folders, and Go will use the appropriate slash for you

// https://pkg.go.dev/path/filepath#Join
func Join(elem ...string) string {
...
}

Join joins any number of path elements into a single path, separating them with an OS specific Separator. Empty elements are ignored. The result is Cleaned. However, if the argument list is empty or all its elements are empty, Join returns an empty string. On Windows, the result will only be a UNC path if the first non-empty element is a UNC path.

To use that, let's change directory using Go.

Change directory cd

And also we generally you would need to use the [chdir](https://pkg.go.dev/os#Chdir) you specify the name of the directory you want to go to, and this function would change the current directory for you

// https://pkg.go.dev/os#Chdir
func Chdir(dir string) error {
...
}

Chdir changes the current working directory to the named directory. If there is an error, it will be of type *PathError.

Lets combine this two, which does allow us to work with either windows or linux who use / or \ backslash and forward slash for each system, and change directory to for now the names we pass in the ChangeDir

func ChangeDir(elem ...string) {
    path := filepath.Join("./", filepath.Join(elem...))

    err := os.Chdir(path)
    if err != nil {
        fmt.Println("Cant change the workig directory", err)
    }
}

Joining strings

On the same note, if for whatever reason you want to join folder names, based on something different, or if is any strings joined, there is in the Go standard package, a string package that has a join method that is as below

https://pkg.go.dev/strings#Join
func Join(elems []string, sep string) string

Join concatenates the elements of its first argument to create a single string. The separator string sep is placed between elements in the resulting string.

And as the official documentation:

s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", "))
//Output
//foo, bar, baz

Whenever you search an element in an array, you have bunch of choices to reduce the time space and memory space, this optimizations add up, and its referred to as a technology, like if you have some extra RAM storage.

Jump search

One common technique you might use, is the jump search Where you search, each foot equals the root of number of elements, so in an array of 100 your jump is 10, in an array of 10000 the jump is 100. Then once you have crossed the desired value, you go back between the last step and this one. And iterate though a much smaller array.

func TwoCrystalBalls(array []int, target int) int {
    step := int(math.Round(math.Sqrt(float64(len(array)))))
    rbound := len(array)
    for i := step; i < len(array); i += step {
        if array[i] > target {
            rbound = i
            break
        }
    }

    for i := rbound - step; i < rbound; i++ {
        if array[i] == target {
            return array[i]
        }
        if array[i] > target {
            break
        }
    }
    return -1
}

func JumpBinarySearch(array []int, target int) int {
    step := int(math.Round(math.Sqrt(float64(len(array)))))
    var high int
    for i := step; i < len(array); i += step {
        if array[i] > target {
            high = i
            break
        }
    }
    low := high - step
    for low < high {
        mid := low + ((high - low) / 2)
        val := array[mid]
        if val == target {
            return val
        } else if val < target {
            low = mid + 1
        } else if val > target {
            high = mid
        }
    }
    return -1
}

Jump search & binary search

Binary search can be combined with jump search where in the last step, you instead use the binary search, which will make your algorithm even faster. as shown in the example

Algorithms and data structure is a big portion of our code, and starting out you might come across Binary Search as one of your lessons, If you are into Go, consider this code, as it helps you solve this common question.

Calculating mid in binary search

Most cases when you write a binary search you make the mistake of using (low + high )/ 2 and while this is valid for uint, unsigned integers (0, 255), you may in certain cases, run to a integers (-128, 127) where you run to some weird issues, this code will demonstrate that for you

func main() {

    var low int8 = 80
    var high int8 = 120
    var mid int8

    mid = (low + (high-low)/2)
    fmt.Println(mid)
    mid = (high + low) / 2
    fmt.Println(mid)
}

Console prints out:

100

-28

try it out

If you need more informations, No one is better than Joshua Bloch article, at Google blog

Binary Search in Golang and Linear Search method

package main

import "fmt"

func main() {
    b := []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 100, 159, 192, 350, 1230, 1341, 4533}

    fmt.Println(BinarySearch(b, 31))
    fmt.Println(LinearSearch(b, 31))

}

func BinarySearch(haystack []int, needle int) bool {
    var high, low, mid, val int
    low = 0
    high = len(haystack)
    for low < high {
        mid = (low + ((high - low) / 2))
        val = haystack[mid]
        fmt.Println(val)
        if val == needle {
            return true
        } else if val > needle {
            high = mid
        } else if val < needle {
            low = mid + 1
        }
    }
    return false
}

func LinearSearch(haystack []int, needle int) bool {
    for _, v := range haystack {
        fmt.Println(v)
        if v == needle {
            return true
        }
    }
    return false
}

func Multiply() {
    for i := 1; i < 10; i++ {
        fmt.Printf("Multiplication table: %v\n", i)
        for j := 1; j < 10; j++ {
            a := j * i
            fmt.Printf("%v * %v = %v\n", i, j, a)
        }
    }
}

func Additioning() {
    for i := 0; i < 11; i++ {
        fmt.Printf("Additioning table: %v\n", i)
        for j := 0; j < 10; j += 1 {
            a := j + i
            fmt.Printf("%v + %v = %v\n", i, j, a)
        }
    }
}

You can do something like this to use it

package main

func main(){
  Additioning()
  Multiply()
}

When you use Golang, Its really a good idea, playing with files is actually fun, however this popular error, occurs when you want to update or append to a file, without deleteing the text written already.

Golang creating a file

This is only possible if you want to write to the file for the first time.

f, err := os.Create(fileName)
if err != nil {
    return err
}
_, err = f.WriteString("text")
if err != nil {
    return err
}

Golang updating a file

This is how you open a file, and append to it.

f, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, os.ModePerm)
// the args: os.O_CREATE|os.O_WRONLY|os.O_APPEND, os.ModePerm
//f, err := os.Create(fileName)
if err != nil {
    return err
}
_, err = f.WriteString("text")
if err != nil {
    return err
}

for more inforamtions please referr to this stackoverflow link.