ParamiSoft’s Pragmatic Pandit Talks

Go-programming language

1

Why Go?No major systems language has emerged in over a decade, but over that time the computing landscape has changed tremendously. There are several trends:!

! •! Computers are enormously quicker but software development is not faster.! ! •! Dependency management is a big part of software development today but the “header files” of languages

in the C tradition are antithetical to clean dependency analysis—and fast compilation.!! •! There is a growing rebellion against cumbersome type systems like those of Java and C++, pushing

people towards dynamically typed languages such as Python and JavaScript.!! •! Some fundamental concepts such as garbage collection and parallel computation are not well supported

by popular systems languages.!! •! The emergence of multicore computers has generated worry and confusion.!

We believe it's worth trying again with a new language, a concurrent, garbage-collected language with fast compilation. Regarding the points above:!

! •! It is possible to compile a large Go program in a few seconds on a single computer.! ! •! Go provides a model for software construction that makes dependency analysis easy and avoids much of

the overhead of C-style include files and libraries.!! •! Go's type system has no hierarchy, so no time is spent defining the relationships between types. Also,

although Go has static types the language attempts to make types feel lighter weight than in typical OO languages.!

! •! Go is fully garbage-collected and provides fundamental support for concurrent execution and communication.!

! •! By its design, Go proposes an approach for the construction of system software on multicore machines.! A much more expansive answer to this question is available in the article, Go at Google: Language Design in the Service of Software Engineering. 2

Guiding Principles in Design

• reduce the amount of typing in both senses of the word!

• reduce clutter and complexity !

• no forward declarations and no header files; everything is declared exactly once!

• most radically, there is no type hierarchy: types just are, they don't have to announce their relationships!

• Want more? - Go read FAQs - http://golang.org/doc/faq

3

Whats Go?

• DNA of Go :)

• compiled, statically-typed,imperative, concurrent and structured language.

• compiled - gc compiler, memory managed by - garbage collection

• statically typed with some dynamically typed capabilities

• imperative - tell computer how to do e.g ruby,

• declarative - tell computer what to do e.g scala

• concurrent - multithreading as well as CPU parallelism.

4

Go by Example :)

• Hello World!

!

package main !import "fmt" !func main() { fmt.Println("hello world") }

5

Go by Example

• package - is like libraries

• fmt - the formatter. No need to format lines :)

6

Go by Example :)

$go run hello-world.go hello world !$ go build hello-world.go $ ls hello-world hello-world.go !$ ./hello-world hello world

7

Go by Example :)

• Values !package main !import "fmt" !func main() { !//Strings, which can be added together with +. ! fmt.Println("go" + "lang") // Integers and floats. fmt.Println("1+1 =", 1+1) ! fmt.Println("7.0/3.0 =", 7.0/3.0) !// Booleans, with boolean operators as you’d expect. ! fmt.Println(true && false) fmt.Println(true || false) fmt.Println(!true) } !$ go run values.go golang 1+1 = 2 7.0/3.0 = 2.3333333333333335 false true false

8

Go by Example :)Variables !package main !import "fmt" !func main() { !// var declares 1 or more variables. var a string = "initial" fmt.Println(a) !// You can declare multiple variables at once. var b, c int = 1, 2 fmt.Println(b, c) !//Go will infer the type of initialized variables. var d = true fmt.Println(d) !//Variables declared without a corresponding initialization are zero-valued. For example, the zero value for an int is 0. var e int fmt.Println(e) !//The := syntax is shorthand for declaring and initializing a variable, e.g. for var f string = "short" in this case. ! f := "short" fmt.Println(f) } !!$ go run variables.go initial 1 2

9

Go by Example :)•Functions !!!package main !import “fmt" !// Here’s a function that takes two ints and returns their sum as an int. !func plus(a int, b int) int { !// Go requires explicit returns, i.e. it won’t automatically return the value of the last expression. ! return a + b } !func main() { !// Call a function just as you’d expect, with name(args). ! res := plus(1, 2) fmt.Println("1+2 =", res) } !$ go run functions.go 1+2 = 3

10

Go by Example :)• Multiple return values !package main !import "fmt" !// The (int, int) in this function signature shows that the function returns 2 ints. !func vals() (int, int) { return 3, 7 } !func main() { !// Here we use the 2 different return values from the call with multiple assignment. a, b := vals() fmt.Println(a) fmt.Println(b) !// If you only want a subset of the returned values, use the blank identifier _. _, c := vals() fmt.Println(c) } !$ go run multiple-return-values.go 3 7 7

11

Go - Learn More

https://gobyexample.com/

http://tour.golang.org

http://golang.org/doc/effective_go.html

http://go-lang.cat-v.org

http://www.stanford.edu/class/ee380/Abstracts/100428.html

12

Go - Thank YourSelf !

13