blinkinglight

#!/usr/bin/env bash

# install docker
# https://docs.docker.com/engine/installation/linux/ubuntulinux/

# install docker-compose
# https://docs.docker.com/compose/install/

# install letsencrypt
# https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-16-04

blinkinglight

/*   
   Copyright 2011 Martin Hawksey

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

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.