DEV Community: Alexandru Bucur

Simple UUID wrapper for MySQL in Go that covers UUID to BIN conversion

Alexandru Bucur — Sun, 20 Aug 2023 18:08:51 +0000

Here's a quick snippet you can use to create a custom type that maps an UUID to a Binary(16) representation in MySQL.

I assume this is not present in gofrs/uuid since it's database specific, but having NullUUID available is an easy 'inspiration' opportunity ;).

import (
    "database/sql/driver"

    "github.com/gofrs/uuid/v5"
)

type NullBinaryUUID struct {
    UUID  uuid.UUID
    Valid bool // Valid is true if UUID is not NULL
}

// Value implements the driver.Valuer interface.
func (u NullBinaryUUID) Value() (driver.Value, error) {
    if !u.Valid {
        return nil, nil
    }

    // Delegate to UUID Value function
    return u.UUID.Bytes(), nil
}

// Scan implements the sql.Scanner interface.
func (u *NullBinaryUUID) Scan(src interface{}) error {
    if src == nil {
        u.UUID, u.Valid = uuid.UUID{}, false
        return nil
    }

    // Delegate to UUID Scan function
    u.Valid = true
    return u.UUID.Scan(src)
}

Are Dev Containers the future for local development environments?

Alexandru Bucur — Wed, 02 Aug 2023 18:08:51 +0000

What are Dev Containers you might ask?
Elementary, my dear Watson* / fellow developer.

It's a fancy way of using container images as a full blown development environment. You can read containers.dev for more details, but the key IMHO that is missing on the homepage, is that it can run actual compose.yaml (popularised by docker-compose) as an entry point.

You can consider this post a follow up A Go(lang) journey in live reload and pretty panics.
As I was writing tests, I realised that by just starting docker compose, there's no easy way to have the tests also run in the container while also allowing the usage of the built in debugger in vscode.

I decided to give devcontainers a go, and see how they would work.
The idea as mentioned in the intro is pretty nice since it allows you to:

use a compose.yaml as your actual entry point to the system
setup the required extensions in vscode (not strictly in the spec, but a nice to have)
have the tests run in the actual container, so you don't need to worry about different golang versions (or any other problems you might have with project specific packages)

You could argue that compared to the old-school setup of setting up your images, and then using them in something like Vagrant, this is a newer approach in which composability (ha, the puns) helps you build your development environment from various pieces.

If your database has different dependencies and packages from your queue system this makes it an non issue as each runs in its own container. Same goes for your test mailing system, queue system and whatever other dependency you will add in the future.

That brings us to the following config:

{
    "name": "API",
    "dockerComposeFile": [
        "../compose.yml"
    ],
    "service": "api",
    "workspaceFolder": "/go/src/app",
    "initializeCommand": "./scripts/devcontainer.sh",
    "shutdownAction": "stopCompose",
    "remoteUser": "devuser:devuser",
    "customizations": {
        "vscode": {
            "settings": {
                "terminal.integrated.shell.linux": "/bin/bash"
            },
            "extensions": [
                "ms-azuretools.vscode-docker",
                "golang.Go",
                "eamodio.gitlens",
                "timonwong.shellcheck",
                "tamasfe.even-better-toml"
            ]
        }
    }
}

After you take a quick look at the config, you'll notice an interesting key called initializeCommand .
That is being used to actually solve a thing / bug / annoyance or whatever you want to call it.

Usually when you run inside a container, you mount your application code and then the user that container image is built with is the root user.
That makes it annoying for a very simple reason, the owner of the file in WSL is going to be root, making it a pita to do cleanup and/or editing of the vscode workspace when the docker engine (in my case) doesn't work.

To fix that, I'm semi abusing the functionality provided by compose.yaml to provide build arguments to the base image.
The devcontainer.sh looks like this:

#!/bin/bash

# Get the current user and group ID in WSL
PROJECT_DOCKER_USERNAME=$(id -u)
PROJECT_DOCKER_GROUPNAME=$(id -g)

# The comment to add to the .env file
COMMENT="# The following two environment variables are needed for container to host permission interoperability"

# If the .env file exists
if [ -f .env ]; then

    # If the variables exist in the .env file, remove them
    if grep -q "PROJECT_DOCKER_USERNAME=" .env; then
        sed -i "/PROJECT_DOCKER_USERNAME=/d" .env
    fi

    if grep -q "PROJECT_DOCKER_GROUPNAME=" .env; then
        sed -i "/PROJECT_DOCKER_GROUPNAME=/d" .env
    fi

    # If the comment exists in the .env file, remove it
    if grep -qF "$COMMENT" .env; then
        sed -i "\|$COMMENT|d" .env
    fi
fi

# Add the comment and variables to the .env file
{
    echo "$COMMENT"
    echo "PROJECT_DOCKER_USERNAME=$PROJECT_DOCKER_USERNAME"
    echo "PROJECT_DOCKER_GROUPNAME=$PROJECT_DOCKER_GROUPNAME"
} >> .env

This allows the creation / reuse of the local .env file that gets automatically used by docker as a source for your ENV variables making the usage in compose.yaml painless.

api:
  build:
    context: .
    dockerfile: Dockerfile
    target: api
    args:
      # Pass the user and group id as build arguments
      USER_ID: ${PROJECT_DOCKER_USERNAME:-1000} # default wsl initial user in case we mess it up
      GROUP_ID: ${PROJECT_DOCKER_GROUPNAME:-1000}
  depends_on:
    db:
      condition: service_healthy # secret db :P
  working_dir: /go/src/app
  ports:
    - 8080:8080
  volumes:
    - ./:/go/src/app
  cap_add:
    - SYS_PTRACE
  security_opt:
    - seccomp:unconfined
  user: ${PROJECT_DOCKER_USERNAME}:${PROJECT_DOCKER_GROUPNAME}

Now we get to the Dockerfile itself. It's technically a container image, but for all intents and purposes you shouldn't treat it different than a normal VM.
This is a development environment, so it is going to need all kinds of packages, especially for support tools like git.

FROM golang:1.20-bookworm AS api

ARG USER_ID
ARG GROUP_ID

# let's add the group / user based on the ARG's passed by compose.yaml
RUN addgroup --gid $GROUP_ID devuser
RUN adduser --uid $USER_ID --gid $GROUP_ID --disabled-password --gecos '' devuser

RUN apt-get install -y \
    git # and other packages you might need

WORKDIR /go/src/app

# A bunch of golang tools needed by vscode and our app
RUN go install github.com/cosmtrek/air@latest \
    && go install github.com/maruel/panicparse/v2@latest \
    && go install golang.org/x/tools/gopls@latest \
    && go install github.com/go-delve/delve/cmd/dlv@latest \
    && go install honnef.co/go/tools/cmd/staticcheck@latest

# Copy Go modules and dependencies to image
COPY go.mod ./

# Download Go modules and dependencies
RUN go mod download

# Copy directory files
COPY . ./

RUN chown devuser. ./

USER devuser # finally let's switch to the devuser

CMD ["/bin/bash", "scripts/dev.sh"]

After all is set and done, it is a pretty nifty and useful setup, since it makes the onboarding in your application a lot more approachable, and developers can just open it in vscoode and have a fully working environment.

With additional support from Jetbrains and other tools it will become hopefully more wide spread and used in other editors and ides, making the life of a DX (developer experience) engineer a lot easier (or however your organisation calls the hard working people that work on allowing your developers to focus on you know... development).

If this doesn't work for you, you can buy me a beer and tell me how to improve it ;-).

* Yes, Sherlock never said that, but it's pop culture :P.

Simple Script to Generate Color Scheme Switchable Css

Alexandru Bucur — Wed, 03 May 2023 19:05:51 +0000

While I was working at yet another secret project that will probably never see the light of day, I wanted to blog about the experience on bootstrapping the project.
As any developer, that means that instead of writing that blog post, I had to dust off my website theme, update hugo, and do other fixes.

I've settled on PaperMod as the theme, since it's simple and to the point, and it also changes the style based on the preferred color scheme.

However, by default there's no way to have the code highlight theme change based on the preferred color scheme, but since I hopefully still know my css, and with the help of phind to generate some shell scripting, we now got this nifty script that can help you do just that, be it in a hugo theme, or any other kind of system as long as you "abuse" hugo for the generation of the theme only.

You see, hugo uses chroma for its theme support, so that makes it pretty flexible to generate the theme css using hugo gen chromastyles --style=your_style_here_from_the_big_list.

After picking the two color schemes I wanted, namely tango and nord (and fixing one of them, twice) I've set up to ... instruct my lovely assistant to help me build what I need.

After some back and forth, and some suggestions on what's wrong on the generated script based on ShellCheck, since Phind has an obsession it seems with escaping $, we got to this lovely code (Github Gist for convenience).

#!/usr/bin/env bash
set -euo pipefail

# Default values
light_theme=""
dark_theme=""
destination_path="assets/css/extended/syntax.css"

# Help message
usage() {
  cat <<EOF
Usage: $0 [options] [--] [light-theme] [dark-theme]

Options:
  -h, --help                Show this help message and exit
  --light-theme=LIGHT_THEME Set the light theme
  --dark-theme=DARK_THEME   Set the dark theme
  --destination-path=PATH   Set the destination path for the output file

Positional arguments:
  light-theme              Light theme (alternative to --light-theme)
  dark-theme               Dark theme (alternative to --dark-theme)
EOF
}

positional_arg_counter=0

# Parse options and arguments
while [[ $# -gt 0 ]]; do
  case $1 in
    -h|--help)
      usage
      exit 0
      ;;
    --light-theme=*)
      light_theme="\${1#*=}"
      positional_arg_counter=$((positional_arg_counter + 1))
      shift
      ;;
    --dark-theme=*)
      dark_theme="\${1#*=}"
      positional_arg_counter=$((positional_arg_counter + 1))
      shift
      ;;
    --destination-path=*)
      destination_path="\${1#*=}"
      shift
      ;;
    *)
      if [[ $positional_arg_counter -eq 0 ]]; then
        light_theme="$1"
      elif [[ $positional_arg_counter -eq 1 ]]; then
        dark_theme="$1"
      else
        echo "Error: Too many arguments" >&2
        usage
        exit 1
      fi
      positional_arg_counter=$((positional_arg_counter + 1))
      shift
      ;;
  esac
done

if [[ -z "$light_theme" ]] || [[ -z "$dark_theme" ]]; then
  echo "Error: Missing arguments" >&2
  usage
  exit 1
fi

hugo gen chromastyles --style="$light_theme" > "$destination_path"
{
    echo "@media (prefers-color-scheme: dark) {"
    hugo gen chromastyles --style="$dark_theme" | sed -E 's/(^\/\*[^*]*\*\/)?(.+)/\1 .dark\2/'
    echo "}"
} >> "$destination_path"

The script does add .dark as an extra class in front of all the classes from the "dark-theme" setup to match the class that's added by PaperMod.

For PaperMod specifically I had to do a few tweaks.

Update config.yml|toml|xml

pygmentsUseClasses: true
markup:
  highlight:
    codeFences: true
    guessSyntax: true
    lineNos: true
    noClasses: false
    style: nord

Update the css with some custom overwrites to make sure we're not overwriting the theme background color and fix a few rounded margins

.post-content .highlight table {
    border-radius: var(--radius);
    background: var(--code-bg);
}

.post-content .highlight:not(table):not(:has(.chroma)) {
    margin: 10px auto;
    background: var(--hljs-bg) !important;
    border-radius: var(--radius);
    direction: ltr;
}

.post-content .highlight .lntable .lntd:first-child code {
    border-top-right-radius: 0;
    border-bottom-right-radius: 0;
}

.post-content .highlight .lntable .lntd:last-child code {
    border-top-left-radius: 0;
    border-bottom-left-radius: 0;
}

.post-content .highlight .lntable .lntd:not(:first-child, :last-child) code {
    border-radius: 0;
}

Needed changes might be slightly different for your theme!

How are you handling code highlights in your theme ?

A Go(lang) journey in live reload and pretty panics

Alexandru Bucur — Wed, 03 May 2023 19:05:51 +0000

TLDR: Use docker + cosmtrek/air +

One of my passions is DX, and while I'm not always getting it right, the enjoyment is there to make people's lives a little bit more productive.

Some context

Coming from a predominantly PHP background, at least in my bubble, having "pretty" error messages when doing development is pretty much a given.

Regardless of the framework you might be using all of them use php.net/set_error_handler in one way shape or form.

For example, using nunomaduro/collision is at easy as doing:

<?php

require 'vendor/autoload.php';

(new \NunoMaduro\Collision\Provider)->register();

Using symphony/error-handler is also easy peasy:

<?php

require 'vendor/autoload.php';

use Symfony\Component\ErrorHandler\Debug;
use Symfony\Component\ErrorHandler\ErrorHandler;
use Symfony\Component\ErrorHandler\DebugClassLoader;

Debug::enable();

The Problem

Although the Go compiler is generally pretty good on catching errors, you won't always get around runtime errors. That brings me to the fact that in Go, panics are just ugly (personal preference).

Since google, bing, ddg and other lovely search engines let me down in finding an equivalent in Go that I can use as a defered panic recover system, I did what everybody would do, and asked my ~~new ai overlords~~ lovely randomly selected large language model (LLM) (in my case phind) to whip me up something that gets closer to the PHP Examples above.

After some back and forth, we got to this lovely sample, which works awesome as a POC.

package errorhandler

import (
    "bufio"
    "fmt"
    "os"
    "runtime"
    "runtime/debug"
    "strconv"
    "strings"
)

const (
    red    = "\033[31m"
    green  = "\033[32m"
    yellow = "\033[33m"
    cyan   = "\033[36m"
    reset  = "\033[0m"
)

func CustomPanicHandler() {
    if r := recover(); r != nil {
        // Use colored output for the panic message and add an error type
        fmt.Printf("\n%sError: %s%s\n\n", red, r, reset)

        stackBytes := debug.Stack()
        stack := string(stackBytes)

        stackLines := strings.Split(stack, "\n")

        var stackBuffer []string
        var lastRealFilename string
        var lastRealLineNum int
        for i, line := range stackLines {
            if i == 0 {
                continue
            } else if strings.Contains(line, "runtime/debug.Stack()") {
                continue
            } else if strings.Contains(line, GetFunctionName()) {
                continue
            }

            if i%2 == 0 {
                stackBuffer = append(stackBuffer, fmt.Sprintf("  %s%s%s", cyan, line, reset))
            } else {
                stackBuffer = append(stackBuffer, line)
            }

            fileAndLine := strings.Split(line, ":")
            if len(fileAndLine) < 2 {
                continue
            }

            fileName := strings.TrimSpace(fileAndLine[0])
            lineNum, err := strconv.Atoi(strings.Split(fileAndLine[1], " ")[0])
            if err != nil {
                continue
            }

            lastRealFilename = fileName
            lastRealLineNum = lineNum
        }

        // Display the offending line only for the last real file found
        if lastRealFilename != "" {
            fileContent, err := readFileLines(lastRealFilename)
            if err != nil {
                fmt.Println("Error reading file:", err)
            } else {
                printOffendingLine(lastRealFilename, fileContent, lastRealLineNum)
            }
        }

        // Print the buffered stack trace
        fmt.Println("\nPanic occurred:")
        for _, line := range stackBuffer {
            fmt.Println(line)
        }

        // Exit the program with a non-zero status code
        os.Exit(1)
    }
}

func readFileLines(filename string) ([]string, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close()

    var lines []string
    scanner := bufio.NewScanner(f)
    for scanner.Scan() {
        lines = append(lines, scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        return nil, err
    }

    return lines, nil
}

func printOffendingLine(filename string, fileContent []string, lineNum int) {
    startLine := lineNum - 3
    if startLine < 0 {
        startLine = 0
    }
    endLine := lineNum + 1
    if endLine >= len(fileContent) {
        endLine = len(fileContent) - 1
    }

    fmt.Printf("\n%sOffending line: %s%s:%d%s\n", yellow, green, filename, lineNum, reset)
    for idx, content := range fileContent[startLine:endLine] {
        if idx+startLine == lineNum-1 {
            fmt.Printf("  %s%d: %s%s\n", yellow, idx+startLine+1, content, reset)
        } else {
            fmt.Printf("  %d: %s\n", idx+startLine+1, content)
        }
    }
}

func GetFunctionName() string {
    pc, _, _, _ := runtime.Caller(1)
    return runtime.FuncForPC(pc).Name()
}

The problem is that the above code didn't work correctly when trying to implement a simple http handler, reason being panic / recover happen per goroutine, and there's no generic catch all setup.

Because of that, even though you could make something it will be a pain in the ass to implement since you need to manually wrap each goroutine with the custom panic handler and it won't catch panics in goroutines created by third-party packages or the Go standard library.

But Alex, why didn't you just use panicparse ?
Answer: I did, but I wanted to understand why panicparse pipes the Go stacktrace to panicparse, and it's not implemented as an SDK.

Perfect solution?

Generally in life, there are no perfect solutions, just perfect compromises :)

At the end of all, my solution for having live reload and nice panics, that I can click in vscode to link to the file that caused the problem, was to use the following setup.

FROM golang:1.20-alpine AS api

RUN apk add --no-cache bash
RUN apk add --no-cache coreutils

WORKDIR /go/src/app

# Install Air and panicparse
RUN go install github.com/cosmtrek/air@latest
RUN go install github.com/maruel/panicparse/v2@latest

# Copy Go modules and dependencies to image
COPY go.mod ./

# Download Go modules and dependencies
RUN go mod download

# Copy directory files
COPY . ./

CMD ["/bin/bash", "scripts/dev.sh"]

And have the following startup script:

#!/bin/bash
export GOTRACEBACK=all

stdbuf -oL air -c .air.toml 2>&1 | \
stdbuf -oL panicparse -force-color -rel-path | \
stdbuf -oL sed 's/\(app\/[^ ]*\)/\1    /g' | \
stdbuf -oL sed 's/\(app\/\)//g'

For the reason on why I used cosmtrek/air, and not CompileDaemon, was pretty easy, but at the same time pretty dumb, I couldn't make CompileDaemon send the correct SIGTERM signal to my app in order to gracefully stop the net/http server.

Sed is there purely for making the links clickable in vscode, since otherwise panicparse keeps app/ at the start of the path even if it's in -rep-path mode.

You do need to use stdbuf -oL since otherwise sed does block buffered, not line buffered, and docker's default log output doesn't like it.

This brings us from the generic panic handler:

To this output panic parse output:

50 Shades of Gray - Are Standups Good or Not

Alexandru Bucur — Sun, 03 Oct 2021 14:29:46 +0000

I’ve noticed that a few articles are arguing about how useful standups are or aren’t on a day-by-day basis, making it a white or black decision. But the situation is a bit more complicated than that.

To make it clear, I 100% agree that if your standup is a quick recap of Alex is working on feature X and Bob the sailor man is working on feature Y, tasks that are in your task management system then it brings zero value to the table.

But it doesn’t need to be that way and I’ll try being the devil’s advocate.

You don’t need to do standups if your team/squad/cell/happy family is all spread across the world.

It should be possible to better isolate projects and have smaller 3–5-man team in each time zone (+/- 2 hours)

Check a standup’s team composition, you might not need your managers.

Call them Morning Sunshine Chat, or Brainfart Session, or whatever name you want.
Why might you ask? Because it’s good to have engineers staying together for a few minutes, rant off about what they’re bothered about and increase the team cohesion. This might sound like a cliche (and it is) but for me, so far interaction with my fellow peers is high on my list of nice things to have.

It might trigger some unexpected domain knowledge sessions:

Think of it this way, you might have a perfectly documented system with 100% test coverage and CI/CD, with updated 3’rd party components that magically don’t break anything, or you might admit you had a nice dream and wake up.

The reason is that the bigger the project, and the varied the feature set, there just might be things that fell between the cracks. That’s normal, there’s no magical fix-it button for a system.

A quick chat about an engineer’s issues with a task in your sprint/Kanban board/email list/cookie template might just remind somebody else in your team that:

They worked on something similar before in the project
They worked on something similar before in another company
They might want to pair up or offer to pair up. The reason is since they know this is a convoluted piece of code in which 100% test coverage means nothing since you could introduce new exceptions that might or might not be covered by tests.

Golang Datetime Cheatsheet from strftime*

Alexandru Bucur — Sun, 25 Jul 2021 11:31:31 +0000

When I initially started working with Go the time format it seemed a bit clunky.

Maybe it's because it's a departure from the normal strftime, but also maybe it's also because there's no simple cheatsheet for the various date formatting options like you would see for example in the PHP documentation or in the Python documentation or to use the fancy language of the day, the Rust Chrono crate documentation.

The alternative is to read the source code, specifically the private constants.

That being said, here is a simple cheatsheet between the golang time format and php datetime format to make it easier to switch.
No two strftime implementations are identical on what they support across various languages (especially if you look at 0 prefixed minutes or seconds), but most of the basic things like Y for full year are present.

`golang` character	`php` character	Description	Example returned values
Day	Day	---	---
`01`	`d`	Day of the month, 2 digits with leading zeros	`01` to `31`
`Mon`	`D`	A textual representation of a day, three letters	`Mon` through `Sun`
`1`	`j`	Day of the month without leading zeros	`1` to `31`
`Monday`	`l` (lowercase 'L')	A full textual representation of the day of the week	`Sunday` through `Saturday`
Month	Month	---	---
`January`	`F`	A full textual representation of a month, such as January or March	`January` through `December`
`01`	`m`	Numeric representation of a month, with leading zeros	`01` through `12`
`Jan`	`M`	A short textual representation of a month, three letters	`Jan` through `Dec`
`1`	`n`	Numeric representation of a month, without leading zeros	`1` through `12`
Year	Year	---	---
`2006`	`Y`	A full numeric representation of a year, 4 digits	Examples: `1999` or `2003`
`06`	`y`	A two digit representation of a year	Examples: `99` or `03`
Time	Time	---	---
`pm`	`a`	Lowercase Ante meridiem and Post meridiem	`am` or `pm`
`PM`	`A`	Uppercase Ante meridiem and Post meridiem	`AM` or `PM`
`3`	`g`	12-hour format of an hour without leading zeros	`1` through `12`
`15`	`G`	24-hour format of an hour without leading zeros	`0` through `23`
`03`	`h`	12-hour format of an hour with leading zeros	`01` through `12`
`N/A`	`H`	24-hour format of an hour with leading zeros - not possible in Golang	`00` through `23`
`4`	`i`	Minutes with leading zeros	`00` to `59`
`04`	`N/A`	Minutes without leading zeros	`0` to `59`
`5`	`s`	Seconds with leading zeros	`00` through `59`
`05`	`N/A`	Seconds without leading zeros	`00` through `59`
Timezone	Timezone	---	---
`MST`	`e`	Timezone identifier	Examples: `UTC`, `GMT`, `Atlantic/Azores`
`-0700`	`O`	Difference to Greenwich time (GMT) without colon between hours and minutes	Example: `+0200`
`Z07:00`	`p`	Difference to Greenwich time (GMT) with colon between hours and minutes	Example: `+02:00`
`MST`	`T`	Timezone abbreviation	Examples: `EST`, `MDT` ...
`-070000`	`Z`	Timezone offset in seconds. The offset for timezones west of UTC is always negative, and for those east of UTC is always positive.	`-43200` through `50400`

How to read metadata easily in powershell with TagLibSharp

Alexandru Bucur — Sun, 21 Mar 2021 11:56:24 +0000

Doing my quarterly phone image cleanup and backup on onedrive I noticed that the script I was using wasn't quite consistent on the folder year and month generation.

If you think of it it does make sense, since it's basically doing a smart workaround on using LastWriteTime for its date source, but that isn't always good enough.

After some hours googling around (not yet on a 'binge' :D) I got two options that looked great.

Reading the Date Taken from the file using ComObject
Reading it using TagLibSharp

Reading the Date Taken from the file using ComObject

  $shellObject = New-Object -ComObject Shell.Application
  $directoryObject = $shellObject.Namespace($file.Directory.FullName)
  $fileObject = $directoryObject.ParseName($file.Name)

  $property = 'Date taken'
  for (
    $index = 5;
    $directoryObject.GetDetailsOf($directoryObject.Items,$index) -ne $property;
    ++$index
    ) {}

  $dateString = $directoryObject.GetDetailsOf($fileObject,$index)

The problem for me was that I couldn't parse that date string to an actual DateTime object no matter what I tried ([datetime]::Parse / [datetime]::ParseExact with various formatting, even if g should have been a match, various cultures etc (including just sending $null)).

If anyone has any ideas on how to fix this I'm really curious.

Reading it using [TagLibSharp]

The tricky part for me here was understanding how to load a c# dll in powershell.
If you install the package using nuget the easiest way to figure out where the package is installed is to run Get-Package TagLibSharp | Format-List -Property Source.

Your output should be similar to:

❯ Get-Package TagLibSharp | Format-List -Property Source

Source : C:\Program Files\PackageManagement\NuGet\Packages\TagLibSharp.2.2.0\TagLibSharp.2.2.0.nupkg

Once we know that we can use the following code to load the dll in our powershell script:

    $TagLib = "C:\Program Files\PackageManagement\NuGet\Packages\TagLibSharp.2.2.0\lib\netstandard2.0\TagLibSharp.dll"
    Add-Type -Path $TagLib

    [System.Reflection.Assembly]::LoadFile($TagLib)

The reading part is really easy, and for images the property you want to look for is ImageTag:

$tag = [TagLib.File]::Create($file)
$tag.ImageTag

There are a few nice things to gain once using TagLibSharp.

ImageTag has a DateTime object directly available.
You have full access to the image metadata so you could for eg create folders automatically based on the latitude and longitude with the closest city name. In case this sounds interesting please let me know and I'll try doing an updated version that does just that.
We can implement a fallback to the simple Tag for videos for eg.

Full version can be found below and in the gist.

    $TagLib = "C:\Program Files\PackageManagement\NuGet\Packages\TagLibSharp.2.2.0\lib\netstandard2.0\TagLibSharp.dll"
    Add-Type -Path $TagLib

    [System.Reflection.Assembly]::LoadFile($TagLib)

    # Get the files which should be moved, without folders
    $files = Get-ChildItem 'X:\OneDrive\Pictures' -Recurse | Where-Object { !$_.PSIsContainer }

    # List Files which will be moved
    $files

    # Target Filder where files should be moved to. The script will automatically create a folder for the year and month.
    $targetPath = 'X:\OneDrive\Photos'

    foreach ($file in $files) {
      $tag = [TagLib.File]::Create($file)

      # Get year and Month of the file
      if ($tag.ImageTag.DateTime) {
        $year = $tag.ImageTag.DateTime.Year.ToString()
        # add 0 prefix to month
        $month = $tag.ImageTag.DateTime.Month.ToString("00")
      }
      elseif ($tag.Tag.DateTime) {
        $year = $tag.Tag.DateTime.Year.ToString()
        # add 0 prefix to month
        $month = $tag.Tag.DateTime.Month.ToString("00")
      }
      else {
        # I used LastWriteTime since this are synced files and the creation day will be the date when it was synced
        $year = $file.LastWriteTime.Year.ToString()
        # add 0 prefix to month
        $month = $file.LastWriteTime.Month.ToString("00")
      }

      # Out FileName, year and month
      $file.Name
      $year
      $month

      # Set Directory Path , change as wanted
      $Directory = $targetPath + "\" + $year + "\" + $year + "-" + $month
      # Create directory if it doesn't exists
      if (!(Test-Path $Directory)) {
        New-Item $directory -type directory
      }

      # Move File to new location, remove -Force if you might have files with the same name, i've used it since i knew that duplicates are ok to overwrite
      $file | Move-Item -Destination $Directory -Force
    }

Why developers should be "lazy"

Alexandru Bucur — Mon, 30 Nov 2020 22:32:36 +0000

Looking back to all the years I've been developing and all the developers I worked with, the best developers were always the "lazy" ones.

What do you mean by "lazy" you might ask, or why do I think that "lazy" developers are great?

It's rather simple:

A "lazy" developer is going to write less code to get the job done. Since he wants to have things working, not tinker with overcomplicated abstractions or feel the need ro fill lines of code to justify work.
A "lazy" developer is going to have more readable code. Since he knows that 80% of the time you're reading code, not writing it.
A "lazy" developer doesn't want to do support or extra work. So that's why he's extra careful in testing and writing tests so he can have minimal downtime.

That's pretty much it :)

Simple JSON:API plugin for Nuxt.js

Alexandru Bucur — Sun, 11 Aug 2019 17:41:18 +0000

Hi all,

So far I am keeping myself on track to work a bit every weekend on my side projects.

That being said, I am a big fan on JSON:API and in my search for streamlining the consumption on the front-end I've finally settled on a nifty JSON:API client called Devour. It has the right amount of magic to make it worthwile and not be over the top 'magical'.

For that, I've made a small nuxt.js plugin that allows me to use it regardless if it's in a component or in the vuex store.

import JsonApi from "devour-client";
import * as apis from "~/api/index.js";

export default (ctx, inject) => {
  // eslint-disable-next-line no-undef
  const jsonApi = new JsonApi({ apiUrl: CONFIG.backend.url });
  const apiMap = {};

  for (const [key, value] of Object.entries(apis)) {
    jsonApi.define(
      apis[key].structure().modelName,
      apis[key].structure().fields
    );
  }

  for (const [key, value] of Object.entries(apis)) {
    // eslint-disable-next-line no-undef
    apiMap[key] = new apis[key](jsonApi, CONFIG);
  }

  apiMap.jsonApi = jsonApi;

  // Inject into the nuxt/vue context
  ctx.$api = apiMap;
  inject("api", apiMap);
};

The CONFIG constant is generated by the following library config and injected into the app for easy access.

To use the plugin, index.js is a generic export for the various API models that we're going to use.

export { default as InventoryItem } from "./InventoryItem";

The model is nothing more than a simple object that returns the required configuration for the api and exposes it after trough its own methods.

I'd rather not tightly couple the app to Devour, so keeping them into our own classes should make it easier to swap it out going forward, and/or just use axios directly if needed.

export default class InventoryItem {
  constructor(api, config) {
    this.api = api;
    this.config = config;
  }

  static structure() {
    return {
      modelName: "inventory-item",
      fields: {
        name: ""
      }
    };
  }

  getInventoryItems() {
    return this.api.findAll(InventoryItem.structure().modelName);
  }
}

I am curious on knowing how you guys are separating your API calls in your own SPA apps

Sideprojects Motivations and Goals

Alexandru Bucur — Sun, 04 Aug 2019 19:08:17 +0000

Hi Everyone,

This is more of an introspective blog post regarding side-projects and finding the motivation and time to do other 'work' outside of the daily job.

As you may or may not notice, I had a solid 6+ months pause from blogging.

The main issue here was the fact that I have the tendency at times in my side projects to search for the best solution, and not focus on the task at hand. Hence, this caused a lack of progress, that well, reduced the 'rewards' so the motivation all but vanished.

Since I recently re-started working on some side projects, there are a few things that I noted down that at least in my case helped to keep myself motivated.

If you are starting a new project, allocate time to define what a minimal viable product means for you.

My mistake here was that I was thinking initially that the project I want to work on will cover a broad range of features.
Allocate at least 30 minutes of uninterrupted time to work on your project.

Don't keep reddit, youtube, ycombinator or any other sites open while you work on your project since at least for me, I am tempted to do a refresh and read new things. That, in turn, makes the limited available time for the side project to get that much smaller.
Don't chase magical solutions that cover all cases, but work on your product and do clean up as you advance.

You will be tempted to work on the 'best' solution since you're not at your daily job and be strongly against cutting corners. But the issue here is that without real deadlines you will not progress and the project world, in general, is full of imperfect solutions that get their job done.
If you choose a technology that takes you out of your comfort zone, have a good reason to do it or just stick to your best technology.

When I initially started on the project, my main motivation was working more with C# . At some point I was asking myself if this isn't something that just keeps me back on being more productive than just writing the backend in something I'm more comfortable with (mainly PHP, Python or Javascript), but at the end of the day it's more important for me to get out of my comfort zone.

Hopefully, this will ring a bell and help somebody else go over their impasse and continue to have fun and progress when working with new things or doing side projects.

How to Stop requestAnimationFrame in Vuejs / Javascript

Alexandru Bucur — Sat, 20 Jul 2019 13:10:10 +0000

TLDR:

let id = window.requestAnimationFrame(fancyFunctionHere)
window.cancelAnimationFrame(id);

Now for the longer version. Technically in Vue.js you might have components/mixins that use window.requestAnimationFrame. Since the fancyFunctionHere is used as a callback, everytime you call window.requestAnimationFrame you are going to get a new id that you should use on the destroy method to stop it.

Unfortunately this is not imediately clear on MDN so hopefully my documentation edit with the comment in the code example goes trough.

{
    created() {
        this.id = window.requestAnimationFrame(
            this.fancyFunctionHere
        );
    },

    destroyed() {
        window.cancelAnimationFrame(this.id);
        this.id = undefined;
    },

    data() {
        return {
            id: undefined
        }
    }

    methods: {
        fancyFunctionHere() {

        }
    }
}

Systemctl shows service file Not Found even though .service file is present

Alexandru Bucur — Mon, 17 Jun 2019 09:05:14 +0000

Hi All,

I'm writing a step by step setup for a self hosted gitea instance (on CentOS 7) and hit the stupidest bug (if you can call it that) of systemd.
After writing the gitea service file I was getting the following error:

[root@gitea ~]# systemctl start giteaselfhost
Failed to start giteaselfhost.service: Unit not found.

After a few hours of maddening permission checks and debugging, the problem was that I had a Requires dependency to a service file that wasn't there.

Removing the broken dependency made the service work, so hopefully at some point systemd will give nicer errors when missing dependencies.