Forem: taijidude

Small prototype... easy coding flash cards on android

taijidude — Thu, 07 Nov 2024 17:32:27 +0000

My Problem...

I recently read the wonderful book the-programmers-brain. One take-away was that if you study concepts with flash cards it will help learn new stuff more efficiently. So i was looking for a while now how to do that using my android phone.

I'm a pretty heavy obsidian user and had a look at the plugins i knew of but was not really satisfied and looked and some apps. This didn't really worked easly or made me jump through more hoops than i wanted to.

I'm no Android Developer yet and not really a web dev either. I want to use flash cards to learn angular and typescript, so my options were a litte limited. Here is what i came up with:

My Solution...

There is a fantastic app called termux on android which gives you a complete linux environment.

termux

In termux you are able to work with python and git. So i came up with a small python project containing of one python script and a markdown file at the moment.

The python file uses the rich library because i can render markdown pretty to the cli (with syntax highlighting).

from rich.console import Console
from rich.markdown import Markdown

def main():
    console = Console()
    with open("angular.md") as f:
        content: str = f.read()
        cards: list[str] = content.split('<!-- Card -->')
        numberOfCards: int = len(cards)
        for card in cards:
            console.clear()
            sides = card.split('<!-- Sides -->')
            console.print(Markdown(sides[0])) 
            input("\nshow the answer!")
            console.print(Markdown(sides[1]))
            input("\nnext card!")
            console.clear()
if __name__ == "__main__":
    main()

The content of my flashcards is stored in a markdown file. I use html comments to seperate the individual cards and the question and the answer on each individual card.

I have this all on a little github project. github. (The name of the project will change.) S

On my phone i have to clone the repo in termux:

git clone https://github.com/taijidude/mochi-cards.git

Install the needed dependencies (typer is a neat cli framework which brings the rich library as dependency. I use typer here because i want to do more with it in the future. )

pip install typer

and than can run the app:

python app.py

Finally i get a basic flashcard functionality with syntax highlighting.
After starting:

When hitting enter the answer is shown:

When hitting enter again i get the next question:

Thank you for your Attention!

A first try of typescript and deno 2

taijidude — Sat, 02 Nov 2024 17:28:19 +0000

After joining a new company I get to work with angular and typescript. To get more familiar with typescript I'm trying to use it as much as possible. I recently started with a small cli app for my git workflow. (I'm fully aware that this can be done in bash... 😉).

The problem...

When working with git I tend to use the git bash on windows. I switch branches often and would like to quickly go back to the branch I have been previously working on.

Example:
The first thing I want my solution to do is to show me the branch I previously worked on. This information should be updated, if I switch branches.

my_computer MINGW64 /c/Dev/temp/blogarticle (test1)
$ gst #Shows the previous branch name along with the output of git status  
previous branch: main ❗
On branch test1
nothing to commit, working tree clean

my_computer MINGW64 /c/Dev/temp/blogarticle (test1)
$ gch main # checks out the branch with the name main
Switched to branch 'main'

my_computer MINGW64 /c/Dev/temp/blogarticle (main)
$ gst
previous branch: test1 ❗
On branch main
nothing to commit, working tree clean

Additionally, I want to be able to switch back to the previous branch. Like this...

my_computer MINGW64 /c/Dev/temp/blogarticle (main)
$ gst
previous branch: test1
On branch main
nothing to commit, working tree clean

my_computer MINGW64 /c/Dev/temp/blogarticle (main)
$ gchl ❗
Switched to branch 'test1'

my_computer MINGW64 /c/Dev/temp/blogarticle (test1)
$ gst
previous branch: main
On branch test1
nothing to commit, working tree clean

The solution...

Deno intrigued me for a long time, so I picked it for this first try. Why?

It can compile your code into native executables.
It comes with a key-value store functionality.
with version 2 you are now able to use npm libraries. I've used commander js to implement the command line functionality. Installing a npm library into your project looks like this:

deno install npm:commander

The code...

import {program} from "commander";

const dbPath:string = "C:\\Dev\\projects\\rememberGitBranch\\db.sqlite3";
const branchKey:string = "previousBranch"

export async function save(branch: string) {
  const kv = await Deno.openKv(dbPath);
  kv.set([branchKey], branch);
  kv.close();
}

export async function load(): Promise<string> {
  const kv = await Deno.openKv(dbPath);
  const lastBranch = (await kv.get([branchKey])).value
  kv.close();
  return lastBranch as string;
}

program
  .command('save')
  .description('save the name of the branch you worked with last')
  .requiredOption('-b, --branch <branch>', 'The branch to work with')
  .action(options => {
    save(options.branch);
  });

program
  .command('load')
  .description('loads the last branch name saved with the save command')  
  .action(() =>  {
    load().then(value => console.log(value));
  });

program.parse();

Lets have a look at the output of the help function.

my_computer MINGW64 /c/Dev/projects/rememberGitBranch
$ ./rememberGitBranch.exe --help
Usage: main [options] [command]

Options:
  -h, --help    display help for command

Commands:
  save [options]  save the name of the branch you worked with last   
  load          loads the last branch name saved with the save command
  help [command]  display help for command

As we can see, the app can be run with three commands, with one beeing the help function.

save: the save command takes a string parameter and runs the save function in the main.ts file. This function calls key-value Store stores it with a key named lastBranch. When opening the connection to the kv store i give it the path of the database file. Normally i would not have to do this, but because the deno runtime has a default storage file. But when you compile your code into an executable it doesn't know about the default file. So you have to explicitly give it a path.
If the file doesn't exists it will get created.

The output for the help call about the save command:

$ ./rememberGitBranch.exe save --help
Usage: main save [options]

save the name of the branch you worked with last

Options:
  -b, --branch <branch>  The branch to work with
  -h, --help            display help for command

load: this commands executes the load function in the main.ts file. This function opens a connection to the kv store and queries it with the key "previousBranch". The function return the result of the query as string. This string gets printed.

The output for the help call about the load command:

$ ./rememberGitBranch.exe load --help
Usage: main load [options]

loads the last branch name saved with the save command

Options:
  -h, --help  display help for command

Compiling the executable

deno compile --allow-write --allow-read --unstable-kv main.ts

The result is a shiny new exe file in my project directory:

my_computer MINGW64 /c/Dev/projects_patrick/rememberGitBranch
$ ls
db.sqlite3  deno.json  deno.lock  main.ts  main_test.ts  rememberGitBranch.exe*

Putting everything together...

Here you see some parts of my .bashrc file which uses the new cli app. This allows me to do the things i have shown in the problem section.

alias gst='echo "previous branch:" $(rememberGitBranch.exe load) && git status'
alias gch='rememberGitBranch.exe save -b "$(git branch --show-current)"&&git checkout'
function gchl {
    currentBranch=$(git branch --show-current) &&
    git checkout "$(rememberGitBranch.exe load)"
    rememberGitBranch.exe save -b "$currentBranch"
}

Take Aways

I had fun trying this out and after a short amount of time had something in my hand that i will use in my day to day workflow. I think it's a nice way to learn about the language and most of the frameworks on a frequent basis. I have some more ideas for some cli apps and for some webapps but i need to get a little further in the udemy angular course i'm doing to work on those.

Thank you for reading! Would you have done anything different? Is there something to make the code more idiomatic?

Check if date is between two other dates

taijidude — Wed, 18 Sep 2024 14:24:10 +0000

A small method to check if a LocalDataTime is in a Range between to other LocalDateTime - Objects.

private boolean isInDateRange(
                        LocalDateTime upper,
                        LocalDateTime lower,
                        LocalDateTime toCheck) {
    var isUpper = toCheck.equals(upper);
    var isLower = toCheck.equals(lower);
    if (isLower || isUpper) {
        return true;
    }
    return toCheck.isBefore(upper) && toCheck.isAfter(lower);
}

Convert LocalDateTime to Date and back

taijidude — Wed, 18 Sep 2024 13:43:58 +0000

At the moment i have to write a lot of Integeration Tests for a migration project. The old code uses java.util.Date a lot, but the project runs in Java 17. So i wanted to use the newer Date Classes for my tests.

I used the following two helper methods to convert Date to LocalDateTime and back.

private LocalDateTime toLocalDateTime(Date toConvert) {
    var instant = toConvert.toInstant();
    var zonedDateTime = instant.atZone(ZoneId.systemDefault());
    return zonedDateTime.toLocalDateTime();
}

private Date toDate(LocalDateTime toConvert) {
    var zonedDateTime = toConvert.atZone(ZoneId.systemDefault());
    return Date.from(zonedDateTime.toInstant());
}

Pod not starting in openshift

taijidude — Mon, 18 Sep 2023 13:16:40 +0000

Today i had a curious case of a pod in openshift with problems to start. The pod contained a simple enough springboot rest web service. The logs looked all fine, But nevertheless openshift would restart the service 4 times and give up with a fairly meaningless error message.

Turns the dependency for the actuator was missing, so openshift could not reach the two endpoints /actuator/health and /actuator/info. These endpoints were configured in the openshift deployment config for the liveness probe and the readiness probe. So openshift could not know the spring app was started successfully and gave up after 4 tries.

I will add two tests for those endpoints.

pgsql Cheatsheet

taijidude — Fri, 16 Jun 2023 17:59:55 +0000

One of my recent tasks was the migration of a small spring boot web service to openshift. The webservice works with a postgres which runs in an openshift pod. I had to migrate the database as well.

The psql CLI Tool came in very handy with working with the database. I could get stuff done quickly and work directly on the openshift pods.

Here are my Notes on the psql Tool:

Get help

From the shell:

psql --help

While running the tool:

postgres=# \?

Connect to a database

psql <database name> [--User <username>]

Example:

psql TESTDB --User testuser

Quit psql

postgres=#\q

list all tables

postgres=#\dt

list all sequences

postgres=#\ds

list all users on the data base

postgres=#\du

Execute SQL Queries and Scripts

From the command line:

psql <database name> [--User <username> -c <command> 
psql <database name> [--User <Username>] -f <Filename>

From the running psql tool you can just write your sql statements:

postgres=#select * from TESTTABLE;

Some more command line tools.

Drop a database

Besides the SQL Drop Database Statement postgres offers another cli utility: dropdb

dropdb <connection parameters> <options> <database name>

Create a Data Dump

To backup data the pg_dump tool might come in handy. The pattern for it is the following:

 pg_dump --table=<tablename> --data-only --column-inserts <databasename>

TIL: isBlank() String Method

taijidude — Tue, 25 Apr 2023 16:09:44 +0000

Today i learned that in Java 11 there was a new String Method introduced that checks if a string is empty or just contains blanks and the same time.

So instead of this:

String toCheck = " ";
if(toCheck.trim().isEmpty()) {
...
}

You can do this:

String toCheck = " ";
if(toCheck.isBlank()) {
...
}

Makes the if statement a bit cleaner.

Get help for a maven plugin

taijidude — Thu, 09 Mar 2023 14:04:10 +0000

Today i was fighting to get a vaadin app building again with maven. During my search for documentation of the vaadin maven plugin i came across this neat little trick. You can get maven to print out help goal descriptions for you with the following command

mvn help:describe -Dplugin=vaadin

The result:

...
Name: Vaadin Maven plugin
Description: Vaadin Platform
Group Id: com.vaadin
Artifact Id: vaadin-maven-plugin
Version: 14.8.0
Goal Prefix: vaadin

This plugin has 8 goals:

vaadin:build-frontend
  Description: Goal that builds the frontend bundle. It performs the
    following actions when creating a package:
    - Update Constants.PACKAGE_JSON file with the NpmPackage annotations
      defined in the classpath,
    - Copy resource files used by flow from `.jar` files to the `node_modules`
      folder
    - Install dependencies by running npm install
    - Update the FrontendUtils.IMPORTS_NAME file imports with the JsModule
      Theme and JavaScript annotations defined in the classpath,
    - Update FrontendUtils.WEBPACK_CONFIG file.

vaadin:clean-frontend
  Description: Goal that cleans the frontend files to a clean state.
    Deletes Vaadin dependencies from package.json, the generated frontend
    folder and the npm/pnpm-related files and folders:

    - node_modules
    - pnpm-lock.yaml
    - package-lock.json

vaadin:copy-production-files
  Description: Goal that copies all production mode files into the
    CopyProductionFilesMojo.copyOutputDirectory directory. Files are copied
    from CopyProductionFilesMojo.frontendWorkingDirectory directory, WebJars
    and regular jars, refer to ProductionModeCopyStep for details.

vaadin:dance
  Description: This is the hidden `vaadin:dance` to clean up the frontend
    files.

vaadin:migrate-to-p3
  Description: This goal migrates project from compatibility mode to NPM
    mode.

vaadin:package-for-production
  Description: Goal that prepares all web files from
    PackageForProductionMojo.transpileEs6SourceDirectory for production mode:
    minifies, transpiles and bundles them.

vaadin:prepare-frontend
  Description: This goal checks that node and npm tools are installed, copies
    frontend resources available inside `.jar` dependencies to `node_modules`,
    and creates or updates `package.json` and `webpack.config.json` files.

vaadin:validate
  Description: This goal checks that node and npm tools are installed, copies
    frontend resources available inside `.jar` dependencies to `node_modules`,
    and creates or updates `package.json` and `webpack.config.json` files.
  Deprecated. use {@link PrepareFrontendMojo} instead

For more information, run 'mvn help:describe [...] -Ddetail'

...

Another example, you can use this with the help plugin itself:

mvn help:describe -Dplugin=help

The Result:

Name: Apache Maven Help Plugin
Description: The Maven Help plugin provides goals aimed at helping to make
  sense out of the build environment. It includes the ability to view the
  effective POM and settings files, after inheritance and active profiles have
  been applied, as well as a describe a particular plugin goal to give usage
  information.
Group Id: org.apache.maven.plugins
Artifact Id: maven-help-plugin
Version: 3.3.0
Goal Prefix: help

This plugin has 8 goals:

help:active-profiles
  Description: Displays a list of the profiles which are currently active for
    this build.

help:all-profiles
  Description: Displays a list of available profiles under the current
    project.
    Note: it will list all profiles for a project. If a profile comes up with a
    status inactive then there might be a need to set profile activation
    switches/property.

help:describe
  Description: Displays a list of the attributes for a Maven Plugin and/or
    goals (aka Mojo - Maven plain Old Java Object).

help:effective-pom
  Description: Displays the effective POM as an XML for this build, with the
    active profiles factored in, or a specified artifact. If verbose, a comment
    is added to each XML element describing the origin of the line.

help:effective-settings
  Description: Displays the calculated settings as XML for this project,
    given any profile enhancement and the inheritance of the global settings
    into the user-level settings.

help:evaluate
  Description: Evaluates Maven expressions given by the user in an
    interactive mode.

help:help
  Description: Display help information on maven-help-plugin.
    Call mvn help:help -Ddetail=true -Dgoal=<goal-name> to display parameter
    details.

help:system
  Description: Displays a list of the platform details like system properties
    and environment variables.

You can even more details if you add -Ddetail to your command.

mvn help:describe -Dplugin=help -Ddetail

The Result:

...
help:system
  Description: Displays a list of the platform details like system properties
    and environment variables.
  Implementation: org.apache.maven.plugins.help.SystemMojo
  Language: java

  Available parameters:

    output
      User property: output
      Optional parameter to write the output of this help in a given file,
      instead of writing to the console.
      Note: Could be a relative path.
...

Path conversion in git bash

taijidude — Fri, 17 Feb 2023 13:49:47 +0000

Hello again,

today i have a small advice for you if you work with the git bash on windows.

To quickly convert paths from windows format to unix format you can use the cygpath tool:

Unix to windows:

$ cygpath -w /d/temp
D:\temp

Windows to unix:

$ cygpath -u 'D:\temp'
/d/temp

Another nice tool that helps you with the conversion of an relative path is realpath. This is useful because it allows your scripts to accept relative paths and than figure out the absolute paths themselve.

Example:

$ ls 
test.txt
$ realpath -s ./test.txt
/d/realpathtest/test.txt

When you give an absolute path to realpath it will just print this path. So if you are working with file paths, this will make your scripts more flexible.

$ realpath -s /d/realpathtest/test.txt
/d/realpathtest/test.txt

check the return code in an if clause

taijidude — Thu, 27 Oct 2022 10:32:55 +0000

I'm working on a bash script that uses git to clone all of our git repositories (only the necessary stuff). We have a mixture of master (old projects, and yes we have a task to migrate this) and main as the repo main branches.

I want the script to first try to clone the branch named master and if this fails try to clone the branch named main.

git docs

My first try

 git clone --depth 1 --branch main "$repoUrl" "$targetFolder"
 if [[ "$?" != "0" ]]; then
   git clone --depth 1 --branch master "$repoUrl" "$targetFolder"
 fi

The first statement tries to clone the master branch of the repository with a url contained within the var repoUrl. And it clones it into a directory contained in the var targetFolder.
Only the latest commit is cloned because of the --depth 1.

So far so good. But i have started using shellcheck a while ago (blog post coming) and it alerted me to slightly better solution.

Turns out it's possible to write it like this:

if ! git clone --depth 1 --branch main "$repoUrl" "$targetFolder"; then
    git clone --depth 1 --branch master "$repoUrl" "$targetFolder"
fi

You are able to run the command whose return code you want to check directly in the if clause. I'm doing this here and checking for a return code that says the execution was not successful.

Still some repetition. We could pull this into a function.

gitclone() {
  git clone --depth 1 --branch "$1" "$2" "$3"
}
if ! gitclone "main" "$repoUrl" "$targetFolder"; then
    gitclone "master" "$repoUrl" "$targetFolder"
fi

TIL: Slightly over engineered (😅) text replace function (sed multiple replacements)

taijidude — Sun, 21 Aug 2022 11:58:00 +0000

I recently had to read a lot of long bash scripts. Stumbled about a few things I found interesting and played a little with them. I will explain them later. But first behold the mighty text replace function i created will played around.

function repl {
    if [[ "$#" -eq 0 ]]; then
        echo "[ERROR]The parameter list needs at least 3 items. The file to work with, the string to replace and the new string! ";
        return
    fi
    local file="$1";
    if ! [[ -f "$file" ]]; then
            echo "[ERROR]The $file doesn't exists!";
            return
    fi
    shift;
    if [[ "$#" -eq 0 ]]; then
        echo "[ERROR]No parameters except the file found!";
        return
    fi
    if [[ $(expr "$#" % 2 ) -eq 1 ]]; then
        echo "[ERROR]Invalid Amount of parameters after the filename!"
        return
    fi
    old=""
    new=""
    replacements=""
    for item in "$@"
    do
        if [[ -z "$old" ]];
        then
            old=$item;
        elif [[ -n "$old" ]] && [[ -z "$new" ]]
        then
            new=$item;  
        fi
        if [[ -n "$old" ]] && [[ -n "$new" ]]
        then
            replacements="s/$old/$new/g; "
            sed -i "$replacements" $file
            unset old;
            unset new;
        fi
    done

}

It's a convenient wrapper function around a sed call to edit a file. For an example let's assume we have the following data file.

The Republic is in control of this planet now.
A Jedi will arrive shortly to solve the most important problems.
The local ewok tribes will be rescued.

This file needs a few corrections. In the bash shell normally sed can be used to edit this file in place.

sed -i s/Republic/Empire/g StarWars.txt
sed -i s/Jedi/Inquisitor/g StarWars.txt
sed -i s/rescued/murdered/g StarWars.txt
cat StarWars.txt

The Empire is in control of this planet now.
A Inquisitor will arrive shortly to solve the most important problems.
The local ewok tribes will be murdered.

Ah, that's better. 😉

You can even write this in one line.

sed -i s/Republic/Empire/g; s/Jedi/Inquisitor/g; s/rescued/murdered/g; StarWars.txt

After this discovering this, i relealized i might not need my function at all. But as an excersis it was nice and i learned a few things.

So how does a call of my function look?

repl StarWars.txt Republic Empire Jedi Inquisitor rescued murdered

It's a little bit less verbose. And provides a little bit of additional error handling. But I need to check out sed's error handling. Maybe I can throw out my custom error handling.

One big takeaway from this (again): What are you trying to do has likely been done before and there likely is a solution for this.

But anyway, What else did I learn?

local: If you put the local keyword in front of a variable. The variable is only visible in the block of code where it is declared.

function ltest {
    local test="Hello from the ltest function!";
    echo "$test"
}
ltest
echo "-->$test"

The result is:

$ ./test456.sh
Hello from the ltest function!
-->

unset: With this keyword you are able to clear previously set variables.

test="Hello!";
echo "-->$test"
unset test
echo "-->$test"

The result is:

$ ./test456.sh
-->Hello!
-->

test command: To test specific conditions for if statement bash has the test command. With this tool you are able to check file attributes and to string and number comparisons. It doesn't has output. But if it exits with a with 0 that means the supplied expression is true. A 1 stands for false.

test 1 -lt 2 && echo "true"
# There is an shortcut to write this
[ 1 -lt 2 ] && echo "true"
# You will see a third way of writing this.
[[ 1 -lt 2]] && echo "true"
# This will run another test command that bash has adopted from the kornshell.

The kornshell test command seems to offer more functionality and the general recommendation seems to be to use it instead of the bash one.

shift: This shifts every parameter in you function to the left and puts every parameter in a lower position. The first parameter gets dropped.

echo "$@";
shift;
echo "$@";
shift;
echo "$@";

The result:

$ ./test456.sh 1 2 3
1 2 3
2 3
3

exit/return: To abort a script you can use the exit keyword. But this will close the shell window as well. If you don't want the window to close, just use the return keyword.

Background Jobs are not run at $PSScriptRoot

taijidude — Tue, 21 Jun 2022 05:20:40 +0000

Stumbled over this one a while ago. While i was developing a script which started several background jobs, i was making the assumption that the jobs would be run in the same directory the "mother script" was in. But turns out this is not true, as we can see in the following example.

test.ps1:

Start-Job -name test1 -ScriptBlock {(Get-Location).Path}
Wait-Job -Name test1 -Timeout 120
Receive-Job -Name test1

When you want to work with your script location, you can just pass it to your scriptblock via the argumentlist.

test2.ps1:

Start-Job -name test2 -ScriptBlock {Set-Location $args[0]; (Get-Location).Path} -ArgumentList $PSScriptRoot
Wait-Job -Name test2 -Timeout 120
Receive-Job -Name test2

And the final output: