clarkmcc

sf := new(scalefunc.Schema)
err := sf.Decode(model)
if err != nil {
	panic(err)
}
s, err := scale.New(scale.NewConfig(signature.New).WithFunction(sf))
if err != nil {
	panic(err)
}
instance, err := s.Instance()

clarkmcc

use rand::random;

/// In this example, we'll attempt to train a single-neuron model to fit
/// a linear line. The slope of this line is 2, and can by expressed by
/// the equation y = 2x. We'll use gradient descent to find the slope of
/// the line, and then we'll use the slope to predict the output for
/// a given input.
///
/// The model won't be able to perfectly fit the line, but it will be
/// able to get very close. The idea here is we want the model to be

clarkmcc

import { useSearchParams } from "react-router-dom";
import { useCallback, useEffect } from "react";
import { isFunction } from "lodash";

/**
 * Setter represents a type that can be passed to the setter function returned
 * from this hook. It can either accept a value to set, or a callback function
 * with access to the current value.
 *
 * @example

clarkmcc

Keybase proof

I hereby claim:

• I am clarkmcc on github.
• I am shardblade (https://keybase.io/shardblade) on keybase.
• I have a public key whose fingerprint is 2E6B 9202 AFE9 1B1B 1D9A 024C AA8A FADB 0CC6 2973

To claim this, I am signing this object:

clarkmcc

// Diffie-Hellman asymetric key exchange allows two
// parties to cooperatively create a shared secret
// key without ever exchanging the shared secret.
// This means that it will be nearly impossible for 
// a malicious party observing the creation of the 
// shared secret to determine the secret key.

// Randomly create a generator number and a number p
// These two numbers are shared between both parties 
// in the public space which means they're potentially

clarkmcc

steps:
  # Build the container image
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 'gcr.io/$PROJECT_ID/$PROJECT_NAME:$SHORT_SHA', '--cache-from', 'gcr.io/$PROJECT_ID/$PROJECT_NAME', '.']
  # Push the container image to Container Registry
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'gcr.io/$PROJECT_ID/$PROJECT_NAME:$SHORT_SHA']
  # Deploy to Google Cloud Run
  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
    entrypoint: gcloud

clarkmcc

#!/bin/sh
for namespace in $(kubectl get ns | awk '{print $1}' | grep -v NAME); do
    for pod in $(kubectl get pod -n $namespace --field-selector=status.phase!=Running | grep Shutdown | awk '{print $1}' | grep -v NAME); do
      kubectl delete pod -n "$namespace" "$pod"
    done
done

clarkmcc

func getAllFilenames(fs *embed.FS, path string) (out []string, err error) {
	if len(path) == 0 {
		path = "."
	}
	entries, err := fs.ReadDir(path)
	if err != nil {
		return nil, err
	}
	for _, entry := range entries {
		fp := filepath.Join(path, entry.Name())

clarkmcc

package reflector

import (
	"sync"
)

// Batcher knows how to batch a slice of objects, calling do for each batch
// until Next returns false.
//
// batcher.Next(func(objs []interface{}) {

clarkmcc

package threadsafe

import (
	"sync"
	"time"
)

// Based on https://gist.github.com/clarkmcc/2c40db4bb7b3aea412d78c8a490f030e
// ExpiringErrorCounter maintains a registry of counter errors that expires
// after a specified amount of time. For example if the expiration were set