I honestly cannot tell if Swift developers are seriously eating Irish babies, or taking the Mickey.

From bad implementations of Equatable and Hashable, the wag leaps to:

```
extension GridPoint : HashVisitable {
func hash<H: Hasher>(_ hasher: inout H) {
self.x.hash(&hasher)
self.y.hash(&hasher)
}
}
```

Bravo! That's easily the funniest punchline to a programming joke since "where do you think the chaos came from?"

Starts with the most bizarre strawman Objective-C Sieve of Erathosthenes I've ever seen. A real implementation would be in C, because Obj-C is C with objects, and it'd be massively faster:

```
#include <stdlib.h>
#include <stdio.h>
typedef char BOOL; // or link in Foundation
#define YES 1
#define NO 0
int main(int argc, char **argv) {
if (argc != 2) {
printf("Usage: primes COUNT\n");
exit(1);
}
long n = atoi(argv[1]);
BOOL p[n];
p[0] = NO;
p[1] = NO;
for (long i = 2; i < n; ++i) {
p[i] = YES;
}
for (long i = 2; i < n; ++i) {
for (long j = i*i; j < n; j += i) {
p[j] = NO;
}
}
for (long i = 1; i < n; ++i) {
if (p[i]) {
printf("%ld ", i);
}
}
puts("");
return 0;
}
```

This does use more lines of code, but they're short, low-density, and it's instantly obvious what it's doing (my predilection for 1-char var names aside). Can you actually decode his filter-based version?

```
func sieve(_ sorted: [Int]) -> [Int] {
guard !sorted.isEmpty else { return [] }
let (head, tail) = (sorted[0], sorted[1..<sorted.count])
return [head] + sieve(tail.filter { $0 % head > 0 })
}
let numbers = Array(2...1000000)
let primes = sieve(numbers)
print(primes)
```

And the runtime experiment:

```
mdh@Aegura:~/Code/CodeC% time clang -O3 -o primes primes.c
clang -O3 -o primes primes.c 0.04s user 0.41s system 83% cpu 0.534 total
mdh@Aegura:~/Code/CodeC% time ./primes 1000000 >~/Desktop/primes.txt
./primes 1000000 > ~/Desktop/primes.txt 0.02s user 0.00s system 89% cpu 0.025 total
mdh@Aegura:~/Code/CodeSwift% time swiftc -O -o swiftPrimes swiftPrimes.swift
swiftc -O -o swiftPrimes swiftPrimes.swift 0.57s user 0.64s system 69% cpu 1.754 total
mdh@Aegura:~/Code/CodeSwift% time ./swiftPrimes >~/Desktop/swiftPrimes.txt
./swiftPrimes > ~/Desktop/swiftPrimes.txt 51.79s user 26.49s system 99% cpu 1:18.78 total
```

So the naïve C implementation is about 3,151x faster. I can't measure it precisely because a limit measurable in C, would take Swift until the heat death of the Universe.

So here's my question: Is Vincent aware of this, and his theme of "diabetes", "sugar", "saccharine", etc. pointing at how fat, bloated, slow, and deadly Swift is? He never lets on if this is a joke, he keeps tossing more syntax layers on top of Swift.