elazarl

package main

import "fmt"
import "net"

var localhost = net.ParseIP("127.0.0.1")

var port1, port2 = 1220, 1229
func conwrite() {
  c1, err := net.DialTCP("tcp", &net.TCPAddr{localhost, port2}, &net.TCPAddr{localhost, port1})

elazarl

import org.junit.Test;

import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;

/**
 * This tests make sure Java prevents a socket from connecting to itself
 * via binding to the same port it connects to

elazarl

#include <stdio.h>
#include <poll.h>

#include <fcntl.h>

int main() {
    int fd = open("/dev/null", O_WRONLY);
    struct pollfd pollfds = { fd, POLLOUT, 0 };
    if (fd < 0) {
        perror("open");

elazarl

package bug

type returnPanic struct {
	err error
}

func F() (err error) {
	defer func() {
		if _, ok := recover().(returnPanic); !ok {
			panic(err)

elazarl

package main

func Panic() { panic("oooh, no stacktrace") }

func make_bt_longer() {
	Panic()
}

func main() {
	Completer = func (text string, start, end int) (replacement string, options []string) {

elazarl

// A signer/verifier compatible with openssl ecdsa signature scheme
// 
//     $ openssl ecparam -name prime256v1 -genkey -noout >ec.pem
//     $ openssl ec -pubout <ec.pem >ecpub.pem
//
// and with sha256 verification
//
//     $ echo a|openssl sha256 -sign ec.pem > sig.bin
//     $ echo a|openssl sha256 -verify ecpub.pem -signature sig.bin
//

elazarl

/**
* Usage:
* $ javac KillRegions
* $ # list all regions in cluster, search for first listed region in MYTABLE
* $ java -cp `hbase classpath`:. KillRegions -l|grep MYTABLE|head -n1 >/tmp/regions.txt
* $ # delete first regions in MYTABLE, listed above
* $ java -cp `hbase classpath`:. KillRegions </tmp/regions.txt
*/
import com.google.common.base.Charsets;
import com.google.common.collect.Lists;

elazarl

/*
Welcome to the game show "lies and benchmarks".

We will present the participants a required result, and they would build a
benchmark that reaches the predetermined conclusions.

When done professionally, this activity is called "benchmarketing".

Our task for today is to prove LongAdder is slower than AtomicLong. Our
observation is, LongAdder prevents write contention to a single a atomic

elazarl

By @cmpxchg16 1%-100% writes samples for LongAdderBench.java:

for  1% writes=16,000 (16 threads * 100,000 ops each=1,600,000):
  LongAdder  1.209ms
  AtomicLong 0.281ms
AtomicLong faster than LongAdder by 76.77%

for  2% writes=32,000 (16 threads * 100,000 ops each=1,600,000):
  LongAdder  2.019ms

AtomicLong 0.485ms

elazarl

alias gdbdump='hexdump -e '\''"0x%04_ax: " 8/1 "0x%02x\t" "\n"'\'''
# hexdump format is: '"0x%04_ax: " 8/1 "0x%02x\t" "\n"'