David Bremner dbremner

"Scar Tissues Make Relationships Wear Out"

04/26/2103. From a lecture by Professor John Ousterhout at Stanford, class CS142.

This is my most touchy-feely thought for the weekend. Here’s the basic idea: It’s really hard to build relationships that last for a long time. If you haven’t discovered this, you will discover this sooner or later. And it's hard both for personal relationships and for business relationships. And to me, it's pretty amazing that two people can stay married for 25 years without killing each other.

[Laughter]

> But honestly, most professional relationships don't last anywhere near that long. The best bands always seem to break up after 2 or 3 years. And business partnerships fall apart, and there's all these problems in these relationships that just don't last. So, why is that? Well, in my view, it’s relationships don't fail because there some single catastrophic event to destroy them, although often there is a single catastrophic event around the the end of the relation

Principles of Adult Behavior

Be patient. No matter what.
Don’t badmouth: Assign responsibility, not blame. Say nothing of another you wouldn’t say to him.
Never assume the motives of others are, to them, less noble than yours are to you.
Expand your sense of the possible.
Don’t trouble yourself with matters you truly cannot change.
Expect no more of anyone than you can deliver yourself.
Tolerate ambiguity.
Laugh at yourself frequently.

Performance comparison of different data pipelines in .NET

Full source code can be found here

Changelog

2016-12-20
New performance test - Paul Westcott (@manofstick) made me aware that SeqComposer has a more performant API. SeqComposer2 uses this API.
2016-12-23

	// gcc -fno-inline -std=gnu99 -Wall -O3 -g -march=native l1d.c -o l1d

	#include <sys/types.h>
	#include <stdint.h>
	#include <string.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <x86intrin.h>
	#include <math.h>

	unsafe void Main()
	{
	var s = "hello world";
	Console.WriteLine($"String hash code: {s.GetHashCode()}");

	var hashCode = RuntimeHelpers.GetHashCode(s);
	Console.WriteLine($"Object hash code: {hashCode}");

	Console.WriteLine("Poking string...");
	fixed (char* cs = s)

	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.

	// x86 SIMD string to uppercase
	// See http://stackoverflow.com/questions/735204/convert-a-string-in-c-to-upper-case

	#include <stdio.h>
	#include <stdint.h>
	#include <string.h>
	#include <strings.h> // for ffs
	#include <ctype.h>
	#include <immintrin.h>

	<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" >
	<asmv3:application>
	<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
	<longPathAware>true</longPathAware>
	</asmv3:windowsSettings>
	</asmv3:application>
	</assembly>

	/* Compile with
	* gcc -O2 -Wall -Wextra -pedantic -o test_bits test_bits.c
	*/

	#define _GNU_SOURCE
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <sched.h>
	#include <stdint.h>

	// Credits: John Stewien
	// From: http://code.cheesydesign.com/?p=572

	/*
	Reading the Portable Executable (PE) header in C#
	My job consists of writing fully custom applications for groups of people. The time pressure of these projects is quite high, so generally people start using the application while I’m still writing it, which means I write it modularly and add features as I go along. I also fix bugs as they are discovered. My clients are 2 tiered where expert users get a new build first, they test if for a while, and if they think it’s acceptable they then pass it on to others.

	This method of distribution is quite ad-hoc so when a client rings me up and asks me to view their screen to look at something, it’s useful to know what build they are running. To facillitate this I print the link date in the main Window Title so I instantly have an idea about how old the version is that I am looking at. This date is calculated at run time. To do this requires reading in the Portable Executable (PE) header from th