A First Look at Google's Go Programming Language

Google’s Go
Introduction to the next “C” language!
S G Ganesh

Agenda
 Introduction to Go (What is “Go”?)
 “Hello world” in Go
 Examples for “getting a hang of” Go
 Examples using some novel features
 Implementation status
 Resources
 Let’s Go!

First things first: Setting the stage
 It’s not possible to cover all details of a new language in a
45-mins presentation
 We’ll quickly cover most important aspects of Go
 Can’t drink ocean in a day – let alone in an hour!
 No one is an “expert” in Go yet
 Creators of the language are the only experts right now
 I am an early adopter and got hooked-on to the
language
 I am making this presentation based on my experience
 For many questions, there are no right or wrong answers:
 Go is still an evolving language and answers might
change!

So, what’s all the buzz about?
 Go: new programming language announced by Google (Sep 09)
 Created lots of excitement in the programming community
 Many tout it as the next C language
 ‘C’ evolved from ‘B’; many languages are named as ‘D’, or
want to be the ‘D’ language
 But nothing has made the cut so far; “Go” might (or will it be
“Gone” in a few years ;-) )
 Is there substance behind hype?
 Yes, a lot! Most system programmers find it very good
 Go won Tiobe’s ‘language of the year award 2009’
 Tiobe is a programming language popularity index:
http://www.tiobe.com/
 Latest status (march 2010)

Okay, so what’s Go?
 Go is a new, experimental, concurrent, garbage-collected,
systems-programming language.
 New & Experimental: Go is still at experimental stage
 with tools, packages etc. still in development.
 No production system implemented using Go till now
 Concurrent: Supports 'communication channels’ for
concurrency - Communicating Sequential Processes (CSP).
 Garbage-collected: The memory is automatically garbage
collected
 For systems-programming: Intended for writing things like
compilers, web servers…

Still, we can use it as a general purpose language.

Who’s behind Go?
 Robert Griesemer, Ken Thompson (of Unix
fame), and Rob Pike are the creators of the
language.
 All three are well-known in programming community
 This is how things fell in place:
 Go project was started around May 2007. Ken Thompson
wrote a Go compiler and runtime from scratch.
 By mid of 2008, working compiler and runtime was ready.
 Ian Lance Taylor and Russ Cox joined Go team in 2008. Ian
Taylor implemented GCC front-end for Go.

Why a new language?
 This description is as given by the creators
 No major sys. programming language came-up in last
decade. But much has changed during the last decade(s)
 Libraries becoming bigger with lots of dependencies
 Internet and networking is becoming pervasive
 Client/server systems, massive clusters used today
 Multi-core processors becoming mainstream.
 Systems programming languages were not designed with
these in mind.
 Other reasons
 construction (enterprise software) has become very slow
 OOP using inheritance hierarchies not effective

Goals of the language
 Efficiency and ease of use:
 Efficiency of C, but ease like Ruby.
 Performance: within 10%-20% of equivalent C
 Safe to use:
 Both type-safe as well as memory-safe.
 Concurrency:
 Good support for concurrency and communication
 Garbage Collected:
 "Attempts" to build an efficient, and latency-free Garbage
Collection mechanism.
 High-speed builds:
 Fast compilation & linking

Some important capabilities of Go
 Simplicity: GO has a clean and concise syntax
 Characteristic of Google products
 For example, light-weight type system
 Use it to believe it
 Separation of interface and the implementation
 I know it’s often misused statement, but Go has it!
 Arguably a novel feature of Go
 Goroutines
 Is based on CSP: much safer than lock-based, like Java
 And more:
 E.g. Reflection (yes! but this is systems prog. lang!)

Enough theory, lets see examples!
 All programs in Go should be in a package, its “main”
here
 We import “fmt” package for using Printf function
 Execution starts with ‘main.main()’ function
 Functions have “func” keyword
 Printf is in fmt package

Now we’ll find factorial of a number
 Lack of declarations
 “fact” and “i” inferred as “ints” from init value 1 because of :=
 “for” loop is the only loop construct supported in Go
 Others like “while” are variations of “for”
 An example of minimal features
 Note the lack of semi-colons
 Have to use only if “necessary”

Looks like C, but not C!
 Go has elegant declaration syntax
 See how arguments are passed and returned
 Not like C: it is infamous for its declaration syntax
 Can return multiple values from functions
 See swap for similar functionality in = operator
 Example for “orthogonal” language features

Built-in support for features like maps
 Maps are built-in, so no need to import
 Initialized with pair separated by “:”
 “range” keyword is useful for traversal
 Using a for loop
 Works for slices, strings etc. (“orthogonal” feature)

Functions as first class objects
 Functions are first
class objects in Go
 We can have
“function literals”
(similar to
“closures” in
functional
languages) for
example

Structures
 Structs are declared with type keyword
 We can have struct literals
 Created in heap
 And print struct members using %v in Printf

Methods
 Methods are implemented by specifying the struct
name before the method name

Interfaces: A novel feature
 Interfaces specified with
‘interface’ keyword
 Not same as in C#/Java
 The structs doesn’t have to
say it implements an
interface
 Any struct that implements
the methods as specified
by any interface satisfies
that interface
 Strict static type checking &
“duck typing”!

Goroutines: easy & safe multithreading
 Goroutines are functions executing in parallel
 in the same address space in stack
 They communicate using “channels” (based on CSP)
 Cleaner, simpler and less-bug prone than using locks
 This shows an example* of how a Sort on big list can be done in
parallel with some other computation

We haven’t covered a lot!
 Important features not covered because of limited time
 reflection, embedding structs (aka inheritance), package
construction etc.
 Lots of libraries already implemented
 math, crypto, networking, regex, OS, testing, html gen….
 Garbage collection & Go runtime capabilities
 Currently mark-and-sweep collector, but better ones under
construction
 Small runtime: GC, channels, stack allocation, goroutines
etc.

Implementation status
 Currently compiler tool-chain available for Mac & Linux
 No “official” windows port; “unofficial” old ports exist
 Compilers: GCC implementation and a stand-alone implementation
 You can download the compilers/tools from this website & try it
 It’s open source (BSD license): We can contribute!
 Lots of work going on in libraries and improving the existing
tool chain
 Frequent builds & releases, quick response times etc.
 Many features & tools still lacking in Go
 For example, generics and debugger tool

Resources
 Go websites:
 Official: www.golang.org (web server implemented in Go!)
 Unofficial: http://go-lang.cat-v.org/
 Want to learn Go?
 No “books” yet
 Read "Effective Go” (http://golang.org/doc/effective_go.html)
 tutorials available online
 Tech talk (http://www.youtube.com/watch?v=rKnDgT73v8s)
 Join go-nuts mailing list gonuts@googlegroups.com
 You can try (compile & run) Go programs online!
 This is really useful: http://ideone.com/

So what are you waiting for?
 Lets Go!

A First Look at Google's Go Programming Language

Related slideshows

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

More Related Content

What's hot

What's hot (19)

Similar to A First Look at Google's Go Programming Language

Similar to A First Look at Google's Go Programming Language (20)

More from Ganesh Samarthyam

More from Ganesh Samarthyam (20)

Recently uploaded

Recently uploaded (20)

A First Look at Google's Go Programming Language