posts // simo.sh

Migrating Raycast Clipboard History

Tue, 01 Oct 2024 00:00:00 GMT

I've been a heavy Raycast user for the last 3 years. One thing I especially love is the Clipboard History feature - I've been keeping the stuff I copy for the last 1 year. I can really easily look stuff up I copied ages ago - links, random JSON responses, images (which are OCR processed), memes within seconds.

Recently I got a new laptop and wanted to move over my history. Unfortunately, even with Raycast's Pro Plan, the clipboard history isn't synced as it's encrypted and stored on device. While researching how to do this I came across this Reddit post which suggests using an AppleScript to copy/paste several entries to a temporary file. I thought there should be another way - thankfully, @pertikaer helped me figure this out on Raycast's slack.

On your new Mac, quit Raycast
Move the ~/Library/Application Support/com.raycast.macos directory somewhere (to use as backup)
Also backup the database_key Keychain entry for Raycast by copying it somewhere
On the old Mac, AirDrop the ~/Library/Application Support/com.raycast.macos directory to the new one and move it to the same place.
Get the database_key from the old Mac's Keychain using the steps from before and overwrite it on the new Mac's keychain
If you want to copy over your clipboard images as well, make sure to send ~/Library/Caches/com.raycast.macos to your other Mac as well.
Start Raycast again

System Observability

Fri, 30 Aug 2024 00:00:00 GMT

Intro

I've been quite interested in system observability for the last few years. I've played around with many different tools – NetData, Prometheus, Loki, Grafana and several more. A few months ago, I was scrolling through my RSS feed and saw an article announcing Grafana's new project called Alloy – It's the successor to the Grafana Agent. I'd known about Grafana Agent for a while, but I never bothered trying it, I figured that now was the perfect time to try Alloy.

This blog post/ramble will go over my preferred system observability setup.

Before I go into detail about what Grafana Alloy is, I want to give some background about the current monitoring setup for my servers.

Background

I've maintained a bunch of servers in different places – from Google Kubernetes Engine on GCP, k3s on bare-metal, to plain old VPS boxes on DigitalOcean.

I'll review my observability setup on my bare-metal home "cluster". It's not really a cluster right now as it has only one node, but I'll eventually make a separate blog post talking more about it. In short, it's an Acer Nitro laptop running Debian 11 with k3s installed.

One of the most common ways to monitor a Kubernetes cluster is using the kube-prometheus-stack Helm chart. It will deploy several components on your cluster (if you're familiar with how this stack works, feel free to skip the next section as it's a brief overview of it):

Prometheus

Prometheus is a time series database and a monitoring system that collects metrics from different applications/exporters.

It uses a pull-based architecture where it will periodically scrape an endpoint on your services (typically called /metrics) and store the resulting measurements in its internal database.

If you have multiple nodes inside your cluster, you can have a single Prometheus instance with many targets, e.g. one node_exporter instance per node. Each exporter instance can assign different labels to its metrics, such that you can filter your data when building your dashboards/alerts.

Exporters are separate services that you deploy that collect metrics and expose a Prometheus-compatible endpoint, such that Prometheus can scrape it. Some examples would be the official node_exporter, the postgres_exporter, and more.

Prometheus Operator

The Prometheus Operator is a project that deploys a Prometheus instance for you, while also giving you complete control over it using Custom Resources and tightly integrating with the Kubernetes API. The operator utilizes service discovery to find targets to scrape automatically – this can be done using the ServiceMonitor custom resource:

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: api-backend-service-monitor
  labels:
    release: kube-prometheus-stack
spec:
  selector:
    matchLabels:
      app: api-backend
  endpoints:
    - targetPort: 8080
      path: /metrics

The operator will look for any ServiceMonitor resources in your cluster and build the necessary config updates in Prometheus. You can also define your Alertmanager rules using the PrometheusRule custom resource.

Grafana Mimir is a long-term storage engine for Prometheus metrics. Using Mimir allows you to "split" Prometheus' storage from the collection/scraping process. This will come into play later when I talk about Grafana Cloud.

Thankfully, you don't have to set all of this up manually as the kube-prometheus-stack helm chart mostly handles all of this for you.

Grafana

Grafana is a data visualization platform that allows you to build different dashboards based on a variety of data sources – Prometheus, Loki, PostgreSQL, etc. Here's an example dashboard that displays Prometheus metrics about the Linux Kubernetes node using the aforementioned node_exporter.

Alertmanager

Alertmanager is pretty self-explanatory - you can build Prometheus alert rules that when triggered, will notify you via different receivers (e.g. Telegram / Slack / Discord). An example rule for detecting high request latency would be:

groups:
- name: HighLatencyAlerts
  rules:
  - alert: HighAverageRequestLatency
    expr: avg(rate(http_request_duration_seconds_sum{endpoint="/api/users"}[5m])) / avg(rate(http_request_duration_seconds_count{endpoint="/api/users"}[5m])) > 0.3
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High average latency on /api/users endpoint"
      description: "Average request duration for /api/users endpoint is above 300ms for the last 5 minutes."

These alerts can be very crucial in a production environment where you want to know what's happening in your system at all times.

Here is my (old) deployment of the kube-prometheus-stack.

Unfortunately, this only handles a third of the 3 pillars of observability. We'll next introduce log aggregation to our system.

Loki

Loki is "Like Prometheus, but for logs.". You can think of it as a database for your logs. Unlike Prometheus, it uses a Push-based architecture using its Promtail daemon.

Similarly to the different exporters, this can be deployed across multiple nodes and labeled with the necessary metadata.

Previously, I've deployed Loki using the loki-stack. It's been mostly fine except for one problem I encountered in a different production cluster while writing this blog post.

Turns out my configuration for retention of 2 weeks hadn't been working ever since I deployed it:

	# ...
    table_manager:
      retention_deletes_enabled: true
      retention_period: 336h # 2 weeks
    # ...

This meant that for the last 2 years, my Loki instance had been storing logs indefinitely, filling up my storage. In this cluster, I'd provisioned a 50GB SSD from GCP:

  persistence:
    enabled: true
    size: 50Gi

It took almost 2 years for me to notice:

This culminated in Loki being stuck in a CrashLoopBackOff, unable to start for the last several days. If I had alerts configured for this, I would've found out much earlier, the irony :D

Grafana Cloud

When I saw Grafana Cloud a while ago I thought to myself "Why would anyone want a cloud-managed Grafana instance? It's pretty simple to self-host". Turns out Grafana Cloud provides you with much more than just a Grafana instance – they give you a hosted version of Loki, Mimir, Alertmanager, k6 load testing, and more. Seeing that piqued my interest. Their free forever tier seemed more than enough for my use cases, I don't even have my billing information filled in. This post is not affiliated with Grafana in any way, I just like the product.

Grafana Alloy

Grafana Alloy is an agent that runs on your servers – it's an OpenTelemetry Collector[^1]. Instead of having multiple different tools collect and store data, you can use as Alloy as a unified collector for everything.

It can act as a replacement for the scraper part of Prometheus, the agent part of Loki (Promtail), be a collector for traces, and more.

It does not store the actual data, however. It's merely a "proxy" that collects your telemetry and pushes it to some remote storage, e.g. Mimir (or a Prometheus instance directly) for metrics, Loki for logs, Tempo for traces, etc. It does, however, have ephemeral storage for replaying the WAL in case of disruption.

This is where Grafana Cloud shined for me – I can get rid of the kube-prometheus-stack & loki-stack deployments, significantly reducing memory, storage, and maintenance overhead on my cluster(s).

Deployment

Alloy can be executed as a simple binary on your machine, as a system service, or be installed in a Kubernetes cluster using the official Helm charts.

There are 2 Helm charts that deploy Grafana Alloy. One is the bare-bones Alloy chart which only deploys Alloy by itself with 0 configuration and the opinionated k8s-monitoring chart. The latter deploys a few more services as well as builds the configuration for them out of the box.

Bare-bones Chart

At first I played around with the bare-bones one. This meant that I had to write the configuration by hand. After messing around with it for a few hours and seeing the appeal of the opinionated one, I scrapped my config. Regardless, here's a quick overview of how it works.

The syntax for Grafana Alloy config files is inspired by HCL, If you've ever written Terraform code, you basically know it.

I was mainly interested in the official Grafana Cloud Kubernetes integration:

It comes with many different metrics, alerts, dashboards, etc. If you use Kubernetes, I highly recommend checking it out, I'll definitely keep using it for future projects. Part of the features are powered by Prometheus metrics and the rest by logs. This meant that I had to configure Alloy to collect both, so I started with logging first.

Alloy has 4 main components that do the following:

Discover targets – discovery.kubernetes, discovery.ec2, local.file_match
Collect data from targets – prometheus.scrape, loki.source.kubernetes
Transform data – prometheus.relabel, loki.relabel, loki.process
Write to a receiver – loki.write, prometheus.remote_write

// 1. Discover targets e.g. all Pods in your Kubernetes cluster
discovery.kubernetes "pod" {
  role = "pod"
}

// 2. Collect logs from our targets e.g. Pods in Kubernetes
loki.source.kubernetes "pod_logs" {
  targets    = discovery.relabel.pod_logs.output
  forward_to = [loki.process.pod_logs.receiver]
}

// 2. Collect logs from another source e.g Kubernetes Cluster Events
loki.source.kubernetes_events "cluster_events" {
  job_name   = "integrations/kubernetes/eventhandler"
  log_format = "logfmt"
  forward_to = [
    loki.process.kubernetes_logs.receiver,
  ]
}

// 3. Transform the log entries, e.g. adding static labels
loki.process "kubernetes_logs" {
  stage.static_labels {
      values = {
        cluster = "anton",
        region = "eu-east1"
      }
  }

  forward_to = [loki.write.grafana_cloud.receiver]
}

// 4. Write our logs to the remote Loki instance
loki.write "grafana_cloud" {
  endpoint {
    url = "https://logs-us-central1.grafana.net/loki/api/v1/push"
    basic_auth {
      username = "327384"
      password = "glc_eyJvI..."
    }
  }
}

Steps can reference each other's output values or pipe the stream of data to a transformation or a write step using the forward_to directive. All of this can be visualized in the following graph[^2]:

You can configure scraping Prometheus metrics in a similar way:

// 1. Discover Kubernetes Pods w/ custom selectors
discovery.kubernetes "pods" {
  role = "pod"
  
  selectors {
    role  = "pod"
    label = "environment in (production)"
  }
}

// 2. Collect metrics by scraping the Pods' metrics endpoints
prometheus.scrape "pods" {
  targets    = discovery.kubernetes.pods.targets
  forward_to = [prometheus.relabel.keep_backend_only.receiver]
}

// 3. Transform data
prometheus.relabel "keep_backend_only" {
  rule {
    action        = "keep"
    source_labels = ["app"]
    regex         = "backend"
  }
  
  rule {
    action = "labeldrop"
    regex  = "instance"
  }
  
  forward_to = [prometheus.remote_write.grafana_cloud.receiver]
}

// 4. Write data
prometheus.remote_write "grafana_cloud" {
  endpoint {
    url = "https://prometheus-prod-24-prod-eu-west-2.grafana.net/api/prom"
    basic_auth {
      username = "59482"
      password = "glc_eyJvI..."
    }
  }
}

k8s-monitoring Chart

2025/11/01 Update This post was written for the v1 version of the k8s-monitoring chart. v2 was released few days ago, which includes several breaking changes, a migration guide can be found here. The general concepts still apply, it's just the overall Helm template structure that was changed.

The Grafana Cloud Kubernetes Integration requires data from the aforementioned log sources, as well as metrics from several agents. Other than Alloy itself, the k8s-monitoring chart also deploys:

kube-state-metrics – provides metrics for Kuberentes itself, e.g. amount of Pods, Services, etc
node_exporter – provides Linux-specific host metrics, e.g. CPU / Memory usage
opencost – cost monitoring tool that I ended up disabling
kepler – system power usage monitor that I also ended up disabling

The chart also configures Alloy to collect some extra stuff, e.g. cAdvisor metrics which are scraped from the Kubelet process on each node. You can definitely deploy all of these by yourself and build the necessary Alloy configuration blocks, but this chart does all of it for you. The bare-minimum chart config for me is this:

metrics:
    enabled: true
    node-exporter:
        enabled: true # enabled by default
    kube-state-metrics:
	    enabled: true # enabled by default
logs:
    enabled: true
    pod_logs:
        enabled: true # enabled by default
    cluster_events:
        enabled: true # enabled by default
prometheus-node-exporter:
    enabled: true # enabled by default
prometheus-operator-crds:
    enabled: true # enabled by default
kepler:
    enabled: false # I don't need kepler
opencost:
    enabled: false # I don't need opencost

Most of the config above can be removed, as the default Helm values are pretty good out of the box, I just like to be explicit. The only thing you'd have to set is your Grafana Cloud credentials (or whatever remote write service you want to use).

externalServices:
    prometheus:
        host: https://prometheus-prod-24-prod-eu-west-2.grafana.net
        basicAuth:
            username: "3245224"
            password: "..."
    loki:
        host: https://logs-prod-012.grafana.net
        basicAuth:
            username: "127038"
            password: "..."

After removing my kube-prometheus-stack and loki-stack deployments in favor of this, I saw a significant memory usage drop – Prometheus, Grafana, Loki, Promtail were taking up to ~2GB, meanwhile, the Alloy deployment itself takes up only 400MB. CPU usage also went down but I don't have my old metrics – Alloy currently seems to be chilling at 0.02 CPU according to my metrics[^3].

On low-spec devices, such as the Raspberry Pi, this setup can free up some more room for your actual workloads.

Extra Integrations

If you want to introduce extra observability, e.g. metrics for a Postgres database, usually you'd have to deploy the postgres_exporter, make sure your Prometheus instance scrapes that, etc. Alloy, however, has many built-in exporters, including one for Postgres. This means that with just a few lines, you can have access to your metrics:

prometheus.exporter.postgres "production" {
  data_source_names = ["postgresql://b64:bWFpa2F0aQ==@localhost:5432/production?sslmode=disable"]
}

prometheus.scrape "postgres" {
  targets    = prometheus.exporter.postgres.production.targets
  forward_to = [prometheus.remote_write.grafana_cloud.receiver]
}

Combining this with the Grafana Postgres Integration, you can get a pretty dashboard w/ alerts in case you aren't using a managed database service.

I repeated the same process for my MinIO deployment and added the respective integration, resulting in my final config here. Definitely explore the other dashboard & alert integrations in Grafana Cloud, especially the Linux Server one.

Tools

Thu, 29 Aug 2024 00:00:00 GMT

This is an evolving personal collection of random tools/SaaS platforms that I'm keeping an eye on.

Email

Plunk
- open-source
- self-hostable

Notification Engines

Novu
- Open Source, can be self hosted for free
  - https://github.com/novuhq/novu
- Seems to be quite early in development
  - As of now, it's v0.22.0
Knock
- Closed Source, Paid
- Seems to be more mature than Novu

Finance

Lotus
- Meant for creating pricing plans and managing them
  - Can implement many different pricing models, e.g. usage-based, seat-based, etc
- Open Source, can be self hosted
- Has support for many payment providers, e.g. Stripe & Braintree
Lago
- Same idea as Lotus, not sure which one is better
- Open Source, can be self hosted
Runway Financial
- Tool for managing company finances, expenses, plans for growth, etc
- Whitelisted / Early-Access currently
Mercury
Midday
Maybe
- personal finance app
Invoice Tola
Antimetal
- AWS Invoice Billing thing

Real-Time

CRM

Twenty
- Fully open source
- Requires 2 containers (worker & main app) & a Postgres database
- Polished UI
- Can build custom objects and relationships easily in their object manager

Application Monitoring

SigNoz
- Open Source, can be self hosted
  - Requires a bunch of services / containers to be deployed, e.g. Clickhouse
- Looks cheap
- All-in-one APM
  - Logs, Metrics, Exception tracking, Dashboards, etc
qryn
- Open Source, can be self hosted
- All-in-one tool for a everything - logs, tracing, metrics, etc, seems to be built on top of Clickhouse
hyperdx
- Open Source, can be self hosted
- All-in-one APM
- UI seems better than SigNoz
- Seems to be less mature than SigNoz?
uptrace
- Open Source, can be self hosted
- All-in-one APM
- Uses Clickhouse
- Exposes Prometheus-compatible endpoints
baselime
- Acquired by Cloudflare
coroot
- All in one APM
- Open Source
- Relies on eBPF
- Depends on Postgres/SQLite, Prometheus, Clickhouse

Internal Tool Builders & Workflow Engines

Directus
- Open Source, can be self hosted
- Can be used as a CMS or a generic BaaS
Windmill
- Much more than just an internal tool builder. can build workflows / scripts / dashboards using code, etc
- Can write scripts in go/typescript/deno/bun/php/python
- Simple deployment architecture, requires only Postgres
- Has many integrations in the Windmill hub

File Storage

Cloudflare Images
- Can automatically resize / pre-process images for serving to users
- Removes the need of your own custom image processing pipeline
- Cheap?

Data Analysis / Analytics

LogSnag
- Looks sick, but it's bit expensive
Clarity
- Free analytics & heatmap
Evidence
- Open Source
- Uses Markdown
- Easily shareable / deployable SQL-based dashboards
UTM Builder
Rill
Hex
Metabase
- Open source, easy to deploy
- Very nice builder - easy to use by non-devs
- Polished UI
Superset
- Open source, easy to deploy as well
  - Uses a worker based architecture, will deploy several containers
- Has a lot more built in charts than Metabase, pretty sure it uses ECharts under the hood
- Configuration was kind of confusing - you use Python code for this 🤔. will have to play around with it more to see how I feel about it
Marimo
- Seems like a better version of Jupyter notebook
- Has really cool features like the embeddings visualiser
- Can be used for making internal tools
- Cells aren't "linear" but instead build a graph of all the dependencies - you can add sliders / variables and when you update them, cells get automatically updated

AI

Rerun
- Tool for visualising data from ML models
Luma AI
- 3D capture scanning tool
mlflow
- Open Source MLOps tooling, similar to weights and biases

IDP

Port
- Decent free tier
- k8s integration available
  - https://docs.getport.io/build-your-software-catalog/sync-data-to-catalog/kubernetes/
Cortex
Porter
Nullstone
Coherence
Northflank

Document Management

Papermark
- Open Source alternative to DocSend
- Self Hostable
  - Although, it's "Built with Vercel Storage and Vercel Edge Functions"
    - Hopefully it's not tightly coupled with Vercel's infrastructure

Developer Tools

Graphite
- Implements a Git workflow called stacking
Harlequin
- TUI tool for data exploration with support for many databases
- Can also write queries / scroll through results / etc

Databases

Tembo
- Postgres based
- Comes in with many built in extensions

Backups

pgbackweb

Diagram Makers

Video

Wide Video
- Free online Video Editor
Remotion
- Make videos using code / React
Rotato Tools
- A bunch of free tools for compression / transparency / metadata, etc

Background Process Engines

Trigger
- Self hostable, Open Source
- Uses Graphile as the task engine for Postgres

Mockups / Graphics

Raytracing
shots.so
- Free
- Pretty good
- Can't position the mocks when you drag them in, unfortunately
rotato
Isometric Shot
PostSpark
Previewed

Feature Flags

CMS

Keystatic
- not exactly a CMS
- just an admin ui for your static astro / next.js / etc apps
Payload
- 2.0 version is alright
  - Used it for FindAudit
  - Postgres adapter was very hit/miss
  - Hit several issues and bugs, reported a bunch of them
  - Was tricky to setup structured contextual logging
  - Would use it again for projects that aren't as dynamic/user facing as FindAudit
- 3.0 version will be a Next.js app which means you can integrate it into any existing Next.js app easily
  - seems to be in beta for half a year or so now

TODO Apps

Tweek
- simple calendar view
- can print your schedule
- no bs

Diagram Editors

Monodraw
- paid
- macOS only
- ascii plain text editor for diagrams

User Feedback

Proxies

Webshare

Activation Function

Thu, 18 Jul 2024 00:00:00 GMT

An activation function in a machine learning model is used to add Non-linearity to the output. This is needed, because otherwise, our model will learn to act as a linear least squares model. We usually want our models to solve complex, non-linear problems.

Examples

ReLU - $f(x) = max(0, x)$
Sigmoid - $f(x) = \frac{1}{1+e^{-x}}$ ^3aed71
Identity - $f(x) = x$

References

https://www.wikiwand.com/en/Activation_function
https://www.quora.com/What-do-you-mean-by-introducing-non-linearity-in-a-neural-network

Arithmetic Mean

Thu, 18 Jul 2024 00:00:00 GMT

The arithmetic mean, also known as average is the most commonly used mean $$ \frac{{\sum_{i=1}^{n} x_i}}{n} $$ You sum up all points in the data set and then you divide them by the number of data points.

Binary Classification

Thu, 18 Jul 2024 00:00:00 GMT

Binary classification is the problem of classifying the class of an element between 2 sets.

Example

A simples example for such a problem would be to classify whether a point lies below or above a line in a coordinate system. Another example would be to determine whether an image is a photo of a hot dog or not a hot dog.

References

https://www.wikiwand.com/en/Binary_classification

Convolutional Neural Network

Thu, 18 Jul 2024 00:00:00 GMT

Neural Network type used primarily for image or video data. It uses an Image Kernel that convolves / strides across the input. Each value in the kernel is a weight in the neural network.

CNNs break down the input into smaller bits, instead of processing the entire image at once. These smaller bits are called features and the process of finding the exact kernels that detect those features is called feature extraction.

Example

A convolutional layer is configured by setting the kernel amount, size and stride.

  # Example with Tensorflow & Keras
  filters = 32
  size = (3, 3)
  input_shape = (226, 226, 3) # 226x226 RGB image
  keras.layers.Conv2D(filters, size, strides=2, input_shape=input_shape, activation=tf.nn.relu)

Increasing the stride will result in a smaller output of the layers

References

https://www.wikiwand.com/en/Convolutional_neural_network
https://keras.io/api/layers/convolution_layers/convolution2d/

Cost Function

Thu, 18 Jul 2024 00:00:00 GMT

A cost function (also known as a loss function) measures how wrong a machine learning model is.

It's different from the error of a neural network in that the error simply measures how far off a single guess was from the real answer. The loss function on the other hand tells you how bad it is that it failed to recognize something and you average the result over the entire data set (or batch).

It is an important distinction because in some contexts, you might want to punish certain results more, e.g getting a false positive might be worse than getting a false negative. In other cases a simple squared error will do just fine.

It is used for optimising the model by computing its derivative and using that for adjusting the weights and biases.

Examples

Mean Squared Error - $\frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y_i})^2$ where $y_i$ and $\hat{y_i}$ respectively mean the output of the model and the expected output, and $n$ is the total number of samples. ^07648b
Binary Cross-Entropy - $-\frac{1}{n}\sum_{i=1}^n [y_i\log(\hat{y_i}) + (1-y_i)\log(1-\hat{y_i})]$ ^8ef262

F1 score

Thu, 18 Jul 2024 00:00:00 GMT

The F-score represents a test's accuracy. It's computed by taking the Harmonic Mean of the Precision and Recall. $$ F_1 = \frac{2}{\frac{1}{Precision}+\frac{1}{Recall}} $$ The result will be between $0.0$ (meaning being completely inaccurate) and $1.0$ (meaning being completely perfect).

References

https://www.wikiwand.com/en/F1_score

Forward Propagation

Thu, 18 Jul 2024 00:00:00 GMT

The forward pass in a Neural Network is also known as the "prediction" step. You give the neural network some input and it gives you an output.

How it works

Passing in the input to the neural network
- The input shape has to match with the first layer of the network
The $j_{th}$ layer's activations are equal to $z_j = \sigma(w_{jk}a_{jk} + b_j)$
- In other words, the activation of the current layer's $j_{th}$ neuron is equal to the weighted sum of the previous layer's weights and activations + a bias which are all then passed to an Activation Function.
  - The weighted sum is computed by performing matrix multiplication between the weight matrix and the previous layer's activations.
- The input layer's "activations" are simply the input values.
- This is repeated for all layers

Gradient Descent

Thu, 18 Jul 2024 00:00:00 GMT

Gradient Descent is the most popular Optimizer for machine learning models.

How it works

It involves the following steps

Go over the entire dataset
Compute the gradients of the weights & biases, using Backward-Propagation with respect to the Cost Function
Average the gradients over the entire dataset
Add the gradients to the weights & biases while also multiplying them by a Learning Rate

Batching

You can introduce some form of batching to the process

Mini-batch Gradient Descent allows you to adjust the parameters every N batches instead of after processing the entire dataset. This is less computationally expensive.
Stochastic Gradient Descent is like Mini-batch Gradient Descent, but with N = 1. This means that you tweak the parameters after every sample in the data set.

Harmonic Mean

Thu, 18 Jul 2024 00:00:00 GMT

The harmonic mean can be represented in terms of the Arithmetic Mean. It is useful if you're interested in the rate (e.g speed) of the data. $$ \frac{n}{\sum_{i=1}^{n} \frac{1}{x_i}} $$ You divide the number of data points by the sum of the reciprocals of all the points in the data set.

Examples

Let's say you want to calculate the average speed of a car on a race track, based on measurements taken each lap. The first lap the car was driving at $120km/h$ and the second lap, at $100km/h$.

Because we have a fixed distance (the track length) and varying time (speed is proportional to time), the speed is the rate we want to calculate.

$$ \frac{2}{\frac{1}{120km/h}+\frac{1}{100km/h}} = \frac{2}{\frac{11}{600}}\approx109km/h $$

References

https://youtu.be/jXKYI7wyqp0
https://www.wikiwand.com/en/Harmonic_mean

Huffman Coding

Thu, 18 Jul 2024 00:00:00 GMT

Huffman Trees are a way to losslessly compress text by encoding the probabilities of each character in a tree. This allows you to use less bits for more frequently used characters, thus saving space. It is the most efficient way to compress text if you look at one character at a time.

You build the tree by going over the text input and storing the frequency of each character in a priority queue. You then start pairing up the 2 least frequently used characters (the 2 top-most elements in the queue) in a new node, whose value is the sum of their frequencies. You repeat this process recursively until you've merged all nodes into one tree (you'll be left with one node in the queue).

After you've built the tree you then encode the original input text into a new stream of bits. You build a dictionary of each letter and its corresponding binary representation. This is done by iterating over the tree (for each leaf node) and storing a 0 or a 1 depending on whether you went left or right. You compress the data by going over each character and using the dictionary, writing a 0 or a 1. You can then send the compressed data and the translation dictionary to the recipient.

To decompress the data you to the same operations in reverse. By going over the input stream and using the dictionary you can easily lookup the corresponding character.

The huffman code dictionary isn't fixed length (thus takes up less space as you don't have to use padding) and therefore posses the prefix property.

Example

References

https://youtu.be/Lto-ajuqW3w
https://youtu.be/M5c_RFKVkko
https://www.youtube.com/watch?v=JsTptu56GM8
https://www.wikiwand.com/en/Huffman_coding

Hyper Parameters

Thu, 18 Jul 2024 00:00:00 GMT

Hyper-Parameters are global parameters in machine learning that aren't adjusted during the learning process. Instead, they are manually configured by the author of the model.

You can use a Grid Search to automate the finding of the optimal values.

Image Kernel

Thu, 18 Jul 2024 00:00:00 GMT

An image kernel (also known as a filter) is a small matrix that is used to apply filters to an image, e.g edge detection, sharpening, blurring, etc. They are typically square arrays that consist of numbers which let you compute a given pixel value using only the surrounding neighbours' values.

Examples

Example filter that makes an image more "sharp":

[
	[0, -1, 0],
  	[-1, 5,-1],
  	[0, -1, 0],
]

How it works

This is achieved by walking / striding / convolving over the source image and building each new pixel value by multiplying the respective values and summing them up The stride amount defines the step size when convolving across the input image. A higher stride will result in a smaller output.

References

https://setosa.io/ev/image-kernels/

Learning Rate

Thu, 18 Jul 2024 00:00:00 GMT

The learning rate is a small number, usually denoted as $\alpha$ which is used to decrease / control the "nudge" / adjustment of the parameters of a machine learning model.

It is required because making too big adjustments might cause you to over-shoot your target. Making it too small however on the other hand will cause the model to converge too slowly.

It is one of many Hyper-Parameters in an Optimizer

Linear System

Thu, 18 Jul 2024 00:00:00 GMT

A linear system is a collection of multiple Linear Equations with the same variables. Finding the solution to a linear system involves finding the right variables, such that all equations are satisfied.

Examples

${\displaystyle {\begin{cases}3x+2y-z=1\2x-2y+4z=-2\-x+{\frac {1}{2}}y-z=0\end{cases}}}$ With the solution being: ${\displaystyle (x,y,z)=(1,-2,-2)}$

If you plot all of the equations, the solution lies in the intersection of their lines / planes. It could be a single number or an entire set. If there isn't a common point across all of them – then there are no solutions.

${\displaystyle {\begin{cases}x-y=1\3x+y=9\end{cases}}}$ With the solution being: ${\displaystyle (x,y)=(2,3)}$

References

https://www.wikiwand.com/en/System_of_linear_equations

Mean

Thu, 18 Jul 2024 00:00:00 GMT

The mean is a way to summarize a dataset using a single number

Types of mean

Harmonic Mean

Arithmetic Mean

Multi label Classification

Thu, 18 Jul 2024 00:00:00 GMT

Multi-label classification is the problem where you try to assign multiple labels/classes to an element of a dataset.

Example

An example problem would be to classify all the instruments in a song.

Neural Network Architecture

Thu, 18 Jul 2024 00:00:00 GMT

A Neural Network consists of many "neurons", which are simply numbers. You can think of them as neurons from biology - they can be activated or not.

These neurons build up layers. The first layer is your input, e.g if we take the problem of classifying images, you would take in an array of all the pixel values.

These neurons are connected using weights and biases. These are the parameters of the neural network. Just like the neurons, they are also just numbers. The end goal of training a neural network is to find the parameters that best solve your problem.

Each neuron from the previous layer is connected to every neuron in the next layer. Generally you need more layers in order to solve more complicated tasks. The term deep learning comes from literally having a deep neural network, i.e using many layers. Having more layers and thus, more parameters, makes the learning process more computationally expensive. There are many different types of layers, each tailored to solving specific problems.

At the end of each layer, you configure an Activation Function. At the last layer, you configure a Cost Function and an Optimizer.

It is commonly represented using matrices (or the more general term, tensors). GPUs are optimized to compute many matrix operations in parallel, such as matrix multiplication (which is the core operation in neural networks), which is why they are used for training and running neural networks.

Here we can see that the weights from the input layer that connect to $j_{th}$ neuron in the output layer, are all in the $j_{th}$ row of the weight matrix.

References

https://www.jeremyjordan.me/intro-to-neural-networks/

Neural Network

Thu, 18 Jul 2024 00:00:00 GMT

A neural network, (also known as a Multi-layer Perceptron) is a mathematical model that is used in machine learning.

There are many ways to make a neural network learn, one of which is Supervised Learning.

The combination of the last layer's Activation Function and Cost Function, determine the type of the problem you're trying to solve, some examples include

Binary Classification uses Sigmoid and Binary Cross-Entropy
- The output is a number between 0 and 1, you can then classify both classes by checking if the value is $< 0.5$ or $> 0.5$
Multi-label Classification uses Sigmoid and Binary Cross-Entropy
- The output is a vector of probabilities, each indicating a different label

A neural network's Forward-Propagation is used for predicting data and its Backward-Propagation used for training itself.

Neural Network Architecture

Non linearity

Thu, 18 Jul 2024 00:00:00 GMT

A non-linear function is one that doesn't follow the requirements for a linear function. This means that it should abide by any of the following conditions

It should be of a higher degree than 1 (have exponents higher than 1)
Include operations that aren't addition - e.g multiplication, division, etc

Examples

$f(x) = x^2$
$f(x, y) = x^3 + y^2$

References

https://www.wikiwand.com/en/Nonlinear_system

Optimizer

Thu, 18 Jul 2024 00:00:00 GMT

An optimizer is an algorithm for adjusting the parameters of a machine learning model to minimize the Cost Function

Examples

Gradient Descent
Adam

Perceptron

Thu, 18 Jul 2024 00:00:00 GMT

The perceptron is a basic mathematical model for solving Binary Classification problems. It consists of 2 components:

Weights & Biases

You can think of these as knobs that you tweak to get the desired result
They are just numbers
The difference between both arises in the learning process

An Activation Function

It's quite limited and can't solve anything that isn't linearly separable, for example the XOR problem.

Example

Let's solve a classic problem, determining whether a point lies below or above a line

The input of our perceptron will be the X and Y coordinates of the point.
The output of our perceptron should be a number, let's say that $-1$ means that it's below the line and $1$, above the line.

Prediction

The feed forward (or in other words, the "prediction") process involves several steps

Provide some sort of input, $x$ and $y$
Compute the weighted sum of the respective weights, $w_0x + w_1y$
Add the bias, $w_0x + w_1y + b$
Plug the result into an activation function $\operatorname{sgn}(w_0x + w_1y + b)$ $$ \operatorname{sgn}(x) = \begin{cases} -1 & \text{if } x < 0, \ 0 & \text{if } x = 0, \ 1 & \text{if } x > 0. \end{cases} $$
The output will determine whether the point lies below or above the line
The above steps can be summarized as $y = f(\sum_{i=0}^{n}w_ix_i + b)$
At first, our perceptron will perform very poorly. This is because usually the weights are completely random.

Learning

We can use a simplified version of Supervised Learning to optimize our model.

We can compute the error for our model - $error = y - \hat{y}$. We can then update our weights - $w_i \leftarrow w_i + \alpha \cdot error \cdot x_i$ where $\alpha$ is our Learning Rate and $x$ is our input. We can then also update our bias - $b \leftarrow \alpha \cdot b \cdot error$.

We repeat this process a bunch of times, until our model converges.

An example implementation can be found on my GitHub repo

References

https://www.wikiwand.com/en/Perceptron

Positional Encoding

Thu, 18 Jul 2024 00:00:00 GMT

When performing a Vector Embedding of a sentence, you would like retain the positional information of each word when passing your input to your model. This way the model can learn to recognize different uses of the words in the sentence.

The authors of the Attention Is All You Need paper decided to use trigonometric functions to encode the positional information. The $cos$ and $sin$ functions have the nice property that the values are constrained between $[-1, 1]$. They also follow a pattern which means that the model can learn accordingly. This is the reason why we don't use the index of the token itself – it has a value in the range $[0, d]$ which means that words that appear further in the sentence will have a bigger value. They decided to encode odd vector indexes with $cos$ and even vector indexes with $sin$: $$ \begin{align*} \text{{PE}}(pos, 2i) &= \sin\left(\frac{{pos}}{{10000^{\frac{{2i}}{{d_{\text{{model}}}}}}}}\right) \ \text{{PE}}(pos, 2i+1) &= \cos\left(\frac{{pos}}{{10000^{\frac{{2i}}{{d_{\text{{model}}}}}}}}\right) \end{align*} $$ After calculating the positional embedding for the given position, it's added up together with the corresponding word vector embedding.

References

https://youtu.be/bCz4OMemCcA
https://machinelearningmastery.com/a-gentle-introduction-to-positional-encoding-in-transformer-models-part-1/

Precision and Recall

Thu, 18 Jul 2024 00:00:00 GMT

Precision and recall are measurements for determining the accuracy of a prediction model.

Precision

Precision (also known as sensitivity) measures how many of the predicted positives were actually positive (correct). $$ Precision = \frac{TP}{TP+FP} $$ For example, let's say you have a Binary Classification model for determining whether a picture contains a hot dog or not. If your model has 1 TP and 1 FP, you get the precision metric equal to 0.5. This means that if your model predicts that some photo contains a hot dog, it is correct 50% of the time.

If your model has no FPs, it will result in 100% precision. You can easily "cheat" this by making your model always return negatives. This means that your recall will go down.

Recall

Recall measures how many of the actual positives were identified correctly. $$ Recall = \frac{TP}{TP+FN} $$ Continuing with the precision example, If your model has 2 TP and 3 FN, you get a recall equal to 0.4. This means that of all pictures (e.g. 10, with 5 of them being hot dogs), your model will identify 40% of the hot dogs.

If your model has no FNs, it will result in 100% recall. You can easily "cheat" this by making your model always return positives. This means that your precision will go down.

When to use one over the other

Both can be useful, depending on the context you're using them in. A simple mnemonic to remember the differences is "PREcision is to PREgnancy tests as reCALL is to CALL center"

In a pregnancy test, you'd want to have high precision, i.e. reducing FPs. You don't want to give people false-hopes by making them think they are pregnant. People might end up making rash decisions based on the result. FNs on the other hand aren't as bad, as you'll find that you're pregnant later on anyway.

In a call center for insurance claims, you'd want to have high recall, i.e. reducing FNs. If the employees' job is to mark claims as a scam (to be further investigated) or not a scam (to pay money to the claimant directly), they'd want to play on the safe side and report anything that seems likely to be a fraud. This will result in more FPs (meaning that employees falsely reported claims as scams, when they were actually legitimate), as opposed to letting a scam fall through the cracks (yielding more FNs)

Terminology

TP means True Positive FP means False Positive TN means True Negative FN means False Negative

References

https://developers.google.com/machinelearning/crashcourse/classification/precisionandrecall
https://www.wikiwand.com/en/Precision_and_recall
https://datascience.stackexchange.com/questions/30881/whenisprecisionmoreimportantoverrecall

Prefix Property

Thu, 18 Jul 2024 00:00:00 GMT

The prefix property allows you to encode different symbols of data with variable-length without using any special markers in between. Any encoding algorithm that can represent different symbols without using common prefixes follows this property. Fixed-length codes inherently abide by this property.

Example

An example of an encoding that doesn't have the prefix property is this: You can see that there is ambiguity when decoding - the encoding for A prefixes the encoding for B. An example of an encoding that does have the prefix property is this: There is no ambiguity when decoding

References

https://www.wikiwand.com/en/Prefix_code

Supervised Learning

Thu, 18 Jul 2024 00:00:00 GMT

Supervised learning is an approach for machine learning where your model goes over thousands of labeled entries in some data set.

For every input of the data set, your model returns an output. You use both the input and the output, combined with an Optimizer to adjust the model's parameters.

You repeat this process many times. One iteration over the data set is called an epoch.

You're supposed to split and randomize your dataset in at least 2 parts - a training one and a testing one.

You use the training one for the actual learning process – adjusting your parameters.
You then use the testing one to validate / evaluate the accuracy of the model, by giving it data that it's never seen before. You don't adjust the parameters when going over the testing dataset.

Transformer Architecture

Thu, 18 Jul 2024 00:00:00 GMT

This is a Neural Network architecture which originates from the paper "Attention Is All You Need". It's primarily use is for text based models, but can also be modified to be used for other data sources, e.g. image purposes (Vision Transformer).

The transformer model can learn which words are important to a given sentence (as well as how words relate to one another), using the attention mechanism. Unlike previous NLP models, it can have an infinitely long context window (within the provided input limit).

It consists of 2 main components – the Encoder (left) and the Decoder (right). Both of them are provided with a text input which is tokenized and then represented as a Vector Embedding. One of the goals is optimizing the encoder and decoder, such that we get the best representation of our inputs. This is known as pre-training. After we've pretrained the encoder and decoder, we can change the head at the end and fine-tune our model for different purposes.

The Encoder's purpose is to encode the meaning of the input (the vector embedding), the positions of the words themselves (Positional Encoding), as well as how words relate to one another (Multi-Head Attention).

The Decoder's purpose is exactly the same, but for the output input. The masked multi-head attention head prevents the model from "cheating" by looking ahead in the output input - it assigns $-\infty$ to the values above the main diagonal. This will make the model causal - it only depends on previous states.

The encoder's output is connected to the decoder's second multi-head attention layer - acting as the Key and Value inputs. We combine that with the output of the previous masked multi-head attention layer to act as the Query input.

In between all the layers, you can find Layer Normalization layers to normalize the values.

During training, the input and output embeddings represent the input and the expected output. You surround the inputs with special tokens to indicate the beginning / end of sentences. The model outputs all of the next tokens in 1 time step. There's no for loop or iteration required for the model to give an answer.

During inference, the input is the also surrounded with special tokens, but the output input is only a token which indicates the beginning of a sentence. This will spit out a single token and you have to keep feeding the output of the model to the output input. You repeat this until you reach a special end of sentence token.

References

https://youtu.be/bCz4OMemCcA

Vector Embedding

Thu, 18 Jul 2024 00:00:00 GMT

You can represent any kind of data as an N-dimensional vector. For example you can use it for representing words when doing natural language processing. You do to this by assigning a random vector to each word in your input. You then train some kind of model, such that it begins grouping related words closer together and opposite words further from each other. The dimensionality of the vector is completely arbitrary and it's up to you to decide. You would hope that the different parts of the vector represent or learn different aspects of the word – but you can't really know what the numbers mean for sure as it's all a black box.

These vectors can be used to perform different mathematical operations. For example, if you take the vector for "King", subtract the vector for "Man", add the vector for "Woman", you would get a vector that's very close to the vector for "Queen". The same idea can be applied to other form of data, for example images.

References

https://www.tensorflow.org/text/guide/word_embeddings
https://youtu.be/gQddtTdmG_8

Word Tokenizing

Thu, 18 Jul 2024 00:00:00 GMT

Words in their raw string form can't be used as as inputs to machine learning models. Tokenizing is the process of assigning a unique number id for each word in your data set / vocabulary. You can build such a vocabulary by going over your data set and assigning random values to each unique word. You may reserve some of these values as special tokens, e.g.

Marking the beginning or the end of your input
Distinguishing questions from answers

Given that your input will be of varying length, you have to pad your input with zeroes, such that it matches the length of your expected input size.

References

https://www.youtube.com/watch?v=bWLvGGJLzF8

Open Graph Previews using Figma and Satori

Sun, 02 Jun 2024 00:00:00 GMT

Intro

When you post a link on Discord, Telegram, Twitter, etc, their servers use metadata that's defined on the page to generate a preview for your link:

This is mainly powered by Open Graph, which is a protocol made by Facebook that defines some special meta tags that are used by social networks/messaging apps.

I was looking for a way to dynamically generate these images at build time for my blog posts and came across this and this article, which helped in my implementation.

Designing in Figma

I started by making some designs in Figma

Instead of manually reimplementing the one I wanted using HTML & CSS, I decided to export it to SVG. To do that, I used the SVG Export Figma plugin. Before doing that, I hid the text layers, as they'll be interpolated in my Satori template.

Satori Rendering

I then copied the generated SVG code into Vercel's OG Playground which uses Satori under the hood. Satori is a JS library that converts HTML / CSS to SVG. I used the playground to verify my experiments in real-time as it updates the preview as soon as you change the code on the left.

In the OG Playground, I added the <p> tags for the post title and subtitle. I also made sure to set the container width/height to 1200x630 as that's the recommended Open Graph preview size. The fonts slightly mismatch with the original Figma design, but that's because DM Sans (the font I use) isn't imported in the playground.

The OG Playground (and Satori) uses JSX or React-elements-like syntax

import satori from 'satori'

const svg = await satori(
  <div style={{ color: 'black' }}>hello, world</div>,
  {
    width: 600,
    height: 400,
    fonts: [
      {
        name: 'Roboto',
        data: robotoArrayBuffer,
        weight: 400,
        style: 'normal',
      },
    ],
  },
)

// or

await satori(
  {
    type: 'div',
    props: {
      children: 'hello, world',
      style: { color: 'black' },
    },
  },
  options
)

Astro doesn't support JSX out of the box and requires extra configuration to allow that. Instead of manually building the React-elements-like tree, I used satori-html. This library takes in raw HTML as a string and converts it to the aforementioned tree.

import { html } from "satori-html"   
  
export const buildHTML = (  
  title: string,  
  date: Date,  
  slug: string,  
) => {  
	return html`<div style="...">
      <svg
        xmlns="http://www.w3.org/2000/svg"
        width="1200"
        height="630"
        fill="none"
        viewBox="0 0 1200 630"
      >
        ...
      </svg>
      <p style="...">${title}</p>
      <p style="...">
        -rw-r--r-- 1 simo nerv 1337
        ${date.toLocaleDateString("en-US", {
          year: "numeric",
          month: "long",
          day: "numeric",
        })}
        ${slug}.md
      </p>
    </div>
	`

Static generation using Astro Endpoints

I then created an Astro Endpoint called og.png.ts for each of my collections.

import { type CollectionEntry, getCollection } from "astro:content"  
import { buildHTML, buildOG } from "../../../og.ts"  
import { filenameToTitle } from "../../../filenameToTitle.ts"  
  
interface Props {  
  params: { slug: string }  
  props: { post: CollectionEntry<"blog"> }  
}  
  
export async function GET({ props }: Props) {  
  const { post } = props
  const buffer = await buildOG(  
    buildHTML(filenameToTitle(post.id), post.data.date, "blog", post.slug),  
  )  
  return new Response(buffer, {  
    headers: { "Content-Type": "image/png" },  
  })
}  

// Invoke the /blog/[slug]/og.png.ts endpoint for each blog post
export async function getStaticPaths() {  
  const posts = await getCollection("blog")  
  return posts.map((post) => ({  
    params: { slug: post.slug },  
    props: { post: post },  
  }))
}

The buildOG function takes in the generated tree from satori-html and returns a PNG preview of the post. To convert the SVG to PNG, I used resvg-js.

import { readFile } from "fs/promises"  
import satori from "satori"  
import { Resvg } from "@resvg/resvg-js"
// ...
const dmSans = await readFile("./public/fonts/DM-Sans.ttf")
export const buildOG = async (input: ReturnType<typeof html>) => {
  const svg = await satori(input, {
    width: 1200,
    height: 630,
    fonts: [
      {
        name: "DM Sans",
        data: dmSans,
        weight: 700,
        style: "normal",
      },
    ],
  })
  const resvg = new Resvg(svg)
  return resvg.render().asPng()
}

Astro will then go over every post in each collection using the getStaticPaths function and render a file called og.png in the respective /${collection}/[slug]/ directory.

$ tree ./dist/projects
.
├── discord-friends
│   ├── index.html
│   └── og.png
├── findaudit
│   ├── index.html
│   └── og.png
├── flappy-ai
│   ├── index.html
│   └── og.png
├── index.html
├── piral
│   ├── index.html
│   └── og.png
├── push
│   ├── index.html
│   └── og.png
├── sugoku
│   ├── index.html
│   └── og.png
└── tic-tac-toe-solver
    ├── index.html
    └── og.png

8 directories, 15 files

Then this Metadata.astro component adds the necessary <meta> tags:

---
interface Props {  
  title: string
  type: "website" | "article"  
  publishedTime?: string
  canonicalUrl: string
  description: string
  image: string
}  
  
const { title, description, image, canonicalUrl, type, publishedTime } = Astro.props  
---  
<link rel="canonical" href={canonicalUrl} />  
<meta property="og:title" content={title} />  
<meta property="og:description" content={description} />  
<meta property="og:url" content={canonicalUrl} />  
<meta property="og:image" content={image} />  
<meta property="og:type" content={type} />  
<meta name="twitter:card" content="summary_large_image" />  
<meta name="twitter:title" content={title} />  
<meta property="twitter:description" content={description} />  
<meta name="twitter:image" content={image} />
<meta name="description" content={description} />  
{publishedTime && <meta property="article:published_time" content={publishedTime} />}

In my /blog/[slug]/index.astro file (which statically builds a page for each slug/entry), I render the Metadata.astro component:

...
<Blog filename={entry.id} {...entry.data}>
  <Metadata
    slot="head"
    title={filenameToTitle(entry.id)}
    description={entry.data.excerpt}
    image={`${Astro.site}blog/${entry.slug}/og.png`}
    canonicalUrl={`${Astro.site}blog/${entry.slug}`}
    publishedTime={entry.data.date.toISOString()}
    type="article"
  />
  <Content />
</Blog>
...

As each thumbnail is called og.png in the same directory as the html page, referring to the${Astro.site}/blog/[slug]/og.png image, will result in the following meta tag:

<meta property="og:image" content="https://simo.sh/blog/uses/og.png">

The final result looks like this:

References

https://og-playground.vercel.app/
https://www.kozhuhds.com/blog/generating-static-open-graph-og-images-in-astro-using-vercel-og/
https://dietcode.io/p/astro-og/
https://github.com/vercel/satori
https://github.com/natemoo-re/satori-html

Flushing DNS on macOS

Wed, 29 May 2024 00:00:00 GMT

here's a one liner that flushes your DNS cache on macOS

$ sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder

My Gear

Tue, 28 May 2024 00:00:00 GMT

Desktop PC

I use this machine for gaming.

Item	Model
CPU	Ryzen 5 5600X
GPU	GeForce RTX 3070
RAM	Crucial Ballistix 2x8GB 3600MHz, G.SKILL Trident Z 2x8GB 3600MHz
Motherboard	MSI MAG B550 Tomahawk
CPU Cooler	be quiet! Pure Rock Cooler
SSD	Samsung 970 Evo 250GB, Kingston KC3000 2TB
HDD	Toshiba P300 1TB
PSU	BITFENIX Whisper M 650W
Case	Cooler Master Force 500

Monitors

Brand	Model
LG	27GP850
BenQ	GL2580H x2

These are all attached to an Arctic Z3 Pro Gen 3 stand

VR

I have an Oculus Quest 3 256GB with the BOBOVR S3 Pro Super Strap

Keyboards

I use a QWERTY keyboard.

Brand	Model	Switches	Using?
HHKB	Hybrid Type-S	Topre	Yes
Varmilo	VA68	MX Brown	Rarely
Logitech	G610	MX Red	No

Mice

Brand	Model	Using?
Logitech	G Pro X Superlight	Yes
Logitech	G403	No
Logitech	G102	No

I use the Zowie G-SR mousepad for all of them.

Chair

I've been using the Herman Miller Aeron Remastered Graphite since 2022.

Audio

I have a pair of Audio-Technica ATH-M50X w/ a FiiO E10K Olympus 2 but never use them nowadays as their head clamp is way too tight for me. Instead, I have a pair of Audioengine A2+ speakers that I use every day. My microphone is a HyperX SoloCast, mounted on a cheap arm.

Hubs

Brand	Model
Dell	D6000
Anker	5-in-1 USB C Hub
UGREEN	USB Switch 4 in 2 Out

Work

~~I've been using a MacBook Pro 13" M1 16GB 1TB since 2021. I've been very satisfied with its battery life and performance.~~ Recently I got a MacBook Pro 14" M3 Max (16 Core CPU, 40 Core GPU, 48GB RAM, 1TB SSD) after dealing with many random crashes, touch bar issues, (and generally DisplayLink problems) for the last 6+ months with the old one. ^5ba2ac

For my main development, I use JetBrains' tools - WebStorm, GoLand, etc. I used to be a die-hard Visual Studio Code fan for years but in 2021 I decided to change things up a bit and haven't looked back.

For my terminal I use iTerm2. Instead of using its built-in tabs, I use tmux as I'm used to its bindings and behavior after using it since 2019. There are other reasons why I love tmux, for which I'm planning on writing a blog post.

For editing within my terminal, I use neovim. I use fish as my preferred interactive shell instead of zsh / bash due to the (in my opinion) better out-of-the-box experience. I've barely configured it and love all the built in features.

I'm a huge fan of Raycast and have been using it for a few years now. It's miles better than Spotlight. There are so many features that I love about it that I can't list them all here.

Some other tools I use include:

Orbstack – an amazing alternative to Docker Desktop & Rancher Desktop
Arc – hipster browser that I've been using since August 2022. I'm a huge fan of the way it handles pinned tabs and Spaces/Profiles.
~~Amie – overrated calendar app that looks better than the built in Apple one.~~ went back to the built in Apple one. Amie is super slow for me
Obsidian – I use it for general note taking, journaling, bookmarking, as well as this blog
Ice - simple app that allows you to hide icons from your macOS menu bar
AlDente – battery management tool for MacBooks
Shottr – screenshot utility
Tailscale – based VPN for my devices – phone, laptop, servers, desktop, IoT.
Reeder – RSS client for macOS & iOS. It's wired up to a FreshRSS instance on my home cluster
LinearMouse – must have app for disabling mouse acceleration / adjusting scroll speed & direction on a per device basis, etc
Macs Fan Control – self explanatory
Screen Studio – screen recorder & editor which allows you to make fancy demo videos (please don't overuse the zoom effect like 95% of so called "indie hackers" on Twitter do)
Infuse – alternative Plex (and media in general) client for macOS / iOS / tvOS
CyberDuck – all-in-one storage browser, from S3, to FTP, to WebDAV, etc.
Swish – macOS window management tool. Mainly targeted towards trackpad use, but ironically I rarely use those gestures. Great alternative would be Rectangle (or whenever macOS Sequoia comes out)
Proxyman – HTTP traffic interceptor for macOS & iOS. Similar to Wireshark, but more intuitive.
Things – simple TODO app, have been trying it out for the last few months.
Parallels – VM hypervisor, has some neat things
Loopback – audio channel router/mixer
BetterDisplay – custom resolution tool
Clop – really neat compression utility
Jomo – app & website blocker/limiter

Discord Friends

Mon, 01 Apr 2024 00:00:00 GMT

2 years ago, this started off as a simple script that generated a GraphViz DOT file which could then be visualised with a tool like Gephi.

2 years later I decided to turn it into a proper desktop app, using Wails.

After hacking it together in a few days, I published it on GitHub.

FindAudit

Fri, 01 Mar 2024 00:00:00 GMT

FindAudit connects cybersecurity researchers with companies seeking security audits. You can find out more about it here.

Push

Sat, 16 Apr 2022 00:00:00 GMT

Push Marketplace is a social network for buying and selling fashion items. We've helped 100k+ users connect with like-minded fashion lovers. Together we've worked with many celebrities and influencers, including, but not exclusive to, FYRE, Emil TRF, V:RGO, Viktor Stoyanov, and many more.

In mid-2021, my two co-founders and I started working on Push. We developed a minimum viable product (MVP) and released it to the app stores on April 16th, 2022. Within the first 24 hours, we gained over 1000 users, processed 25 orders, and had over 750 listings. Our app led the Apple App Store charts as the most downloaded app for several days.

Since then, we've secured funding from angel investments and two venture capitalist firms, Vitosha Venture Partners and Innovation Capital.

As of the time of writing this, we've partnered with 25+ influencers and celebrities, processed over 15k orders, and have more than 20k active listings. We're currently operating only in the Bulgarian region, but we're planning on expanding to other countries in Eastern Europe.

My technical role in building Push spans the entire stack – from the mobile app to the backend server, all the way to the infrastructure it's deployed on. The mobile app uses React and Capacitor.js, allowing us to share one codebase for Android and iOS. For the backend, we use Go, Postgres, Redis, and MeiliSearch. All of this is deployed on a GKE Kubernetes cluster and monitored using Prometheus, Loki, and Grafana. The infrastructure is entirely provisioned using Terraform. Here I'll be blogging about some of the technical lessons I've learned while building this startup.

Watching a PostgreSQL Query

Thu, 22 Jul 2021 00:00:00 GMT

few years ago, I had to debug a very hard-to-reproduce bug with my production backend deployment. for some reason db writes were coming in late or not coming in at all. in order to monitor the state of my database, i created a small script that runs my query every n seconds.

#!/usr/bin/env bash
if [ "$1" == "help" ] || [ $# -eq 0 ]; then
    echo "usage: watch-psql 'select count(*) from users' 0.1 123 app";
    echo "                               ^                ^   ^   ^ ";
    echo "                             query            time pass db";
    exit 0;
fi

if [ -z "$1" ]; then
    echo "No query provided";
    exit 1;
fi

if [ -z "$2" ]; then
    echo "No time provided";
    exit 1;
fi

if [ -z "$3" ]; then
    echo "No password provided";
    exit 1;
fi

if [ -z "$4" ]; then
    echo "No db provided";
    exit 1;
fi

PGPASSWORD=$3 watch -n $2 "echo \"$1\" | psql -h localhost -U postgres -d $4"

the code is kinda crappy but it helped. nowadays i'd use datagrip's built in refresh feature

Piral

Thu, 19 Nov 2020 00:00:00 GMT

This was inspired by 3Blue1Brown's video on the same topic. The source code is here

Tic Tac Toe Solver

Wed, 12 Aug 2020 00:00:00 GMT

This is a tic-tac-toe implementation in Go & Raylib, as well as a minimax & alpha-beta pruning solver. The solver will always play the most optimal turn, making it impossible to beat.

At best, you can draw it:

You can check the source code here

Flappy AI

Sun, 26 Apr 2020 00:00:00 GMT

A genetic algorithm with a neural network (fr3fou/gone) built on top of fr3fou/flappy-go which plays flappy bird.

How it works

The core game is reused and built on top of using composition

type Game struct {
    *flappy.Game
    // extra fields only used from the AI
}

type Bird struct {
    *flappy.Bird
    // extra fields only used from the AI
}

AI Architecture

500 birds in total are put in the game with the following architecture of their "brain"

var BrainLayers = []gone.Layer{
	{
		Nodes:     5,
		Activator: gone.Sigmoid(),
	},
	{
		Nodes:     8,
		Activator: gone.Sigmoid(),
	},
	{
		Nodes:     2,
		Activator: gone.Sigmoid(), // ideally should be softmax
	},
}

There are 5 inputs, 4 of them in the following diagram and the last 1 is the velocity of the bird. $\alpha, \beta, \gamma, \delta$ describe the position of the bird relative to the next pipe and world.

The 2 outputs determine whether the bird should jump or not

if output[0] > output[1] {
    bird.Jump()
}

Their score is determined by how well they perform (how long they survive)

At the end of each generation, the best performing birds are to mate.

Using the crossoverOdds and mutationRate arguments to ai.New() it is determined what rate of the new population should be created using only mutation or crossover and mutation.

After a new population has been created, the process gets repeated.

Sugoku

Fri, 06 Mar 2020 00:00:00 GMT

Sugoku is a sudoku backtracking solver written in Go. You can explore the source code here.

posts // simo.sh

Migrating Raycast Clipboard History

System Observability

Intro

Background

Prometheus

Prometheus Operator

Grafana

Alertmanager

Loki

Other Solutions

Grafana Cloud

Grafana Alloy

Deployment

Bare-bones Chart

k8s-monitoring Chart

Extra Integrations

Further Reading

Tools

Email

Notification Engines

Finance

Real-Time

CRM

Application Monitoring

Internal Tool Builders & Workflow Engines

File Storage

Data Analysis / Analytics

AI

IDP

Document Management

Developer Tools

Databases

Backups

Diagram Makers

Video

Background Process Engines

Mockups / Graphics

Feature Flags

CMS

TODO Apps

Diagram Editors

User Feedback

Proxies

Activation Function

Examples

References

Arithmetic Mean

Binary Classification

Example

References

Convolutional Neural Network

Example

References

Cost Function

Examples

F1 score

References

Forward Propagation

How it works

Gradient Descent

How it works

Batching

Harmonic Mean

Examples

References

Huffman Coding

Example

References

Hyper Parameters

Image Kernel

Examples

How it works

References

Learning Rate

Linear System

Examples

References

Mean

Types of mean