Read "Streaming Systems" 1&2, Streaming 101 Read "F1, a distributed SQL database that scales" Read "Zanzibar, Google’s Consistent, Global Authorization System" Read "Spanner, Google's Globally-Distributed Database" Read "Designing Data-intensive applications" 12, The Future of Data Systems IOS development with Swift Read "Designing Data-intensive applications" 10&11, Batch and Stream Processing Read "Designing Data-intensive applications" 9, Consistency and Consensus Read "Designing Data-intensive applications" 8, Distributed System Troubles Read "Designing Data-intensive applications" 7, Transactions Read "Designing Data-intensive applications" 6, Partitioning Read "Designing Data-intensive applications" 5, Replication Read "Designing Data-intensive applications" 3&4, Storage, Retrieval, Encoding Read "Designing Data-intensive applications" 1&2, Foundation of Data Systems Three cases of binary search TAMU Operating System 2 Memory Management TAMU Operating System 1 Introduction Overview in cloud computing 2 TAMU Operating System 7 Virtualization TAMU Operating System 6 File System TAMU Operating System 5 I/O and Disk Management TAMU Operating System 4 Synchronization TAMU Operating System 3 Concurrency and Threading TAMU Computer Networks 5 Data Link Layer TAMU Computer Networks 4 Network Layer TAMU Computer Networks 3 Transport Layer TAMU Computer Networks 2 Application Layer TAMU Computer Networks 1 Introduction Overview in distributed systems and cloud computing 1 A well-optimized Union-Find implementation, in Java A heap implementation supporting deletion TAMU Advanced Algorithms 3, Maximum Bandwidth Path (Dijkstra, MST, Linear) TAMU Advanced Algorithms 2, B+ tree and Segment Intersection TAMU Advanced Algorithms 1, BST, 2-3 Tree and Heap TAMU AI, Searching problems Factorization Machine and Field-aware Factorization Machine for CTR prediction TAMU Neural Network 10 Information-Theoretic Models TAMU Neural Network 9 Principal Component Analysis TAMU Neural Network 8 Neurodynamics TAMU Neural Network 7 Self-Organizing Maps TAMU Neural Network 6 Deep Learning Overview TAMU Neural Network 5 Radial-Basis Function Networks TAMU Neural Network 4 Multi-Layer Perceptrons TAMU Neural Network 3 Single-Layer Perceptrons Princeton Algorithms P1W6 Hash Tables & Symbol Table Applications Stanford ML 11 Application Example Photo OCR Stanford ML 10 Large Scale Machine Learning Stanford ML 9 Anomaly Detection and Recommender Systems Stanford ML 8 Clustering & Principal Component Analysis Princeton Algorithms P1W5 Balanced Search Trees TAMU Neural Network 2 Learning Processes TAMU Neural Network 1 Introduction Stanford ML 7 Support Vector Machine Stanford ML 6 Evaluate Algorithms Princeton Algorithms P1W4 Priority Queues and Symbol Tables Stanford ML 5 Neural Networks Learning Princeton Algorithms P1W3 Mergesort and Quicksort Stanford ML 4 Neural Networks Basics Princeton Algorithms P1W2 Stack and Queue, Basic Sorts Stanford ML 3 Classification Problems Stanford ML 2 Multivariate Regression and Normal Equation Princeton Algorithms P1W1 Union and Find Stanford ML 1 Introduction and Parameter Learning

Golang tricks



Data types in Go:

  • primitive
    • string
    • int
    • bool
    • float
  • advanced
    • struct
    • array
    • slice
    • map
    • chan
    • func

The pointers in Go are for reference basically to determine whether passing by value or by reference.

The memory includes stack and heap. stack is used to store simple-type data that are currently used, like those primitive types in Go. Data of these types occupy less memory and are easy to recycle. The space for their value and pointer are comparable so can be copied directly. Garbage collection is also easy to optimize.

Complex data types are usually stored in heap, since they need relatively large memory. Gabage collection is less frequent and costs more. So passing reference is more economic since it avoids expensive copy operation; saves memory and improve efficiency.

So pointer can be used in 3 cases as below:

  1. Need to change value
  2. Avoid copy
  3. Save memory

In Go, we can actually use slice, map and chan directly without considering pointer or value, since they all pass reference. However, we need to pay attention to struct. It’s a little more complicated.


For func, passing type is determined by function argument. It will report error if wrong argument type.

func passVal(s struct){}

func passRef(s *struct){}

For method, receiver can be pointer or value. If receiver is value, we pass by value, thus method itself cannot modify outside variable. However, It’s recommend to use pointer as receiver in order to modify value and avoid large object copy.

type MyPoint struct {
    X int
    Y int
func printFuncValue(p MyPoint){
    p.X = 1
    p.Y = 1
    fmt.Printf(" -> %v", p)
// input should be pointer like pp (type MyPoint), cannot use just p
func printFuncPointer(pp *MyPoint){
    pp.X = 1 // should be actually (*pp).X, but a syntactic sugar here
    pp.Y = 1
    fmt.Printf(" -> %v", pp)
func (p MyPoint) printMethodValue(){
    p.X += 1
    p.Y += 1
    fmt.Printf(" -> %v", p)
func (pp *MyPoint) printMethodPointer(){
    pp.X += 1
    pp.Y += 1
    fmt.Printf(" -> %v", pp)


Follwing code is an example for inheritance in Go.

  • We cannot use a Student object as type Human.
  • When we do student.Drink(), func (s Student) Drink() will be used, thus override Human method.
  • When we do student.Eat(), func (h Human) Eat() will be called. Inside the method, func (h Human) Drink() is called instead of Student.
type Being struct {
    IsLive bool

type Human struct {
    Name string
    Age int

func (h Human) Eat(){
    fmt.Println("human eating...")
func (h Human) Drink(){
    fmt.Println("human drinking...")

type Student struct {
    Grade int
    Major string

func (s Student) Drink(){
    fmt.Println("student drinking...")


Unlike Java, we don’t need to explicitly implement an interface. For following example, as long as an object looks like a duck, walks like a duck, sounds like a duck, then it’s a duck.

interface Duck {

Use type assertion to determine whether an interface is a type

var i interface{} = "hello"

s := i.(string)

s, ok := i.(string)
fmt.Println(s, ok)

f, ok := i.(float64)
fmt.Println(f, ok)

// use it to convert type with an empty interface
v := interface{}(old).(string)

// type switch, perform several assertion at a time
func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
		fmt.Printf("I don't know about type %T!\n", v)


Read and write file

import (
// read all content of a file without open or close
file, err := ioutil.ReadFile(fileStr)

// create a file, if exists, will empty it
file, err := os.Create(fileStr)

// open a file and writes to end
file, err := os.OpenFile(fileStr, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0600)


import (

// writes json of kv pairs to file
type KeyValue struct {
	Key   string
	Value string
file, err := os.Open(fileStr)
kv := KeyValue{"hi", "world"}
enc := json.NewEncoder(file)
err3 := enc.Encode(&kv)

// decode json from file
file, err := os.Open(fileStr)
jsonDecoder := json.NewDecoder(file)
var kv *KeyValue
for jsonDecoder.Decode(&kv) == nil {
    //do something

Creative Commons License
Melon blog is created by melonskin. This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.
© 2016-2019. All rights reserved by melonskin. Powered by Jekyll.