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

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.

blinkinglight

/*
Parallel processing with ordered output in Go
(you can use this pattern by importing https://github.com/MarianoGappa/parseq)

This example implementation is useful when the following 3 conditions are true:
1) the rate of input is higher than the rate of output on the system (i.e. it queues up)
2) the processing of input can be parallelised, and overall throughput increases by doing so
3) the order of output of the system needs to respect order of input

- if 1 is false, KISS!

blinkinglight

package main

import (
	"fmt"
	"reflect"
)

type Foo struct {
	FirstName string `tag_name:"tag 1"`
	LastName  string `tag_name:"tag 2"`