Martin Mauch nightscape

Dependency Injection in Functional Programming

There exist several DI frameworks / libraries in the Scala ecosystem. But the more functional code you write the more you'll realize there's no need to use any of them.

A few of the most claimed benefits are the following:

Dependency Injection.
Life cycle management.
Dependency graph rewriting.

Kakmacs

Introduction

Setup

Dependencies

These aren’t all dependencies, but only the ones which isn’t loaded by my usual init-file.

Installing Kubernetes on ArchLinux

Packages

pacman -S curl docker ebtables ethtool wget unzip

Also cfssl is needed but available on AUR, using pacaur

pacaur -S cfssl

Nord 2 Guides

Those guides are applicable to every Nord 2 model:

DN2101/IND
DN2103/EEA
DN2103/EEA PAC-MAN Edition

Summary

Learning Rust

Getting Started + Installation | Cheat Sheet

Overview

I just read this trick for text compression, in order to save tokens in subbsequent interactions during a long conversation, or in a subsequent long text to summarize.

SHORT VERSION:

It's useful to give a mapping between common words (or phrases) in a given long text that one intends to pass later. Then pass that long text to gpt-4 but encoded with such mapping. The idea is that the encoded version contains less tokens than the original text. There are several algorithms to identify frequent words or phrases inside a given text, such as NER, TF-IDF, part-of-speech (POS) tagging, etc.


	class ParentType(val id: Long)
	class ChildType
	class ChildTypeBatchApi {
	fun load(keys: List<Long>): List<ChildType> = mutableListOf()
	}
	val childTypeBatchApi = ChildTypeBatchApi()

	// Example BatchLoader
	var batchLoader: BatchLoader<Long, ChildType> = BatchLoader { keys ->

	import scala.concurrent.{Await, ExecutionContext, Future, Promise}
	import cats.implicits._

	import scala.concurrent.duration.Duration
	import scala.util.{Failure, Success}

	final case class FutureConcurrentEffect()(implicit ec: ExecutionContext) extends FutureEffect with ConcurrentEffect[Future] {
	def start[A](fa: Future[A]): Future[Fiber[Future, A]] = Future.successful {
	FutureFiber(fa)
	}

	package jp.rdlabo.capacitor.plugin.screenshotevent;

	import com.getcapacitor.JSObject;
	import com.getcapacitor.NativePlugin;
	import com.getcapacitor.Plugin;
	import com.getcapacitor.PluginCall;
	import com.getcapacitor.PluginMethod;
	import com.getcapacitor.util.HostMask;

	import android.os.FileObserver;

	// ----------------------------------------------------------------
	// ▗▄▄▄▖ █
	// ▐▛▀▀▘ ▐▌ ▀
	// ▐▌ ▝█ █▘▐███ ▟█▙ ▐▙██▖▗▟██▖ ██ ▟█▙ ▐▙██▖▗▟██▖
	// ▐███ ▐█▌ ▐▌ ▐▙▄▟▌▐▛ ▐▌▐▙▄▖▘ █ ▐▛ ▜▌▐▛ ▐▌▐▙▄▖▘
	// ▐▌ ▗█▖ ▐▌ ▐▛▀▀▘▐▌ ▐▌ ▀▀█▖ █ ▐▌ ▐▌▐▌ ▐▌ ▀▀█▖
	// ▐▙▄▄▖ ▟▀▙ ▐▙▄ ▝█▄▄▌▐▌ ▐▌▐▄▄▟▌▗▄█▄▖▝█▄█▘▐▌ ▐▌▐▄▄▟▌
	// ▝▀▀▀▘▝▀ ▀▘ ▀▀ ▝▀▀ ▝▘ ▝▘ ▀▀▀ ▝▀▀▀▘ ▝▀▘ ▝▘ ▝▘ ▀▀▀
	// ----------------------------------------------------------------