bigs

data GeoCoordinate = GeoCoordinate
    { _geoCoordinateLatitude :: Double
    , _geoCoordinateLongitude :: Double
    } deriving (Eq, Read, Show, Generic)

instance Binary GeoCoordinate where
    put (GeoCoordinate lat long) = do
        put (0 :: Int8) -- we'll use big endian, Data.Binary's default
        put (1 :: Int32)
        put (4326 :: Int32)

bigs

(
play{
  var n = 5;
	var fmodrate = Duty.kr(2, 0, Drand([1/16, 1, 1/16, 1/8, 4], inf));
	var modfreq = Slew.kr(Duty.kr(8, 0, Drand([110, 220, 440], inf)));
  Limiter.ar(GVerb.ar(Pan2.ar(
    Mix.fill(n, { arg index;
			SinOsc.ar(220 + (index ** n), SinOsc.ar(modfreq + (index ** n), 0, Saw.kr(fmodrate, 2.5, 2.5)), 1 / n)
    }),
    SinOsc.kr(1)

bigs

package main

import (
	"bufio"
	"context"
	"fmt"
	"os"
	"time"

	cid "github.com/ipfs/go-cid"

bigs

s.boot;

(
SynthDef(\thicc, { |freq, ffreq=0, ftrack=1.0, res=0.5, gate=1, amp=1, out|
	var unison = 5;
	var freqs = Array.fill(unison, { |i|
		var even, offset;
		even = i % 2 == 0;
		offset = ((i / 2).floor + 1) / (unison / 2) * (freq * 0.01);
		offset = if (even, offset, offset.neg);

bigs

testbed notes

worth considering notes here https://github.com/ipfs/notes/issues/191, though
i have fears this leads us towards a path to kubernetes!

definition of terms:
- topology: weighted composition of nodes, e.g. gateway vs full ipfs vs p2pd
            with specific modules enabled.
- scenario: the general definition of behaviors of nodes in the testbed. one
            scenario runner is run per physical machine. it is responsible for

bigs

Keybase proof

I hereby claim:

• I am bigs on github.
• I am protocole (https://keybase.io/protocole) on keybase.
• I have a public key ASB8fxzU6Sz1-uRaVvmHK0fR7Xt3WdowS5XXJ4HcZ4mqLQo

To claim this, I am signing this object:

bigs

#!/bin/bash ruby

require "open3"

sigint_caught = false
Signal.trap("INT") do
  sigint_caught = true
  throw :sigint
end

bigs

module Data.Matrix

Matrix : (m: Nat) -> (n: Nat) -> (a: Type) -> Type
Matrix m n a = Vect m (Vect n a)

madd : Num a => {n : _} -> Matrix m n a -> Matrix m n a -> Matrix m n a
madd [] [] = []
madd (x :: xs) (y :: ys) = vadd {n=n} x y :: madd xs ys
  where
    vadd : {n : _} -> Vect n a -> Vect n a -> Vect n a

bigs

module IndexedTypes

data Foo i = MkFoo
data FooInt i = MkFooInt Integer

mkFooInt : Foo i -> Integer -> FooInt i
mkFooInt _ = MkFooInt

addFoos : Foo i -> FooInt i -> FooInt i -> FooInt i
addFoos f (MkFooInt x) (MkFooInt y) = mkFooInt f (x + y)

bigs

module Adder

AdderType : Nat -> Type
AdderType 0 = Int
AdderType (S k) = Int -> AdderType k

adder : {n : Nat} -> {default 0 acc : Int} -> AdderType n
adder {n=Z} {acc} = acc
adder {n=S k} {acc} = \x => adder {n=k} {acc=acc + x}