DEV Community: Ujjwal Goyal

Deploy Hugo website using Github pages

Ujjwal Goyal — Mon, 27 Sep 2021 09:33:08 +0000

Hugo is one of the most widely used static site generators, and I found it to be a great tool to build my website. I knew about Github pages providing a custom domain for each account, so I chose it to deploy my website. Here's how you can deploy your Hugo website using Github pages as well.

Setting up the repositories

Build your Hugo website (if you're not familiar with the tool, here's the official quickstart guide). Push the complete website folder to a Github repository.
This is our source repository, containing the Hugo source files. It can be either public or private, but I would recommend to keep it private.

Next, create a Github repository named <your-username>.github.io, where <your-username> should be replaced by your Github account username (see Github pages).
This will be the URL for your website once deployed. This repository should be public.

In your source repository, in config.toml, add a baseurl field with your website URL.
For example:
baseurl = "https://importhuman.github.io"

Github workflow for deploying website

We need to add a Github workflow to our source repository, so the static pages are deployed to the public repository and our website can be viewed.

In the source repo, add the following workflow (with modifications, detailed below) in the .github/workflows folder.

name: Github Pages

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  deploy:
    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: true  # Fetch Hugo themes (true OR recursive)
          fetch-depth: 0    # Fetch all history for .GitInfo and .Lastmod

      - name: Setup Hugo
        uses: peaceiris/actions-hugo@v2
        with:
          hugo-version: '0.83.0'

      - name: Build
        run: hugo --minify

      - name: Deploy
        uses: peaceiris/actions-gh-pages@v3
        with:
          deploy_key: ${{ secrets.PRIVATE_KEY }}
          external_repository: <username/username.github.io>
          publish_dir: ./public

"on" is the Github event that triggers the workflow. Here, it is triggered when a commit is pushed to the main branch, or a pull request is made.
"hugo-version" specifies the Hugo version you want to build your website with. Here, it is '0.83.0'.
The "deploy_key" field is required to deploy from our source repo to public repo (Detailed steps below).
"external_repository" is the path to your public repo. In my case, it is importhuman/importhuman.github.io. It is important to include the username.
"publish_dir" is the folder that contains the files we want to deploy. By default, static files in Hugo are stored in the ./public folder on running hugo -D. If you have modified this in your configuration, make the corresponding change in the workflow.

For more information about the actions used and their options, please see Hugo and Github pages on Github.

Adding keys

After adding the workflow and pushing to Github, we need to add keys to allow the workflow to run.

In the command line, run the following command to generate a pair of keys:

ssh-keygen -t rsa -b 4096 -C "$(git config user.email)" -f deployment -N ""

This will create private and public keys in files named deployment and deployment.pub respectively.

(This command uses the global git email on the computer. If you haven't set it before, you can do so by running git config --global user.email "youremail@yourdomain.com", or simply generate the keys by replacing $(git config user.email) with your email directly.)

Copy the private key from deployment, and in the Github source repository, navigate to Settings > Secrets > New repository secret. Add the private key and save it as PRIVATE_KEY. This is what we've referred to in our workflow.

Next, copy the public key from deployment.pub, and in the Github public repository, navigate to Settings > Deploy keys > Add deploy key. Add the public key and save it as PUBLIC_KEY.

(Source: bodunhu.com)

Other settings and configurations

By default, Github pages use Jekyll for building websites. To prevent this, add a .nojekyll file (blank, no content needed) in the public repository.

Finally, in the Github public repository, navigate to Settings > Pages. In the 'Source' section, select the gh-pages branch and / (root) folder and save.

And you're all set! Now pushing a commit or opening a PR on the source repo should automatically reflect the changes on your website!

Feel free to reach out in the comments or on Twitter if you have any doubts or issues :)

Pushing and running Docker images

Ujjwal Goyal — Thu, 24 Jun 2021 18:54:47 +0000

(This post assumes you have a DockerHub account.)

In the previous post, we built a Docker image. Now, we're going to "push", or upload it to DockerHub, and also see how to run it in a container!

DockerHub

DockerHub is a library for container images. By pushing our image (with an appropriate tag), we can make our image available to others (or keep it private if we so require), or use the same image on different systems.

Before we can push our image, we need to give a proper name to it. This name will include our DockerHub username, the image name, and a version tag.
Consider a local image named "python-helloworld". We run the following command.

docker tag python-helloworld importhuman/python-helloworld:v1.0.0

Let's break this down. With the docker tag command, we take our local image, python-helloworld, and give it the name importhuman/python-helloworld:v1.0.0. Here,

importhuman is the name of my DockerHub account. This is needed to decide which account the image is pushed to. Replace this with your account name.
python-helloworld is the image I want to push. This is also the name that will be given to the DockerHub repository. Replace this with the name you gave your image (see previous post in this series).
v1.0.0 is the tag name. Tags are used to version images.

Now, if we run docker images, we should see both our local image and the newly tagged image.

(If you haven't logged in to DockerHub in the terminal, run docker login, and input your username and password.)

To push the image, we simply run

docker push importhuman/python-helloworld:v1.0.0

and we should have a new repository on DockerHub with our newly tagged image!

To pull this image to our system, we would simply run
docker pull importhuman/python-helloworld:v1.0.0

Running the image

Let's see the command to run our image in a container, and then we'll break it down.

docker run -d -p 8080:5000 importhuman/python-helloworld:v1.0.0

-d runs the container in "detached mode". This essentially starts the container while leaving you free to run other commands in the terminal window. Without this flag (foreground mode), the terminal attaches to the process’s standard input, output, and standard error. (Source: Docker)
-p 8080:5000 specifies that host port 8080 is connected to container port 5000. The container port here is 5000 as it is the default port exposed by Flask. Thus, if we open "localhost:8080" in a browser, we'll see the expected "Hello World!" output.
importhuman/python-helloworld:v1.0.0 is the image we want to run in a container (a local image can be used rather than the tagged version as well).

(For more information on the above explanation, or on running images in Docker containers, please see here)

To see more information about currently running containers, run
docker ps

To stop a running container, run the command
docker stop <container-id>
OR
docker stop <container-name>

Congratulations! You now know how to

tag Docker images
push and pull Docker images from DockerHub
run Docker images in containers

Please feel free to ask any questions you have in the comments or on Twitter.

Writing Dockerfiles for Python application

Ujjwal Goyal — Wed, 16 Jun 2021 15:21:45 +0000

Note: The original code is from Udacity's Cloud Native Fundamentals Nanodegree Scholarship Program. The referenced files can be found here.

This post does not provide instructions on installing Docker. For assistance, please refer here.

In this post we're going to go through the process of running a simple Python web app on a container. But, what is a container?

Containers

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. (Source: Docker)

As containers run on the same operating system, they require fewer resources than virtual machines. (Source: Wikipedia)

Python application

Let's start with a simple Python web application that serves a single endpoint. We save this file as app.py.

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World"

if __name__ == "__main__":
    app.run(host='0.0.0.0')

On running the command python3 app.py, we can open our browser and on checking http://0.0.0.0:5000/ (or http://localhost:5000/), we get a simple web page with the text "Hello World"!!

(We use port 5000, as it is the default port for Flask. For more about getting started with Flask, please see here.)

Since we're importing the Flask package, we need a file that contains the requirements for the app to run.
Create a new file named requirements.txt with the contents

Flask==1.1.1

where 1.1.1 is the Flask version. Feel free to use a different version! We'll use this file later for our Dockerfile.

Now that we have a working application, we can get started on containerizing it!

Building an image

A container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings. (Source: Docker)

To build an image, we require a Dockerfile, which is a text-based script of instructions (Source: Docker Docs).

To start with, our Dockerfile requires a parent image on top of which our instructions will run (more info here).

FROM python:3.8-alpine3.12

Here, python is the image name, while 3.8-alpine3.12 is the tag. An image can have various tags, representing different versions of the image. Alpine images are smaller in size than normal images.

An optional step is to add a label to the image.

FROM python:3.8-alpine3.12
LABEL developer="importhuman"

Next, we need to copy the contents from our local directory to the container directory.

FROM python:3.8-alpine3.12
LABEL developer="importhuman"
COPY . /app

This copies all contents from the current directory, to a new directory named /app on the container.

Next, we set this directory as our working directory. All further instructions will be carried out in this directory.

FROM python:3.8-alpine3.12
LABEL developer="importhuman"
COPY . /app
WORKDIR /app

The container needs to install dependencies to run the application successfully. So, we add a command to carry out the installation.

FROM python:3.8-alpine3.12
LABEL developer="importhuman"
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt

All these steps will build the image. To run the image and hence the container, we add the final step.

FROM python:3.8-alpine3.12
LABEL developer="importhuman"
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
CMD ["python3", "app.py"]

Our instructions are ready. Now, we can build our image!
In the command line, run the following command:

docker build -t image-name path/to/image

-t image-name gives your image the name "image-name", thus you can give it whatever name you'd like!
path/to/image is the path to the directory containing the Dockerfile. If you're running the command in the same directory as the Dockerfile, replace path/to/image with a dot.

Now, you can run docker images and you should be able to see your newly built image!

How to build a web app backend in Go (with user authentication and database)

Ujjwal Goyal — Wed, 26 May 2021 14:53:57 +0000

APIs, databases, user authentication. A lot goes into making a to-do list web application than I initially thought. Having done all that, I'm excited to bring it all to you! Through this blog you will learn how to build the backend of a web application, namely, how to:

connect a PostgreSQL database to Go
write APIs in Go
authenticate users with JSON web tokens (JWTs) via Auth0
deploy everything you've written to Heroku

Note: This post does not go into installing or signing up for any of the tools or services used. We will, however, see how to use them.

The complete repository can be found here.

Getting started with the database

We'll start with our database, to which we'll need to connect our APIs. Databases are ideal for storing and looking up large sets of data. If you're curious on why using databases is better than saving data to a file, I found this thread to be a brief and excellent starting point.

If you'd like a detailed starting guide to PostgreSQL with Go (or SQL in general), I'd recommend Jon Calhoun's excellent free articles.

Open your terminal, login to psql with your account, create a database and connect to it.

<!-- connect to psql -->
❯❯❯ psql -U ujjwal
Password for user ujjwal: <password>
psql (13.2 (Ubuntu 13.2-1.pgdg20.04+1))
Type "help" for help.

<!-- create database -->
ujjwal=# CREATE DATABASE blog;
CREATE DATABASE

<!-- connect to database -->
ujjwal=# \c blog;
You are now connected to database "blog" as user "ujjwal".

We will be using 2 tables, one for the tasks and one for the users.

Our tasks will have 4 properties:

A unique id to distinguish them
The task itself, that is, the text content
A boolean value that reflects if the task is done or not
A user id to distinguish the tasks of each user

We will assign 2 properties to users:

A unique distinguishing id
The user email (or some other identifying feature)

The user id in the 'tasks' and 'users' table will be the same. A new user shall be assigned an id, and when they add a task, their id shall be used to distinguish it.

Note: If you don't plan to deploy your application and only use it locally for yourself, you can skip the 4th property and the users table. In this case, you won't need authentication either.

Create tables with the suitable column names and properties.

CREATE TABLE tasks (id SERIAL PRIMARY KEY, task TEXT NOT 
NULL, status BOOLEAN NOT NULL, user_uuid UUID NOT NULL);

CREATE TABLE users (email VARCHAR (255) UNIQUE NOT NULL, 
user_id UUID PRIMARY KEY);

Hold up.

What's a UUID?

A universally unique identifier (UUID) is a 128-bit label used for information in computer systems. UUIDs are unique when generated according to the standard methods. A UUID can be used to identify something with near certainty that the identifier does not duplicate one that has already been, or will be, created to identify something else. Information labeled with UUIDs by independent parties can therefore be later combined into a single database or transmitted on the same channel, with a negligible probability of duplication. (Source: Wikipedia)

(You can use UUID as the primary key for tasks, or integers for users if you want.)

At this point, if you try to insert an email in the users table, you'll get an error. Namely, the table can't autogenerate UUIDs. This is easily remedied.

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
ALTER TABLE users ALTER COLUMN user_id SET DEFAULT 
uuid_generate_v4();

Finally, we need to connect the two tables, so on adding an item through our API, the user_id in users is automatically inserted as user_uuid in tasks. This is done via a foreign key.

ALTER TABLE tasks ADD CONSTRAINT constraint_fk FOREIGN KEY 
(user_uuid) REFERENCES users(user_id) ON DELETE CASCADE ON 
UPDATE CASCADE;

The CASCADE options ensure that changes in the user_id are reflected in both tables. For example, if a record is deleted from the users table, that UUID will also be deleted, and as a result all records in the tasks table with that particular UUID will also be deleted. If the UUID is modified in the users table, the tasks table will be automatically updated.

Our database is now complete! Now let's start with our backend code and connect it to the database.

Connecting Go to database

The below file structure (backend is my working directory) shows how our directory will look when we're done with everything.

backend
├── .env
├── .git
├── .gitignore
├── go.mod
├── go.sum
├── main
├── main.go
├── packages
│   ├── auth.go
│   └── handlers.go
└── Procfile

We'll connect to our database in a package rather than our main.go file. Here, I'm starting with handlers.go. We'll write the code for local development first (code for deployment described later).

package backend

import (
    // Includes all packages to be used in this file
    "database/sql"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "strconv"

    "github.com/gorilla/mux" // An HTTP router
    "github.com/joho/godotenv" // For getting the env variables
    _ "github.com/lib/pq" // Postgres driver for database/sql, _ indicates it won't be referenced directly in code
)

// Constants for database, can be set in .env file
const (
    host = "localhost"
    port = 5432 // default port for PostgreSQL
)

// The struct for a task, excluding the user_uuid which is added separately.
// Tasks in JSON will use the JSON tags like "id" instead of "TaskNum".
type Item struct {
    TaskNum int    `json:"id"`
    Task    string `json:"task"`
    Status  bool   `json:"status"`
}

// Connect to PostgreSQL database and also retrieve user_id from users table
func OpenConnection() (*sql.DB, string) {
    // Getting constants from .env
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }

    user, ok := os.LookupEnv("USER")
    if !ok {
        log.Fatal("Error loading env variables")
    }
    password, ok := os.LookupEnv("PASSWORD")
    if !ok {
        log.Fatal("Error loading env variables")
    }
    dbname, ok := os.LookupEnv("DB_NAME")
    if !ok {
        log.Fatal("Error loading env variables")
    }


    // connecting to database
    // 1. creating the connection string
    psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)

    // 2. validates the arguments provided, doesn't create connection to database
    db, err := sql.Open("postgres", psqlInfo)
    if err != nil {
        panic(err)
    }

    // 3. actually opens connection to database
    err = db.Ping()
    if err != nil {
        panic(err)
    }

    // add email to users table if not present
    email := GetEmail()
    addEmail := `INSERT INTO users (email) VALUES ($1) ON CONFLICT (email) DO NOTHING;`
    _, err = db.Exec(addEmail, email)
    if err != nil {
        panic(err)
    }

    // get user_id
    var userId string
    getUser := `SELECT user_id FROM users WHERE email = $1;`
    err = db.QueryRow(getUser, email).Scan(&userId)
    if err != nil {
        panic(err)
    }

    return db, userId
}

func GetEmail() string {
    // To be explained, related to authentication
}

We will look at the GetEmail() function later, as it is related to authentication. For now, know that it gives us the user email. We also retrieve user_id in this step, which we'll require for our APIs.

The "github.com/joho/godotenv" package is for loading our .env file in which we'll store our credentials that we cannot hardcode into the package or upload for public view. Add constants to .env file in the format

USER=username
PASSWORD=password

and so on.

addEmail and getUser are SQL statements without hardcoded values, which prevents SQL injection.

db.Exec(addEmail, email) executes the query (inserting email into table if not already present) without returning any rows.
db.QueryRow(getUser, email) queries and returns the user_id of the given email, followed by the Scan which copies the user_id into the variable 'userId' defined by us.

IMPORTANT: Make sure you add a .gitignore file to your directory, and to it add your .env file. This will avoid sharing your credentials with others if you upload your project somewhere public.

Writing APIs

Application Programming Interfaces (APIs) allow applications to communicate with each other. They define the types of requests that can be made, how to make them, data formats to be used, etc. (Source: Wikipedia)

In our application, the React frontend (the client) will make a request to the APIs that we write in Go, which will then send a response with the relevant information (the server).

Let's start with getting the complete list of tasks a user has (we're continuing in the handlers.go file).

// Get complete list of tasks
var GetList = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // Set header to json content, otherwise data appear as plain text
    w.Header().Set("Content-Type", "application/json")

    // Connect to database and get user_id
    db, userId := OpenConnection()

    // Return all tasks (rows) as id, task, status where the user_uuid of the task is the same as user_id we have obtained in the previous step
    rows, err := db.Query("SELECT id, task, status FROM tasks JOIN users ON tasks.user_uuid = users.user_id WHERE user_id = $1;", userId)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }
    defer rows.Close()
    defer db.Close()

    // Initializing slice like this and not "var items []Item" because aforementioned method returns null when empty thus leading to errors, 
    // while used method returns empty slice
    items := make([]Item, 0)
    // Add each task to array of Items
    for rows.Next() {
        var item Item
        err := rows.Scan(&item.TaskNum, &item.Task, &item.Status)
        if err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            panic(err)
        }
        items = append(items, item)
    }

    // Output with indentation
    // convert items into byte stream
    itemBytes, _ := json.MarshalIndent(items, "", "\t")
    // write to w
    _, err = w.Write(itemBytes)
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        panic(err)
    }

    w.WriteHeader(http.StatusOK) 

    // Alternatively, output without indentation
    // NewEncoder: WHERE should the encoder write to
    // Encode: encode WHAT
    // _ = json.NewEncoder(w).Encode(items)
})

Some additional information about defer statements and the "StatusOK" header:

Defer statement is used to execute a function call just before the surrounding function where the defer statement is present returns. (Source: Golangbot)
200 OK is the standard response for successful HTTP requests. (Source: Wikipedia)

When this API is called successfully, it will return all the tasks the user has entered so far.

Similarly, we write our other APIs.

// Add new task
var AddTask = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // Set header to json content, otherwise data appear as plain text
    w.Header().Set("Content-Type", "application/json")

    // decode the requested data to 'newTask'
    var newTask Item

    // NewDecoder: Decode FROM WHERE
    // Decode: WHERE TO STORE the decoded data
    err := json.NewDecoder(r.Body).Decode(&newTask)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    db, userId := OpenConnection()
    defer db.Close()

    sqlStatement := `INSERT INTO tasks (task, status, user_uuid) VALUES ($1, $2, $3) RETURNING id, task, status;`

    // retrieve the task after creation from the database and store its details in 'updatedTask'
    var updatedTask Item
    err = db.QueryRow(sqlStatement, newTask.Task, newTask.Status, userId).Scan(&updatedTask.TaskNum, &updatedTask.Task, &updatedTask.Status)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    w.WriteHeader(http.StatusOK)

    // gives the new task as the output
    _ = json.NewEncoder(w).Encode(updatedTask)
})

// delete task
var DeleteTask = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // Set header to json content, otherwise data appear as plain text
    w.Header().Set("Content-Type", "application/json")

    // getting the task id from the request URL
    vars := mux.Vars(r) // vars includes all variables in the request URL route. 
    // For example, in "/list/delete/{id}", "id" is a variable (of type string)

    number, err := strconv.Atoi(vars["id"]) // convert the string id to integer and assign it to variable "number"
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    db, userId := OpenConnection()
    sqlStatement := `DELETE FROM tasks WHERE id = $1 AND user_uuid = $2;`

    // Note that unlike before, we assign a variable instead of _ to the first returned value by db.Exec, 
    // as we need it to confirm that the row was deleted
    res, err := db.Exec(sqlStatement, number, userId)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    // verifying if row was deleted
    _, err = res.RowsAffected()
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    // to get the remaining tasks, same as the GET function
    rows, err := db.Query("SELECT id, task, status FROM tasks JOIN users ON tasks.user_uuid = users.user_id WHERE user_id = $1;", userId)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }
    defer rows.Close()
    defer db.Close()

    // var items []Item
    items := make([]Item, 0)
    for rows.Next() {
        var item Item
        err := rows.Scan(&item.TaskNum, &item.Task, &item.Status)
        if err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            panic(err)
        }
        items = append(items, item)
    }

    // output with indentation
    // convert items into byte stream
    itemBytes, _ := json.MarshalIndent(items, "", "\t")

    // write to w
    _, err = w.Write(itemBytes)
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        panic(err)
    }

    w.WriteHeader(http.StatusOK)
})

// edit task
var EditTask = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // Set header to json content, otherwise data appear as plain text
    w.Header().Set("Content-Type", "application/json")

    // get the task id from the request url
    vars := mux.Vars(r)
    number, err := strconv.Atoi(vars["id"])
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    sqlStatement := `UPDATE tasks SET task = $2 WHERE id = $1 AND user_uuid = $3 RETURNING id, task, status;`

    // decode the requested data to 'newTask'
    var newTask Item

    // NewDecoder: Decode FROM WHERE
    // Decode: WHERE TO STORE the decoded data
    err = json.NewDecoder(r.Body).Decode(&newTask)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    db, userId := OpenConnection()
    defer db.Close()

    // retrieve the task after creation from the database and store its details in 'updatedTask'
    var updatedTask Item
    err = db.QueryRow(sqlStatement, number, newTask.Task, userId).Scan(&updatedTask.TaskNum, &updatedTask.Task, &updatedTask.Status)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    w.WriteHeader(http.StatusOK)

    // gives the new task as the output
    _ = json.NewEncoder(w).Encode(updatedTask)
})

// change task status
var DoneTask = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // Set header to json content, otherwise data appear as plain text
    w.Header().Set("Content-Type", "application/json")

    // get the task id from the request url
    vars := mux.Vars(r)
    number, err := strconv.Atoi(vars["id"])
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    // store current status of the task from database
    var currStatus bool

    // store updated task
    var updatedTask Item

    sqlStatement1 := `SELECT status FROM tasks WHERE id = $1 AND user_uuid = $2;`
    sqlStatement2 := `UPDATE tasks SET status = $2 WHERE id = $1 AND user_uuid = $3 RETURNING id, task, status;`

    db, userId := OpenConnection()
    defer db.Close()

    // getting current status of the task
    err = db.QueryRow(sqlStatement1, number, userId).Scan(&currStatus)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }

    // changing the status of the task
    err = db.QueryRow(sqlStatement2, number, !currStatus, userId).Scan(&updatedTask.TaskNum, &updatedTask.Task, &updatedTask.Status)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        panic(err)
    }
    w.WriteHeader(http.StatusOK)

    // gives the new task as the output
    _ = json.NewEncoder(w).Encode(updatedTask)
})

We've written all our APIs! Now, we'll work on some authentication before bringing it all together in the main.go file.

Authentication

Note: This section was heavily derived from this post on authentication in Go, but does have some changes. If you require more help with setting up your Auth0 dashboard than specified here, it's a great resource.

In your Auth0 dashboard, create a new application. The complete details will be added only after writing the frontend.
Create a new API (in Applications section). The identifier is where you deploy your backend to. For running locally, it'd be something like http://localhost:8000/. Deploying to Heroku would give you something like https://YOUR-APP-NAME.herokuapp.com/. Identifier cannot be modified once set.
Auth0 by default provides an email sign up, but you can add your own options in the Authentication tab. For example, if you add a GitHub sign in, you'll have to configure the GitHub developer account as well, adding relevant details to Auth0 and GitHub. The application using this connection is the one you created in step 1.
Add the user email (for database) to the JSON web token by adding a custom "Add email to access token" rule (in the Auth pipeline section). This rule is provided by Auth0. All you need to do is give your own "namespace" to it, which is basically a unique identifier to recognize the email. It could be as simple as "thisismyemail". You can decode and play around with JWTs here. Add the complete namespace to .env file as "NAMESPACE_DOMAIN".

For now, that's all we have to do in our dashboard.
Now, let's make a new file auth.go (in the same directory as handlers.go).

package backend

import (
    "encoding/json"
    "errors"
    "fmt"
    "net/http"

    "github.com/auth0/go-jwt-middleware"
    "github.com/form3tech-oss/jwt-go"
)

type Jwks struct {
    Keys []JSONWebKeys `json:"keys"`
}

// holds fields related to the JSON Web Key Set for the API. These keys contain the public keys, which will be used to verify JWTs
type JSONWebKeys struct {
    Kty string   `json:"kty"`
    Kid string   `json:"kid"`
    Use string   `json:"use"`
    N   string   `json:"n"`
    E   string   `json:"e"`
    X5c []string `json:"x5c"`
}

// declaring variable outside function
var GetToken map[string]interface{}

func Middleware() (*jwtmiddleware.JWTMiddleware, map[string]interface{}) {
    // jwtMiddleware is a handler that will verify access tokens
    jwtMiddleware := jwtmiddleware.New(jwtmiddleware.Options{
        ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
            // get token for database
            // assigning value to earlier declared variable through pointer
            p := &GetToken
            *p = token.Claims.(jwt.MapClaims)

            // Verify 'aud' claim
            // 'aud' = audience (where you deploy the backend, either locally or Heroku)
            aud := "YOUR_API_IDENTIFIER"

            // convert audience in the JWT token to []interface{} if multiple audiences
            convAud, ok := token.Claims.(jwt.MapClaims)["aud"].([]interface{})
            if !ok {
                // convert audience in the JWT token to string if only 1 audience
                strAud, ok := token.Claims.(jwt.MapClaims)["aud"].(string)
                // return error if can't convert to string
                if !ok {
                    return token, errors.New("Invalid audience.")
                }
                // return error if audience doesn't match
                if strAud != aud {
                    return token, errors.New("Invalid audience.")
                }
            } else {
                for _, v := range convAud {
                    // verify if audience in JWT is the one you've set
                    if v == aud {
                        break
                    } else {
                        return token, errors.New("Invalid audience.")
                    }
                }
            }

            // Verify 'iss' claim
            // 'iss' = issuer
            iss := "https://YOUR_DOMAIN/"
            checkIss := token.Claims.(jwt.MapClaims).VerifyIssuer(iss, false)
            if !checkIss {
                return token, errors.New("Invalid issuer.")
            }

            cert, err := getPemCert(token)
            if err != nil {
                panic(err.Error())
            }

            result, _ := jwt.ParseRSAPublicKeyFromPEM([]byte(cert))
            return result, nil
        },
        SigningMethod: jwt.SigningMethodRS256,
    })
    return jwtMiddleware, GetToken
}

// function to grab JSON Web Key Set and return the certificate with the public key
func getPemCert(token *jwt.Token) (string, error) {
    cert := ""
    resp, err := http.Get("https://YOUR_DOMAIN/.well-known/jwks.json")

    if err != nil {
        return cert, err
    }
    defer resp.Body.Close()

    var jwks = Jwks{}
    err = json.NewDecoder(resp.Body).Decode(&jwks)

    if err != nil {
        return cert, err
    }

    for k := range jwks.Keys {
        if token.Header["kid"] == jwks.Keys[k].Kid {
            cert = "-----BEGIN CERTIFICATE-----\n" + jwks.Keys[k].X5c[0] + "\n-----END CERTIFICATE-----"
        }
    }

    if cert == "" {
        err := errors.New("Unable to find appropriate key.")
        return cert, err
    }

    return cert, nil
}

Note: I have slightly modified the middleware from the linked post to check for audience (original method couldn't convert slices correctly), and also return some data from the JWT in a modified form, which we'll use to get the user email.

Now that we have added user email to the JWT and can get the token data as well, it's time to complete the GetEmail() function in our handlers.go file which we left incomplete earlier.

// get and parse the token data for email
func GetEmail() string {
    // load .env file
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }
    // The field in the JWT to which email is added
    key, ok := os.LookupEnv("NAMESPACE_DOMAIN")
    if !ok {
        log.Fatal("Error loading env variables (namespace domain)")
    }
    // extract token via Middleware function
    _, token := Middleware()
    // parse token for email and convert it to string
    email := token[key].(string)
    return email
}

Finally, it's time to bring everything together in our main.go file!

main.go and CORS

Our main.go file looks like this:

package main

import (
    "log"
    "net/http"
    "os"

    "backend/packages" // importing files from the packages directory, to be explained
    "github.com/gorilla/mux" // An HTTP router
    _ "github.com/lib/pq" // Postgres driver for database/sql, _ indicates it won't be referenced directly in code
    "github.com/rs/cors" // For handling CORS (to be explained)
)

func main() {
    // the handler to verify access tokens
    jwtMiddleware, _ := backend.Middleware()

    r := mux.NewRouter()
    r.Handle("/list", jwtMiddleware.Handler(backend.GetList)).Methods("GET")
    r.Handle("/list/add", jwtMiddleware.Handler(backend.AddTask)).Methods("POST")
    r.Handle("/list/delete/{id}", jwtMiddleware.Handler(backend.DeleteTask)).Methods("DELETE")
    r.Handle("/list/edit/{id}", jwtMiddleware.Handler(backend.EditTask)).Methods("PUT")
    r.Handle("/list/done/{id}", jwtMiddleware.Handler(backend.DoneTask)).Methods("PUT")

    // for handling CORS
    c := cors.New(cors.Options{
        // Only add 1 value to allowed origins. Only the first one works. "*" is no exception.
        AllowedOrigins:   []string{"https://YOUR-FRONTEND-URL/"},
        AllowedMethods:   []string{"GET", "DELETE", "POST", "PUT", "OPTIONS"},
        AllowedHeaders:   []string{"Content-Type", "Origin", "Accept", "Authorization"},
        AllowCredentials: true,
    })

    // if deployed, looks for port in the environment and runs on it. Otherwise, runs locally on port 8000
    port, ok := os.LookupEnv("PORT")
    if !ok {
        port = "8000"
    }

    // apply the CORS specification on the request, and add relevant CORS headers as necessary
    handler := c.Handler(r)
    log.Println("Listening on port " + port + "...")
    // run on the designated port
    log.Fatal(http.ListenAndServe(":"+port, handler))
}

Let's break down the r.Handle("/list", jwtMiddleware.Handler(backend.GetList)).Methods("GET") line.

r is the router instance. It registers a new route jwtMiddleware.Handler(backend.GetList) for the URL path /list, that is, when a request is made to this path, the route specified decides what will happen next.
jwtMiddleware.Handler() wraps around the actual route backend.GetList. This wrapping protects the API endpoint, preventing unauthorized access.
Methods("GET") specifies which HTTP method is used.

{id} in some routes is a variable in the path, decided by the task that sends the request. For example, if a task with the id 65 sends the DELETE request, the URL path would be /list/delete/65. This 65 is stored in the route variables (of type map[string]string) with the key id.

Cross-Origin Resource Sharing (CORS)
This concept is not something you'll encounter if you're only sending API requests via a tool like Postman, but when you have any origin other than the backend, you'll need to account for it.

CORS is a mechanism that allows restricted resources on a web page to be requested from another domain outside the domain from which the first resource was served. (Source: Wikipedia)

CORS relies on a mechanism by which browsers make a “preflight” request to the server hosting the cross-origin resource, in order to check that the server will permit the actual request. In that preflight, the browser sends headers that indicate the HTTP method and headers that will be used in the actual request. (Source: MDN Web Docs)

Not all HTTP requests trigger a preflight request (see MDN documentation linked above), but in our case, they will. An HTTP request is first sent using the OPTIONS method to the resource on the other origin, to determine if the actual request is safe to send. Cross-site requests are preflighted like this since they may have implications to user data.

Thus, through the imported rs/cors package, we add the requisite headers, and subsequently wrap the router instance with the CORS handler. You can skip the AllowedOrigins for now.

log.Fatal(http.ListenAndServe(":"+port, handler)) runs our code on the particular port, and we can access our APIs locally! That is... after one more step.

Initializing module

A module is a collection of Go packages stored in a file tree with a go.mod file at its root. The go.mod file defines the module’s module path, which is also the import path used for the root directory, and its dependency requirements, which are the other modules needed for a successful build. Each dependency requirement is written as a module path and a specific semantic version. (Source: The Go blog)

Don't worry if you didn't understand everything above, you will soon!

In the terminal, in the root directory of your project (that is, the same level as the main.go file), run the following command:

go mod init backend

You should have a new go.mod file in your directory that looks like this:

module backend

go 1.16

require (
    github.com/auth0/go-jwt-middleware v1.0.0
    github.com/form3tech-oss/jwt-go v3.2.3+incompatible
    github.com/gorilla/mux v1.8.0
    github.com/joho/godotenv v1.3.0
    github.com/lib/pq v1.10.1
    github.com/rs/cors v1.7.0
)

module backend indicates that "backend" is the module path, and also the import path for the root directory. This is why we imported our auth.go and handlers.go files as "backend/packages". (The "backend" in backend.GetList and other parts of the code is because the name of the package is also backend. You can give another name to the package or the module if it's confusing, just ensure to replace it in the relevant sections).
go 1.16 is the version of Go to be used.
require specifies all the dependency requirements of the directory.

Running the code

There are two ways we can go about this step.

Running go run main.go in the terminal. This build the source file into an executable binary in a temporary location, runs the compiled program, then removes the binary.
Running go build ./main.go followed by ./main. This compiles and builds the executable in the current directory, and doesn't require compilation each time the program is to be run. (Sources: DigitalOcean, Oldbloggers)

The first method is suitable for development when regular testing is required, while in production the latter method should be preferred.

Now you can finally test your program locally! You can use a tool like Postman to make API requests. Make sure to include the complete path (including http://localhost:8000/). To get the access token and make a request,

open the "test" section of your API on the Auth0 dashboard
copy the string value in the "access_token" field in the "response" section
in Postman, in the request headers section, type in "Authorization" as the key, and "Bearer YOUR_TOKEN" as the value.

So far, we've worked on our local system. Now, we will deploy our code so it is available to everyone!

Getting ready for deployment to Heroku

Firstly, the code for deployment differs slightly, so we'll make those changes. The major changes are in the OpenConnection() function in handlers.go. We won't need the "github.com/joho/godotenv" package in this file either.

// -------- This section is no longer needed ----------
// const (
//  host = "localhost"
//  port = 5432
// )
// ----------------------------------------------------

// Connect to PostgreSQL database that will be deployed on Heroku and also retrieve user_id from users table
func OpenConnection() (*sql.DB, string) {
    // Retrieve database URL (obtained after deployment) from the environment. It contains all the necessary information to connect to the database.
    dbURL, ok := os.LookupEnv("DATABASE_URL")
    if !ok {
        log.Fatal("Error loading env variables.")
    }

    // Connect to database
    db, err := sql.Open("postgres", dbURL)
    if err != nil {
        panic(err)
    }

    // Add email to users table if not present
    email := GetEmail()
    addEmail := `INSERT INTO users (email) VALUES ($1) ON CONFLICT (email) DO NOTHING;`
    _, err = db.Exec(addEmail, email)
    if err != nil {
        panic(err)
    }

    // Get user_id from users table
    var userId string
    getUser := `SELECT user_id FROM users WHERE email = $1;`
    err = db.QueryRow(getUser, email).Scan(&userId)
    if err != nil {
        panic(err)
    }

    return db, userId
}

Thus, the only way we are altering our code is how we connect to our database, which will need to be deployed as well.

Next, create a new file at the root level of the directory named Procfile.

Heroku apps include a Procfile that specifies the commands that are executed by the app on startup. (Source: Heroku)

In it, enter the following code.

web: backend

That's it, you've just configured the commands to be run on deployment. (If you changed the name of the module, use that instead of "backend").

Your file structure should finally look like what we discussed at the beginning.

backend
├── .env
├── .git
├── .gitignore
├── go.mod
├── go.sum
├── main
├── main.go
├── packages
│   ├── auth.go
│   └── handlers.go
└── Procfile

It is important to note that all your code to be deployed should be on the master/main branch of git. Also, you'll be configuring the environment manually, so the .env file won't be used, but you can leave it as it is.

Deploying to Heroku

Note: The following steps do not cover installing or signing into Heroku. Please visit this page if you require assistance. The following steps also assume your terminal is opened at the root level of your project directory.

Run heroku create app-name (or simply heroku create, autoassigning an app name).
Run git push heroku main (or master, depending on your default branch name).

This will deploy the code to the given URL, but it is not ready yet for use. We still have to deploy our database. (Official documentation here)

Run heroku addons:create heroku-postgresql:hobby-dev (hobby-dev is the free plan available on Heroku, but you can use another plan if you want).

Next, we're going to push our local database which we used in local development to this database. You can skip this section if you don't wish to do so.

Run heroku addons. This will give you a list of the addons associated with your application, including a line heroku-postgresql (DEPLOYED_DATABASE_NAME). Take note of this name.
Run heroku pg:push LOCAL_DATABASE_NAME DEPLOYED_DATABASE_NAME --app APP_NAME.

Finally, we need to add configuration variables for Heroku to use. This is done via the command heroku config:set KEY=VALUE.

Set NAMESPACE_DOMAIN to your namespace domain (set earlier in .env file as well).
We need the DATABASE_URL to connect to our deployed database. Run heroku config and check if it is already present. If not, run DATABASE_URL=$(heroku config:get DATABASE_URL -a APP_NAME).

That's all! Your program should now be up and running along with the database! If you have any problems or doubts, please feel free to reach out to me on Twitter or in the comments below.

Methods and Interfaces in Go

Ujjwal Goyal — Tue, 26 Jan 2021 16:48:22 +0000

In the last blog, we looked at functions in Go. Let's move 1 step forward.

Methods and receivers

Consider the program

package main

import (
    "fmt"
)

type Point struct {
    x, y int
}

func tenfold(p Point) Point {
    return Point{p.x * 10, p.y * 10}
}

func main() {
    q := Point{4, 5}
    fmt.Println(tenfold(q))
}

This prints {40 50} as the answer.

This function can be rewritten as a method. A method in Go is a function with a special receiver argument (more about receivers in a moment). The above function can be written as

func (p Point) tenfold() Point {
    return Point{p.x * 10, p.y * 10}
}

func main() {
    q := Point{4, 5}
    fmt.Println(q.tenfold())
}

Here, the tenfold method has a receiver of type Point named p. This function prints the same result of {40 50}.

Methods are not limited to receivers of struct types. The only condition for the receiver is that the receiver type must be defined in the same package as the method. Thus, built-in types like int or float64 cannot be used directly as receiver types. To do so, define a custom type first

type MyInt int

Now, you can use MyInt as a receiver which will take an integer value.

Note: Functions with a pointer/value argument can only take a pointer/value respectively, but methods with a pointer/value receiver can take either a pointer or value.

Interfaces

In the above example, tenfold() Point is defined as a method signature. This leads into the next segment, interfaces. Interfaces are abstract types that are a set of method signatures. Values of these interface types can have any value that implements all the methods in that interface. Phew, that's enough of theory, now let's look at some code to understand interfaces.

package main

import (
    "fmt"
)

type Point struct {
    x, y int
}

type MyInt int

type Operations interface {
    double()
}

func (p Point) double() {
    fmt.Println(Point{p.x * 2, p.y * 2})
}

func (number MyInt) double() {
    fmt.Println(number * 2)
}

func main() {
    var q Operations = Point{4, 5}
    var n Operations = MyInt(6)
    q.double()
    n.double()
}

We have defined the double() method on both the Point and the MyInt types, and added the method to the Operations interface. We declare variables q and n to be of type Operations, and assign a Point and MyInt value to them respectively. We call the double() method, giving the output

{8 10}
12

The part (p Point) double() indicates that type Point implements the Operations interface (as the interface has the double method), but this does not need to be declared explicitly. Thus, a type implements an interface by implementing its methods.

If we were to add the tenfold() method from before to our code, but only define it for the Point type, we would get a compilation error saying MyInt does not implement Operations (missing tenfold method).

type Operations interface {
    tenfold() Point
    double()
}

func (p Point) tenfold() Point {
    return Point{p.x * 10, p.y * 10}
}

func (p Point) double() {
    fmt.Println(Point{p.x * 2, p.y * 2})
}

func (number MyInt) double() {
    fmt.Println(number * 2)
}

func main() {
    var q Operations = Point{4, 5}
    var n Operations = MyInt(6)
    fmt.Println(q.tenfold())
    q.double()
    n.double()
}

Compilation error:

cannot use MyInt(6) (type MyInt) as type Operations in assignment:
MyInt does not implement Operations (missing tenfold method)

Thus, for a type to implement an interface, all the methods of that interface have to be defined for that particular type.

Note: Not all interface methods have to be called. For example, the fmt package has a Stringer interface:

type Stringer interface {
    String() string
}

From the documentation:
"If an operand implements method String() string, that method will be invoked to convert the object to a string, which will then be formatted as required by the verb (if any)."

Thus, if the String() string method is defined, the print functions will invoke the Stringer interface automatically, i.e. without explicitly calling the String() method. Click here for an example of the Stringer interface in action.

Go for beginners: syntax, functions, and more

Ujjwal Goyal — Tue, 05 Jan 2021 16:00:30 +0000

Curious about Go?

New to Go?

Huh, Go what?

As described by Wikipedia, "Go is a statically typed, compiled programming language designed at Google". Apparently, it is syntactically similar to C, but as I do not know C (or any other compiled language for that matter), it is completely new to me. In this series, I will break down certain features of the language. First up: basic syntax, packages, functions, variables and structs.

Let's begin with the following program to add two numbers.

package main

import (
    "fmt"
)

type Example struct {
    x float64
    y float64
}

func Add(e Example) float64 {
    return e.x + e.y
}

var numbers = Example{2, 3}
var number2 float64 = 7

func main() {
    answer := Add(numbers)
    fmt.Println(answer, number2)
}

Let's break it down line-by-line:

package main indicates this program is executable. The code runs in the main() function. Other packages are intended as shared libraries, that is, shared files. These shared packages would not have the main package or function, and hence would not be executable.
The import statement imports the fmt package, a part of the Go standard library. Here, we will use it for printing our output via fmt.Println(). The "P" is capital because Println is exported from the fmt package, and exported names in Go are capitalized. As we have imported this package, we can only refer to the exported names. The bracket syntax is useful to import multiple packages, but individual packages can be imported using the syntax import "fmt" and so on.
The type keyword defines a new type! Go has certain basic types, and you can create your own custom type. Here, we create an "Example" of type struct. A struct is simply a user defined type comprised of a collection of fields. I like to think of this as creating a custom data structure as required. It can contain various data types, such as strings, integers, and even other structs!
x float64 and y float64 denote the data fields expected in the Example type. x and y are simply variable names, while float64 is the data type. It is a number format (more information here).
The next part is the Add function.
- func keyword describes the function named "Add".
- (e Example) describes the argument to be provided to the function and its type, that is, 1 argument (here indicated by e, a variable) of type Example is needed. Multiple parameters can be separated by commas, and if consecutive parameters are of the same type, the type can be given at the end of the arguments. Thus:
  - (text string, number int) requires, in order, a string and an integer argument.
  - (a int, b int) and (a, b int) both are equivalent, requiring 2 integer arguments.
- float64 describes the format of the value returned by the function, as described by the return statement.
- e.x and e.y refer to the x and y fields of the e Example type. Thus, dot notation is used to refer to individual fields of a struct by their name.
var numbers = Example{2, 3} declares a variable of name "numbers", which is equal to an Example type with values x=2 and y=3.
var number2 float64 = 7 is another example of a variable declaration, where "number2" is equal to 7 and its type is float64.
func main() is the part of the program that is executed after compilation.
- answer := Add(numbers) calls the Add function on numbers defined earlier, and assigns this value to the variable "answer". := is shorthand notation for variable declaration that does not require the "var" keyword or a particular type, with its type being implicit. However, this notation is only available inside functions.
- Finally, fmt.Println(answer, number2) prints out our two variables, giving us the output 5 7!

And there you have it! Although a simpler function could be used for adding two numbers, I wrote it this way to include structs.

Next up, methods and interfaces!

Happy coding!

Notes:

Standard formatting of a Go program file can be done using the go fmt command in the terminal:
go fmt /path/to/file
or alternatively:
gofmt -w file.go
The golint linter requires commenting throughout the code at various locations. You can use an alternate linter such as golangci-lint (used for this program), which does not require you to do so.

Clearing terminal in any OS

Ujjwal Goyal — Thu, 08 Oct 2020 20:23:42 +0000

Compatibility of a program across different operating systems is very important, and going through a project codebase, I found one operation which might be of use. I didn't expect to learn cross-platform operations this early in my learning process, so I found it really cool, and figured I'd share.

You might need to clear the terminal screen for certain scripts. That's where the os module comes in handy. It is a part of the Python standard library, so you do not need to install it separately. We'll need the module objects system and name, so:

from os import system, name

Since you want to clear the terminal, it's likely that you'll be doing it multiple times, so it's best to define a function.

def clearscreen():

Next, we want to check the operating system. Windows operating systems have the name value "nt", while Unix-based operating systems have the name value "posix". Both of them take different functions to clear the screen, which can be done as follows:

if name == "nt":
    system('cls')
else:
    system('clear')

Thus, the if statement runs for Windows, and the else statement runs for Linux/MacOS.
Our complete code becomes:

from os import system, name
def clearscreen():
if name == "nt":
    system('cls')
else:
    system('clear')

Now all you need to do is place your clearscreen() function wherever you require in your script, and voila!

From thinking, to doing

Ujjwal Goyal — Thu, 17 Sep 2020 14:58:48 +0000

"Perhaps you're laughing. Perhaps you're enjoying it. But that isn't the truth. Only I know the tragedy that's hidden behind your smile."
~One coder to another

Okay, that MAY have been taken from an anime, but it could very well be true. It's been 6 days since I took up the 100 Days of Code challenge, and there have been numerous moments when the aforementioned quote could've been said to me. That's not to say that there haven't been good moments, of course. Oh, the sheer joy of seeing the output you want! I reflexively clapped when that happened, and commended myself on a job well done. Here, I'll try to share my experiences over the past few days.

The road to the challenge

I'm not entirely new to coding. I've taught myself a bit of Python over the past few months, but it's never been consistent. It's always been in short patches followed by long breaks. But with college over, no other interests, and in eventual search of a job, there was no better time to take up the 100 Days of Code challenge and level up my skills while being regular. Okay yes, there's also the small matter of a deadly pandemic confining us to our homes for a still unknown length of period until we develop herd immunity or a vaccine is developed allowing us to carry on with life as usual, but I still would've done it. I hope.

The journey begins. Almost.

I found out about the challenge, and it seemed an excellent idea. Or as Ron Weasley would say, "Brilliant!" It would build up knowledge and experience over time, slowly, sure, but surely. It only required an hour per day, so it wasn't demanding too much. Perhaps most important, however, was the fact that I would publicly commit to the challenge, which as I've experienced, ensures consistency and accountability. It doesn't matter if you've been able to do what you wanted to or not, you put it out there for everyone to see.

So... Why didn't I get started as soon as I found out about it? I put it down to my tendency to be over-prepared and hesitant before embarking on something new. I kept researching for projects to contribute to, read posts on DEV and Twitter about coding, but didn't actually start anything. It's not a bad thing at all to read and think. It's important, but at some point there can be too much input. You do need to think what you're going to do before you do it, but you can also end up just thinking about thinking. So, if you're reading this and haven't started on something you thought you would, do it. It doesn't matter how you start off, it starts making sense eventually.

The journey begins, this time for real

I'd settled on working on Conway's Game of Life towards the end of my postponement phase. It was based on simple rules, and yet seemed so elegant. Here's my project so far.

On Day 1, I tried to make a visible 100*100 grid. To this end, I used matplotlib for the first time. I was able to create a grid alright, but I couldn't control its dimensions or how the cells would be filled. Just random gridlines. Making the axes labels and ticks disappear would come later, first I needed to solve the issue at hand. I was unable to do much however, and so I spent some time learning CSS via FreeCodeCamp, which allowed me to feel like I had achieved something on the day after all.

Day 2 was much better. I switched my approach, and using numpy (again, for the first time), I created a small 11*11 array of 0s. This essentially gave me a blank canvas, on which I could color the cells I wanted by assigning them a value of 1 and choosing a colormap (I went with binary) that visually reflected the difference in values. This method would not show gridlines, but that did not matter, for the animation did not require them to be plotted or visualized. In addition, I managed to clear away the axes ticks and labels, giving me a clean plot. I also wrote the game's rules, and all that was left was animating the plot. Surely that wouldn't be so difficult given the progress I'd made? Oh, how innocent I was.

Day 3 was spent trying to animate the plot, but to no avail. If I didn't use the FuncAnimation function I couldn't animate it, and if I didn't assign a colormap via imshow() then there was nothing to animate. I couldn't seem to get them to work together, so I tried looking for methods that would allow me to assign colors to values without using imshow. I still was as out of luck as movie halls in 2020.

I began day 4 from where I'd previously left off, trying to animate the plot. Not only did I not do it, I found out that the rules of the game, the one part of the code I thought was alright, was ridiculously wrong. I put the animation struggle on hold and fixed the rules. I was just testing to see if it was alright, when that happened. The animation worked. All by itself. Oh, I was so happy! Just goes to show that your problems may not lie where you think they lie.

Day 5 was the beginning of enhancing the project. I increased the array size to 51 * 51, allowing bigger animations. I also wrote some code specifically for the edges and corners of the array, thinking that I was getting index errors in some cases because of general description of all cells. Later, I realized that it made no difference, so I removed that block. The animation was also getting slowed down in later frames, so I added a function that would clear the previous image before plotting the next one. This however, brought back the ticks and labels, so after the clearing function, I cleared away the ticks and labels within the loop.

Today is day 6. I realized that the coding block I thought was redundant was not so after all. I found the earlier commit and merged it after some difficulties.

There is still more work to do on the project, but I'm very happy with what I've done so far. I honestly did not expect to get here so quickly, since the animations I'd seen before looked very complex. Judging by how it's been so far, there will be even worse days of work, but there'll be rewarding days as well, and I'm ready for it.