borud

// formWrapper converts a POST'ed form to the JSON object we want.  grpc-gateway doesn't
// normally accept anything other than application/json, so we intercept anything that
// has Content-Type equal to "application/x-www-form-urlencoded".
func formWrapper(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// If we can't get the media type this request we just pass it on
		mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
		if err != nil {
			h.ServeHTTP(w, r)
			return

xhit

package main

import (
	"errors"
	"fmt"
	"time"
)

func main() {
	dur, _ := ParseDuration("1.000000001s")

bcherny

Notes on Martin Kleppmann's excellent Designing Data-Intensive Applications.

Chapter 1: Reliable, Scalable, and Maintainable Applications

• Data Systems
  • Dimensions to consider when thinking about data systems: access patterns, performance characteristics, implementations.
  • Modern data systems often blur the lines between databases, caches, streams, etc.
• Reliability
  • Systems should perform the expected function at a given level of performance, and be tolerant to faults and user mistakes
• Fault: One component of a system deviating from its spec. Prefer tolerating faults over preventing them (except for things like security issues). Faults stem from hardware failures, software failures, and human error (in a study, config errors caused most outages).

System-Glitch

package main

// This is an example of a resilient worker program written in Go.
//
// This program will run a worker, wait 5 seconds, and run it again.
// It exits when SIGINT or SIGTERM is received, while ensuring any ongoing work
// is finished before exiting.
//
// Unexpected panics are also handled: program won't crash if the worker panics.
// However, panics in goroutines started by the worker won't be handled and have

urandom

package pipes_test

import (
	"context"
	"crypto/md5"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"runtime"

faiface

Go 2 generics counterproposal: giving up restricting types

"I want to make a generic function which works on any type that satisfies these and these constraints."

When we think about generics, this is the sort of problem that pops up into our minds. The critical part is restricting the set of types our function intends to work on. Trying to solve this problem of restriction has led people to what I call reasons why we hesitate to have generics in Go.

C++ templates with horrific error messages, or even it's new concepts, Java's T extends Comparable<T>, Rust's generic traits, Haskell's type classes, and sadly even contracts from the [original generics proposal by the Go Team](https://go.googlesource.com/proposal/+/master/desig

bzerangue

NDJSON is a convenient format for storing or streaming structured data that may be processed one record at a time.

• Each line is a valid JSON value
• Line separator is ‘\n’

1. Convert JSON to NDJSON?

cat test.json | jq -c '.[]' > testNDJSON.json

stefanoverna

// First option:
// This will dump every content of a DatoCMS space in the "backup" directory
// To be used with the `dato dump` command (see https://docs.datocms.com/other/basic-usage.html)

module.exports = (dato, root, i18n) => {
  i18n.availableLocales.forEach(locale => {
    root.directory(`backup/${locale}`, localeDir => {
      dato.itemTypes.forEach(itemType => {
        localeDir.createDataFile(
          `${itemType.apiKey}.json`,

vitorreus

#!/bin/bash
#This script creates 1 master, 2 slaves and 3 sentinels services in docker swarm.

docker network create \
  --driver overlay \
  testes_network

SWARM_MASTER=192.168.205.125

#Master

derekchiang

package main

import "fmt"

// WithPrefix

type prefixOption struct{}

func WithPrefix() interface {
	GetOption