natdm

definition(
    name: "Smarter Nightlight",
    author: "Nathan Hyland",
    description: "Turns on lights when it's dark and motion is detected and lights are not already on. Turns lights off when it becomes light or some time after motion ceases.",
    category: "Convenience",
    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Meta/light_motion-outlet-luminance.png",
    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Meta/light_motion-outlet-luminance@2x.png"
)

preferences {

natdm

Pipelines in Go are really neat. They're composable functions that allow you to chain concurrent events together, safely.

If you have the need to call API after API after API, witl the same data, maybe pipelines could help. Imagine you have the following:

func create(item Object) Object {
  // do things, call APIs
  return item
}

natdm

#!/bin/bash

# Install and extract go
sudo wget -P /home/ec2-user/ https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz
cd /home/ec2-user/
tar -xzf go1.7.4.linux-amd64.tar.gz

# Set up env. variables
export GOROOT=/home/ec2-user/go
export PATH=$PATH:$GOROOT/bin 

natdm

Reading and replacing some bytes!

Here is the entire application. Below that is a step by step guide.

package main

import (
	"bytes"
	"io/ioutil"

natdm

package main

import (
	"bytes"
	"io/ioutil"
	"log"
	"os"
)

//Open a file, read the bytes, check if the bytes have a sequence of bytes, then replace those bytes with other ones

natdm

package main

import (
	"fmt"
	"time"

	"golang.org/x/net/context"
)

func main() {

natdm

package main

//Messing with Negroni subroutes.

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

natdm

package main

import (
	"fmt"
)

func main() {
	//initialize an array with len/cap 6
	a := [6]string{"G", "o", "l", "a", "n", "g"}

natdm

package main

/*
This isn't meant to be the idiomatic way to read files and copy them - this is a learning exercise
for myself. I wanted to be able to read multiple chunks of a file and write them concurrently to a
new file

I don't really handle all errors with log.Fatalln. It's just done here in the interest of keeping the focus on concurrency.

Example output:

natdm

//GetTransactionsAndLinesForBidder hits the database 3 times. Let's make that fast.
func (db *DB) GetTransactionsAndLinesForBidder(bidderID int) ([]BidderTransaction, error) {

  //Establish a waitgroup. This has 3 functions only. Add, Wait, and Done. You add to the WaitGroup and hit Done when you are
  // done with a process. It will stop the function at Wait until the WaitGroup is at 0.
	var wg sync.WaitGroup
	
	//Get the transaction 'shell'
	trans, err := db.GetTransactionsForBidder(bidderID)
	if err != nil {