The University of Technology, Sydney recently opened a new building (the ‘Broadway building’). It was created for the Faculty of Engineering and IT. It is wrapped in aluminium screens that are perforated with binary code. The university has a video about it on YouTube.
What do the screens say? How are they encoded? Read on for an explanation.
Binary
Computers calculate using circuits that switch on and off. Everything in a computer - numbers, programs, images and sounds - is stored using combinations of ‘on’ and ‘off’.
For example, the letter ‘U’ is stored using the following combination: off on off on off on off on.
Programmers and engineers write these sequences using zeros and ones: 01010101.
The encoding of English text is typically based on a standard known as ASCII or its derivatives. If you’d like to explore binary encodings, there are many conversion tables and automatic converters available online.
Binary Screens
The aluminium screens of the new building are perforated with binary code.
Suppose we have the letters ‘U’ and ‘n’ (from the word ‘University’).
The letter ‘U’ is 01010101 in binary.
The letter ‘n’ is 01101110 in binary.
If we put them one-after-the-other, it would look like this:
0101010101101110
On the binary screens, zeros look like squares and ones look like lines:
However, they are printed vertically. You can see this pattern in the binary screens:
The Message
The screens say “University of Technology Sydney Faculty of Engineering and Information Technology”.
Converted to binary, this is as follows:
01010101 01101110 01101001 01110110 (Univ)
01100101 01110010 01110011 01101001 (ersi)
01110100 01111001 00100000 01101111 (ty o)
01100110 00100000 01010100 01100101 (f Te)
01100011 01101000 01101110 01101111 (chno)
01101
100 01101111 01100111 01111001 (logy)
00100000 01010011 01111001 01100100 ( Syd)
01101110 01100101 01111001 00100000 (ney )
01000110 01100001 01100011 01110101 (Facu)
01101100 01110100 01111001 00100000 (lty )
0
1101111 01100110 00100000 01000101 (of E)
01101110 01100111 01101001 01101110 (ngin)
01100101 01100101 01110010 01101001 (eeri)
01101110 01100111 00100000 01100001 (ng a)
01101110 01100100 00100000 01001 (nd I)
001
01101110 01100110 01101111 01110010 (nfor)
01101101 01100001 01110100 01101001 (mati)
01101111 01101110 00100000 01010100 (on T)
01100101 01100011 01101000 01101110 (echn)
01101111 01101100 01101111 01100111 (olog)
01111001 (y)
I have split the binary code above into four groups. This is because the binary screens are split into four rows.
The start of each group can be collected together into a section:
01010101 0110... (start of "Univ")
100 01101111 01... (start of "logy")
1101111 01100110... (start of "of E")
001 01101110 0... (start of "nfor")
Each row is converted to boxes (0) and lines (1). The rows are then stacked together on top of each other.
The above binary sequences are translated into the first section of the binary screens:
Here is how it looks rotated 90 degrees, and shown alongside the real screen:
Repeating Pattern
If you look at the binary screens, you will notice that they have been installed in rectangular sections. These sections form a vertical pattern that repeats every 15 sections.
The first section in the pattern is taken from the start of each group of binary digits (as just seen).
The second section is formed from the next binary digits in each group:
...1110 01101001 0... (from "Univ")
...100 11101111 00... (from "logy")
...0 0100000... (from "of E")
...1100 11001101... (from "nfor")
Each subsequent section is formed from the next lot of binary digits.
Here are all 15 sections used on the building:
You can download these sections as a high-quality PDF. I have also created a single (but very long) image of all the sections joined together.
Each group of eight binary digits (i.e., a letter) is shown in alternating intensity (light / dark). This is to assist with recognising individual letters (it does not appear on the real screens).
Sections are marked by a faint blue rectangle. Letters corresponding to binary code appear in small red letters.
Mystery Binary Digits
The 15 sections of binary code do not exactly match the message. At the end of each group (i.e., in Section 15), there are a few extra binary digits. In the diagram of sections, I have marked those digits in red.
I believe they were added to ensure that the pattern lines up and can repeat. However, they may have some other significance. If you have any ideas, please let me know.
Here are the extra digits:
101010010110 (first row)
000001001010111 (second row)
101011110101100110 (third row)
010101111100 (last row)
This is the entire binary sequence as seen on the screens:
First Row:
01010101 01101110 01101001 01110110 (Univ)
01100101 01110010 01110011 01101001 (ersi)
01110100 01111001 00100000 01101111 (ty o)
01100110 00100000 01010100 01100101 (f Te)
01100011 01101000 01101110 01101111 (chno)
01101
101010010110 (????)
Second Row:
100 01101111 01100111 01111001 (logy)
00100000 01010011 01111001 01100100 ( Syd)
01101110 01100101 01111001 00100000 (ney )
01000110 01100001 01100011 01110101 (Facu)
01101100 01110100 01111001 00100000 (lty )
0
000001001010111 (????)
Third Row:
1101111 01100110 00100000 01000101 (of E)
01101110 01100111 01101001 01101110 (ngin)
01100101 01100101 01110010 01101001 (eeri)
01101110 01100111 00100000 01100001 (ng a)
01101110 01100100 00100000 01001 (nd I)
101011110101100110 (????)
Fourth Row:
001
01101110 01100110 01101111 01110010 (nfor)
01101101 01100001 01110100 01101001 (mati)
01101111 01101110 00100000 01010100 (on T)
01100101 01100011 01101000 01101110 (echn)
01101111 01101100 01101111 01100111 (olog)
01111001 (y)
010101111100 (????)
Applying the Sections to the Building
The sections are applied in sequence vertically down the building.
Section 2 is underneath Section 1. Section 3 is underneath Section 2. This continues until Section 15 when it repeats again. That is, Section 1 is underneath Section 15.
The vertical “columns” of sections on the binary screen are not aligned. One column, for example, may start with Section 10, while the next could start with Section 2.
I have created an Excel document with the location of each section on the binary screens. The document shows every section on the front face of the building (when seen from the street).
Here is a simple image showing how the sections are distributed. Every occurence of Section 1 in the image is marked with a red star.
In the picture above it looks like there are many Section 1s towards the right. However, this is just an illusion created by the perspective when taking the photograph.
A Mistake
There is at least one mistake in the binary screens.
I’ve noticed an error near the bottom right (as seen from the street) corner of the screens facing Broadway. Section 3 has been installed upside-down.
You can compare the sceens with Section 3 (and an upside-down Section 3) in this image:
Even if you did not know the binary sequence, you could still notice the mistake. Carefully look at the section and you will notice that the binary digits don’t appear to lined up correctly between sections (especially the zero at the top left).
I have not noticed any other errors yet. However, there may be others (e.g., near the top where it is difficult to see/photograph clearly).
Conclusion
While the screens look quite complex, they have a surprisingly repetitive structure.
The screens do say what we were told they say (except for installation mistakes and the unknown extra digits).
Why?
I guess a final question might be “why bother?”
Naturally, I was curious. We were told what the screens said, but I had not seen an explanation. Perhaps the architects slipped in a rude message. Unless someone was to check, we’d never know.
This post originally started out as an exercise in image processing. I wrote some code to do automatic translation.
Unfortunately, automatic translation is not very forgiving. There are 8 binary digits per letter so even 97% accuracy means every fourth letter will be wrong. Once I had a simple prototype, I noticed that the output was a systematic pattern. With the systematic pattern, automatic translation is unnecessary: it is simple enough to understand manually so I did not continue fine-tuning my code.