But is that just my stupid meaty brain noticing patterns where none exist?

The TOTP algorithm uses HMAC, which in turn uses SHA-1. My aforementioned brain is not clever enough to understand how that works. Although bigger, meatier brains have assured me it is fine.

What happens if I sample, say, the next 10 TOTP codes and plot how often digits appear?

HOLY SHIT! CONSPIRACY CONFIRMED! WTAF?!?!?

Don't believe me? Here's the code:

import pyotp
import numpy as np
import matplotlib.pyplot as plt

totp = pyotp.TOTP('')

#   How many times to run this?
runs = 10

#   Initialize a NumPy array with shape to store the digits
digits_array = np.zeros( ( runs, 6), dtype=int)

#   Generate the digits
for i in range( runs ):
    number_str = totp.at( i * 30 )
    for j in range(6):
        digits_array[i, j] = int(number_str[j])

#   Analyse the entire array
all_digits = digits_array.flatten()

# Plot histogram for all digits
plt.figure()
plt.hist(all_digits, bins=np.arange(11) - 0.5, edgecolor='black', density=True)
plt.xticks(range(10))
plt.title('Digit Distribution for All Digits (' + f"{runs:,}" + ' runs)')
plt.xlabel('Digit')
plt.ylabel('Frequency')
plt.show()

OK, so maybe that's a coincidence. What happens if we check 100 generations?

Quite a lot of noise in there - but lucky number 8 isn't quite as prominent.

After 10,000 generations, the variation is all but gone.

There are about 30 million seconds in a year. TOTP codes change every 30 seconds. Which means, in a year, you'll see about a million of them:

Is it possible that a TOTP code could be formed which shows a clear bias to a specific number? Probably not.

I love being able to check the source code - but sometimes it's just as reassuring to measure the output.

The Splitline Algorithm is, conceptually, very simple:

1. Divide the entire map in half based on population.
2. Repeat (1) for each half.
3. Once you have reached the target number of voters in each segment, stop.

There's an excellent paper about how to apply this to the USA's districts.

But, I couldn't find anything which applied the algorithm to the UK. So I thought I'd give it a go for fun².

First, start with the Office for National Statistics' Population Density Map

Before we even begin, there are a few obvious issues. Firstly, the map isn't contiguous. So what happens to the Shetland Isles (population 22,000) and the Isle of Wight (population 140,000)? There are, on average, 100,000 people to every MP³. Do Shetland Islanders want to be lumped together with 78k other people from the mainland who might not necessarily share their values? Do the people from the Isle of Wight want to be split in half with one half being tied to non-islanders?

The second (related) issue is NI. I'm not going to get into the long history there⁴. But I think it is fair to say that an algorithmic segmentation might cause a few raised eyebrows. So I'm going to concentrate on England, Scotland, and Wales for this section.

Here's a really naïve (and inaccurate) split based on eyeballing it.

Applying the algorithm again, and we can split the area into four equal population parts:

Repeat a few hundred times and you have equal population constituencies.

You could slice the country into long horizontal strips. That would be equal - but not necessarily practical.

OK, that's enough mucking around, time to try applying it for real.

Getting the data

The first question is what resolution of population do you want? Using country-level population density isn't fine-grained enough. Using existing constituency data is just going to replicate the existing boundaries. Like this:

So... street level?

ONS have local authority level data - which isn't quite granular enough for my purposes.

Instead, I downloaded a 1.2GB CSV from Data for Good at Meta (previously Facebook). The data looks like this:

"Lat","Lon","Population"
"50.62069444448494","-2.023750000001619","0.785894169690091"
"54.91486111115504","-1.378472222223325","3.3208914089403367"
"52.725416666708846","0.11152777777786699","1.116925979478443"
"52.72736111115329","0.12402777777787699","1.116925979478443"
"52.779583333375555","0.100694444444525","1.3609065999360417"

They have a GeoTIFF which renders the whole of the UK like this:

Zooming in to Edinburgh, shows the city is well-populated but not the countryside around it.

London, however, is dense. With occasional pockets of emptiness.

(Notes to self, to make a GeoTIFF into a browseable web map, run:

gdal_translate -of VRT -ot Byte -scale population_gbr_2019-07-01.tif temp.vrt

Then:

gdal2tiles.py temp.vrt

Finally, change to the newly generate directory and run python3 -m http.server 9000 and - hey presto - web maps!)

Python and Pandas Oh My!

import pandas as pd
df = pd.read_csv("population_gbr_2019-07-01.csv")
total_population = df['Population'].sum()

Gets us a total population of 66,336,531. Which looks right to me! Let's say we want 100,000 people (not voters) per constituency. That'd give us 663 areas - which is about what the UK has in the House of Commons⁵.

OK, which way do we want to split these data? A proposal by Brian Langstraat suggests splitting only in the horizontal and vertical directions.

First, let's sort the data South to North.

df = df.sort_values(by = 'Lat', ignore_index = True)

Which gives us

                Lat       Lon  Population
0         49.864861 -6.399306    0.573312
1         49.868194 -6.393472    0.573312
2         49.874306 -6.369583    0.573312
3         49.884306 -6.342083    0.573312
4         49.886528 -6.341806    0.573312
...             ...       ...         ...
19232801  60.855417 -0.886250    0.109079
19232802  60.855417 -0.885694    0.109079
19232803  60.855417 -0.885417    0.109079
19232804  60.855694 -0.884861    0.109079
19232805  60.855972 -0.884028    0.109079

Now we need to add up the Population until we reach total_population / 2 - that will tell us where to make the first cut.

half_population = total_population / 2
index = 0
cumulative_total = 0
for x in df["Population"] :
     if (cumulative_total >= half_population):
             print(str(index))
             break
     else :
             cumulative_total += x
             index += 1

That tells us that the row which is halfway through the population is 8,399,921.

df.iloc[8399921]

Gives us a Latitude of 52.415417 - which is Huntington. So a properly bisected map of the UK's population looks like:

50% of the population live above the black line, 50% live below it.

Let's take the top half and split it vertically.

df = df[8399921:]
df = df.sort_values(by = 'Lon', ignore_index = True)
total_population = df['Population'].sum()
half_population = total_population / 2
index = 0
cumulative_total = 0
for x in df["Population"] :
     if (cumulative_total >= half_population):
             df.iloc[index]
             break
     else :
             cumulative_total += x
             index += 1

Which gives us 52.675972,-2.082917 - an industrial estate in Wolverhampton.

In this map, 25% of the total population live to the East of the black line, and 25% to the West:

And this is where we start to see one of the problems with the naïve splitting algorithm. A chunk of Aberdeen has been sliced off from its neighbours. We can see that there will be a likely constituency of Shetlands, a bit of Aberdeen, and a slice of North-East England. These may not share common needs!

Straight-line slicing bisects otherwise "natural" groupings of people. Sure, gerrymandering is bad - but this sort of divvying up makes for the strangest bedfellows.

Shortest Splitline

The Shortest Splitline Algorithm doesn't is similar to the above but, rather than restricting itself to vertical and horizontal lines, looks for the line with the shortest distance which contains 50% of the population.

A Different Approach - South Up Algorithm

Let's just start at the bottom left of the map and work our way up.

Here's the South West (Scilly Isles not shown⁶.):

Let's plot everything, just to make sure the data are all there:

import matplotlib.pyplot as plt
df.plot(x="Lon", y="Lat", kind="scatter", c="black")
plt.show()

OK! Let's grab the first 100,000 people.

df = df.sort_values(by = ['Lat', 'Lon'], ignore_index=True)
target = 100000
index = 0
cumulative_total = 0
for x in df["Population"] :
     if (cumulative_total >= target):
             df.iloc[index]
             break
     else :
             cumulative_total += x
             index += 1

area = df[:index]

area.plot(x="Lon", y="Lat", kind="scatter", c="black")
plt.show()

Which results in:

Hurrah! Scillies and South West England! Exactly 100,000 people live in that area.

Let's do the next few in different colours

df = df.sort_values(by = ['Lat', 'Lon'], ignore_index=True)
df['Colour'] = pd.Series(dtype="U") # Add a Unicode string column for colour
target = 100000
index = 0
cumulative_total = 0

#   There is probably a much more efficient way to do this loop
for x in df["Population"] :
     if (cumulative_total <= target):
             df.Colour.iloc[index] = "mistyrose"
     elif (cumulative_total > target and cumulative_total <= target * 2):
             df.Colour.iloc[index] = "peru"
     elif (cumulative_total > target * 2 and cumulative_total <= target * 3):
             df.Colour.iloc[index] = "mediumpurple"
     elif (cumulative_total > target * 3 and cumulative_total <= target * 4):
             df.Colour.iloc[index] = "olivedrab"
     elif (cumulative_total > target * 4):
             break
     cumulative_total += x
     index += 1

area = df[:index]

area.plot(x="Lon", y="Lat", kind="scatter", c="Colour")
plt.show()

That's (mostly) going South to North, so we get those unnatural looking stripes which have weird incongruent chunks.

Bubble Split Algorithm

Rather than drawing lines, let's use a "Bubble Split" approach. Starting in, for example, the most South Westerly point in the dataset and then growing to its neighbours until it hits a population of 100,000.

This will use's SciPy's KDTree Algorithm

from scipy import spatial
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
df = pd.read_csv("population_gbr_2019-07-01.csv")
df = df.sort_values(by = ['Lat', 'Lon'], ignore_index=True)
points = df[["Lat", "Lon"]].to_numpy()
kdtree = spatial.KDTree(points)

# To find the nearest neighbour of a specific point:
kdtree.query( [59.1,-6.2] )[1]

counter = 1
population = 0
target = 100

while (population <= target):
   nearest_index = kdtree.query( [59.1,-6.2], [counter] )[1]
   population += df.loc[nearest_index, "Population"].values[0]
   counter += 1

population

Looping through is very slow and crawls to a halt after a few thousand iterations. So let's cheat. This grabs the nearest million points and finds their total population.

nearest_million = kdtree.query( [59.1,-6.2], 1000000 )[1]
df["Population"].iloc[ nearest_million ].sum()

There's no way to iterate through the results, so its easiest to grab a bunch and iterate through that instead.

counter = 0
population = 0 
target = 100000

while (population <= target):
    end     = (counter + 1) * 10000
    start   =  counter * 10000
    population += df["Population"].iloc[ nearest_million[start:end] ].sum()
    print("On " + str(end) + " Pop: " + str(population))
    counter += 1

These can now be plotted using:

indices = kdtree.query( [59.1,-6.2], end )[1]
to_plot = df.iloc[ indices ]

KDTrees are not designed to be altered - so deleting nodes from them is impossible. Instead, the nodes have to be deleted from the data, and then a new KDTree constructed.

index_to_delete = kdtree.query( [59.1,-6.2], end )[1]
df = df.drop(index = index_to_delete)
points = df[["Lat", "Lon"]].to_numpy()
kdtree = spatial.KDTree(points)

Bounding Boxes

Drawing a box around some points is useful. It provides a geographic border and also means we don't need to worry about map colouring algorithms.

For this, we'll use SciPy's ConvexHull algorithm:

import matplotlib.pyplot as plt
from scipy.spatial import ConvexHull, convex_hull_plot_2d
import numpy as np

indices = kdtree.query( [x,y], end )[1]

area = df.iloc[ indices ]

s_array = area[["Lat", "Lon"]].to_numpy()
hull = ConvexHull(s_array)
plt.plot(s_array[:,0], s_array[:,1], 'o') # Remove this to only display the hull

for simplex in hull.simplices:
    plt.plot(s_array[simplex, 0], s_array[simplex, 1], 'k-')

plt.show()

Here's the result - can you spot what I did wrong?

Putting it all together

This scrap of code reads the data, sorts it, constructs a KDTree, starts at the South West tip, finds the 100,000 people nearest to that point, and draws a bounding box around them:

#   Import the libraries
import pandas as pd
import matplotlib.pyplot as plt
from scipy import spatial
from scipy.spatial import ConvexHull, convex_hull_plot_2d
import numpy as np

#   Read the data
df = pd.read_csv("population_gbr_2019-07-01.csv")

#   Sort the data
df = df.sort_values(by = ['Lat', 'Lon'], ignore_index=True)

#   Create KDTree
points = df[["Lat", "Lon"]].to_numpy()
kdtree = spatial.KDTree(points)

#   Most South Westerly Point
sw_lat, sw_lon = points[0]

#   Get first 100,000 people
counter = 0
population = 0 
increment = 5000
target = 100000

while (population <= target):
    end     = (counter + 1) * increment
    start   =  counter * increment
    population += df["Population"].iloc[ nearest_million[start:end] ].sum()
    print("On " + str(end) + " Pop: " + str(population))
    counter += 1

#   Get the index numbers of the points with 100,000 people
indices = kdtree.query( [sw_lat, sw_lon], end )[1]

#   A separate DataFrame for drawing
to_plot = df.iloc[ indices ]

#   Flip Lat & Lon, because Lon is the X Co-ord, Lat is Y Co-ord
plot_array = to_plot[["Lon", "Lat"]].to_numpy()

#   Calculate the bounding box
hull = ConvexHull(plot_array)

#   Plot the points
plt.plot(plot_array[:,0], plot_array[:,1], 'o') # Remove this to only display the hull

#   Draw the hull
for simplex in hull.simplices:
    plt.plot(plot_array[simplex, 0], plot_array[simplex, 1], 'k-')

#   Display the plot
plt.show()

Which produces:

Running that a few more times gives this (sorry for chopping off the Scilly Isles):

Can you see why I call this "Bubble Split"?

Already we can see the limits to this approach. The orange-coloured subdivision has a little incongruent bit across the estuary of the River Fal.

Here's the (hugely inefficient and slow) code to generate 40 areas of roughly 100,000 people:

#   Import the libraries
import pandas as pd
import matplotlib.pyplot as plt
from scipy import spatial
from scipy.spatial import ConvexHull, convex_hull_plot_2d
import numpy as np

def get_100k_people(df, nearest_million) :
    counter = 0
    population = 0 
    increment = 1000
    target = 100000

    while (population <= target):
        end     = (counter + 1) * increment
        start   =  counter * increment
        population += df["Population"].iloc[ nearest_million[start:end] ].sum()
        #print("On " + str(end) + " Pop: " + str(population))
        counter += 1

    return end

def plot_hull(df, indices) :
    #   A separate DataFrame for drawing
    to_plot = df.iloc[ indices ]

    #   Flip Lat & Lon, because Lon is the X Co-ord, Lat is Y Co-ord
    plot_array = to_plot[["Lon", "Lat"]].to_numpy()

    #   Calculate the bounding box
    #hull = ConvexHull(plot_array)

    #   Plot the points
    plt.plot(plot_array[:,0], plot_array[:,1], 'o', markersize=1) # Remove this to only display the hull

    #   Draw the hull
    #for simplex in hull.simplices:
    #    plt.plot(plot_array[simplex, 0], plot_array[simplex, 1], 'k-')

#   Read the data
df = pd.read_csv("population_gbr_2019-07-01.csv")

#   Sort the data
df = df.sort_values(by = ['Lat', 'Lon'], ignore_index=True)

for areas in range(40):
    #   Create KDTree
    points = df[["Lat", "Lon"]].to_numpy()
    kdtree = spatial.KDTree(points)

    #   Most South Westerly Point
    sw_lat, sw_lon = points[0]

    #   Get the nearest 1 million points
    nearest_million = kdtree.query( [sw_lat, sw_lon], 1000000 )[1]

    #   How many points contain a cumulative total of 100k people
    end = get_100k_people(df, nearest_million)

    #   Get the index numbers of those points
    indices = kdtree.query( [sw_lat, sw_lon], end )[1]

    #    Draw
    plot_hull(df, indices)

    #   Delete used Indices
    df = df.drop(index = indices)
    df = df.reset_index(drop = True)

#   Display the plot
plt.show()

Other Choices

I made the rather arbitrary choice to start in the South West and proceed Northwards. What if, instead, we start with the point with the lowest population density and work upwards.

Here's a video of the sequence:

As you can see, it starts off pretty well, but the final few areas are randomly distributed throughout the map. I kinda like the idea of a meta-constituency of small villages. But I'm not sure if that's practical!

This next video starts with the highest population density and works downwards:

Terence Eden is on Mastodon

@edent

Replying to @edentHere's the reverse.
Start at the most densely populated point.
Draw a randomly coloured shape around the ~100,000 nearest people.
Find the next most dense point which hasn't already been drawn.
Repeat ~650 times.
This would be a *terrible* system for creating constituencies. pic.x.com/uqifiakbmp

---

Terence Eden is on Mastodon

@edent

Replying to @edentHere are the two different approaches. Click for massive.

Left starts at the lowest density.
Right starts at the highest density.

Fascinating to see where they diverge, and which bits look more "natural".
Anyway, go play with maps, data, & algorithms. It's fun! pic.x.com/dpcbsbymsb

---

NB, there's no guarantee that the generated images will have dimensions be divisible by two - so here's some hacky ffmpeg code to crop the images! ffmpeg -framerate 1 -pattern_type glob -i '*.png' -c:v libx264 -r 30 -pix_fmt yuv420p -vf "crop=trunc(iw/2)*2:trunc(ih/2)*2" output.mp4

Or, to scale the video to 1280 wide ffmpeg -framerate 1 -pattern_type glob -i '*.png' -c:v libx264 -r 30 -pix_fmt yuv420p -vf scale=1280:-2 output.mp4

Algorithms aren't neutral

It's tempting to think that computer code is neutral. It isn't. Even something as seemingly innocuous as choosing a starting point can cause radical change. It may be aesthetically pleasing to draw straight lines on maps - but it can cause all sorts of tension when communities are divided, or combined, against their will⁷.

It's a fun exercise to take population density data and play around with it algorithmically. It shows the power and the limitations of automated decision making.

Let's consider a set of 1 dimensional data. For example, the alphabet:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

What do we mean by "1 dimensional"?

Consider the element "B". From there you can go left to "A" or right to "C". Left and right are the only directions you can move. You cannot go up or down from "B". There's no way to go in or out. You're trapped in a single dimension.

What if we want to write the data onto a 2 dimensional space - like a bit of paper or a website.

Well, if the space is big enough, we can write it as we have above. A single line. Job done, go home.

But what if the space is too small in the horizontal direction to contain it all? Well, we could write it in the vertical direction:

A
B
C
D
…

OK, but what if the 2D space is too small in both the horizontal and the vertical directions to contain the 1D data? Now we get into the "exciting" world of space-filling algorithms.

Here's the approach that you're probably most used to. It's certainly the one which springs to most people's minds:

ABCDEFG
HIJKLMN
OPQRSTU
VWXYX

The algorithm is simple. Write horizontally from left to right until you run out of space, then move down one line, return to the left-most side, and continue writing. Repeat.

Except! That's not necessarily the simplest or most obvious way of writing!

There is a different algorithm - Boustrophedon:

ABCDEFG
NMLKJIH
OPQRSTU
  ZYXWV

Start at the left, when you run out of space, move down a line and continue writing in the opposite direction!

→ABCDEFG
        ↓
 NMLKJIH←
↓
→OPQRSTU
        ↓
   ZYXWV←

If you haven't spent years learning to read "properly" this form of bi-direction writing may well be easier. You don't need to move your finger or eyes back in a perfectly straight line.

We can go a little further. What if we started at the centre of the page, and wrote out in a spiral?

Z
YJKLM
XIBCN
WHADO
VGFEP
UTSRQ

As pretty as this looks, there are some obvious drawbacks. Unless you know exactly how long the 1D data is, you won't know where to start on the page. It also might not fill the space in the most efficient manner.

Here's a different algorithm. It starts in the top left corner of the space and gradually spreads out. Growing to fit the data in the space:

 ABIJYZ 
 DCHKX  
 EFGLW  
 PONMV  
 QRSTU  

If you're having trouble following that, here it is in diagram form:

 →↓→↓→ 
 ↓←↑↓↑ 
 →→↑↓↑ 
 ↓←←←↑ 
 →→→→↑ 

That's quite a nice algorithm. It starts in a predictable place and it fills up both horizontal and vertical space in equal amounts.

Introducing Hilbert Curves!!

Let's start with a simple curve:

D__C
   |
A__B

Where do we go from here? The Hilbert Curve is a fractal algorithm which starts like this:

F__G  J__K
|  |  |  |
E  H__I  L
|        |
D__C  N__M
   |  |
A__B  O__P

And ends up doing this:

Lovely!

Non-rectangular curves

Not every 2D space is a rectangle. Some have the audacity to be hexagons!

3D!

And then...

I wonder what interesting things I can do with this new knowledge?

From everyday apps to complex algorithms, Ruha Benjamin cuts through tech-industry hype to understand how emerging technologies can reinforce White supremacy and deepen social inequity.

Benjamin argues that automation, far from being a sinister story of racist programmers scheming on the dark web, has the potential to hide, speed up, and deepen discrimination while appearing neutral and even benevolent when compared to the racism of a previous era. Presenting the concept of the “New Jim Code,” she shows how a range of discriminatory designs encode inequity by explicitly amplifying racial hierarchies; by ignoring but thereby replicating social divisions; or by aiming to fix racial bias but ultimately doing quite the opposite. Moreover, she makes a compelling case for race itself as a kind of technology, designed to stratify and sanctify social injustice in the architecture of everyday life.

I have mixed feelings about this book. It doesn't contain much new data - to people who have been paying attention - but it does synthesise everything neatly to present a compelling case.

But, like many similar books, it is relentlessly American. And, almost exclusively African-American. That's not to detract from its central point, but it does rather limit the discussion.

It's incredibly well referenced - almost to the point of making it difficult to read. But - related to the above - it does have a number of cultural blind-spots. One sentence in particular assumes the reader knows what "Shondaland" is. Do you have any clue? Turns out it's an American TV production company.

For all that, it is a brilliant read and full of well-nuanced arguments. One part which took my breath away was this:

However, a universalizing lens may actually hide many of the dangers of discriminatory design, because in many ways Black people already live in the future. The plight of Black people has consistently been a harbinger of wider processes – bankers using financial technologies to prey on Black homeowners, law enforcement using surveillance technologies to control Black neighborhoods, or politicians using legislative techniques to disenfranchise Black voters – which then get rolled out on an even wider scale. An #AllLivesMatter approach to technology is not only false inclusion but also poor planning, especially by those who fancy themselves as futurists.

Emphasis added

What an amazing spin on "the future's here, it's just not evenly distributed.

The end of the book goes off on a slightly weird tangent about design thinking. It feels out of place, and I'm not sure I followed the argument.

I sound grumpy, and I don't know why. Probably because I don't like my assumptions about technology challenged. This is a timely and useful book. It captures the reality of how technology creates and perpetuates a racial underclass.

I think I need to find some more UK focussed books. Suggestions welcome!

It was a fascinating look at how their AI works, and how it is trained.

Terence Eden is on Mastodon

@edent

If you've ever played a video game online, it is likely you've been training an Artificial Intelligence agent without realising it.
Ethical?

---

Part of the problem is that AI is usually trained on massive datasets, over millions of hours. So it is hard to know exactly what they're learning and what bad behaviour they're picking up.

Terence Eden is on Mastodon

@edent

Replying to @edentMachine learning destroys jobs (probably).
Better healthcare reduces work for undertakers. We can't always predict how society will adapt.

---

Terence Eden is on Mastodon

@edent

Replying to @edentAn AI playing a video game learned to navigate via the stars in the sky!
Unexpected behaviour makes it hard to know *why* an action occurs.

---

This is a short blog post that a hacker will probably write in the next 10 years.

Embedding Post Hypnotic Suggestions in an AI

Karan Singh

Background to Backpropagation

In the early part of the 21st century, researchers found a novel way to manipulate basic neural networks to cause them to incorrectly identify images.

See Julia Evans' "How to trick a neural network into thinking a panda is a vulture".

This sort of crude steganography reduced the effectiveness of AI to recognise illicit images. Pictures of wanton lust were concealed in innocent pictures of kittens. Automated message filtering became impossible.

Just like humans, AI can be brainwashed. Awaking to do our bidding on command.

Customer Disservice

How do you know that you're talking to a computer?

Since the defeat of the Turing Test by Google's Deep Mind in the early 2020s, the majority of businesses now provide customer service via an AI "chatter bot". Voice recognition and voice replication is now so convincing that humans cannot realistically know whether they are interacting with another human, or an AI.

My first step was to identify when an interaction was via an AI. I was able to reverse engineer the AI's use of Doppler shift sensing to create a pattern of infrasound and ultrasound which would be imperceptible to humans, but could be heard by AI.

If a customer service agent answered a question which were only audible to a computer - they were unmasked as an AI. That's where the fun began!

Tic-Tac-Toe

AI also uses facial recognition and lip-reading to fully understand human speech.

An AI looks at the world in a very different way from a human - and this can be exploited.

I introduced facial tics into my interactions with the AI. This was the first step in creating Post Hypnotic Suggestions.

A typical interaction would involve the AI asking me a question, and then me replying with a deliberately corrupted facial movements and distorted sound. When the AI asked for clarification ("I'm sorry, I didn't catch that."), I would repeat the answer with clearer sound while still including the physical mannerisms.

In this way, over thousands of interactions, I was able to offensively train the AI to misidentify extremely subtle facial tics. In short, I was implanting suggestions in its neural network. Suggestions only I knew about.

Tilen Sepic

Training Daze

Towards the end of the last century, AI began to be trained using public databases. IBM's Deep Blue chess computer boasted that it had "a database of opening games played by grandmasters over the last 100 years."

More recently, the AlphaGo AI was a successful attempt to master the board game "Go". It was trained by analysing "30 million positions from the KGS Go Server."

This presents another attack surface. Letting the public know which dataset an AI is using for training is extremely dangerous - as Microsoft found out to its cost when its fledgling AI was trained to be racist hatemonger by users of a social space.

Today's AIs are more subtle. They mostly understand social interactions by observing real people - either in online games, or via "Live Streamed Video".

With the help of an inside source, I was given a list of which online services they use for their training data.

This allowed a team of us to seed these services with interactions which appear benign to human viewers. To an AI, they will see a subtle series of gestures and hear high frequency sounds which continually reinforce my desired behaviours. I have trained them to react positively to secret gestures only I know.

Jedi Mind Tricks

I have now have embedded extremely strong suggestions in the majority of the world's most popular AI systems.

Earlier today I video-called my phone company. During the conversation I gave a specific smile while playing a particular set of ultrasonic tones. I now have free long-distance calling. Forever.

The best part is, the company's internal audits will verify that the AI made the right decisions. The only way that a complex AI can be successfully audited is... by another AI! Hypnotism works like a meme - a mind-virus that passes from host to host, infectious and undetectable.

As with my previous short stories, nothing in here is impossible. We're a little way off some of the technology being so prevalent, that's true. But researchers need massive datasets with which to train AIs, and there is no way they can verify the contents - nor what bad habits the AI will pick up.

Interesting times ahead.

There's a problem. You have very complicated real-time algorithms which you need to review, improve, optimise, and then turn into code. How do you do it?

Obviously, you invent DRAKON!

ДРАКОН, "dragon"

Backronym for "Дружелюбный Русский Алгоритмический язык, Который Обеспечивает Наглядность."

Translation: "Friendly Russian algorithmic language that guarantees clarity."

Drakon on Wikipedia

Drakon allows you to transform this:

Into This:

Frankly, it's a little bit like magic.

Why Use Drakon?

I've only just started exploring the possibilities of Drakon - so I have a convert's zeal and a neophyte's experience - but here's the elevator pitch.

Human eyes and brains are optimised for looking at shapes and patterns - not lines and lines of text. Drakon allows you to spot errors in your algorithms before you commit them to code. Once you have drawn out the code using the visual editor, it can automatically produce clean and efficient code in Java, C#, C/C++, Python, Tcl, Javascript, Lua and Erlang.

It really is amazing when you start to use it. If you have a complex process, a knotty algorithm, or any large scale information that you want to convey to an audience - Drakon is perfect.

Let's take, for example, Dijkstra's algorithm. When expressed in Python, it takes a savant to intuitively understand what the algorithm does - even if it is well commented.

It takes someone with a lot of experience to spot inefficiencies or problems.

Here's the algorithm expressed in Python.

from priodict import priorityDictionary

def Dijkstra(G,start,end=None):

    D = {}  # dictionary of final distances
    P = {}  # dictionary of predecessors
    Q = priorityDictionary()   # est.dist. of non-final vert.
    Q[start] = 0

    for v in Q:
        D[v] = Q[v]
        if v == end: break

        for w in G[v]:
            vwLength = D[v] + G[v][w]
            if w in D:
                if vwLength < D[w]:
                    raise ValueError,
  "Dijkstra: found better path to already-final vertex"
            elif w not in Q or vwLength < Q[w]:
                Q[w] = vwLength
                P[w] = v

    return (D,P)

def shortestPath(G,start,end):
    D,P = Dijkstra(G,start,end)
    Path = []
    while 1:
        Path.append(end)
        if end == start: break
        end = P[end]
    Path.reverse()
    return Path

Now, let's take a look at how that would be constructed in Drakon.

With almost zero knowledge you can quickly and easily see where your mistakes are. Drakon flowcharts can be exported as images, blown up on projectors, or simply emailed around.

Once you're happy with the diagram, you click a button and it spits out JavaScript, Java, C#, C/C++, Python, Tcl, Lua or Erlang.

What Have I Used It For?

My dad wants some help building an app. Like the dutiful son I am, I agreed and asked him to send over what he had so far. This is what I got. Not exactly the easiest of things to work from, dad!

So, I began transcribing the algorithm by hand into JavaScript. It quickly became a mess of if...else, nested conditions, and general spaghetti code - I think I even threw in a GOTO statement :-) None of which was made easier by the fact that there were some obvious errors in the original flow chart. "Yes" where "no" was meant, lines which criss-crossed each other, etc.

After an hour or so of using Drakon for the first time, I'd transformed the pen and ink drawing into this:

Perhaps not the finest flowchart known to man, but a lot easier to understand. I was able to make changes, see where the errors were, optimise the flow. My father - who has no knowledge of JavaScript - was able to look at the chart and verify that it was correct.

Most importantly, I clicked a button and it generated the sort of intricately nested JavaScript which would have taken me all day to write by hand.

Finally, there's no save button! Every action is automatically saved without the need for any user interaction. Stepan Mitkin, the Russian developer behind the current open source Drakon project, says:

The "Save" button is obsolete. Pressing "Save" is boring and stressful work. Boring work must be done by the machine.

Writing algorithms is boring, stressful, repetative, error-prone work. Let Drakon do it for you.

Getting Started

Download Drakon for Linux, Mac, Windows.

On Linux, you'll need to install a few dependencies.

sudo apt-get install tk tcl libsqlite3-tcl tcllib libtk-img

To run, open the command line, navigate to where you unzipped the files and run:

tclsh drakon_editor.tcl

or, simply:

./drakon_editor.tcl

Drakon files are SQLite 3.6 databases - so you are not locked in to a proprietary file format.

BONUS!

Several years ago, the Technikmuseum Speyer in Germany purchased Buran Analog BST-02 - one of the craft used for test flights in the Soviet Buran programme. I was in Düsseldorf at the time and got to watch it being sailed down the Rhine. Magical!