notes.txt

Magesh Kuppan

Schedule:
    Commence    : 9:30 AM
    Tea Break   : 11:00 AM (20 mins)
    Lunch Break : 1:00 PM (1 hr)
    Tea Break   : 3:30 PM (20 mins)
    Wind up     : 5:30 PM

Methodoly:
    No powerpoints
    100% Hands on
    Atleast 50% of the participants should have completed the assignments 

About You:
    Name
    Experience
    Primary Skillset
    Experience in Go
    Any intesting books / shows you read / watched


interfaces
functional programming
concurrency

interfaces
    implementation is 'implicit'
    

Higher Order functions
    Functions that can be treated like 'data'
        Functions can be assigned to variables
        Functions can be passed as arguments to other functions
        Functions can be returned as return values by other functions

Concurrency
    Golang is built FOR concurrency
    go, select, range, chan (data type), <- (channel operator)

    DO NOT ASSUME:
        1. the time taken for a goroutine to complete
        2. the order in which goroutines invoked / complete

    To detect race conditions
        go run --race demo-06.go 
        
        go build --race demo-06.go


    channel
        //create
        ch := make(chan int)

        //send data 
        ch <- 100

        //receive data
        <- ch

    Receive operation is ALWAYS a blocking operation

    Send operation is blocked until a Receive operation is initiated

Assignment-01:
    modify demo-20.go to generate the prime numbers until the user hits ENTER key
        NOTE: do NOT capture the ENTER key from the genPrimes function

Resource Pooling
    Create a pool with a size & factory

    Acquire Resource from the pool
        if there are resources in the pool
            return from the pool
        else
            use the factory to create the resource and return it

    Release Resource to the pool
        if the pool is full
            discard the resource
        else
            add the resource to the pool

    IMPORTANT:
        1. the factory should be thread-safe
        2. the pool should be thread-safe
        3. When a resource is acquired, it should not be allowed to be acquired again until it is released

    
GRPC
    http2

    Communication Patterns
        Request & Response
        Server Streaming (One Request & Stream of Responses)
        Client Streaming (Stream of Requests & One Response)
        Bidirection Streaming (Stream of Requests & Stream of Responses)

    Create a .proto file with the following contracts
        Service contract
        Operation Contract
        Message Contract

    ON the service side
        Create a Stub using the .proto file
        Implement the service
        Host the service

    On the client side
        Create a proxy using the .proto file
        Us the proxy to Call the service

Installation
        go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
        go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

        (when the above is installed, executables are created in the gopath/bin folder. Make sure this path is set in environment variables)

    Windows
        Install the binaries from https://github.com/protocolbuffers/protobuf/releases/

    Mac
        brew install protoc-gen-go
        brew install protoc-gen-go-grpc

To generate the proxy and stub
    protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative proto/service.proto

HTTP Services
    Only using the platform APIS
        How to handle errors?
        How to serialize / deserialze data?
        How to log the request and response?

    Routing Libraries
        router.GET("/", func(){

        })

    Web Frameworks
        Gin
        
    Microservice
        go-kit

HTML5 (Browser as an OS)

    Persist data on the client side
        Local Storage
        Session Storage
        IndexedDB
    Make the application available offline
        Offline Application Cache
        Service Worker
    Real time updates from the server
        Server Sent Events
        Web Sockets
    Multithreading
        Web Workers

Web Socket
    gorilla/websocket