DEV Community: IamKhan

Exploring Rate Limiting in Go

IamKhan — Tue, 16 Dec 2025 16:09:44 +0000

Let's explore rate limiting together in go. If you are here, you probably already know what rate limiting is and why it is important but spare me half a minute to do a brief intro for the guys at the back.

Rate limiting is a technique used to restrict the number of requests a client can make to a server within a specific time window.

Why do I need a rate limiter you ask? to prevent DDoS attacks. What is a DDoS attack you ask? DDoS is acronym for Distributed Denial of Service. When your server is suddenly inundated with an absurb amount of internet traffic, you're are probably experiencing a DDoS attack.

Now that we have gotten definitions out of the way, let's talk about some common rate limiting algorithms. There are quite a number of rate limiting algorithms with varying degrees of complexity, resource usage and trade offs. I'll be exploring 3 of the more common rate limiting strategies:

Fixed window counter
Sliding window counter
Token bucket algorithm

In this expedition, I'll be focusing on the fixed window counter strategy.

Fixed Window Counter

This is the simplest and most common algorithm used for rate limiting. It is essentially acts like a timer for incoming traffic. It is an excellent chioce for low risk APIs where slight traffic spikes aren't a problem. A drawback to this algorithm is the burstiness that can occur immediately the window resets - which in plain english means an attacker can basically make 2 times the request allowed in one window a second before and immediately after the window resets. If your API allows 10 requests per minute, an attacker can wait for the last second of that minute make 10 requests then and make another immediately after the counter resets - that's 20 requests in 2 seconds.

Let's write a go implementation of this strategy

Start a go project and create your entry file. In your entry file create a http server and with an example handler

package main

import (
    "fmt"
    "log"
    "net/http"
)

const DEFAULT_PORT = 3000

func hello(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"message": "hello"}`))
}

func main() {
    mux := http.DefaultServeMux
    mux.Handle("/", hello)

    serv := &http.Server{
        Addr: fmt.Sprintf(":%d", DEFAULT_PORT),
        Handler: mux,
    }

    if err := serv.ListenAndServe(); err != nil {
        log.Fatal(err)
    }
}

We should now be able to run our server, visit http://localhost:3000 and get a "hello world" response in our client. Right now, we can send an unrestricted number of http requests to the server. Let's add rate limiting to fix that.

In the same directory create a ratelimit package. In your limiter.go file let's write our rate limiting logic

package ratelimit

import (
    "fmt"
    "encoding/json"
    "net"
    "net/http"
    "strings"
    "sync"
    "time"
)

type Counter struct {
    value     int // tracks the number of visits
    windowEnd time.Time // tracks expiration time
}

type RateLimiter struct {
    windowSize time.Duration // window duration
    counters   map[string]*Counter // holds counter information per IP
    mu         sync.Mutex
    maxRequest int // maximum number requests
}

func newRateLimiter(maxRequest int, windowSize time.Duration) *RateLimiter {
    // initialise rate limiter
    limiter := &RateLimiter{
        maxRequest: maxRequest,
        windowSize: windowSize,
        counters:   make(map[string]*Counter),
    }

    // start a goroutine to cleanup expired counters
    go func() {
        t := time.NewTicker(time.Minute)
        defer t.Stop()
        // do cleanup every minute
        for range t.C {
            limiter.cleanup()
        }
    }()

    return limiter
}

func (r *RateLimiter) cleanup() {
    r.mu.Lock()
    defer r.mu.Unlock()
    now := time.Now()

    // remove expired counters
    for key, c := range r.counters {
        if now.After(c.windowEnd) {
            delete(r.counters, key)
        }
    }
}

type LimiterInfo struct {
    Allowed   bool
    Remaining int
    Reset     time.Time
}

func (r *RateLimiter) allow(key string) (bool, LimiterInfo) {
    r.mu.Lock()
    defer r.mu.Unlock()
    now := time.Now()

    // check if counter exists
    c, ok := r.counters[key]

    // if it doesn't create a counter and add to the counters map
    if !ok || now.After(c.windowEnd) {
        c := Counter{
            value:     1,
            windowEnd: now.Add(r.windowSize),
        }

        r.counters[key] = &c

        return true, LimiterInfo{
            Allowed:   true,
            Remaining: r.maxRequest - 1,
            Reset:     c.windowEnd,
        }
    }

    // check if maximum amount of requests exceeded
    if c.value < r.maxRequest {
        // increment value count
        c.value++

        return true, LimiterInfo{
            Allowed:   true,
            Remaining: r.maxRequest - c.value,
            Reset:     c.windowEnd,
        }
    }

    return false, LimiterInfo{
        Allowed:   false,
        Remaining: 0,
        Reset:     c.windowEnd,
    }
}

// helper function to help get client IP
func getRequestIP(r *http.Request) string {
    if ips := r.Header.Get("X-Forwarded-For"); ips != "" {
        parts := strings.Split(ips, ",")
        return parts[0]
    }

    if ip := r.Header.Get("x-Real-IP"); ip != "" {
        return ip
    }

    ip, _, err := net.SplitHostPort(r.RemoteAddr)
    if err != nil {
        return r.RemoteAddr
    }

    return ip
}

// create middleware function
func New(maxRequest int, windowSize time.Duration) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        // create limiter in closure
        limiter := newRateLimiter(maxRequest, windowSize)

        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // get IP address
            key := getRequestIP(r)

            // check if window is valid
            allowed, info := limiter.allow(key)

            // set rate limiter headers
            w.Header().Set("X-RateLimit-Limit", fmt.Sprint(limiter.maxRequest))
            w.Header().Set("X-RateLimit-Remaining", fmt.Sprint(info.Remaining))
            w.Header().Set("X-RateLimit-Reset", fmt.Sprint(info.Reset.Unix()))

            if !allowed {
                // set retry after header
                w.Header().Set("Retry-After", fmt.Sprintf("%.0f", time.Until(info.Reset).Seconds()))

                // set content type header
                w.Header().Set("Content-Type", "application/json")

                // set status code
                w.WriteHeader(http.StatusTooManyRequests)

                // send json response
                json.NewEncoder(w).Encode(map[string]string{
                    "detail": "rate limit exceeded",
                    "retry_after": info.Reset.Format(time.RFC1123),
                })

                return
            }

            next.ServeHTTP(w, r)
        })
    }
}

Now let's adjust our main.go file to use the rate limiter

import (
    // imports remain the same
    "time"

    ratelimit "path-to-ratelimit-package"
)

func main() {
    mux := http.DefaultServeMux

    // rate limiter allows 2 requests per minute 
    limiter := ratelimit.New(2, time.Minute)
    mux.Handle("/", limiter(http.HandlerFunc(hello)))

    serv := &http.Server{
        Addr: fmt.Sprintf(":%d", DEFAULT_PORT),
        Handler: mux,
    }

    if err := serv.ListenAndServe(); err != nil {
        log.Fatal(err)
    }
}

If you try making a request to the appropriate endpoint more than 2 times in one minute, you'll get a 429 error status code.

Powershell is low-key cool

IamKhan — Thu, 04 Dec 2025 13:51:50 +0000

As far as developer tools go, Microsoft gets a bad rep. There's a long list of reasons tools built by the big M get clowned on but it's hard to deny obvious success stories like VSCode among others - however few.

One tool I think is actually good but not talked about enough is powershell. If you use a windows machine you've
probably come across it - yep, it's that shell that shows up in your VSCode integrated terminal before you adjust
your settings to use bash instead - well, maybe you shouldn't.

This isn't a dump bash and pick up powershell exposition, I use both (you will too) - this is a give powershell
a chance appeal.

What exactly is powershell? Well, it's a command-line shell and it's also a scripting language - just like bash is. While both have a lot of similarities, the fundamental difference between both technologies lie in their approach to handling data. In bash, the output of a command is a text stream; with powershell however, the output of a command is a stream of .NET objects.

What I intend to do with this article is share one of the ways I use powershell in my local development process.

Everyone who has done any work with javascript is familiar with nodemon. It is a dev tool that watches files and
restarts your program when a change is detected. When I started writing golang, I needed golang's nodemon. I didn't find air (go's nodemon alternative) in time so I wrote a simple powershell script I still use till this day.

Here's how I did it:

In your powershell terminal, create a directory.

# create a directory called watcher
mkdir watcher

Fun fact, "mkdir" is a bash command. The underlying cmdlet (as they are called in powershell) for creating directories is New-Item. New-Item is a cmdlet that takes a few arguments. In true powershell fashion the proper way to create a directory from your terminal is:

New-Item -Path watcher -Item-Type directory

But that's too verbose and so the wonderful folks that gave us powershell decided to provide bash-like aliases to quite a number of powershell cmdlet. When you see what looks like a bash command in powershell it really is an alias for a powershell cmdlet.

Now that we have a directory to work with, "cd" into it and create few files:

# go into watcher
cd watcher

# create a go file
ni main.go

# create a powershell script
ni watcher.ps1

Before we continue, you might need to adjust the execution policy option in your terminal. This is important because the wrong option can stop your script from executing.

# check execution policy
Get-ExecutionPolicy

# if response is RemoteSigned you're fine
# if it isn't set execution policy
Set-ExecutionPolicy RemoteSigned

In your go file write some code - that prints something to the terminal. This isn't an article about go, you can replicate the same process for any other language.

package main

import "fmt"

func main() {
    // prints "Hello World to the terminal"
    fmt.Println("Hello World")
}

Before we start writing our script, let's go over what we are trying to build. We want to write a script that continuously watches go files and restarts our program whenever a changed is made to any of the files being watched. We will do this
by tracking the hash of each file. In simple terms, if a file changes, so will its hash; when the hash change, we re-run the program. It's that simple.

# go file path
$path = "main.go"


# write welcome message
Write-Host 'GoWatcher *Press CTRL+C to quit*'

# current directory
$dirname = "."

# recursively get all files in the current directory as well as nested directories
$files = Get-ChildItem $dirname -Filter "*.go" -Recurse

# run go program - initial run
go run $path

# get file hash, sort them and parse the result as string
$signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String

# start a while loop to continuously track file changes
while($true) {
    # get file hash, sort them and parse the result as string again - for comparison (will be different if there's been a change)
    $current_signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String

    # check for a change
    if ($signature -ne $current_signature) {
        Write-Host 'File change detected: Restarting...'

        # re-run go program
        go run $path

        # swap new signature for old one
        $signature = $current_signature
    }

    # sleep for 300 milliseconds
    Start-Sleep -Milliseconds 300
}

Here we have a powershell script that tracks all go files in a directory starts the program and re-runs it when a change is made to any go file.

A small adjustment we can make to the script is - pass the path value via the terminal as a flag. That's quite easy to do - just add the following to the top the file.

[CmdletBinding()]
Param(
    [Parameter(Mandatory)]
    $path
)

# go file path
# $path = "main.go"

In your terminal you can run the script file by typing the script name ("./watcher.ps1") followed by the path argument

./watcher.ps1 -path 'main.go'

We aren't quite done. If the go app performs a blocking/long-running operation, our watcher script will freeze. An example of a blocking operation is a web server.

Now let's adjust out script accordingly.

Just before we begin, I'd like us to take a detour and talk a little bit about jobs in powershell. They are a way to run scripts or commands asynchronously. They are perfect for allowing you perform long running processes in the background of your current session. They are quite easy to start:

# start a background job
Start-Job -Name GoServer -ScriptBlock {
    # perform long running task here
}

# stop a background job
Stop-Job -Name GoServer

# remove a background job
Remove-Job -Name GoServer

# receive response from a background job
Receive-Job -Name GoServer

# get a job
Get-Job -Name GoServer

Now that we've gone over some powershell job specific commands, let's write a script that will fix the issue we have with the first script.

[CmdletBinding()]
Param(
    [Parameter(Mandatory)]
    $path
)

# write welcome message
Write-Host 'GoWatcher *Press CTRL+C to quit*'

# current directory
$dirname = "."

# job name
$jobname = "GoServer"

# binary name
$binary = "GoApp"

# create a function that starts a job
function Start-ServerJob {
    # quietly stop previously running job
    # important because our watcher restarts when a file changes
    Get-Job -Name $jobname -ErrorAction SilentlyContinue | Remove-Job -Force

    # start new job
    # use the argument list parameter to pass values to the job
    $job = Start-Job -Name $jobname -ScriptBlock {
        param($path, $dirname)
        # set location
        Set-Location $dirname

        # build go script to avoid that annoying popup that shows up any time we run a go server
        go run build -o "bin/$binary.exe" $path

        # run binary
        Invoke-Expression "./bin/$binary.exe"
    } -ArgumentList $path, $dirname

    return $job
}

# recursively get all files in the current directory as well as nested directories
$files = Get-ChildItem $dirname -Filter "*.go" -Recurse

# start job - initial run
$job = Start-ServerJob

# get file hash, sort them and parse the result as string
$signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String

# run a while loop in a try-finally block because we want to perform clean-up when the watcher is terminated
try {
    while($true) {
        # get file hash, sort them and parse the result as string again - for comparison (will be different if there's been a change)
        $current_signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String

        # check for a change
        if ($signature -ne $current_signature) {
            Write-Host 'File change detected: Restarting...'

            # re-run the job
            $job = Start-ServerJob

            # swap new signature for old one
            $signature = $current_signature
        }
    }
}
# clean-up - release resources locked up by job
finally {
    # quietly stop previously running job
    # important because our watcher restarts when a file changes
    Get-Job -Name $jobname -ErrorAction SilentlyContinue | Remove-Job -Force

    # stop process if running
    if (Get-Process -Name $binary -ErrorAction SilentlyContinue) {
        Stop-Process -Name $binary -Force
    }
}

Just like that, we have a script that can watch a long running process. We can run a go web server and our script
will watch for changes.

There is a pesky little issue though, since we have the go server running as a background job, we do not get any logs.
We can fix this easily with the Receive-Job cmdlet

# in the while loop, after the signature check, add the following if statement
if ($job -and $job.HasMoreData) {
    # collect job data
    $logs = Receive-Job -Job $job

    # loop over job data and log to the console
    foreach($log in $logs) {
        Write-Host $log
    }
}

Problem fixed. Now let's combine the logic from both scripts into one:

[CmdletBinding()]
param(
  [Parameter(Mandatory)]
  $Path,
  [Parameter()]
  [ValidateSet('Basic', 'Server')]
  $Mode = 'Basic'
)

$Jobname = "GoApp"
$BinaryName = "goapp"
$Dirname = "."

Write-Host 'GoWatcher ' -Foregroundcolor green -NoNewLine
Write-Host '*Press CTRL+C to terminate*' -Foregroundcolor red
Write-Host '**************************************' -Foregroundcolor green

function Run-BasicMode {
  go run $Path

  $files = Get-ChildItem -Path "." -Filter "*.go" -Recurse
  $signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String

  while ($true) {
    $current_signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String

    if ($signature -ne $current_signature) {
      Write-Host 'File change detected: Restarting...' -Foregroundcolor yellow
      go run $Path
      $signature = $current_signature
    }

    Start-Sleep -Milliseconds 100
  }
}


function Start-ServerJob {
  Get-Job -Name $Jobname -ErrorAction SilentlyContinue | Remove-Job -Force

  $job = Start-Job -Name $Jobname -ScriptBlock {
    param($dirname, $path)
    Set-Location $dirname
    go build -o "bin/$BinaryName.exe" $path
    Invoke-Expression "./bin/goapp.exe"
  } -ArgumentList $Dirname, $Path

  return $job
}

function Run-ServerMode {
  $job = Start-ServerJob

  $files = Get-ChildItem . -Filter '*.go' -Recurse
  $signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String

  try {
    while($true) {
      $current_signature = $files | Get-FileHash -ErrorAction SilentlyContinue | Sort-Object Path | Out-String
      if ($signature -ne $current_signature) {
        Write-Host 'File change detected: Restarting...' -Foregroundcolor yellow
        $job = Start-ServerJob
        $signature = $current_signature
      }

      if ($job -and $job.HasMoreData) {
        $logs = Receive-Job -Job $job
        foreach ($log in $logs) {
          Write-Host $log
        }
      }

      Start-Sleep -Milliseconds 300
    }
  }
  finally {
    Get-Job -Name $Jobname -ErrorAction SilentlyContinue | Remove-Job -Force

    if (Get-Process -Name $BinaryName -ErrorAction SilentlyContinue) {
      Stop-Process -Name $BinaryName -Force
    }
  }
}

switch ($Mode) {
  'Basic' { Run-BasicMode }
  'Server' { Run-ServerMode }
}

With the logic for both operations combined, we can now run the script with the appropriate flags depending on your need

# run the script in basic mode
./watcher.ps1 -Path main.go -Mode Basic

#run the script in server mode
./watcher.ps1 -Path main.go -Mode Server

To avoid the need to copy the script into every project we can add an alias to $PROFILE. On a windows machine,
$PROFILE is the path to the current user's powershell profile script. It loads every time powershell is opened.

# Set-Alias **add name** **add path to watcher script**
Set-Alias watcher 'C:/Users/Documents/scripts/watcher.ps1'

Now you can run your go programs with this script from any directory in powershell by running the command:

# for basic mode
watcher -Path main.go -Mode Basic

# for server mode
watcher -Path main.go -Mode Server

Organize your desktop: Build a file organizer in Go.

IamKhan — Wed, 20 Nov 2024 10:30:11 +0000

Is your desktop chaotic? Do you have files of all sorts cluttering your desktop or downloads directory? Let's fix that with a simple script.

As we do at the beginning of any go project, we generate our go.mod file with the "go mod init" directive. To keep things simple, we will write all of our logic in our main.go file.

Let's talk a little about how we will like the script to behave before we write any code. We want to be able to organize our files into directories that indicate the file type or creation date. In short, we want our script to sort video files into a videos directory, music files into a music directory and so on; or sort all files created on a particular date into the same directory.

Now let's code:

Create a main.go file and write the following:

package main

type fileAnalyzer interface {
    analyzeAndSort() error
}

func analyze(fa fileAnalyzer) error {
    return fa.analyzeAndSort()
}

Because we want our program to sort files by different criteria, we create a fileAnalyzer interface that defines a method: analyzeAndSort.
Then we write a function: analyze - that takes any struct that implements the fileAnalyzer interface as an argument and executes its analyzeAndSort method.

In some cases like we will see in this program, there may be certain files you don't want moved. For example, while testing the script, we don't want the program to move our go files or executable/binary into another directory. To prevent this from happening, we have to create a blacklist that includes all the files we will like to remain untouched.

In our main.go file, write the following:

var blacklist = []string{
    "go",
    "mod",
    "exe",
    "ps1",
}

Here, I added the file extension for files I will like to remain unsorted. ".go" and ".mod" are extensions for go files. Because I use a windows machine, my binary will have ".exe" as its extension. I also included ".ps1" because I like to work with powershell scripts in development - as you will see.

Next, we write some helper functions.

func getFileExtension(name string) string {
    return strings.TrimPrefix(filepath.Ext(name), ".")
}

func listFiles(dirname string) ([]string, error) {
    var files []string

    list, err := os.ReadDir(dirname)
    if err != nil {
        return nil, err
    }

    for _, file := range list {
        if !file.IsDir() {
            files = append(files, file.Name())
        }
    }

    return files, nil
}

func listDirs(dirname string) ([]string, error) {
    var dirs []string

    list, err := os.ReadDir(dirname)
    if err != nil {
        return nil, err
    }

    for _, file := range list {
        if file.IsDir() {
            dirs = append(dirs, file.Name())
        }
    }

    return dirs, nil
}

func mkdir(dirname string) error {
    err := os.Mkdir(dirname, 0644)

    if err != nil && os.IsExist(err) {
        return nil
    }

    var e *os.PathError

    if err != nil && errors.As(err, &e) {
        return nil
    }

    return err
}

func moveFile(name string, dst string) error {
    return os.Rename(name, filepath.Join(dst, name))
}

func getCurrentDate(t time.Time) string {
    return t.Format("2006-01-02")
}

func filter[T any](ts []T, fn func(T) bool) []T {
    filtered := make([]T, 0)

    for i := range ts {
        if fn(ts[i]) {
            filtered = append(filtered, ts[i])
        }
    }

    return filtered
}

Most of these are self-explanatory but I'll like to talk about the "mkdir" function. The "mkdir" function creates a directory with the name passed to it as argument - but the function does not return an error if the directory already exists or if there is an "os.PathError".

Now let's create a struct that implements the fileAnalyzer interface:

type fileTypeAnalyzer struct {
    wd     string
    mapper map[string][]string
}

func newFileTypeAnalyzer(wd string) *fileTypeAnalyzer {
    return &fileTypeAnalyzer{
        wd: wd,
        mapper: map[string][]string{
            "video":  {"mp4", "mkv", "3gp", "wmv", "flv", "avi", "mpeg", "webm"},
            "music":  {"mp3", "aac", "wav", "flac"},
            "images": {"jpg", "jpeg", "png", "gif", "svg", "tiff"},
            "docs":   {"docx", "csv", "txt", "xlsx"},
            "books":  {"pdf", "epub"},
        },
    }
}

func (f fileTypeAnalyzer) analyzeAndSort() error {
    files, err := listFiles(f.wd)
    if err != nil {
        return fmt.Errorf("could not list files: %w", err)
    }

    if err := f.createFileTypeDirs(files...); err != nil {
        return err
    }

    return f.moveFileToTypeDir(files...)
}

func (f fileTypeAnalyzer) moveFileToTypeDir(files ...string) error {
    dirs, err := listDirs(f.wd)
    if err != nil {
        return fmt.Errorf("could not list directories: %w", err)
    }

    for _, dir := range dirs {
        for _, file := range files {
            if slices.Contains(f.mapper[dir], strings.ToLower(getFileExtension(file))) {
                if err := moveFile(file, dir); err != nil {
                    return err
                }
            }
        }
    }

    files, err = listFiles(f.wd)
    if err != nil {
        return err
    }

    if len(files) == 0 {
        return nil
    }

    files = filter(files, func(f string) bool {
        return !slices.Contains(blacklist, getFileExtension(f))
    })

    for i := range files {
        if err := f.moveToMisc(files[i]); err != nil {
            return err
        }
    }

    return nil
}

func (f fileTypeAnalyzer) moveToMisc(file string) error {
    if err := mkdir("misc"); err != nil {
        return err
    }

    return moveFile(file, "misc")
}

func (f fileTypeAnalyzer) createFileTypeDirs(files ...string) error {
    for ftype, fvalues := range f.mapper {
        for _, file := range files {
            if slices.Contains(fvalues, getFileExtension(file)) {
                if err := mkdir(ftype); err != nil {
                    return fmt.Errorf("could not create folder: %w", err)
                }
            }
        }
    }

    return nil
}

The fileTypeAnalyzer struct has two properties: wd which holds the name of the current working directory and a mapper. The mapper's keys will be the type of file detected while its values is a list of file extensions associated with the key. We then create a constructor function and provide the file types as well as their associative file extensions to the mapper. Feel free to add more file types and extensions to the list. The anaylyzeAndSort method calls a couple of helper functions and methods that maps file extension to a file type, creates the file type directory and moves the file into said directory. I also added a "misc" folder to hold files that were not captured by the mapper - excluding the blacklisted files of course.

We also want to be able to organize files by creation date. Let's create another struct that implements the fileAnalyzer interface but organizes files by date.

type fileDateAnalyzer struct {
    wd string
}

func newFileDateAnalyzer(wd string) *fileDateAnalyzer {
    return &fileDateAnalyzer{
        wd: wd,
    }
}

func (f fileDateAnalyzer) analyzeAndSort() error {
    files, err := listFiles(f.wd)
    if err != nil {
        return fmt.Errorf("could not list files: %w", err)
    }

    if err := f.createFileDateDirs(files...); err != nil {
        return err
    }

    return f.moveFileToDateDir(files...)
}

func (f fileDateAnalyzer) createFileDateDirs(files ...string) error {
    for _, file := range files {
        info, err := os.Stat(file)
        if err != nil {
            return err
        }

        if !slices.Contains(blacklist, getFileExtension(file)) {
            if err := mkdir(getCurrentDate(info.ModTime())); err != nil {
                return err
            }
        }
    }

    return nil
}

func (f fileDateAnalyzer) moveFileToDateDir(files ...string) error {
    dirs, err := listDirs(f.wd)
    if err != nil {
        return fmt.Errorf("could not list directories: %w", err)
    }

    files = filter(files, func(f string) bool {
        return !slices.Contains(blacklist, getFileExtension(f))
    })

    for _, dir := range dirs {
        for _, file := range files {
            info, err := os.Stat(file)
            if err != nil {
                continue
            }

            if dir == getCurrentDate(info.ModTime()) {
                if err := moveFile(file, dir); err != nil {
                    continue
                }
            }
        }
    }

    return nil
}

A lot of the logic is the same as that from the fileTypeAnalyzer. The main difference is we are not providing a mapper - instead we get the creation date from the file info and create directories accordingly.

Now let's put everything together in our main function:

func main() {
    logger := slog.Default()
    slog.SetDefault(logger)

    var analyzer fileAnalyzer

    wd, err := os.Getwd()
    if err != nil {
        log.Fatal(err)
    }

    var mode string

    flag.StringVar(&mode, "mode", "", "Provide sort mode (type|date)")
    flag.Parse()

    switch mode {
    case "date":
        analyzer = newFileDateAnalyzer(wd)
    case "type":
        analyzer = newFileTypeAnalyzer(wd)
    default:
        fmt.Println("Provide sort mode flag: --mode=(type|date)")
        return
    }

    if err := analyze(analyzer); err != nil {
        log.Fatal(err)
    }
}

We configure a logger; get the current working directory to pass as an argument to our fileAnalyzer implementation; create a mode variable to hold values passed in as flags to the application and a switch statement to control how we want to sort. Finally we call the analyze function and pass our fileAnalyzer implementation as argument.

That's all. Let's build our binary and test. I called mine sorter. You can call yours whatever you want to call it with "go build -o [name]"

Here is a folder littered with files of different types:

Let's organize by file type:

Let's organize by file creation date:

As a bonus, if you use a windows machine and you use powershell - here's a script to help make testing your program seemless.

Create a task.ps1 file and type the following:

[CmdletBinding()]
Param(
  [Parameter(Mandatory)][string]$Action
)

function Get-Dirs {
  [CmdletBinding()]
  Param(
    [Parameter(Mandatory)][string]$Path
  )
  return Get-ChildItem -Path $Path | Where-Object { $_.GetType() -eq [System.IO.DirectoryInfo] }
}

switch($Action) {
  'build' {
    Write-Host -ForegroundColor green 'building binary...'
    go build -o sorter.exe
  }
  'remove' {
    $folders = Get-Dirs -Path '.'

    foreach($folder in $folders) {
      if ((Get-ChildItem $folder).Count -eq 0) {
        Remove-Item $folder
      } else {
        Write-Host -ForegroundColor yellow 'folder not empty'
      }
    }
  }
  'unsort' {
    Write-Host -ForegroundColor green 'unsorting...'
    Get-ChildItem (Get-Dirs -Path '.') | ForEach-Object { $_ | Move-Item -Destination '.' }
  }
  Default {
    Write-Host -ForegroundColor red 'invalid action'
  }
}

To build your binary with the script:

To unorganize files with the script:

To delete directories with script:

Let's build a password generator we can actually use

IamKhan — Wed, 13 Nov 2024 01:37:04 +0000

For our next beginner project, we will build a password generator that doesn't only generate passwords but encrypts and saves them - so that it is actually functional.

We will be splitting our code into different files so we don't end up with a large "main.go" file.

First, we initialize a go project and create a "profile.go" file that will contain the logic for encrypting and decrypting passwords.

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "errors"
    "io"
)

// must be 32 characters 
var key = "askdjasjdbreonfsdfibsdhfgsdfhboo"

var ErrMalformedEncryption = errors.New("malformed encryption")

// password in small letters so it is not stored
type profile struct {
    Enc, Platform, password string
}

func (p *profile) encrypt() error {
    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        return err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return err
    }

    nonce := make([]byte, gcm.NonceSize())

    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return err
    }

    enc := gcm.Seal(nonce, nonce, []byte(p.password), nil)
    p.Enc = hex.EncodeToString(enc)

    return nil
}

func (p *profile) decrypt() error {
    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        return err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return err
    }

    nsize := gcm.NonceSize()

    if len(p.Enc) < nsize {
        return ErrMalformedEncryption
    }

    enc, err := hex.DecodeString(p.Enc)
    if err != nil {
        return err
    }

    password, err := gcm.Open(nil, enc[:nsize], enc[nsize:], nil)
    if err != nil {
        return err
    }

    p.password = string(password)

    return nil
}

Here we create a profile struct that has 3 fields - Enc, Platform and password. Enc will hold the encrypted password, the service we are generating the password for will be stored in Platform and password will hold the actual generated password. The profile struct has 2 methods "encrypt" and "decrypt". We use AES - a symmetric key encryption algorithm to encrypt and decrypt our password.

Next we create a "store.go" file that contains the logic for storing and retrieving passwords.

package main

import (
    "encoding/gob"
    "errors"
    "os"
    "sync"
)

const filename = "profile.bin"

var (
    ErrInvalidArgs = errors.New("invalid args")
    ErrNotFound    = errors.New("not found")
)

type store struct {
    sync.RWMutex
    data map[string]*profile
}

func newStore() (*store, error) {
    s := &store{
        data: make(map[string]*profile),
    }

    if err := s.load(); err != nil {
        return nil, err
    }

    return s, nil
}

func (s *store) load() error {
    flags := os.O_CREATE | os.O_RDONLY
    f, err := os.OpenFile(filename, flags, 0644)
    if err != nil {
        return err
    }
    defer f.Close()

    info, err := f.Stat()
    if err != nil {
        return err
    }

    if info.Size() == 0 {
        return nil
    }

    return gob.NewDecoder(f).Decode(&s.data)
}

func (s *store) save() error {
    f, err := os.OpenFile(filename, os.O_WRONLY, 0644)
    if err != nil {
        return err
    }
    defer f.Close()

    return gob.NewEncoder(f).Encode(s.data)
}

func (s *store) find(platform string) (string, error) {
    s.RLock()
    defer s.RUnlock()

    p, ok := s.data[platform]
    if !ok {
        return "", ErrNotFound
    }

    if err := p.decrypt(); err != nil {
        return "", err
    }

    return p.password, nil
}

func (s *store) add(platform, password string) error {
    if platform == "" {
        return ErrInvalidArgs
    }

    p := &profile{
        Platform: platform,
        password: password,
    }

    if err := p.encrypt(); err != nil {
        return err
    }

    s.Lock()
    defer s.Unlock()

    s.data[platform] = p

    return s.save()
}

We chose gob files for storage because they are not exactly human readable. If the file ever gets exposed, your passwords are safe because they will be encrypted and really difficult to read. The store struct contains methods for loading, finding and saving to the gob file. We save the passwords in a dictionary. We also use a mutex to make the dictionary concurrent safe. An important thing to note is that we will not be storing the plain generated password - we will store its encrypted value instead.

Now let's write a couple of functions that will actually generate the passwords. Create a "password.go" file and type the following

package main

import (
    "math"
    "math/rand"
    "slices"
    "strings"
)

const (
    half      = .5
    onethird  = .3
    onefourth = .25
)

var (
    randlowers  = randFromSeed(lowers())
    randuppers  = randFromSeed(uppers())
    randdigits  = randFromSeed(digits())
    randsymbols = randFromSeed(symbols())
)

var basicPassword = randlowers

func mediumPassword(n int) string {
    frac := math.Round(float64(n) * half)
    pwd := basicPassword(n)
    return pwd[:n-int(frac)] + randuppers(int(frac))
}

func hardPassword(n int) string {
    pwd := mediumPassword(n)
    frac := math.Round(float64(n) * onethird)
    return pwd[:n-int(frac)] + randdigits(int(frac))
}

func xhardPassword(n int) string {
    pwd := hardPassword(n)
    frac := math.Round(float64(n) * onefourth)
    return pwd[:n-int(frac)] + randsymbols(int(frac))
}

func randFromSeed(seed string) func(int) string {
    return func(n int) string {
        var b strings.Builder
        for range n {
            b.WriteByte(seed[rand.Intn(len(seed))])
        }
        return b.String()
    }
}

func lowers() string {
    var b strings.Builder
    for i := 'a'; i < 'a'+26; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func uppers() string {
    var b strings.Builder
    for i := 'A'; i < 'A'+26; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func symbols() string {
    var b strings.Builder
    for i := '!'; i < '!'+14; i++ {
        b.WriteRune(i)
    }
    for i := ':'; i < ':'+6; i++ {
        b.WriteRune(i)
    }
    for i := '['; i < '['+5; i++ {
        b.WriteRune(i)
    }
    for i := '{'; i < '{'+3; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func digits() string {
    var b strings.Builder
    for i := '0'; i < '0'+9; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func shuffle[T any](ts []T) []T {
    cloned := slices.Clone(ts)
    rand.Shuffle(len(cloned), func(i, j int) {
        cloned[i], cloned[j] = cloned[j], cloned[i]
    })
    return cloned
}

func shuffleStr(s string) string {
    return strings.Join(shuffle(strings.Split(s, "")), "")
}

Here we've written functions that generates passwords at different levels of difficulty. The basicPassword function generates random small letter strings. The mediumPassword function takes a fraction of the characters from basicPassword function and adds random capital letters to it. The hardPassword function does the same for mediumPassword but adds digits to it. The xhardPassword does the same and adds symbols. The shuffle function does exactly what you'd expect on slices while shuffleStr shuffles strings.

Now let's put everything together. Create a "main.go" file and type the following

package main

import (
    "errors"
    "flag"
    "fmt"
    "log"
    "regexp"
    "strconv"
    "strings"
)

var usage = `
Usage 
-----
--get platform=[string] - Gets saved password for a platform
--set platform=[string] len=[int] level=(basic|medium|hard|xhard) - Creates and saves a password
`

var ErrUsage = errors.New(usage)

var pattern = regexp.MustCompile(`\S+=\S+`)

type level int

const (
    _ level = iota
    level_basic
    level_medium
    level_hard
    level_xhard
)

var level_key = map[string]level{
    "basic":  level_basic,
    "medium": level_medium,
    "hard":   level_hard,
    "xhard":  level_xhard,
}

type commands struct {
    get, set bool
}

func createCommands() (c commands) {
    flag.BoolVar(&c.get, "get", false, "get password for platform")
    flag.BoolVar(&c.set, "set", false, "set password for platform")
    flag.Parse()
    return
}

func (c commands) exec(store *store) (string, error) {
    switch {
    case c.get:
        return c.getPassword(store)
    case c.set:
        return c.setPassword(store)
    default:
        return "", ErrUsage
    }
}

func (c commands) getPassword(store *store) (string, error) {
    params, err := c.parse()
    if err != nil {
        return "", err
    }

    return store.find(params["platform"])
}

func (c commands) setPassword(store *store) (string, error) {
    params, err := c.parse()
    if err != nil {
        return "", err
    }

    var password string

    n, err := strconv.Atoi(params["len"])
    if err != nil {
        return "", err
    }

    if n < 8 {
        return "", fmt.Errorf("password len cannot be less than 8")
    }

    switch level_key[params["level"]] {
    case level_basic:
        password = basicPassword(n)
    case level_medium:
        password = mediumPassword(n)
    case level_hard:
        password = hardPassword(n)
    case level_xhard:
        password = xhardPassword(n)
    default:
        return "", ErrUsage
    }

    password = shuffleStr(password)

    if err := store.add(params["platform"], password); err != nil {
        return "", err
    }

    return password, nil
}

func (c commands) parse() (map[string]string, error) {
    args := flag.Args()

    if len(args) == 0 {
        return nil, ErrUsage
    }

    params := make(map[string]string)

    for i := range args {
        if !pattern.MatchString(args[i]) {
            return nil, ErrUsage
        }

        parts := strings.Split(args[i], "=")
        params[parts[0]] = parts[1]
    }

    return params, nil
}

func main() {
    store, err := newStore()
    if err != nil {
        log.Fatalf("could not initialize store: %v", err)
    }

    c := createCommands()

    password, err := c.exec(store)
    if err != nil {
        log.Fatalf("could not execute flag commands: %v", err)
    }

    fmt.Printf("password: %s\n", password)
}

We used flags to specify how we expect the application to behave. "--get" to get a password and "--set" to generate and save a password. To set a password, the user provides arguments with the flags to instruct the application on the type of password to generate and save. To get a password, the user also provides arguments to specify the password to retrieve.

You can now run "go build" to build a binary and test the application.

Writing a Typing Speed Test CLI Application in Golang

IamKhan — Fri, 18 Oct 2024 01:09:27 +0000

Had to think long and hard about that title 🙄... now that we've gotten that out of the way, let's write some darn code :)

Pumps brake 🚗 screechhhhh.... Let's do a bit of introduction into what we will be attempting to build today. Incase the title wasn't obvious, we will be building a CLI application that calculates your typing speed in golang - although you can literally build the same application, following the same techniques in any programming language of your choice.

Now, let's code 😎

package main

import (
    "bufio"
    "fmt"
    "log"
    "math/rand"
    "os"
    "strings"
    "time"
)

var sentences = []string{
    "There are 60 minutes in an hour, 24 hours in a day and 7 days in a week",
    "Nelson Mandela is one of the most renowned freedom fighters Africa has ever produced",
    "Nigeria is the most populous black nation in the world",
    "Peter Jackson's Lord of the rings is the greatest film of all time",
}

In our main.go file, we import the packages we will need to write our logic. We also create a slice of sentences. Feel free to add a bunch more.

// A generic helper function that randomly selects an item from a slice
func Choice[T any](ts []T) T {
    return ts[rand.Intn(len(ts))]
}

// Prompts and collects user input from the terminal
func Input(prompt string) (string, error) {
    fmt.Print(prompt)
    r := bufio.NewReader(os.Stdin)

    line, err := r.ReadString('\n')
    if err != nil {
        return "", err
    }

    return strings.Trim(line, "\n\r\t"), nil
}

// Compares two strings and keeps track of the characters  
// that match and those that don't
func CompareChars(target, source string) (int, int) {
    var valid, invalid int

    // typed some of the words
        // resize target to length of source
    if len(target) > len(source) {
        diff := len(target) - len(source)
        invalid += diff
        target = target[:len(source)]
    }

    // typed more words than required
        // resize source to length of target
    if len(target) < len(source) {
        invalid++
        source = source[:len(target)]
    }

    for i := 0; i < len(target); i++ {
        if target[i] == source[i] {
            valid++
        }
        if target[i] != source[i] {
            invalid++
        }
    }

    return valid, invalid
}

// Calculates the degree of correctness
func precision(pos, fal int) int {
    return pos / (pos + fal) * 100
}

// Self explanatory - don't stress me 😑
func timeElapsed(start, end time.Time) float64 {
    return end.Sub(start).Seconds()
}

// Refer to the last comment
func accuracy(correct, total int) int {
    return (correct / total) * 100
}

// 😕
func Speed(chars int, secs float64) float64 {
    return (float64(chars) / secs) * 12
}

We then go on to create a couple of function that will come in handy when we write our application logic.

func main() {
    fmt.Println("Welcome to Go-Speed")
    fmt.Println("-------------------")

    for {
        fmt.Printf("\nWould you like to continue? (y/N)\n\n")
        choice, err := Input(">> ")
        if err != nil {
            log.Fatalf("could not read value: %v", err)
        }

        if choice == "y" {
            fmt.Println("Starting Game...")
            timer := time.NewTimer(time.Second)
            fmt.Print("\nBEGIN TYPING NOW!!!\n\n")
            _ = <-timer.C

            sentence := Choice(sentences)
            fmt.Printf("%s\n", sentence)

            start := time.Now()
            response, err := Input(">> ")
            if err != nil {
                log.Fatalf("could not read value: %v", err)
            }

            elasped := timeElapsed(start, time.Now())
            valid, invalid := CompareChars(sentence, response)
            fmt.Print("\nResult!\n")
            fmt.Println("-------")
            fmt.Printf("Correct Characters: %d\nIncorrect Characters: %d\n", valid, invalid)
            fmt.Printf("Accuracy: %d%%\n", accuracy(valid, len(sentence)))
            fmt.Printf("Precision: %d%%\n", precision(valid, invalid))
            fmt.Printf("Speed: %.1fwpm\n", Speed(len(sentence), elasped))
            fmt.Printf("Time Elasped: %.2fsec\n", elasped)
        }

        if choice == "N" {
            fmt.Println("Quiting Game...")
            break
        }

        if choice != "N" && choice != "y" {
            fmt.Println("Invalid Option")
        }
    }
}

In our main function, we write a welcome message to the terminal and create an infinite loop to run our program. We then print a confirmation message to stdout - terminal - with an option to quit the program. If you choose to continue, a sentence is selected from the slice of sentences previously written and displayed in the terminal just after the start time is recorded. We collect the user input and calculate the time, speed, precision and accuracy then display the results back to the terminal. The infinite loop resets and the application runs again until you opt out of the program.

Voila!!! We just wrote our first program in golang.