Marcus Borkenhagen fritschy

Why you should never have to call super.Foo() in an Foo overload.

This is a classic example of poorly structured points of customisation.

For example, when you have:

class Base
{

virtual void Foo();

The Scammiest Scam To Yet Anonymity Scam

I'm still holding out for this being a hoax, a big joke, and that they're going to cancel the kickstarter any minute. It'd be quite the cute "lessons learned" about anonymity scams. However, I will be treating it from here on out as a genuine scam. (As of May 2nd, the kickstarter has been cancelled, after the strangest attempt to reply to this imaginable. Good riddance.)

This absolutely ridiculous thing was brought to my attention by a friend and since it was late at night I thought I must be delirious in how absurdly over the top fake it seemed. So I slept on it, woke up, and found that it had gotten a thousand dollars more funding and was every bit as flabbergasting as I thought it was.

Since I realize that not everyone has spent their entire lives studying computers – and such people are the targets of such scams –

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

	# Marcus Fritzsch, July 2014

	import os.path
	import sys
	import glob

	from tempfile import mkdtemp
	from email.parser import Parser
	from email.generator import Generator
	from subprocess import check_output

	Below I collected relevant links and papers more or less pertaining to the subject of tetrahedral meshes.
	It's an ever-growing list.

	------------------------------
	Relevant links:

	http://en.wikipedia.org/wiki/Types_of_mesh
	http://en.wikipedia.org/wiki/Tetrahedron
	http://en.wikipedia.org/wiki/Simplicial_complex

	// Conjugate split-radix FFT inner loop

	// Both of these compiled with VC++ 2012, 32-bit, "/O2 /fp:fast".
	// NOTE: I also tried clang-cl and it seems to be primarily a VC++
	// problem. (Which doesn't help me much.)
	//
	// NOTE 2: argh, did the Clang test wrong. It's still primarily a
	// VC++ problem, but Clang has a notable slowdown too. Anyway, new
	// results generated automatically from a simpler standalone test
	// where I can toggle between versions using a single commandline

	// rover.ks
	// Written by KK4TEE
	// License: GPLv3
	//
	// This program provides stability assistance
	// for manually driven rovers

	set speedlimit to 10. //All speeds are in m/s
	lock turnlimit to min(1, 1.5 / surfacespeed). //Scale the
	//turning radius based on current speed

	/*
	* Random-Number Utilities (randutil)
	* Addresses common issues with C++11 random number generation.
	* Makes good seeding easier, and makes using RNGs easy while retaining
	* all the power.
	*
	* The MIT License (MIT)
	*
	* Copyright (c) 2015-2022 Melissa E. O'Neill
	*

	/*

	Twisting Pool Allocator
	=======================
	written by Leonard Ritter (leonard.ritter@duangle.com)

	This file is in the public domain

	I don't know if I was the first one to stumble upon this technique, so
	I can't guarantee there's no patent on it, but let's hope there's not,