Declaring variables of different types:

// type variablename = value; 
int num;
string s;
bool b;
char ch;
double dub;
float fl;
decimal dc;
// arrays are of fixed length and can be provided a size during initialisation. 
// Compiler infers the size if you do not provide it. 
int[] arr; 
List<int> nums; // List<type> varname
Dictionary<string, int> dict;  // Dictionary<keyType, valueType> varname;

Initialising variables of different types.

// Syntax: 
// Either `var varname = value;` — here type is inferred by the compiler 
// Or `type varname = value;`

var num1 = 1;
int num2 = 2;

var dub1 = 1.99;
double dub2 = 2.99;

var fl1 = 1.99f; // for float 'f' or 'F' suffix must be provided at the end of the value.
float fl2 = 2.99f;

var dc1 = 1.99m;
decimal dc2 = 2.99m; // for decimal 'm' or 'M' suffix must be provided at the end of the value.

var ch1 = 'A';
char ch2 = 'B';

var s1 = "first one";
string s2 = "second one";

var b1 = true;
bool b2 = false;

// Ways to Initialise an array:

// NOTE: Some of the other ways to initialise an array, a list, and a dictionary have not been added here.
// Only standard and recommended ways have been added.

// recommended way for legacy projects
int[] arr1 = { 1, 2, 3 }; // creates an array with values {1, 2, 3}

// recommended for new projects
int[] arr2 = [1, 2, 3]; // use square brackets; creates an array with values [1, 2, 3].

// Ways to initialise a list:

List<int> nums1 = [1, 2, 3]; // modern syntax: c# 12+
// traditional standard: using var keyword
var nums2 = new List<int>() { 1, 2, 3 }; 


// Ways to initialise a dictionary:
// classic way:
var dict1 = new Dictionary<string, int> {
    {"user1", 1},
};

// Recommended way:
var dict2 = new Dictionary<string, int>
{
    ["user1"] = 1,
};

Constants

// const type varname = value;
const int num = 5;

OOP

In short words, Object-oriented programming (OOP) is a way of designing software around data, or objects, rather than functions and logic.

using Finance;

namespace Notes; // namespace is like a declaration of name for this package.


class Cheatsheet
{
    // Main method; methods behave similar to functions from other languages. 
    static void Main() // static keyword: this method belongs to the class itself, and not an instance.  
    {

        var c = new Car("toyota", 2022, "Dean", 5000);
        var c2 = new Car("nissan", 2020, "Noah", 4000);

        Console.WriteLine(c.Brand); // toyota
        Console.WriteLine(c.EofySale); // false
                                       // Console.WriteLine(c.EofySale); // you can do this way too, if you have created a property. 

        Console.WriteLine(c.PriceAfterDiscount()); // 4500

        // call static method for Car.
        Console.WriteLine(Car.CarInstances()); // 2

        // call another namespace 
        Console.WriteLine(FinanceOptions.IsAvailable(c2.CustomerName)); // true 
        Console.WriteLine(FinanceOptions.s_customers[0]); // here, internal is accessible because they are in same assembly (project), 
                                                          // even though they have different namespace.

        // c.EofySale = true; // This will throw an error as only get method have been added for this member.
        // Console.WriteLine(c.CarInstances()); // this will fail: static methods can only be invoked on the Class itself.

        // call static method for Car
        Console.WriteLine(Car.CarInstances()); // 3

    }
}


// class and objects.
class Car
{
    public bool EofySale { get; } // syntatic sugar to allow get method only.

    public string Brand; // public keyword (also called an access modifier) makes a field accessible from outside.
    public int Year;
    public int Cost;
    public string CustomerName;
    private decimal _discountPercent = 10.00m; // private: can only be accessed within the same class, not accessible from an instance. 

    static int s_noOfInstances = 0; // fields are private by default, cannot be accessed outside of the class. 

    // Constructor
    public Car(string brand, int year, string customerName, int cost)
    {
        this.Brand = brand; // this keyword refers to the values for this specific instance/object.
        this.Year = year;
        this.CustomerName = customerName;
        this.EofySale = false;
        this.Cost = cost;
        s_noOfInstances++;
    }

    public static int CarInstances() // static keyword: this method belongs to the class itself, and not an instance.  
    {
        return s_noOfInstances;
    }

    public decimal PriceAfterDiscount()
    {
        return this.Cost - ((this._discountPercent / 100) * this.Cost);
    }
}

// Finance.cs
namespace Finance;


class FinanceOptions
{
    internal static string[] s_customers = { "John", "Aki", "Noah" }; // internal: accessible anywhere within this assembly.

    public static bool IsAvailable(string customerName)
    {
        foreach (string c in s_customers)
        {
            if (c == customerName)
            {
                return true;
            }
        }
        return false;
    }
}

// Encapsulation: 
// In C#, usually "private" keyword and properties are used to achieve 
// encapsulation — encapsulation means hiding sensitive data from the users, 
// and protecting the integrity of an object's internal state.  



// A note on access modifiers:
// public: code is accessible for all classes
// private: code is only accessible within the same class  —  not accessible from an instance.
// protected: code is only accessible within the same class, or in a class that inherits this class. 
// internal: code is accessible within its own assembly (project). 
// 	     field with "internal" can be used throughout this project, even though they maybe of different namespaces.  
// 	     Example: If you have install a package which has internal field, you cannot access that field from your project. 
// static: code belongs to the class itself, and not an instance.  

C# Naming Conventions:

• Public methods, fields, and classes: PascalCase
• Private methods: camelCase
• Private fields: _camelCase
• local variables, parameters: camelCase
• Interface: IPascalCase (Note: Letter ‘I’ is required at front)
• static fields: s_camelCase
• static methods: camelCase

Inheritance:

Inheritance is a way to inherit fields and methods from parent class (base class) to child class (derived class). In C#, this is achieved using the single colon “:” symbol.

// UsedCar inherits the parent class "Car"

class UsedCar : Car
{
    public int WarrantyYears { get; } // read-only field for anyone accessing this field outside this class.

    // base passes the arguments for these parameters to the parent class's constructor. 
    public UsedCar(string brand, int year, string customerName, int cost) : base(brand, year, customerName, cost)
    {
        if (cost > 5000)
        {
            this.WarrantyYears = 3;
        }
        else
        {
            this.WarrantyYears = 1;
        }
    }
}


// Use sealed keyword to not allow the class to be inherited. 
sealed class Person
{
}

// This will fail: no class can inherit from Person. 
// class Student: Person {
// }

Polymorphism:

Polymorphism means “many forms”. In programming, this mainly refers to methods of inherited classes with same name as parent’s method, but different behaviours.

// Example without polymorphism: 

namespace Notes;

class Cheatsheet
{
    static void Main()
    {
        Device dv = new Device();

        // Here, variable mp's reference type is "Device". 
        // Even though it's actual object type is "Mobile", 
        // when the method with same name "getInfo" is called, C# uses the parent's method. 
        // This is C#'s hiding behaviour. 
        // Polymorphism is used in the next paragraph to solve this problem.
        Device mp = new Mobile();

        Console.WriteLine(dv.GetInfo()); // I am a device
        Console.WriteLine(mp.GetInfo()); // I am a device 

    }
}

class Device
{
    public string GetInfo()
    {
        return "I am a device";
    }
}

class Mobile : Device
{
    public string GetInfo()
    {
        return "I am a mobile phone";
    }
}

// Example with polymorphism:
// In C#, polymorphism is achieved using `virtual` keyword on the method inside the base class, 
// and 'override' keyword on the method with same name in the derived class. 

namespace Notes;

class Cheatsheet
{
    static void Main()
    {
        Device dv = new Device();
        Device mp = new Mobile();

        Console.WriteLine(dv.GetInfo()); // I am a device
        Console.WriteLine(mp.GetInfo()); // I am a mobile phone

    }
}

class Device
{
    public virtual string GetInfo() // virtual keyword in the base class's method.
    {
        return "I am a device";
    }
}

class Mobile : Device
{
    public override string GetInfo() // override keyword in the derived class's method. 
    {
        return "I am a mobile phone";
    }
}

Abstraction:

In simple words, abstraction is about hiding complexity from the user.

Example: Let us say “stripe” provides a method charge that charges the amount from user when card and amount are passed as arguments. stripe(card, amount)

Here, when we call this method, we don’t know (and don't have to know) all internal things such as fraud checks, http calls, etc. This is an example of abstraction.

Difference between encapsulation and abstraction:Encapsulation is about hiding what's inside, 
while abstraction is about how things are done. 

In C#, abstraction can be achieved primarily by two ways:

• Using “abstract” keyword is used for classes and methods.
• Using interface.

In C#, an object/instance cannot be created from an abstract class.

Methods with abstract keyword can only live inside an abstract class. Abstract methods cannot have a body, and the derived class that inherits from the abstract class overrides the abstract method, and provides a body.

Example using “abstract” keyword:

namespace PaymentFlow;

class Payment
{

    public static void Main()
    {
        PaymentType pp = new PayPal();
        PaymentType ap = new Afterpay();

        Console.WriteLine(pp.Checkout()); // You are now paying via PayPal
        Console.WriteLine(ap.Checkout()); // You are now paying via Afterpay


        // NOTE: Polymorphism is occuring here.
        // The reference type is "PaymentType" and actual object types are "PayPal" and "Afterpay". 
        // The method "Checkout" of the parent class gets overriden by the "Checkout" of the derived class. 
    }
}

abstract class PaymentType
{
    // abstract methods cannot have a body.
    public abstract string Checkout();
}

class PayPal : PaymentType
{
    // Abstract method gets override on the derived class. 
    public override string Checkout()
    {
        return "You are now paying via PayPal";
    }

}

class Afterpay : PaymentType
{
    public override string Checkout()
    {
        return "You are now paying via Afterpay";
    }
}

Interface

Interface is a completely abstract class, whose members are abstract and public by default. It can only contain methods and properties with empty body — not fields.

namespace OrderingSystem;

class Order
{

    public static void Main()
    {
        var dl = new Delivery();
        var cc = new ClickAndCollect();

        Console.WriteLine(dl.Order());
        Console.WriteLine(cc.Order());
        Console.WriteLine(cc.Address());
    }
}


interface IOrderType // Good practice to add 'I' at the beginning of an interface's name.
{
    string Order(); // methods/properties are abstract and public by default. 
}

interface IAddress
{
    string Address();
}


// Use the : colon to implement an interface (just like inheriting)
class Delivery : IOrderType
{
    public string Order() // No need to add "override" keyword on methods of the class that implements an interface. 
    {
        return "Your order will be delivered within 3 business days.";
    }
}


class ClickAndCollect : IOrderType, IAddress // Multiple interfaces can be implemented by using ','
{
    public string Order()
    {
        return "Please allow up to 4 hours for your Click & Collect order to be processed.";
    }

    public string Address()
    {
        return "Your order will be ready to collect from CS Warehouse Anewol";
    }
}

enums

enum Phone
{
    Used,
    New,
    Refurbished
}

yield

C# has “yield” keyword which can be used to temporarily pause a function, and return a value to the caller.

namespace YielderRunner;

class Yielder
{
    public static void Main()
    {
        foreach (int num in GenSingDigits())
        {
            if (num == 100)
            {
                break;
            }
            Console.WriteLine(num);
        }

    }

    public static IEnumerable<int> GenSingDigits()
    {
        yield return 0;
        yield return 1;
        yield return 2;
        yield return 100;
    }
}

Task, async, await, record

• In C#,Task represents an asynchronous operation, similar to promise concept in js.
• record: a shorthand to get a type that holds data, nothing else. Pairs really well with JSON deserialisation, returning a record instead of returning multiple values,etc.

namespace ExampleAsync;

using System.Net.Http.Json;

class AsyncAwaitExample
{
    public static async Task Main()
    {
        var ip = await MyIp();
        Console.WriteLine(ip);
    }

    public static HttpClient client = new()
    {
        BaseAddress = new Uri("https://api.ipify.org/?format=json"),
    };

    public static async Task<string> MyIp()
    {
        try
        {
            var ip = await client.GetFromJsonAsync<IP>("");
            if (ip != null)
            {
                return ip.ip;
            }
            return "No IP returned";
        }
        catch (HttpRequestException error)
        {
            return error.Message;
        }
    }

}

public record IP(string ip);

Delegates/Action/Func

• A delegate is a type that safely encapsulates a method.
• A delegate can be a variable that holds a method.
• Once in a while, you might need to send a method as a parameter to another method, and that is one of the scenarios where you will need delegates.

NOTE: Create/Use a delegate when you want the caller to inject the behaviour from outside.

An example where a delegate is a variable that holds a method.

public delegate void Log(string s); // use "delegate" keyword.

class Logger
{
    public static void Main()
    {
        Log logHere = Println; // Here the delegate "logHere" is holding a method "println".
        logHere("Hello world"); // And executing the "println" here.  
    }

    public static void Println(string msg)
    {
        Console.WriteLine(msg);
    }
}


// An example where a method is sent as a parameter to another method. 

An example where a delegate holds multiple methods. public delegate void Remind(string s);

class Reminder
{
    public static void Main()
    {
        Remind r = RemindViaMessage; // This delegate holds RemindViaMessage.
        r += RemindViaEmail; // appending a method to this delegate.
        r += RemindViaNotification; // appending another method to this delegate.

        r("Go to Csharp Meetup");
        // Output:
        //Sending a message: Go to Csharp Meetup
        // Sending an email: Go to Csharp Meetup
        // Sending a notification: Go to Csharp Meetup
    }

    public static void RemindViaMessage(string s)
    {
        // simulate sending a reminder via message. 
        Console.WriteLine($"Sending a message: {s}");
    }

    public static void RemindViaEmail(string s)
    {
        // simulate sending a reminder via email. 
        Console.WriteLine($"Sending an email: {s}");
    }

    public static void RemindViaNotification(string s)
    {
        // simulate sending a reminder via email. 
        Console.WriteLine($"Sending a notification: {s}");
    }
}

An example where a method is sent as a parameter to another method.

public delegate void PrintFunction<T>(IEnumerable<T> value);

class Printer()
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3 };
        Print(PrintHorizontal, nums);
        Print(PrintVertical, nums);
    }

    public static void Print<T>(PrintFunction<T> fn, IEnumerable<T> value)
    {
        fn(value);
    }

    public static void PrintHorizontal<T>(IEnumerable<T> value)
    {
        foreach (var v in value)
        {
            Console.Write($"{v} ");
        }
    }

    public static void PrintVertical<T>(IEnumerable<T> value)
    {
        foreach (var v in value)
        {
            Console.WriteLine(v);
        }
    }
}

• Action: Action is a built-in delegate that takes in 0-16 parameters but doesnot return a value.
• Func: Funce is a built-in delegate that that takes in 0-16 parametes and returns a value.

namespace Delegation;

class Example
{
    public static void Main()
    {
        Action<int> log = (s) => Console.WriteLine(s);
        log(5);

        // Here, the last int before ">" represents the return type. 
        Func<int, int, int> add = (a, b) => a + b;
        log(add(2, 3));
    }
}

Extension method:

Extension method enables you to add new methods to an existing type without creating a derived type or modifying the original type. Three rules to follow when creating an extension method:

1. class using the extension method must be declared as “static” — static classes cannot instantiated or inherited.
2. The method itself must be declared static.
3. The data type you want to extend must have “this” keyword before writing that type.

Simplest example to show an extension to an “int” type.

class Program
{
    public static void Main()
    {
        var num = 4;
        Console.WriteLine(num.IsEven()); // true
    }
}

// 1. class must be static.
static class ExtensionMethods
{
    // 2. method must be static.
    public static bool IsEven(this int n) // 3. this keyword infront of the type is necessary.
    {
        return n % 2 == 0;
    }
}

Cleaning up resources such as an opened file, database connection, etc:

C# provides an interface “IDisposable” with a method “Dispose” that can be implemented on a class to safely cleanup the resources — if your class manages native resources.

When using built-in class that manages resources, you should use the using statement. This will make sure “Dispose” method gets called before this method/block returns.

Example of using statement to manage resource:

namespace Reader;

class File
{
    public static void Main()
    {
        try
        {
            // Read a file line by line. 
            using var reader = new StreamReader("input.txt"); // use "using" statement"
            {
                while (true)
                {
                    var line = reader.ReadLine();
                    if (line != null)
                    {
                        Console.WriteLine(line);
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Dependency Injection

Example: Instead of creating a new instance of a database for each controller, you inject the shared instance to all the controllers.

namespace DI;

class DInjection
{
    public static void Main()
    {
        var db = new DB();
        db.PrintUsers(); // Luke, Noah

        var uc = new UserController(db);
        uc.AddUser("Abraham");
        db.PrintUsers(); // Luke, Noah, Abraham 
    }
}


class DB
{
    public List<string> Users { get; set; }

    public DB()
    {
        Users = new List<string> { "Luke", "Noah" };
    }

    public void PrintUsers()
    {
        foreach (var user in Users)
        {
            Console.WriteLine(user);
        }
    }
}

class UserController
{
    private DB _db; // underscore added in variable name to identify it as a private member. 

    public UserController(DB db)
    {
        _db = db;
    }

    public void AddUser(string name)
    {
        _db.Users.Add(name);
    }
}

Docker is best understood with a problem that you likely have faced: the same code runs in your machine, but it does not run on your friend’s/colleague’s machine.

Docker solves this machine by packaging and running your application in a loosely isolated environment called a container. Containers contain everything that is required to run your application.

Docker objects

Images:

An image is a read-only template with instructions to build and run a Docker container. You might either create your own images, or use those that are available in Docker’s public registry.

To create your own image, a Dockerfile is used, which contains simple syntax that defines the steps needed to create that image. Each instruction creates a layer in the image. When a Dockerfile is changed, only the layer that has changed is rebuilt. This is what makes the rebuilding process significantly faster, compared to other virtualization technologies.

Containers:

A container is a runnable instance of an image that you can create, stop, move, or delete using your CLI or Docker API. When you remove a container, all changes to its state that are not stored in a persistent disk are removed.

Example of docker run command

docker run -i -t ubuntu /bin/bash

The above command runs the ubuntu container, attaches your terminal directly to the container, and runs /bin/bash.

The following things happen under the hood:

• If you don’t have “ubuntu” image locally, it is pulled from the configured registry, as if you had manually run docker pull ubuntu.
• It creates a new container, as if you had manually run the docker create command.
• A read-write filesystem is allocated to the container to create or modify files and directories in its local filesystem.
• A network interface is created to connect the container to the default network.
• After the container starts, /bin/bash is executed.

docker compose Command

Docker Compose allows you to define all your containers and configurations in a single YAML file. This is a way to replace long docker run commands with a clean and small docker compose command without having to worry about managing networks, and all the flags needed to connect those containers.

Example of compose.yaml file:

` services: web: build: . ports: - “8000:5000” redis: image: “redis:alpine” `

This file defines 2 services: web and redis.

The web service will use the image built from the Dockerfile present in the current directory, and then map port 5000 of the container to the port 8000 of the host. This means that when you visit localhost:8000, Docker will send that traffic to the container’s port 5000.

With this, you can easily start up your application by running docker compose up, and without worrying about manually configuring networks in the docker run commands.

To tear this down

To remove everything, simply use docker compose down. By default volumes are not automatically removed. To remove the volumes, add the --volumes flag.

docker compose down --volumes

Building production-ready images

To create container images, a Dockerfile is used. It provides instructions to the image builder about the steps needed to build that image. These steps include: commands to run, files to copy, etc.

Below is an example of a Dockerfile with steps, for a simple API written in Go, listening on port 8080.

1.

On the first line of your Dockerfile, you can add an optional directive line that instructs the Image builder to interpret your file according to the version you have specified.
#syntax=docker/dockerfile:1

You can then tell the image builder about the base image that you want to use for your application using the FROM keyword, in this case, we are using Go.
FROM golang:1.25.5

So, combining that it looks like this:

#syntax=docker/dockerfile:1

FROM golang:1.25.5

2.

Next step is to make it easy to run the rest of our commands, we can create a directory inside the image that we are building. From here on, we can just type the relative paths based on this directory, and not the full file paths.

WORKDIR /app

From here on, all the commands that we write will treat this directory as our current base directory.

3.

The next thing you would usually do after you have downloaded your project on go, would be to install all the dependencies. In go. go.sum and go.mod handle all the required dependencies. So, the next step for us is to copy these files into our image, before we start installation. To this, we can use the COPY keyword, which takes two arguments, the first: the files that you want to copy, and second: the destination (the directory in which you want those files to be copied). So the next line will look like this:

COPY go.mod go.sum ./

Since we are already in our /app directory (because of the previous command), we can simply type ./ as our destination directory.

4.

The next step is to install all the dependencies for your project. We can install all the required dependencies in Go using go mod download, and we can use the RUN command in Docker to tell the image builder to run it. So, our next line will be:

RUN go mod download

5.

Now, we can copy all our source code to our image. To do this, we can use the COPY command again, just like the way we did on step 3.

COPY *.go ./

This copies all the files ending with .go extension to our current directory inside the image.

6.

The next step is to compile our go program, and we can achieve this using the RUN command again.

RUN CGO_ENABLED=0 GOOS=linux go build -o /docker-go-api

In case, you are not familiar with the compilation command:

• CGO_ENABLED=0: This tells the compiler to disable CGO (a mechanism to call C code from Go). This is done to create a truly static binary that does not depend on external C libraries.
• GOOS=linux: This tells the compiler that the targeted operating system will be linux. “Linux” is specified because our container will run Linux.
• go build: This is the standard command to compile, and build a binary.
• -o: This specifies the output filename and path.
• /docker-go-api: Our binary will be called docker-go-api, and will be located in the root of the filesystem of our image.

7.

The next step is to add documentation about the port this app will run on. This way, the person running this container will know which port is intended to be published. We can do this using the EXPOSE command.

EXPOSE 8080

Now the person running this container will know that this app runs on port 8080.
NOTE: EXPOSE command does not actually publish the port, it is added only for documentation.

8.

The next and final command is to tell our image builder what to run when it starts a container. We can do this using the CMD command.

CMD [“/docker-go-api”]

Now, when our container starts, it will run our binary “docker-go-api”.

Below you can find the complete file:

# syntax=docker/dockerfile:1

FROM golang:1.25.5

WORKDIR /app

COPY go.mod go.sum ./

RUN go mod download 

COPY *.go ./

RUN CGO_ENABLED=0 GOOS=linux go build -o /docker-go-api

EXPOSE 8080

CMD ["/docker-go-api"]

Before we go onto the next part of building this image, let’s quickly create a small Go project, with one single API, in the same directory.

First, initialize a Go project:

go mod init docker-go-api

Create a main.go file:

If you are on linux/mac, use the touch command:

touch main.go

Add this to your main.go file:

package main

import (
	"github.com/gin-gonic/gin"
)

func main() {
	router := gin.Default()
	router.GET("/", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "Hello Docker!",
		})
	})
	router.Run() // listens on 0.0.0.0:8080 by default
}

The above code imports “gin” to create a small API, with a single endpoint “/”, that returns a JSON message:

{"message": "Hello Docker!"}

Run go mod tidy to automatically import gin and to update go.sum.

Now, we are ready to build this.

Building this image

To build this image, we can use the docker build command. This will build images from the Dockerfile.

While building the image, you can optionally provide a string name for the name of the image. You can do this using the --tag flag. Below we will use the --tag file to name the image as docker-go-api.

Command:

docker build --tag docker-go-api .

The .(dot) at the end tells the image builder to look for dockerfiles in the current directory.

When build is completed successfully, you will see a “Finished” log on your terminal.

Viewing local images

To see the local images that are available/have been built on your machine, you can use docker image ls command.

docker image ls

IMAGE ID DISK USAGE CONTENT SIZE EXTRA
docker-go-api:latest 0b0a24003886 1.84GB 431MB U

Running this container:

We can run the container using the docker run command. This command takes image name as the parameter. So, in our case, our command will be:

docker run docker-go-api

Output:

[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /                         --> main.main.func1 (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://github.com/gin-gonic/gin/blob/master/docs/doc.md#dont-trust-all-proxies for details.
[GIN-debug] Listening and serving HTTP on 0.0.0.0:8080

You will see an output similar to the above, and it says that it is serving on localhost:8080. However, when you send a request, or even visit that site through your browser at that port, you will get a “Failed to connect” error. This is because by default the container’s network is isolated from the host network. The container can access the outside world, but the host and other machines cannot access the container’s ports unless you publish them.

To publish, you can use the --publish or just -p flag with the syntax host_port:container_port on the docker run command. So, here, in our case, if we do 3000:8080, when we visit 3000 on our local host, our request will be forwarded to 8080 of the container’s port, which is where our api server is running. However, to keep it simple for our example, we will keep the host_port the same as the container_port, which is 8080.

docker run -p 8080:8080 docker-go-api

So now, when you make a request to localhost:8080, you will get the response:

{"message":"Hello Docker!"}

In this method:

1. The client sends the word “Basic” followed by the Base64-encoded <username>:<password> in the standard Authorization header.
2. The server then matches that username and password against the credentials stored on the server/db.
3. If the credentials match, access to the resource is allowed, else, access is denied.

In Basic HTTP Authentication, each request follows the same methods mentioned above - each request contains Basic <username>:<password> in the authorization header.

Since this request is sent in Base64-encoded plain text, it is highly vulnerable to security attacks. Although, using HTTPS makes it at least usable, it is still considered a very weak authentication method, as HTTPS keeps the data encrypted only in transit, not in other places where it is decrypted, such as web browsers, servers, reverse proxies, etc.

Bearer-Token-Based Authentication Method

This method is also a part of the Basic HTTP Authentication scheme. In this method:

1. The client sends a login request, with a username and a password (in the request body).
2. Server generates a string (a hexadecimal character string, or a JWT token - which has been written about in the next section).
3. The client then uses this new string (called Token) every time to make authenticated requests - unlike Basic HTTP, where username and password were sent in the Authorization Header in each request.

The generated token is sent in this format in the authorization header:

Authorization: Bearer <token>

JWT

JWT (JSON Web Token) is a cryptographically signed JSON object that contains information about the user. JWT is commonly used as a bearer token in Bearer Token Based authentication method. Using JWT, the server can verify the integrity of the request, and get the information about the user.

NOTE: JWT is not an encryption, it is a digitally signed token.

Because JWTs are signed, we can be sure that the senders are who they claim to be, and verify that the content has not been changed.

Structure of JWT

JWT consists of 3 parts, separated by dots:

Header.Payload.Signature

Header

The header consists of two parts: the type of token (which is JWT), and the signing algorithm that is being used, such as HMAC SHA256 or RSA.

Example:

{
    “alg”: “HS256”,
    “typ”: “JWT”
}

Payload

Payload is where the main data lives. It generally contains information about a user, and the expiration time for that token. This information/data is also called as claims.

Example:

{
  "sub": "1234567890", 
  "name": "John Doe",
  "admin": true,
  "iat": 1751494086,
  "exp": 1751497686
}

In the above example:

• “sub” stands for subject, and it is commonly set to User ID or some unique data of a user.
• “iat” is the time the token was issued at.
• “exp” is the expiration time of that token.

Signature

The signature part is created by taking the encoded header, encoded payload, a secret, the algorithm specified in the header, and then signing it.

Here, a secret is like a password that only the server knows.

Example:
If you used HMAC SHA256 algorithm, the creation of the signature will look like this:

HMACSHA256(
    base64UrlEncode(header) + “.” + base64UrlEncode(payload), secret)

JWT Example Output

This will generate three Base64-URL strings separated by dots. It will look something like this for the example set above:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTc1MTQ5NDA4NiwiZXhwIjoxNzUxNDk3Njg2fQ.XLD0Tg9wzbv3Y3XgjL3fHpsXlIqCWeoNsiYPvyzVnFk

Below is an oversimplified example of generating and validating JWT in Go, using golang-jwt package.

Generating a JWT in Go

func generateJWT() (string, error) {
	// Create a new token with the specified signing method and claims.
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, // This is the Header (the signing method, and the token type)
		jwt.MapClaims{ // This is the Payload Section.
			"sub":   "1234567890", // These are the claims about an entity - the user.
			"name":  "John Doe",
			"admin": true,
			"iat":   time.Now().Unix(), // These are the metadata of the token (issue date and expiration time).
			"exp":   time.Now().Add(5 * time.Minute).Unix(),
		})

	// Convert the token into a string format.
	tokenString, err := token.SignedString([]byte(JWT_SECRET)) // JWT_SECRET is loaded as an environment variable.
	if err != nil {
		return "", err
	}
	return tokenString, nil
}

Parsing and Validating a JWT in Go

An oversimplified example of a function for parsing and validating a JWT in Go, using golang-jwt:

func parseAndValidateJWT() (jwt.MapClaims, error) {
	// Token string generated from the previous generateJWT() function.
	tokenString := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhZG1pbiI6dHJ1ZSwiZXhwIjoxNzY3MjY0MjkwLCJpYXQiOjE3NjcyNjM5OTAsIm5hbWUiOiJKb2huIERvZSIsInN1YiI6IjEyMzQ1Njc4OTAifQ.qR3WwHotE4u3PrZLCRCkMVsvIOn9rcPW5sLPHdGVbRU"

	// Parse, validate, and verify the signature
	// jwt.Parse takes a token string, and a keyFunc as arguments.
	// The keyFunc should return the cryptographic key, which was used for signing.
	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (any, error) {
		return []byte(JWT_SECRET), nil // JWT_SECRET is loaded as an environment variable.
	}, jwt.WithValidMethods([]string{jwt.SigningMethodHS256.Alg()})) // Validate if 'alg' claimed in the token matches the expected algorithm.

	if err != nil {
		return nil, err
	}

	claims, ok := token.Claims.(jwt.MapClaims)
	if ok {
		return claims, nil
	}
	return nil, fmt.Errorf("Error extracting claims")
}

OAuth - An Authorization Method

OAuth can be understood with this simple problem scenario: Imagine you want to let a photo editor app get access to your facebook’s profile picture. However, you certainly do not want to provide your login credentials to that photo editor app. OAuth comes in to solve problems like these: providing authorization to resources without handing in user credentials.

Getting started with OAuth

All OAuth providers such as Github, Google, and Facebook issue a client ID and client secret to use their OAuth service. As a developer, you need those to get started. Follow the documentation provided on their website to get them.

For example, to get started with using Google’s OAuth service, you can follow this documentation:
Google OAuth 2.0 Documentation

Understanding Implementation with an Example

For an example, let us suppose we have 3 routes: /login, /callback, /profile.

1. /login: Here, using our client ID and secret, we can generate a unique OAuth URL, and redirect the user to that URL - which will take them to the OAuth Provider’s website. While creating the redirect OAuth URL, two important variables state and verifier are created, which are later used in the callback to stay protected from CSRF attacks.

2. /callback: After successful authentication and authorization, the user can be redirected to this route. Here, we can process the redirected callback, and create an account for that user.

3. /profile: This is our protected resource. After a successful account creation in /callback, the user can be redirected here.

In the example, we have set, after a successful login with the OAuth provider, the user is redirected to /callback URL. The redirect URL contains a code parameter, which can be used to get an Access Token from the OAuth provider, which then canb be used to get the user information from the OAuth provider.

NOTE: In OAuth protocol, there are 2 access types. When the access type is set to offline, a Refresh Token is provided in addition to the Access Token. This Refresh Token can be used to generate a new Access Token without re-authenticating the user.

NOTE: To reduce chances of CSRF attack - and to make sure that the browser that started the login is the one finishing it - you can pass a state variable while generating a unique OAuth URL for that user. Then, after a successful login, when the user is returned to /callback (you can have a different URL to handle callback, this is what we have set in our example), you can check if the sent state matches the state that you created. state is generally a random string.

OAuth in Go Example

The following example is implemented in Go, with the official OAuth2 implementation package golang.org/x/oauth2, and the OAuth2 provider package from Google golang.org/x/oauth2/google.

Code comments have been added to explain each section/part, rather than using separate paragraphs for explanation.

NOTE: You will need to add http://localhost:8080/auth/callback to your Authorized redirect URIs section for your project in Google console.

Below is an oversimplified way to get the user’s details through OAuth, and Google OAuth API. It is a single function that creates an OAuth URL, and prints it to the terminal. You can then copy the URL and paste it to your browser, which will take you to Google’s consent and permission page. After successful consent, you will be forwarded to the /callback page, which in this case, will fail, as we have not set up a server yet. From the /callback URL that failed in your browser, copy the value of the code query, and paste it to the terminal. This code will be used to request a token from the OAuth provider (in this case Google). Once the token is received, a request is made to a Google API endpoint to retrieve the public details of the user.

NOTE: The function is meant to show the process in which OAuth works, and does not include any actual routes or server implementation.

func initGoogleOauthConfig() {
	ctx := context.Background()
	// Prepare Config with the information about our server, and OAuth provider.
	conf := &oauth2.Config{
		ClientID:     os.Getenv("CLIENT_ID"),
		ClientSecret: os.Getenv("CLIENT_SECRET"),
		RedirectURL:  "http://localhost:8080/auth/callback",
		Scopes:       []string{"email", "profile"},
		Endpoint:     google.Endpoint,
	}

	// use PKCE to protect against CSRF attacks
	// https://www.ietf.org/archive/id/draft-ietf-oauth-security-topics-22.html#name-countermeasures-6
	//
	// Generate a PKCE code verifier with 32 octets of randomness.
	verifier := oauth2.GenerateVerifier()

	// Create an unique OAuth URL, and redirect user to ask for permission, and consent
	// for the scopes specified above.
	//
	// Below, we are using "state" as the state variable parameter, as an example.
	// Always use a random string in real cases.
	//
	// For the second parameter of AuthCodeURL, we are using AccessTypeOffline to obtain
	// a refresh token, which can then be used to regenerate access tokens.
	//
	// The third argument takes the PKCE verifier that we create above, hashes it using SHA-256,
	// encodes it as Base64 URL. So, the url will contain something like this:
	// &code_challenge=G0XPRtz3fyPcN14e0TmX-Ct2-ZMW_cMssOyoHJ3GBPA
	//
	authUrl := conf.AuthCodeURL("state", oauth2.AccessTypeOffline, oauth2.S256ChallengeOption(verifier))
	fmt.Printf("Visit the URL for the auth dialog: %v", authUrl)

	fmt.Println("")
	fmt.Print("Please copy and paste the code from the redirect URL in the browser: ")

	// Copy the code from the redirect URL in the browser.
	var enterCode string
	// Wait for the user to type in code in the terminal
	if _, err := fmt.Scan(&enterCode); err != nil {
		log.Fatal(err)
	}

	code, err := url.QueryUnescape(enterCode) // decode %2F → /
	if err != nil {
		log.Fatal("Failed to decode code:", err)
	}

	// Send a request to the OAuth provider for the token.
	// Since, we are using PKCE, we have included a VerifierOption as the third argument.
	tok, err := conf.Exchange(ctx, code, oauth2.VerifierOption(verifier))
	if err != nil {
		log.Fatal(err)
	}

	// Attach access token to all the requests that are going to be made.
	client := conf.Client(ctx, tok)

	// Get the user public details from google API endpoint
	resp, err := client.Get("https://www.googleapis.com/oauth2/v2/userinfo")
	if err != nil {
		log.Fatalf("Error: %v \n", err)
	}

	defer resp.Body.Close()

	var v any

	// Read the JSON body using JSON decoder
	err = json.NewDecoder(resp.Body).Decode(&v)
	if err != nil {
		log.Fatalf("Error: %v \n", err)
	}

	// Print all the details of the user
	// (for demonstration only)
	fmt.Printf("%v", v)
}

Unit test

A unit test is a way of testing where the smallest unit of code is tested to see if it works correctly. This smallest part is usually a function, a method, or a code block.

Below is an oversimplified example of a unit test in Go.

Here, we have a function add, and two corresponding unit tests: (1) TestAddPositive, and (2) TestAddNegative.

package main

import "testing"

func add(x, y int) int {
	return x + y
}

func TestAddPositive(t *testing.T) {
	sum := add(2, 3)
	if sum != 5 {
		t.Errorf("\nExpected: %v \nReceived: %v \n", 5, sum)
	}
}

func TestAddNegative(t *testing.T) {
	sum := add(-2, -3)
	if sum != -5 {
		t.Errorf("\nExpected: %v \nReceived: %v \n", 5, sum)
	}
}

Unit tests are a great way to quickly pinpoint to the exact part of the code, when an error occurs, especially during testing. It also helps to quickly catch regression-based bugs, which are bugs that are produced from recent code changes.

Integration test

Integration testing is a way of testing where different components are integrated and tested to see if it works correctly.

Example: Let us say you have 2 functions:
(1) CreateOrder function that creates an order.
(2) SaveOrder function that saves the order to your database.

If you integrate them, and then test them together, that is an integration test. Below is an oversimplified example to demonstrate this:

type Order struct {
	Name  string
	Price float64
}

// A slice of Orders to simulate a database.
var orders []Order

// createOrder creates an instance of an Order.
func createOrder() Order {
	return Order{
		Name:  "Headphone",
		Price: 50.00,
	}
}

// saveOrder appends it to the 'orders' slice.
// It simulates a database for this example.
func saveOrder(o Order) {
	orders = append(orders, o)
}

func TestCreateAndSaveOrder(t *testing.T) {
	order := createOrder()
	saveOrder(order)

	if len(orders) < 0 {
		t.Errorf("Order did not get saved correctly.")
	}

	if orders[0] != order {
		t.Errorf("\nExpected: %v \nReceived: %v \n", order, orders[0])
	}
}

End-to-End Test

The end-to-end test is best understood with an example. Imagine, you have a Login webpage for your website, and you want to test it. Here, in this case, the end-to-end test will be written in a way such that login details are automatically filled, and the login button is automatically clicked. In other words, the interaction with that webpage is done just like a real user. Furthermore, the end-to-end test will ensure that interaction with the error messages, responses, url redirects, database updates, etc are all done correctly, and automatically.

To achieve this kind of testing, tools like “Selenium” are commonly used. “Selenium” can drive a web browser natively, just like a user would.

Below is an official link from Selenium to get you started:
https://www.selenium.dev/documentation/webdriver/getting_started/

What is a primary key?
A primary key is a column in a table that uniquely identifies each row. In the example presented below, the id column is a primary key for the table “Users”.

An example of a table (called Users) in a relational database:

A column containing unique numeric values (integers) are generally used as a primary key because RDBMs systems can process them more quickly.

What is a foreign key?
A foreign key in one table refers to the primary key of another table and is used to link between the tables.

An example of a table called Orders, showing a foreign key:

Transactions in a relational database
Relational databases are associated with transactional databases, and it is an important concept to understand. A transaction in a database is a series of operations that are performed as if they are one single operation. Either all of them are saved in the database after they are performed, or none of them are saved.

An easy to understand example is a transaction in a banking system. Let us say, A is transferring money to B.

Steps in which that happens:

1. A transfers $5 to B, so $5 is deducted from A’s account.
2. In the second step, $5 is added to B’s account.

This is where a transaction comes in: either results from both of these actions are saved, or none of them are saved. If a connection error or server outage would happen in between, the database would cancel the transaction: no action would be saved.

The properties of transactions are represented by the acronym ACID. These properties are explained below:

Atomic: All changes are performed as a single operation, and either all of the operations are performed and saved, or none of them are.

Consistency: Database stays in a correct state before and after a transaction.

Isolation: Each transaction is isolated, so it acts like only one transaction is happening at a time.

Durability: After a successful transaction, data persists, even in the event of a system failure.

What is a RDBMS (Relational Database Management System)?
RDBMS is the underlying software that manages relational databases, organizing data into rows and columns, and allowing users to perform CRUD (Create, Ready, Update, Delete) operations on it. Examples: MySQL, PostgreSQL, Oracle, etc.

What is SQL?
SQL (Structured Query Language) is the standard programming language used for interacting with RDBMSs. SQL queries allow an easy way to perform CRUD operations over a relational database.

Below is an intro to SQL, with simple examples:
NOTE: The following examples were run in PostgreSQL.

Create a table:
Define a table, and its structure

CREATE TABLE users (
user_id serial primary key,  
name varchar(80), 
email varchar(255) unique 
);

This creates a “users” table with three columns: user_id, name, and email.
serial: indicates primary key for users, and “serial” indicates autoincrementing four-byte integer
varchar(n): variable length char string of length n.

Remove a table:

DROP TABLE users;

Populate a table with rows:

INSERT INTO users(name, email)
VALUES (‘john’, ‘john22@gmail.com’);

The above statement adds a new row to the users table with name ‘john’, and email ‘john22@gmail.com’.

Querying a table:

SELECT * FROM users;

‘*’ is a shorthand for all columns.

Output:

 user_id | name |      email       
---------+------+------------------
       1 | John   |    john22@gmail.com
(1 row)

NOTE: SELECT * is considered bad in production code, because adding a column would affect/change the results.

So if you wanted just the column “name”, you could do:

SELECT name FROM users;

Output:

name 
------
John
(1 row)

To get more than one column, use comma:

SELECT name, email FROM users;

Output:

name  |      email       
------+------------------
 John | john22@gmail.com
(1 row)

To introduce new SQL keywords – AS, WHERE, and ORDER BY – I have prepared a new table with new data.

      name      | price  | discount 
----------------+--------+----------
 Iphone 8       | 500.00 |    10.00
 Ipad           | 300.00 |    20.00
 Acer monitor   | 200.00 |    33.00
 Magni Keyboard | 200.00 |    33.00
(4 rows)

AS Keyword:
For the table above, you can write an expression that applies a discount to the current price, and then returns the product and the new discounted price as “discount price”, using the “AS” keyword.

SELECT name, ROUND(price - ((discount / 100) * price)) AS discount_price 
FROM products;

Output:

      name      | discount_price 
----------------+----------------
 Iphone 8       |            450
 Ipad           |            240
 Acer monitor   |            134
 Magni Keyboard |            134
(4 rows)

WHERE:
WHERE can be used to retrieve only those rows that satisfy your mentioned conditions.
Example:

SELECT name, price 
FROM products 
WHERE price <= 200;

Output:

      name      | price  
----------------+--------
 Acer monitor   | 200.00
 Magni Keyboard | 200.00
(2 rows)

ORDER BY:
You can use ORDER BY to retrieve your results in a sorted order.
Example shows retrieving the products sorted according to the price.

SELECT name, price 
FROM products 
ORDER BY price;

Output:

      name      | price  
----------------+--------
 Acer monitor   | 200.00
 Magni Keyboard | 200.00
 Ipad           | 300.00
 Iphone 8       | 500.00
(4 rows)

JOIN:
JOIN allows you to combine rows from two or more tables, based on a column related between them.
Example:

Users table

 user_id | name |      email       
---------+------+------------------
       1 | John | john22@gmail.com
(1 row)

Orders table

 order_id | customer_id | order_date 
----------+-------------+------------
        1 |           1 | 2025-12-27
(1 row)

Join operation:

SELECT u.user_id, u.name, u.email, o.order_id, o.order_date 
FROM users u 
JOIN orders o 
ON u.user_id = o.customer_id;

In the above example we have introduced aliases by relabeling u for users and o for orders.

Output:

 user_id | name |      email       | order_id | order_date 
---------+------+------------------+----------+------------
       1 | John | john22@gmail.com |        1 | 2025-12-27
(1 row)

Join by default is INNER JOIN. Here, INNER JOIN returns only those users that actually have an order.

If we wanted all the users – even those users who did not have an order – we would use LEFT JOIN.
Example query and output:

select * from users u 
LEFT JOIN orders o 
ON u.user_id = o.customer_id;

Output:

 user_id | name |      email       | order_id | customer_id | order_date 
---------+------+------------------+----------+-------------+------------
       1 | John | john22@gmail.com |        1 |           1 | 2025-12-27
       2 | Ren  | ren212@gmail.com |          |             | 
(2 rows)

Aggregate functions:
An aggregate function calculates a single result from multiple input rows. Examples of aggregate functions, and their use cases are mentioned below:

COUNT(): Count returns the number of rows.

COUNT(*) -> Returns total number of rows for that table, including rows that have null values.

Example query:

SELECT COUNT(*) FROM products;

Output:

 count 
-------
     4
(1 row)

COUNT(column_name) -> Returns total number of rows, excluding rows where that column is null.

Example query:

SELECT COUNT(price) FROM products;

SUM(): Returns the total sum of a column from the selected table.

Example query:

SELECT SUM(price) FROM products;

Output:

   sum   
---------
 1200.00
(1 row)

AVG(): Returns the average value of a column from the selected table.

Example query:

SELECT ROUND(AVG(price)) FROM products;

Output:

 round 
-------
   300
(1 row)

MIN(): Returns the smallest value of a column from the selected table.

Example query:

SELECT MIN(price) FROM products;

Output:

  min   
--------
 200.00
(1 row)

MAX(): Returns the largest value of a column from the selected table.

Example query:

SELECT MAX(price) FROM products;

Output:

  max   
--------
 500.00
(1 row)

Sub-queries:

The above queries that utilised aggregate functions MAX and MIN only provided one value from the column that we asked. What if I want all the columns or specific columns from that specific row with the smallest value or the max value? This is where sub-queries come in to help.

Example:
I want name, price, and discount columns for rows that have the smallest price. I can do a query like this:

SELECT name, price, discount 
FROM products 
WHERE price = (SELECT MIN(price) FROM products); -- This is a sub query.

Output:

      name      | price  | discount 
----------------+--------+----------
 Acer monitor   | 200.00 |    33.00
 Magni Keyboard | 200.00 |    33.00
(2 rows)

The query at the end, within the brackets, is our sub-query.

Similarly, if we wanted the row with the max price, we could do something like this:

SELECT name, price, discount 
FROM products 
WHERE price = (SELECT MAX(price) FROM products);

Output:

   name   | price  | discount 
----------+--------+----------
 Iphone 8 | 500.00 |    10.00
(1 row)

GROUP BY:

For tables with multiple rows that have some common column values, such as the name of the student in the scores table, GROUP BY groups those rows first, and then applies your aggregate function. GROUP BY is often used with aggregate functions.

Example of a scores table:

 name  | score |      course      
-------+-------+------------------
 Ren   |    92 | Chemistry
 Nancy |    85 | Physics
 Nancy |    91 | Biology
 Ren   |    84 | Biology
 Linus |    95 | Computer Science
 Linus |    99 | Mathematics
(6 rows)

Let us say, we want the average score of each student. We could do something like this:

SELECT name, ROUND(AVG(score)) 
FROM scores 
GROUP BY name;

Output:

 name  | avg 
-------+-----
 Nancy |  88
 Linus |  97
 Ren   |  88
(3 rows)

Here, GROUP BY first groups the students according to the name, and then the aggregate function is applied.

NOTE: First GROUP BY is executed, which groups the rows according to the same values of the specified column, and then the aggregate function is executed on top of those grouped rows.

HAVING:

Having can be used to filter rows that are grouped and aggregated. In other words, in a SQL query, “HAVING” is executed only after GROUP BY and an aggregation function is executed.

For example, we can use the SQL query we wrote above, to return only those rows where the average score is greater than 90:

SELECT name, ROUND(AVG(score)) AS avg 
FROM scores 
GROUP BY name 
HAVING ROUND(AVG(score)) >= 90;

Output:

 name  | avg 
-------+-----
 Linus |  97
(1 row)

FILTER:

Filter is a pre-aggregation method, meaning, it runs before aggregation is executed. It runs after grouping is executed, and allows you to apply aggregation only on the certain rows, according to your specifications.

While writing a query, FILTER expects to be followed by an aggregation function.

Let us say, we want the total number of courses where each student has achieved greater than 95, we could do something like this:

SELECT name, COUNT(*) 
FILTER (WHERE score > 95) 
FROM scores 
GROUP BY name;

Output:

 name  | count 
-------+-------
 Nancy |     0
 Linus |     1
 Ren   |     0
(3 rows)

Here, grouping is done first, and then the aggregation function COUNT(*) is applied only on those rows where the filter condition matches.

UPDATES:

UPDATE allows you to update existing rows in a table.

Let us apply this to our ‘scores’ table again.

Original scores table:

 name  | score |      course      
-------+-------+------------------
 Ren   |    92 | Chemistry
 Nancy |    85 | Physics
 Nancy |    91 | Biology
 Ren   |    84 | Biology
 Linus |    95 | Computer Science
 Linus |    99 | Mathematics
(6 rows)

For our scores table, let us say, we want to update the name of “Ren” to “Renu”.

UPDATE scores 
SET name = 'Renu' 
WHERE name = 'Ren';

Updated scores table:

 name  | score |      course      
-------+-------+------------------
 Nancy |    85 | Physics
 Nancy |    91 | Biology
 Linus |    95 | Computer Science
 Linus |    99 | Mathematics
 Renu  |    92 | Chemistry
 Renu  |    84 | Biology
(6 rows)

Delete:

Delete allows you to delete existing rows from a table.

NOTE: Delete commands do not ask for confirmation, so you must be careful when executing them.

Example: To delete all the rows of “Nancy”, we could do something like this:

DELETE FROM scores 
WHERE name = 'Nancy';

Transactions:

Like explained on the top of this post, a transaction in a database is a series of operations that are performed as if they are one single operation. Either all of them are saved in the database after they are performed, or none of them are saved.

In PostgreSQL, BEGIN and COMMIT commands are used to set up a transaction.
All the SQL commands of a transaction are surrounded by BEGIN and COMMIT commands.

To proceed, an example of an accounts table has been created.

Original accounts table:

 name | balance 
------+---------
 A    |  100.00
 B    |  100.00
(2 rows)

Here, we will:

• Deduct 100 from A’s account balance.
• Add 100 to B’s account balance.

Example query:

BEGIN;                 

UPDATE accounts SET balance = balance - 100.00 
WHERE name = 'A' AND balance > 100;

UPDATE accounts SET balance = balance + 100.00 
WHERE name = 'B';

COMMIT;

If the server had crashed after the first update, then on restart, the database would roll back the transaction.

In the above query, if account ‘A’ did not have enough balance, the first query would not update any rows. However, the second query would still run and credit B’s account with 100. Despite no rows being updated from the first query, it would still be regarded as a valid transaction. You can check for errors or perform validation during the transaction, and can abort the transaction using ROLLBACK.

Rollbacks are generally explicitly initiated from the backend if a validation or a conditional check fails during mid-transaction.

Below is an over-simplified example where the transaction is set to roll back if any validation fails or if an error occurs. The example below is written in Go, for the accounts table that was shown in the previous example.

Go Code Example:

func transferMoney() {
	tx, err := db.Begin()
	if err != nil {
		log.Printf("Error: %v \n", err)
		return
	}
	defer tx.Rollback() // defer a roll back in case anything fails.

	var balance float64 // Get the current balance of account A.
	if err := tx.QueryRow("SELECT balance FROM accounts WHERE name = 'A'").Scan(&balance); err != nil {
		if err == sql.ErrNoRows { // Confirm that the account exists.
			log.Printf("Account 'A' does not exist.")
			return
		}
	}

	if balance < 100 {
		log.Printf("Account 'A' has insufficient balance.")
		return
	}

	// Debit 100 from account A.
	_, err = tx.Exec("UPDATE accounts SET balance = balance - 100 WHERE name = 'A'")
	if err != nil {
		log.Printf("Error: %v \n", err)
		return
	}

	// Credit 100 from account B.
	_, err = tx.Exec("UPDATE accounts SET balance = balance + 100 WHERE name = 'B'")
	if err != nil {
		log.Printf("Error: %v \n", err)
		return
	}

	// Commit the transaction.
	if err := tx.Commit(); err != nil {
		log.Printf("Error: %v \n", err)
		return
	}
}

Indexes:

Indexes allow you to retrieve data more quickly. Think of it as an index in a book.

Indexes can be made using the CREATE INDEX statement.

Example of creating an index on id for the products table:

CREATE INDEX product_id ON products(id);

NOTE: For a table with a small number of rows, the database decides to scan the whole table instead of using an index.

NOTE: Although indexes make reading/querying faster, updating/writing processes on that table will take longer. This is because indexes will also need an update.

How do you see if the index is being used?

• Use the EXPLAIN keyword

EXPLAIN SELECT * FROM products WHERE id = 5;

You will get an output, similar to this:

                                 QUERY PLAN                                 
----------------------------------------------------------------------------
 Index Scan using product_id on products  (cost=0.29..8.31 rows=1 width=19)
   Index Cond: (id = 5)
(2 rows)

A simple example:

• In the first step, you execute a query to get a list of users.
• In the second step, you make individual queries to get a list of orders for each single user.

Situations like these are exactly where N+1 query problems occur. You may think that making many small queries would be faster than making a single large query. However, the opposite is the truth: making a large single query is usually faster than many small queries.

An oversimplified code for the above example in Go (with PostgreSQL) can be found below:

Bad Example:

// Bad way to make queries; results in N+1 query problem.
func getOrdersForEachUser() ([]CustomerOrder, error) {
	var customerOrders []CustomerOrder
	// Get all the users, and their info.
	userRows, err := db.Query("SELECT * FROM users;")
	if err != nil {
		return nil, err
		// NOTE: Handle errors gracefully in your code. This function is only an oversimplified example.
	}
	defer userRows.Close()
	// For each row get the user id, and query for all the orders of that user.
	for userRows.Next() {
		var u User
		if err := userRows.Scan(&u.User_id, &u.Name, &u.Email); err != nil {
			return nil, err
			// NOTE: Handle errors gracefully in your code. This function is only an oversimplified example.
		}
		// Get all the orders of that user.
		orderRows, err := db.Query("SELECT * FROM orders WHERE customer_id = $1;", u.User_id)
		if err != nil {
			return nil, err
			// NOTE: Handle errors gracefully in your code. This function is only an oversimplified example.
		}
		c := CustomerOrder{
			User:   u,
			Orders: []Order{},
		}
		defer orderRows.Close()
		for orderRows.Next() {
			var o Order
			if err := orderRows.Scan(&o.Order_id, &o.Customer_id, &o.Order_date); err != nil {
				return nil, err
				// NOTE: Handle errors gracefully in your code. This function is only an oversimplified example.
			}
			c.Orders = append(c.Orders, o)
		}
		customerOrders = append(customerOrders, c)
	}
	return customerOrders, nil
}

The above example shows a bad approach, leading to N+1 problem.

The Better Approach

A better approach would be to use a single query. In this case, a LEFT JOIN operation could easily solve this with a single sql query.

There are multiple ways to do this too, this is just one of the ways:

SELECT u.user_id, u.name, u.email, o.order_id, o.order_date 
FROM users u 
LEFT JOIN orders o 
ON u.user_id = o.customer_id;

One of the ways to do this with an oversimplified example in Go (with PostgreSQL) can be found below:

// One of the good ways to do this: using a single SQL query.
func getOrdersForEachUser() ([]CustomerOrder, error) {
	customerOrdersMap := make(map[int]*CustomerOrder)
	// Make a single query.
	rows, err := db.Query(`
	SELECT u.user_id, u.name, u.email, o.order_id, o.order_date 
	FROM users u 
	LEFT JOIN orders o 
	ON u.user_id = o.customer_id;`)

	if err != nil {
		return nil, err
		// NOTE: Handle errors gracefully in your code. This function is only an oversimplified example.
	}
	defer rows.Close()

	for rows.Next() {
		var u User
		var o Order
		if err := rows.Scan(&u.User_id, &u.Name, &u.Email, &o.Order_id, &o.Order_date); err != nil {
			return nil, err
			// NOTE: Handle errors gracefully in your code. This function is only an oversimplified example.
		}
		// Check if this is the first time adding this user to the customerOrdersMap.
		if _, exists := customerOrdersMap[u.User_id]; !exists {
			customerOrdersMap[u.User_id] = &CustomerOrder{
				User:   u,
				Orders: []Order{},
			}
		}
		customerOrdersMap[u.User_id].Orders = append(customerOrdersMap[u.User_id].Orders, o)
	}

	customerOrders := []CustomerOrder{}
	for _, co := range customerOrdersMap {
		customerOrders = append(customerOrders, *co)
	}
	return customerOrders, nil
}

Conclusion

Writing your code such that you have a single query that returns all the data you need, instead of executing multiple small queries, can make your reads significantly faster and more efficient.

What is REST?
REST stands for Representational State Transfer; it is a set of rules for designing web APIs where data is treated as resources, and HTTP Methods like GET, PUT, POST, and DELETE are used to access them.

What is an API?
API stands for Application Programming Interface; it is a way through which different systems can communicate with each other. API lets you share your resources while maintaining security and control.

For RESTful APIs, JSON is usually used as a file format to transfer the information from client to server, and vice versa. This allows RESTful APIs to provide platform independence.

In REST APIs, HTTP methods are used to perform the fundamental data management operations: CRUD (Create, Read, Update, and Delete). Corresponding HTTP methods that are used to perform those operations are mentioned below:

Designing RESTful APIs correctly:

REST APIs are designed around resources (data), and each resource is represented by a URI (Uniform Resource Identifier) that uniquely identifies that resource.

Example of a particular user:

https://api.bypress.com/users/1

Follow the guidelines mentioned below to correctly design APIs:

• Name URIS on nouns (the resource) and not on verbs (the operations on the resource).

  The HTTP methods such as GET, POST, PUT, DELETE, etc imply the verbal action. That is why, adding operation names to URIs are unnecessary.

  Correct and good examples:

    https://api.bypress.com/accounts  // Good
    https://api.bypress.com/reactions // Good
    https://api.bypress.com/reminders // Good
  

  Avoid representing operations, and avoid using verbs in URIs. Bad examples that you should avoid:

    https://api.bypress.com/get-accounts    // Bad
    https://api.bypress.com/post-reaction   // Bad
    https://api.bypress.com/remove-reminder // Bad
  

• Plural nouns should be used to name collection URIs.

  Examples:

    /accounts // Good
    /users    // Good
    /orders   // Good
  

• Avoid URIs that include several levels of relationships.

  Example:

    /accounts/1/posts/22/comments // Avoid this: this is bad.
  

  The example mentioned above is hard to maintain. Instead, follow these steps:

  1. Get all the posts for account 1.

       /accounts/1/posts
     

  2. Then, get all the comments for that post.

       /posts/22/comments
     

• Avoid creating a large number of APIs that respond with smaller resources.

  In other words, have a smaller number of APIs. This small set of APIs should combine related information, create a bigger resource, and then return them via a single request. But be careful not to take it to its extreme, and keep it balanced, as unnecessary fetching will increase latency and bandwidth costs.

  Bad Example:

    /users/1
    /users/1/address
    /users/1/contact
  

  Instead of creating 3 different APIs to get basic user information, you should return all these details through a single API:

    /users/1
  

• Implement data pagination and filtering:

  Data pagination:

  • In RESTful APIs, pagination is a technique of dividing large datasets into smaller chunks.

  • To achieve this, query parameters like limit (to specify the number of items to return), and offset (to specify the starting index) are generally used.

    Example:

      GET /posts?limit=10&offset=5
    

    Note: Implement max-limit to prevent server overload.

  Filtering:

  • Filtering allows clients to request only the data that they are interested in.

    Example:

      GET /posts?status=hidden&edited=true
    

  These techniques improve performance, and allow clients to retrieve only the subset of data that they need.

• Implement API versioning:

  • API versioning allows you to update/change your API over time without breaking existing clients.

  • One of the most common ways to achieve this is through URI versioning: adding v1, v2, v3, etc to your URI.

    Examples:

      https://api.bypress.com/v1/accounts
      https://api.bypress.com/v2/accounts // Respond with different resources.
      https://api.bypress.com/v3/accounts // Respond with different resources.
    

Declaring variables of different types:

var i int
var s string
var b byte
var bo bool         // Boolean: true or false
var ch rune         // Go's equivalent of a single character.
var sSlice []string // This creates a slice of strings.
var sArr [3]string  // This creates an array with a length of 3 strings.
var mp map[string]int // Creates a map with string type as key, and int type as value.

Note: For the map declared above, when doing write operations, Go panics: panic: assignment to entry in nil map. So an initialization is required before the first write.

Either mp = map[string]int{} or mp = make(map[string]int) will work.

Constants

const n = 20 // Go supports untyped constants.
const num int = 5
const str string = "const"
const st = "this is a string"

Declaration/Initialisations that are only valid inside a function.

func declare() { // All functions start with "func" keyword.
	str := "" // This way of initialization is only valid inside a function.
	num := 3
	isTrue := true
	c := 'a'                    // creates a rune
	s := []string{}             // creates a slice of string type.
	hashMap := map[string]int{} // Creates a map of string as key, and int as value.
}

Note: In Golang, all declared variables must be used, else compiler will throw an error.
Example of the error: declared and not used: str

Functions

In Golang, functions are declared using the func keyword. Below a and b are parameters with an int type.

func add(a int, b int) int { // int indicates the type of the return value.
	// function parameters of the same type can also be written like this:
	// func add(a , b int) int {
	return a + b
}

func nums() (int, int) { // A way to indicate multiple return values/types.
	return 3, 4
}

NOTE: Function names that start with lowercase (example: func add()) act like private methods of a package. And function names that start with an uppercase (example: func Add()) act like public methods, and are automatically exported.

Variadic functions

Variadic functions can accept a variable number of arguments. In Go, three dots(…) followed by a type, is used as a parameter to signify a variadic function.

func variadic(nums ...int) {
	sum := 0
	for _, n := range nums {
		sum += n
	}
	fmt.Println(sum)
}

variadic(3, 4, 5)
variadic(1,2)

Defer

An important concept/keyword to understand when learning functions in golang is the concept of “defer”. defer works quite similar to what it means: it puts off an event to a later time. defer runs just before the function returns.

func deferExample() {
	defer fmt.Println("print this later") // prints this later, when the function is about to return.  
	fmt.Println("print this now")         // prints this first.
}

Slice methods

func sliceMethods() {
 	arr := []int{1, 2, 3, 4}
 	arr = append(arr, 5) // appending to a slice
 	val := arr[0]        // getting the value at 0th index
 	arr[2] = 4           // setting the value as 4 at 2nd index of the slice.

 	// Create a new slice from a specific range of the original slice.
 	newSlice := arr[0:2]    // Here, 0 is start index, 2 is end index. Value at 2nd index is not included.
 	length := len(newSlice) // len() gives the length of the slice.
}

Map methods

func mapMethods() {
 	mp := map[string]int{}
 	mp["a"] = 1               // set a key/value
 	if v, ok := mp["a"]; ok { // checks if the key exists.
 		// do something with the value.
 	}
 	delete(mp, "a")   // deletes "a" from the map "mp"
 	clear(mp)         // deletes all entries from the map.
 	length := len(mp) // Total number of entries in the map.
}

Loops

In Golang, loops are done using the for and range keyword

func loops() {
	for i := 0; i < 5; i++ {
		// do something
	}

	n := 5
	for range n { // range lets you loop over things easily.
		// do something
	}

	// An infinite loop, similar to "while" from other languages.
	for {
		if n > 5 {
			break
		}
	}

	arr := []int{1, 2, 3, 4}
	for idx, val := range arr {
		// here idx is an index of the current item in arr.
		// val is the value at that index.
	}

	mp := map[string]int{
		"a": 0,
		"b": 1,
	}

	for k, v := range mp {
		// k: key, v: value
	}
}

Conditionals:

if/else statements

func conditionals() {
	a := 0
	b := 1
	if a < b {
		// do something
	} else if b > a {
		// do something
	} else {
		// do something
	}
}

Switch/case

func cases() {
	a := 5
	switch a {
	case 6:
	// do something if a == 6
	case 7:
	// do something if a == 7
	default:
	// by default do this, if other cases do not match.
	}
}

Pointers and references

func pointer() {
	num := 4
	p := &num
	fmt.Println(p) // prints the memory address of num.
}

func changeValue() {
	num := 4
	passWithoutPointerAndChange(num)
	fmt.Println(num)               // still prints 4
	passWithPointerAndChange(&num) // This changes the value to 5.
	// When passed with the pointer, it modifies the value at that address.
	fmt.Println(num) // now prints 5

	// Same applies to other data types.
	arr := []int{}
	tryChangingArrWithoutPointer(arr)
	fmt.Println(arr) // prints an empty slice [].
	tryChangingArrWithPointer(&arr)
	fmt.Println(arr) // prints [3].
}

func passWithoutPointerAndChange(num int) {
	num = 5 // change is made to the copy, not the original
}

func passWithPointerAndChange(num *int) {
	// * is used infront of num to dereference the pointer.
	// In simple words, go to the memory address stored in num,
	// and give the value that lives there. In this case, 4. 
	*num = 5 // modifies the value at that address.
}

func tryChangingArrWithoutPointer(arr []int) {
	arr = append(arr, 3) // append is used this way in golang.
}

func tryChangingArrWithPointer(arr *[]int) {
	*arr = append(*arr, 3) // append is used this way in golang.
}

Struct

Struct, in easy words, is a way to create your own type with multiple fields.

type Card struct {
	Name   string
	Number string
	CCV    int
}

// Initialize Card.
c := &Card{}

// This is a way to create a method for a struct in Golang.
// Go does not have classes.
func (c *Card) Add() {
	c.Name = "Rob Kim" // struct fields are accessed using a dot
	c.Number = "123456890"
	c.CCV = 532
}

// This can be called like this:
c.Add() // Calls Add method on the card created above.

Interface

In simple words, an interface is a contract that says: any type that has these methods automatically satifies this interface type. In golang, there is no explicit declaration for interfaces.

Below is a simple “Animal” example to showcase interface:

type Animal interface {
	Speak()
}

type Cat struct {
	Name string
}

func (c *Cat) Speak() {
	fmt.Printf("Meow says %s\n", c.Name)
}

type Dog struct {
	Name string
}

func (d *Dog) Speak() {
	fmt.Printf("Woof says %s\n", d.Name)
}

func main() {
	c := &Cat{
		Name: "Zing",
	}

	d := &Dog{
		Name: "Max",
	}
	animals := []Animal{c, d}   // Here, both Cat and Dog have the same method Speak(), which is a method of the Animal interface.
	for _, a := range animals { // The types Cat and Dog satisfy the Animal interface type.
		a.Speak()
	}
}

Generics

Generics allows you to write functions or data structures that work with any data type.

Simple example:

func printSlice[T any](s []T) {
	for _, v := range s {
		fmt.Println(v)
	}
}

// Now you can call this generic function printSlice with any data type. 
nums := []int{1, 2, 3, 4}
printSlice(nums)

s := []string{"a", "b", "c"}
printSlice(s)

Concurrency/Goroutines:

Goroutines are a way to handle concurrent tasks in Go. It allows multiple tasks to be executed at the same time without blocking each other.

func add() {
	time.Sleep(2 * time.Second)
	fmt.Println("Adding completed")
}

func subs() {
	time.Sleep(2 * time.Second)
	fmt.Println("Subtracting completed")
}

go add()
go subs()
fmt.Println("I could be doing something else while my goroutines are executing concurrently")
time.Sleep(3 * time.Second) // This is to not let the main function return immediately. 

NOTE: In a real case, if the above code did not have time.Sleep(3 * time.Second) on the last line, the main function would return immediately after printing the last line, instead of waiting for all the goroutines to finish. To deal with this, either channels, or a sync package is generally used in real case scenarios.

Channels

In easy to understand words, a channel is like a pipe through which multiple goroutines can share data, without worrying about mutex locks, or deadlocks.

func main() {
	ch := make(chan int, 2) // Makes a channel of buffer length 2, that can hold data of type int.
	// ch := make(chan int) // You could write this too. This would create a channel without any specific length/size.  
	go add(5, 4, ch)
	go add(2, 5, ch)

	res1 := <-ch // receive the value from the channel, and assign it to res1. The program waits here, until it receives the value.
	res2 := <-ch // receive the value from the channel

	fmt.Println(res1)
	fmt.Println(res2)
}

func add(a, b int, ch chan int) {
	time.Sleep(2 * time.Second)
	ch <- a + b // send the value to the channel
}

Mutex

Mutex is a mutual exclusion lock.

Example use case: Mutex is generally used to update a shared slice across multiple goroutines.

Mutex, and other items from the sync package are generally used together. These include: WaitGroup and its methods. This is a way in Go to avoid deadlocks, and race conditions.

A simple example is shown below:

import (
	"fmt"
	"sync"
	"time"
)

type Res struct {
	values []int
	mu     sync.Mutex // To ensure only one goroutine access this resource at a time.
}

func NewRes() *Res {
	return &Res{
		values: []int{},
	}
}

func main() {
	var wg sync.WaitGroup // A way to wait for all goroutines to finish their tasks.

	r := NewRes()
	wg.Add(2) // Add goroutines to the wait group.
	go add(5, 4, r, &wg)
	go add(1, 3, r, &wg)
	wg.Wait() // Wait for all the goroutines to finish their tasks.
	for _, v := range r.values {
		fmt.Println(v)
	}
}

func add(a, b int, r *Res, wg *sync.WaitGroup) {
	defer wg.Done() // Mark this goroutine as done, when this function is about to returns.
	time.Sleep(2 * time.Second)
	sum := a + b
	r.mu.Lock() // Lock this resource.
	r.values = append(r.values, sum)
	r.mu.Unlock() // Unlock this resource.
}

The internet is an interconnection of devices and computer systems that are connected through a set of standardized protocols such as IP, and TCP. At the core of the internet, routers are responsible for transferring the data. Data is broken down into smaller chunks called packets, and these packets are first examined by the router, and then transferred from one router to the next, until it arrives at its destination. Routers are responsible for determining the path through which the packets travel.

IP (Internet Protocol) ensures that the packets arrive at the right destination, and TCP (Transmission Control Protocol) ensures that packets are transmitted reliably, and in correct order.

What is a domain name?

A domain name is used to identify a website on the internet. It is a human readable name.

What is DNS?

DNS is the Domain Name System responsible for converting a domain name into an IP address. When you type, let us say, “google.com”, your browser sends a DNS query to a DNS server, which then returns the corresponding IP address, if found. This IP address is used by your browser to create connections with the website/server.

What is an IP address?

An IP address is a unique number used to identify each device on a network, and to route data to the correct destination.

What is HTTP?

HTTP (Hyper Text Transfer Protocol) is a protocol used to transfer data between a client and a server. Example: from a browser to a website, or vice versa.

What is HTTPS?

HTTPS (Hyper Text Transfer Protocol Secure) is a protocol used to provide secure communication between a client and a server. It is an encrypted version of HTTP.

Using a SSL/TLS certificate makes a website HTTPS(secure). This provides encryption; all the data between a browser (client) and server is scrambled. Similarly, authentication is provided; the website/server proves that its authenticity, in other words, it is who it is claiming to be.

TLS (Transport Layer Security) is a modern and upgraded version of SSL (Secure Sockets Layer) that fixes many vulnerabilities of SSL.

Difference between TCP and UDP:

What is a socket?

A socket represents a specific endpoint used for communication. This endpoint is achieved by combining IP address and a port number.

Conclusion

Though there are plenty of concepts that have not been covered here, the concepts described above provide an introduction to the fundamentals in short and easy to understand words.