nanne007

git ls-files -z | xargs -0n1 git blame -w | perl -n -e '/^.*\((.*?)\s*[\d]{4}/; print $1,"\n"' | sort -f | uniq -c | sort -n

nanne007

Rust/Haskell: Higher-Kinded Types (HKT)

A higher kinded type is a concept that reifies a type constructor as an actual type.

A type constructor can be thought of in these analogies:

• like a function in the type universe
• as a type with a "hole" in it

nanne007

// licensed under public domain
// author: matianfu@gmail.com

const EventEmitter = require('events')

// K combinator, not necessary, just for fun
const K = x => y => x

// this class is mainly for settle logic.
// the concrete class should emit a 'finish' event with err/data at the end of the process

nanne007

Producer

Setup
bin/kafka-topics.sh --zookeeper esv4-hcl197.grid.linkedin.com:2181 --create --topic test-rep-one --partitions 6 --replication-factor 1
bin/kafka-topics.sh --zookeeper esv4-hcl197.grid.linkedin.com:2181 --create --topic test --partitions 6 --replication-factor 3

Single thread, no replication

bin/kafka-run-class.sh org.apache.kafka.clients.tools.ProducerPerformance test7 50000000 100 -1 acks=1 bootstrap.servers=esv4-hcl198.grid.linkedin.com:9092 buffer.memory=67108864 batch.size=8196

nanne007

AllCops:
  RunRailsCops: true

# Commonly used screens these days easily fit more than 80 characters.
Metrics/LineLength:
  Max: 120

# Too short methods lead to extraction of single-use methods, which can make
# the code easier to read (by naming things), but can also clutter the class
Metrics/MethodLength: 

nanne007

require 'msgpack'
require 'thread'

class ProcessPool
  def initialize(num_process, args={})
    queue_size, worker_class = parse_args([
      :queue_size, nil,
      :worker_class, Worker,
    ], args)

nanne007

• USP: Implementing signal handlers - some caveats
• GServer in Ruby 2.0.0
• "self-pipe trick" - GServer in Ruby 2.0.0
• Bug #7917: Can't write to a Logger in a signal handler - ruby-trunk - Ruby Issue Tracking System
• Tweet by @xpaulbettsx
• cod - Unix: Things to be aware of - Tricks
• The self-pipe trick (djb)
• Safe UNIX Signal Handling Tips
• Avoiding races with Unix signals and select()
• signal(7) - Async-signal-safe functions

nanne007

Why do compilers even bother with exploiting undefinedness signed overflow? And what are those
mysterious cases where it helps?

A lot of people (myself included) are against transforms that aggressively exploit undefined behavior, but
I think it's useful to know what compiler writers are accomplishing by this.

TL;DR: C doesn't work very well if int!=register width, but (for backwards compat) int is 32-bit on all
major 64-bit targets, and this causes quite hairy problems for code generation and optimization in some
fairly common cases. The signed overflow UB exploitation is an attempt to work around this.

nanne007

#!/bin/bash

# Build latest version of Emacs, version management with stow
# OS: Ubuntu 14.04 LTS
# version: 24.5
# Toolkit: lucid

# Warning, use updated version of this script in: https://github.com/favadi/build-emacs

set -e

nanne007

# unicorn_rails -c /data/github/current/config/unicorn.rb -E production -D

rails_env = ENV['RAILS_ENV'] || 'production'

# 16 workers and 1 master
worker_processes (rails_env == 'production' ? 16 : 4)

# Load rails+github.git into the master before forking workers
# for super-fast worker spawn times
preload_app true