rauchg

Effective transpiling of ES6

After publishing my article on ECMAScript 6, some have reached out to ask how I exactly I make it all work.

I refrained from including these details on the original post because they're subject to immiment obsoletion. These tools are changing and evolving quickly, and some of these instructions are likely to become outdated in the coming months or even weeks.

The main tool

When evaluating the available transpilers, I decided to use 6to5, which has recently been renamed to Babel. I chose it based on:

lavalamp

There are three easy to make mistakes in go. I present them here in the way they are often found in the wild, not in the way that is easiest to understand.

All three of these mistakes have been made in Kubernetes code, getting past code review at least once each that I know of.

1. Loop variables are scoped outside the loop.

What do these lines do? Make predictions and then scroll down.

func print(pi *int) { fmt.Println(*pi) }

zabirauf

defmodule ROP do

  defmacro try_catch(args, func) do
    quote do
      (fn ->
        try do
          unquote(args) |> unquote(func)
        rescue
          e -> {:error, e}
        end

jonhoo

Distributed Read-Write Mutex in Go

This project has moved to https://github.com/jonhoo/drwmutex so it can be imported into Go applications.

Mistobaan

// Default HTTP handler
type Handler func(ctx *Context, w http.ResponseWriter, r *http.Request) error

// ServeHTTP implements http.Handler for our custom type Handler
func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	ctx = NewContext(r)
	defer ctx.Cancel()

	err := h(ctx, w, r)

twotwotwo

github.com/twotwotwo/sorts is a Go package with parallel radix- and quicksorts. It can run up to 5x faster than stdlib sort on the right kind of large sort task, so it could be useful for analysis and indexing/database-y work in which you have to sort millions of items. (To be clear, I don't recommend most folks drop stdlib sort, which is great, and which sorts depends on.)

While the process of writing it's fresh on my mind, here are some technical details, some things that didn't make the cut, and some thoughts about the process:

Concretely, what this looks like inside:

• Both number and string versions are in-place MSD radix sorts that look at a byte at a time and, once the range being sorted gets down to 128 items, call (essentially) the stdlib's quicksort.

• The [parallelization code

danwakefield

Just some stuff you might like to read / watch on the plane if you are interested.

OP-ED:
http://www.evanmiller.org/four-days-of-go.html

Video:
https://youtu.be/elu0VpLzJL8 -- Go for pythonista's -- 51m
https://youtu.be/woCg2zaIVzQ -- Concurrency + Composition -- 14m
https://youtu.be/B-r3Wf_I2Lk -- General stuff -- 18m
https://www.youtube.com/playlist?list=PLMW8Xq7bXrG58Qk-9QSy2HRh2WVeIrs7e -- Others

JoshCheek

require 'objspace'

class A
  # When we include a module, it makes an invisible "included class" (T_ICLASS),
  # and places it in the inheritance hierarchy, as the superclass.
  # Hence A the inclusion, A no longer has a direct reference to Object,
  # it now has a direct reference to the included class
  ObjectSpace.reachable_objects_from(self)  # => [#<InternalObject:0x007f8cd29343b8 T_CLASS>, "A", Object]
  m = Module.new
  include m

taotetek

package main

import (
	"encoding/gob"
	"fmt"

	"github.com/zeromq/goczmq"
)

// person is an example type we will encode, send, and decode

michiwend

type LimitedWaitGroup struct {
	limit     int
	count     int
	countChan chan int
}

func NewLimitedWaitGroup(limit int) *LimitedWaitGroup {
	wg := LimitedWaitGroup{limit: limit}
	wg.countChan = make(chan int)
	return &wg