Hi, I'm @yburyug

(Bobby)

I love really simple slides

The Halting Problem

Are all problems decidable?

Kurt Gödel:

No. (in math)

Turing:

No. (in CS)

A Fun Proof

def p(func) do
  # Will it blend?
  # Will it halt?
end

You feed in your program, with suitable data,

and p gets to work, and a little while later

(in finite compute time) correctly infers

whether infinite looping behavior occurs.

def p(func) do
  # dance until some point before the world ends
  # know if the function stops
end

If there will be no looping, then p prints out ‘Good.’

That means work on this input will halt, as it should.

But if it detects an unstoppable loop,

then p reports ‘Bad!’ — which means you’re in the soup.

def p(func) do
  case func.() do
    :no_loop       -> IO.puts "good"
    :infinite_loop -> IO.puts "bad"
  end
end

(This soup is sad)

Here’s the trick that I’ll use — and it’s simple to do.

I’ll define a procedure, which I will call q,

that will use p’s predictions of halting success

to stir up a terrible logical mess.

def q(func) do
  # gonna done goof it up
end

For a specified program, say A one supplies,

the first step of this program Q I devise

is to find out from P what's the right thing to say

of the looping behaviour of A run on A

def q(a) when is_function a do
  a.(a)
end

If P's answer is "Bad!", Q will suddenly stop,

But otherwise Q will go back to the top,

and start off again looping endlessly back

til the universe dies and turns frozen and black

And this program called Q wouldn't stay on the shelf

I would ask it to forecast it run on itself.

When it reads its own source code just what will it do?

What's the looping behaviour of Q run on Q?

Our Computers Are Losers

Like, no, seriously, we broke most of the computers

What did that proof do?

Abstracted the complex

(in the most fun way possible)

Choice of Abstraction

Ruby:

Syntax & developer happiness

SciPy/Numpy:

Hard (but quickly computed) math

Haskell:

Reinforcing Your Inferiority Complexes

JavaScript:

The Interwebz™

Primitives

General Qualities

• Built-in
• Simplest unit of the language

Let's look at a random one...

Numbers

With love, from JavaScript

The 'simplest' building blocks can become quite complex

A Process as a Primitive

Parts we can (mostly) forget about

• Concurrency
• Fault Tolerance
• Shared Mutable State

This lets us concentrate on what we really need to build

How to Parallelize and Isolate Bottlenecks

Umbrella Apps

Separate our concerns

GenStage

Think about the steps, not the throughput