LorisSigrist

I just spent way too much time chasing an out of memory error when running one of my Symfony Commands. Apparently the Doctrine ORM was holding on to too many entities. I tried flushing, clearing, all the usual stuff, but nothing worked.

Turns out, when running Symfony commands via php bin/console <command-name>, Doctrine's BacktraceDebugDataHolder is used, which NEVER DELETES ENTITIES. This was news to me too. Simply appending --no-debug disables this & seems to fix the issue.

I wish this was made more obvious.

LorisSigrist

Vite-Plugin-SQLC Concept

SQLC can generate typesafe code for interacting with your database. This is done via code-generation.

I thought it would be nice to use vite to hide the code generation and instead import the .sql files where the queries are defined directly.

Thanks to Typescript's typeRoots option this is still entirely typesafe, but offers a better editing experience IMO.

LorisSigrist

import * as vscode from "vscode"
import * as Comlink from "comlink"

type MessageEvent = Parameters<typeof listener>[0]

function webviewEndpoint(webview: vscode.Webview): Comlink.Endpoint {
	const listeners = new Map<any, vscode.Disposable>()

	return {
    // NO OWNERSHIPT TRANSFERS POSSIBLE

LorisSigrist

import { Hono } from "hono"
import { ParaglideHono } from "./paraglide-hono.js"
import * as runtime from "./paraglide/runtime.js"
import * as m from "./paraglide/messages.js"

// custom function that determines which language should be used based on the Context
function detecLanguage(c) {
  const pathname = new URL(c.req.url).pathname;
  const parts = pathname.split("/");
  return isAvailableLanguageTag(parts[1]) ? parts[1] : sourceLanguageTag;

LorisSigrist

const rerouteSequence(...reroutes) {
    return ({ url }) => {
       for(const reroute of reroutes) {
           url.pathname = reroute({ url: new URL(url) }) ?? url.pathname
       }
       
       return url.pathname
    }
}

LorisSigrist

import { dev } from "$app/environment";
import { sequence } from "@sveltejs/kit/hooks";
// A rule segment has the form ($ruleName)
const ruleSegmentRegex = /^\(\$[a-zA-Z_]+\)$/;

/**
 * Checks if a segment is a rule segment.
 * 
 * @param {string} segment
 * @returns {segment is `($${string})`}

LorisSigrist

const num_days = 16_000_000;
const num_participants = 100_000;

const samples = 100_000;
let collisions = 0;

const percentageFormatter = new Intl.NumberFormat('en-US', {
    style: 'percent',
    maximumFractionDigits: 3,
});

LorisSigrist

/**
 * Get's the shortest href that gets from `from` to `to`
 *
 * @param {URL} from
 * @param {URL} to
 * @returns {string} The shortest href that gets from `from` to `to`
 */
export function getHrefBetween(from, to) {
	//check if they use the same protocol - If not, we can't do anything

LorisSigrist

type TypeMap = {
    [key: string]: any
}

type Entries<T extends TypeMap> = {
    [K in keyof T]: [K, T[K]];
}[Extract<keyof T, string>];

export type OkResult<OkVal> = {
    ok: true,

LorisSigrist

This is in response to This comment I got on the t18s announcement. This was too long, so reddit wouldn't allow me to post it there.

---

Hi. I saw inlang's tweet yesterday and am very excited about what you are building!

I looked at the repo you linked and agree that the API is very similar. However, I did arrive at this on my own.

Let me walk you through how I arrived at the design I'm currently at. I want to write a blog post about this anyway, so I'll take this opportunity to write a draft. Sorry if this gets long.