blinkinglight

class MidpointLruCache:
    def __init__(self, size, oldpercentage):
        self.size = size
        self.oldsize = size * oldpercentage / 100
        self.youngsize = size * (100 - oldpercentage) / 100

        self.youngitems = collections.OrderedDict()
        self.olditems = collections.OrderedDict()

    def __call__(self, func):

blinkinglight

// only 1 sensor to test
const int led = 8;
const int echo = 3;
const int trig = 2;

const long wait = 1000; //cooldown time for the sensor
unsigned long last = 0;

blinkinglight

# -*- coding: utf-8 -*-

# i2c bus (0 -- original Pi, 1 -- Rev 2 Pi)
I2CBUS = 1

# LCD Address
ADDRESS = 0x27

import smbus
from time import sleep

blinkinglight

package main

import (
  "fmt"
  "io"
  "io/ioutil"
  "strings"
  "exec"
  "http"
)

blinkinglight

// Package main is an example of how handler pattern works in golang.
//
// At first you will need some sort of start point. To do this we create
// ExampleHandler interface, this interface has a trigger method that will
// execute the chain, in his case is RunExample, it accepts a writer, and a
// custom input object, as you see there is an out and an in parameter.
//
// We could work like this you can create multiple ExampleHandlers in a helper
// function and call them on in another. But this is not very handy and it smells
//

blinkinglight

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"
)

blinkinglight

on nats server run:
- start gnatsd server then:
-- go run natswsproxy.go -token test -bind :8888

on client run:
- go run client.go -to ws://ws.domain.tld:8888/mq?token=test -nats-user test -nats-pass test # user and pass from nats.server config

blinkinglight

package main

func main() {

	t := htc.New()

	ht := http.Client{}
	r, _ := ht.Get("http://500mbfile.blob")
	go func() {
		io.Copy(t, r.Body)

blinkinglight

package main

import "fmt"

type Node struct {
	prev *Node
	next *Node
	key  interface{}
}

blinkinglight

/*
This snippet is an example of backpressure implementation in Go.
It doesn't run in Go Playground, because it starts an HTTP Server.

The example starts an HTTP server and sends multiple requests to it. The server starts denying
requests by replying an "X" (i.e. a 502) when its buffered channel reaches capacity.

This is not the same as rate-limiting; you might be interested in https://github.com/juju/ratelimit
or https://godoc.org/golang.org/x/time/rate.