wmertens

Store Nix store in git

The Nix store is an immutable file tree store, addressed by output hashes ($outhash-$name or $out), but could also be tweaked to be addressed by the content hash of the file tree ($cas).

Git is a content-addressed immutable object store. It is optimized for storing files as blobs and directories as tree objects.

Here we consider using a git repository for deduplicating, compressing and distributing the Nix store. We want to achieve maximum deduplication so we extract small changes from files before storing, so they become more similar.

Method

ctrlplusb

import { Country, Photon } from '@prisma/photon';
import { findManyCursor } from './findManyCursor';

const photon = new Photon();

let data: Country[];

const createCountry = async (id: string) => photon.countries.create({
  data: {
    id,

ajdruff

#####################
#
# Use this with or without the .gitattributes snippet with this Gist
# create a fixle.sh file, paste this in and run it.
# Why do you want this ? Because Git will see diffs between files shared between Linux and Windows due to differences in line ending handling ( Windows uses CRLF and Unix LF) 
# This Gist normalizes handling by forcing everything to use Unix style.
#####################


# Fix Line Endings - Force All Line Endings to LF and Not Windows Default CR or CRLF

michelmilezzi

--Table
CREATE TABLE IF NOT EXISTS person (
  id integer NOT NULL,
  person_name character varying(40) NOT NULL,
  updated_date date,
  CONSTRAINT person_pkey PRIMARY KEY (id)
);
  
--Index
CREATE INDEX IF NOT EXISTS idx_person_name ON person (person_name);

Rich-Harris

Why imperative imports are slower than declarative imports

A lot of people misunderstood Top-level await is a footgun, including me. I thought the primary danger was that people would be able to put things like AJAX requests in their top-level await expressions, and that this was terrible because await strongly encourages sequential operations even though a lot of the asynchronous activity we're talking about should actually happen concurrently.

But that's not the worst of it. Imperative module loading is intrinsically bad for app startup performance, in ways that are quite subtle.

Consider an app like this:

// main.js

gogromat

/**
 * Concatenates n-many ArrayBuffers
 * Based on the https://gist.github.com/72lions/4528834
 *
 * @param {...ArrayBuffer} ArrayBuffer(s) to concatenate
 * @return {ArrayBuffer} The new ArrayBuffer created out of n buffers.
 */
var concatArrayBuffers = function () {
    var buffers = Array.prototype.slice.call(arguments),
        buffersLengths = buffers.map(function(b) { return b.byteLength; }),

burtonsamograd

;; -*- mode: lisp -*-
;;
;; A quick and dirty tree shaker for SBCL.  Basically, it destroys the
;; package system and does a gc before saving the lisp image.  Gives
;; about a 40% reduction in image size on a basic hello world test.
;; Would like to hear how it works on larger projects.
;;
;; Original idea from: https://groups.google.com/d/msg/comp.lang.lisp/6zpZsWFFW18/WMy4PyA9B4kJ
;;
;; Burton Samograd

KoviRobi

# vim: set softtabstop=2 tabstop=2 shiftwidth=2 expandtab autoindent syntax=nix nocompatible :
# Containers

{ config, pkgs, ... }:

{ containers.browser =
  let hostAddr =  "192.168.100.10";
  in
  { privateNetwork = true;
    hostAddress = hostAddr;