govspython.slide

#+theme=black

Go vs. Python

Dmytro Grendach
Nokia

[[https://github.com/grendach/GOvsPython]]


* Agenda
.image images/golang_vs_python.jpg 130 800
1. Who is Who
2. Hello World
3. Differences in:
  - lists
  - dictionaries
  - loops
  - error handling
  - other differences 
4. And the winner is...

* Who is who: Python

- Created by *Guido* *van* *Rossum*  in 1991.

- Python is dynamicly typed, interpreter language. 

- Use whitespace for indentation.

- Has 33 keywords (`class`, `def`, `for`, `if`, `while`, etc.)

 The Zen of Python
 - Beautiful is better than ugly.
 - Explicit is better than implicit.
 - Simple is better than complex.
 - Complex is better than complicated.
 - Flat is better than nested.
.image images/python.png 100 100


* Who is who: Go

- Created by Rob Pike , Robert Griesemer and Ken Thompson in 2009.
- Go is a statically typed, compiled language.
- Built in `fmt` package makes code formate for you.
- Go has 25 kyewords (`go`, `goto`, `chan`, `func`, `for`, `if`, etc. )
  
The designers wanted to resolve common criticisms of other languages, while retaining many of their useful characteristics:

  - Statically typed and efficient (like C++ or Java)
  - Productive and easy to use (like Python or JavaScript)
  - Go has pointers but unlice C, Go has no pointer arithmetic.
  - Enabling high-performance networking and multiprocessing.
.image images/strongGopher.jpg 100 100



* Python vs Go
.image images/begin.gif 350 500
Let the battle begin...


* Hello world in Python
.code -numbers code/hello.py

* Hello world in Go 
.play -numbers code/hello.go


* Differences in 
- Lists(slices)
- Dictionaries(maps)
- Loops.
- Error handling.
- Pointers.
- Coroutine vs Goroutine and channell.
- Inheritance.

* List in Python

Python has next data types:
  - *List* [ ] - ordered and changeable collection.
  - *Tuple* ( )- ordered and unchangeable.
  - *Set* { } - unordered and unindexed.
  - *Dictionary* { } - unordered, changeable and indexed.

.code -numbers code/lists.py 


* Slices (lists) in Go
Slices are like references to arrays.
A slice does not store any data, it just describes a section of an underlying array.
Slices can be created with the built-in `make` function.
This is how you create dynamically-sized arrays.

.play -numbers code/lists.go

* Dictionary in Python
.code -numbers code/dict.py

* Dictionary in Go it's Map!
.play -numbers code/dict.go

* Loop in Python
Python has two primitive loop commands:

*while* loops
*for* loops

.code -numbers code/loop.py

* Loop in Go
Go has only one looping construct, the *for* loop.

.play -numbers code/loop.go

* Error handling in Python:
Error handling in Python is done through the use of exceptions.

.code -numbers code/error.py


* Error handling in Go
Go doesn’t have exceptions.
Errors are represented using the built-in `error` type, same as `int`, `string`.
Each time you need to check for error manually.

.play -numbers code/error.go

* Pointers in Python
*Python* *doesn't* *use* *pointers!*
Variables cannot point to other variables.
Variables always point to the underlying object instead.

.code -numbers code/pointers.py


* Pointers in Go
Go use *pointers* but doesn't use *pointer* math.
*Pointer* holds the memory address of a value and represented using the `*` (asterisk).
Operator `&`  used to find the address of a variable.

.play -numbers code/pointers.go


* Coroutine in Python
*Coroutines* declared with `async`/`await` syntax.
Is the preferred way of writing asyncio applications. 

The following snippet of code (requires Python 3.7+) prints “hello”,
waits 1 second, and then prints “world”

.code -numbers code/routine.py


* Goroutine and channell

*Channels* are the pipes that connect concurrent *goroutines*.
You can send values into channels from one *goroutine* and receive those values into another *goroutine*.

.play -numbers code/routine.go

* Inheritance in Python

For *inheritance* Python use *base* (parent) and *sub* (child) classes.
*Base* class create a pattern out of which *sub*, child can be based on.

.code -numbers code/inheritance.py


* Inheritance in Go

Go is unique from a lot of object-oriented languages in that it doesn’t have classes. 
Instead, Go has two awesome features: *interface* and *struct*.

*Interfaces*:
 - You don’t explicitly say a data type implements an interface.
 - Your data types must implement all of the methods that the interface defines.
 - Compiler checks to see if assignments to variables of the interface type are valid.

*Struct*:
 - It's a sequence of named elements, called fields, each of which has a name and a type.
 - Field names may be specified explicitly (IdentifierList) or implicitly (EmbeddedField)
 - Within a struct, non-blank field names must be unique.


* Inheritance in Go
.code -numbers code/inheritance.go


* Python vs Go

.image images/finish.gif 350 500

And the winner is...



* And the winner is...

Go is a very performant language with great support for concurrency. 
It is almost as fast as languages like C++ and Java.

While it does take a bit more time to build things using Go compared to Python you’ll save a ton of time spent on optimizing the code.

*Python* *usage*: it's almost everywhere :)

*Golang* *usage*: Docker, K8s, Prometheus are written in Go. 
Google and Soundcloud using it!

.image images/codeGopher.gif 100 100