Forem: LeafChage

How to get Location from Text in Apple Shortcuts

LeafChage — Sat, 20 Dec 2025 13:07:59 +0000

Is this possible? Yes, it is!!

I wanted to create shortcuts to notify me whether I have to take my umbrella.
And I want to share it my family as well.

That's why I want to make a list of location by Text.

This is how I solved it.

Get the URL by using map shortcuts by name.
Convert this URL into Location.
Finally, you can get weather information.

How to output log of pgx ASAP!

LeafChage — Thu, 11 Dec 2025 06:58:49 +0000

This article about github.com/jackc/pgx/v5

I want to just read logs while developing.
I don't have time to think about well-organized log.

If you think so, let's use this.

1. implement tracelog.Logger

type logger struct{}

func NewLogger() tracelog.Logger {
    return &logger{}
}

// you should update this logger before production
func (l *logger) Log(ctx context.Context, level tracelog.LogLevel, msg string, data map[string]any) {
    logArgs := make([]any, 0, len(data))
    for k, v := range data {
        logArgs = append(logArgs, k, v)
    }

    fmt.Printf("%s %s %+v\n", level.String(), msg, data)
}

2. set it on config before connecting

config, err := pgxpool.ParseConfig(dbURL)
config.ConnConfig.Tracer = &tracelog.TraceLog{
    Logger:   NewLogger(), // set your logger
    LogLevel: tracelog.LogLevelTrace,
}
pool, err := pgxpool.NewWithConfig(context.Background(), config)

OK! You can see logs:)

sample code

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/jackc/pgx/v5/pgxpool"
    "github.com/jackc/pgx/v5/tracelog"
)

type logger struct{}

func NewLogger() tracelog.Logger {
    return &logger{}
}

func (l *logger) Log(ctx context.Context, level tracelog.LogLevel, msg string, data map[string]any) {
    logArgs := make([]any, 0, len(data))
    for k, v := range data {
        logArgs = append(logArgs, k, v)
    }

    fmt.Printf("%s %s %+v\n", level.String(), msg, data)
}

func main() {
    dbURL := "postgres://sample:password@localhost:5432/sample"
    config, err := pgxpool.ParseConfig(dbURL)
    if err != nil {
        log.Fatalln(err)
    }

    config.ConnConfig.Tracer = &tracelog.TraceLog{
        Logger:   NewLogger(),
        LogLevel: tracelog.LogLevelTrace,
    }

    pool, err := pgxpool.NewWithConfig(context.Background(), config)
    if err != nil {
        log.Fatalln(err)
    }

    _ = pool
}

The info you should know before making a map app.

LeafChage — Wed, 10 Dec 2025 03:34:26 +0000

OpenStreetMap(OSM)

You can get oss data from this map.
https://www.geofabrik.de/
- You can get raw data in OSM.

Overpass API

You can use this to get OSM data.
overpass turbo
- You can try to use overpass API.

Open Source Routine Machine (OSRM)

https://project-osrm.org/
API references
- https://project-osrm.org/docs/v5.5.1/api/#general-options
the OSS to detect the route on the map
it has docker container

GeoJSON

You can easily debug your point, line, polygon data on a map.
geojson.io
- You can debug your geojson.
https://github.com/paulmach/go.geojson
- the library to handle geojson with golang.

Database

PostGIS
- https://postgis.net/
- the application to expand PostgreSQL to treat with the information about map, like point, polygon.
SpatiaLite
- https://www.gaia-gis.it/fossil/libspatialite/index
- for sqlite

Simple Stopwatch

LeafChage — Tue, 07 Oct 2025 01:51:00 +0000

I created super simple stopwatch with React.
https://leafchage.github.io/stopwatch/

It was a little hard to make restartable hook.
https://github.com/LeafChage/stopwatch/blob/main/src/hooks/interval.tsx

import { useRef, useState } from "react";

export type StopWatchCondition = | "pausing" | "running" | "initialized";
export const StopWatchCondition = {
    playable: (self: StopWatchCondition) => self === "initialized",
    replayable: (self: StopWatchCondition) => self === "pausing",
    stoppable: (self: StopWatchCondition) => self === "running",
    refreshable: (self: StopWatchCondition) => self === "pausing",
} as const;

type StopWatchState = {
    currentMs: number,
    condition: StopWatchCondition,
}
const StopWatchState = {
    init: (): StopWatchState => ({
        currentMs: 0,
        condition: "initialized",
    })
} as const;

const conditionRule = <T,>(
    condition: StopWatchCondition,
    is: StopWatchCondition,
    fn: () => T
) => {
    if (condition !== is) { throw `fatal the condition should be ${is}` }
    return fn();
}

export type StopWatch = {
    condition: StopWatchCondition,
    currentMs: number,
    pause: () => void,
    start: () => void,
    restart: () => void,
    reset: () => void,
};
export const useStopwatch = (intervalMs: number = 100): StopWatch => {
    const [state, setState] = useState<StopWatchState>(StopWatchState.init);
    const intervalID = useRef<number>(null);
    const previous = useRef<number>(Date.now());

    const start = () => conditionRule(state.condition, "initialized", () => {
        console.info("start")
        previous.current = Date.now();
        setState({ currentMs: 0, condition: "running", })
        intervalID.current = setInterval(() => {
            const now = Date.now();
            const dt = now - previous.current;

            previous.current = now
            setState(prev => ({
                currentMs: prev.currentMs + dt,
                condition: "running"
            }))
        }, intervalMs)
    });

    const pause = () => conditionRule(state.condition, "running", () => {
        console.info("pause")
        clearInterval(intervalID.current!); // should be not null;

        const now = Date.now();
        const dt = now - previous.current;
        setState(prev => ({
            currentMs: prev.currentMs + dt,
            condition: "pausing"
        }))
    });

    const restart = () => conditionRule(state.condition, "pausing", () => {
        console.info("restart")
        previous.current = Date.now();
        setState({ currentMs: state.currentMs, condition: "running", })
        intervalID.current = setInterval(() => {
            const now = Date.now();
            const dt = now - previous.current;
            previous.current = Date.now();
            setState(prev => ({
                currentMs: prev.currentMs + dt,
                condition: "running"
            }))
        }, intervalMs)
    });

    const reset = () => conditionRule(state.condition, "pausing", () => {
        console.info("reset")
        setState(StopWatchState.init())
    });

    return {
        ...state,
        start,
        restart,
        pause,
        reset,
    }
}

Super simple counter

LeafChage — Tue, 07 Oct 2025 01:46:59 +0000

I created super simple counter with sound.
please use carefully, this site make sound.

https://leafchage.github.io/counter/

Web application is so easy to make small tools.

TypeScript Channel like go

LeafChage — Sat, 04 Jan 2025 15:05:45 +0000

I wanted to use channel like Golang:)

ref: queue.ts

import { Queue } from "queue";
import { sleep } from "bun";

type Config = {
  /**
    * @description (ms)
    */
  checkInterval: number

  /**
    * @description buffer size of queue
    */
  capacity: number

  /**
    * @description timeout to wait for reading and writing(ms)
    */
  timeout: number

  /**
    * @description timeout to wait for reading(ms)
    */
  readTimeout?: number

  /**
    * @description timeout to wait for writing(ms)
    */
  writeTimeout?: number
}

const Config = {
  padding(config: Partial<Config>): Config {
    return {
      checkInterval: config?.checkInterval ?? 300,
      capacity: config?.capacity ?? 1,
      timeout: config?.timeout ?? 1000,
      readTimeout: config?.readTimeout,
      writeTimeout: config?.writeTimeout,
    }
  },
}


export interface Sender<T> {
  send(v: T): Promise<void>;
}

export interface Receiver<T> {
  receive(): Promise<T>;
}

/***
  * @todo support mutex
  */
export class Chan<T> implements Sender<T>, Receiver<T> {
  private readonly config: Config;
  private readonly buf: Queue<T>;
  public constructor(
    buf: T[] = [],
    config: Partial<Config> = {},
  ) {
    this.buf = new Queue(buf);
    this.config = Config.padding(config);
  }

  private get readTimeout(): number {
    return this.config.readTimeout ?? this.config.timeout;
  }
  private get writeTimeout(): number {
    return this.config.writeTimeout ?? this.config.timeout;
  }
  private checkReadTimeout(from: number): boolean {
    return Date.now() - from > this.readTimeout;
  }
  private checkWriteTimeout(from: number): boolean {
    return Date.now() - from > this.writeTimeout;
  }

  public send(v: T): Promise<void> {
    return new Promise(async (resolve, reject) => {
      const from = Date.now()
      while (this.buf.size() >= this.config.capacity) {
        await sleep(this.config.checkInterval);
        if (this.checkWriteTimeout(from)) {
          return reject(new Error("timeout"));
        }
      }
      this.buf.enqueue(v);
      resolve();
    })
  }

  public async receive(): Promise<T> {
    return new Promise<T>(async (resolve, reject) => {
      const from = Date.now();
      while (this.buf.size() <= 0) {
        await sleep(this.config.checkInterval);

        if (this.checkReadTimeout(from)) {
          return reject(new Error("timeout"));
        }
      }
      const v = this.buf.dequeue()!;
      resolve(v);
    })
  }
}

Gist

TypeScript Queue

LeafChage — Sat, 04 Jan 2025 15:00:49 +0000

I wanted to use queue in TypeScript.

export class Queue<T> {
  public constructor(
    private items: T[] = []
  ) {
  }

  public enqueue(v: T) {
    this.items.push(v)
  }

  public dequeue(): T | undefined {
    if (this.items.length < 0) {
      return undefined;
    }

    const result = this.items[0];
    this.items = this.items.slice(1,);
    return result;
  }

  public peek(): T | undefined {
    if (this.items.length < 0) {
      return undefined;
    }

    return this.items[0];
  }

  public clear() {
    this.items = [];
  }

  public size() {
    return this.items.length
  }
}

Gist

Make environment to develop commonlisp with NeoVim

LeafChage — Sun, 25 Aug 2024 11:32:16 +0000

You can refer the document to make environment for sbcl.

The plugin in neovim

nvlime
lazy.nvim (It's not related this topic though)

How to use

I recommend some function for you. (You can read :h nvlime-tutor if you want to know more.)

<leader>rr To launch REPL server
<leader>si To send a command to REPL
<leader>cd To stop REPL server
<leader>rt To restart REPL server.
<leader><enter> To change interactive mode?
- During this mode, you can eval a code that your cursur is on when you type enter in normal mode.

Problem1. SBCL can not load quicklisp, when it launch.

You can check help :h nvlime when you face some problems.
It may custome initializing function, so I try to call the function.

vim.g.nvlime_config = {
    implementation = "custom"
}

local setup_lisp_file_path = vim.fn.expand('$HOME/quicklisp/setup.lisp')

local fn = string.format([[
function! NvlimeBuildServerCommandFor_custom(nvlime_loader, nvlime_eval)
return [ "sbcl",
\ "--load", "%s",
\ "--load", a:nvlime_loader,
\ "--eval", a:nvlime_eval]
endfunction
]], setup_lisp_file_path)

vim.api.nvim_exec(fn, false)

Problem2. Your package is not included in quicklisp when you launch REPL server.

I want to load my package when I launch the REPL server, so I customed my neovim setting, which it can load a file if the file named .sbcl.lisp is in current directory.
- source

Problem3. How to load my develping package in the first place.

There is the variable asdf:*central-registry* included loading directory for some asdf, so you need to register your develping directory to the variable.

 (let ((packages '("project/"
                   "project/sub-module/")))
   (loop for p in packages
         do (let ((path (merge-pathnames  p (user-homedir-pathname))))
              (pushnew path asdf:*central-registry* :test #'equal))))

Debug with CommonLisp

LeafChage — Sun, 25 Aug 2024 11:15:41 +0000

1. Debug with print (It's easiest way)

It's easy way to make a function that output variable to standard output and return the variable.

(defun dbg (t)  (progn  (print t) t ))

2. If you know of REPL

If you use 'break', you can see stack traces in REPL.

 (progn (break "hello debug dayo")
 ;; target code
 )

3. It's my recommendation.

If you use 'step', you can see the variable when the target function is called. So it's best for me.
You need to surround a target function with progn, but you don't need it if you use 'step' function.

 (step (something))