The closest environment I got to work with Matrix-like UI but real experience was:
There is board I'm developing on with serial port, and kernel debug prints so much garbage it literally fills the entire screen in less than couple of seconds. It was because of faulty/broken hardware and there is busy loop that keeps retrying to access the device.
I could enter shell commands but I/O lines get mixed in between the verbose kernel debug lines. After some time my eyes synced to the screen scroll rate and I could follow the output from bottom to top to read it (repeatedly run command until I could catch the output correctly).
For the moment, I saw "blonde" in fast scrolling random code :) Anyone else had to work like this?
Everytime u-boot barfed on me or I messed up the serial port I ended up having to scan through screenfulls of ASCII junk scrolling by at full speed to get my commands and results out.
The closest I ever got to -real- blonde/brunette effects was when I was debugging the output from a H264 streamer. I could figure out video resolution and slicing properties from the tcpdump trace scrolling by :)
If we're going to get real nitpicky, this is just a rendering of the Matrix UI, and not the code of the Matrix itself. I imagine that would be orders of magnitude bigger than 600b, considering the original storyline had the brain being part of a network (and not just human batteries).
Inconsistency among visualizations of The Matrix code [1] is a really common problem, and I don't think all or even most of it is for copyright reasons. The solution is obvious: if it doesn't yet exist (I wasn't able to find one) somebody should write a specification for what a "correct" visualization is.
It might be a decade too late but better late than never.
- The "leader" seems to cycle from one character to the next faster than it advances from cell to cell.
- The "random" groups don't look random at all to me. More like there's a series of "standing" characters left behind by the light-green leader, and behind that there's a stream of "running" characters advancing at a different rate. We only see the running characters through gaps in the standing characters, and only in cells that the leader has already visited.
Why is this using a map when the result is just being thrown away? Imagine how left out forEach feels :(.
Also: the afterglow is caused by the main loop filling the entire canvas with a black rect with very low opacity. The result is that after so many frames, everything but the actively drawing characters are much darker. Increase the opacity if you want to reduce the length of the effect.
I didn't mean the "rgba()-fillRect-command", but why the font blur is still slightly visible as dark green, while the character itself has already faded to black.
Also, if we're being picky, the characters change in the trails, trails have different lengths, not every trail is lead by a brighter char, some moving/stationary single chars, etc.
"Headlong motion through walls of emerald green, milky
jade, the sensation of speed beyond anything he'd known before
in cyberspace... The Tessier-Ashpool ice shattered, peeling
away from the Chinese program's thrust, a worrying impression
of solid fluidity, as though the shards of a broken mirror bent
and elongated as they fell --"
Have you gotten the Data link hardware to work? I've been trying to install it into my spinal cord, but I'm getting Neurons_Out_Of_Bounds exceptions all the time.
If anyone is curious how the code actually works, I've commented up a version below:
<script type="text/javascript">
function matrix() {
// initialize variables
for (s = window.screen,
w = q.width = s.width, // on my monitor: 1920
h = q.height = s.height, // on my monitor: 1200
m = Math.random, // random number from 0-1
p = [],
i = 0;
// i ranges from 0 to 255, one element for each character horizontally
// this is enough characters to fill the entire screen horizontally
// canvas won't let you draw off the screen - so I could set this to 1000
i < 256;
// initialize p (the y coordinate of each character) to start at 1
p[i++] = 1);
setInterval(
// every time we call this function we draw the entire screen a very faint black (with a high transparency of 0.05)
// this means every 33 milliseconds the screen is getting slightly darker
// this also acts to darken and fade the green characters - when they are first printed they are dark green, then they slowly fade to black
function() {
// draw black (0,0,0) with alpha (transparency) value 0.05
q.getContext('2d').fillStyle='rgba(0,0,0,0.05)';
// fill the entire screen
q.getContext('2d').fillRect(0,0,w,h);
// #0f0 is a short form for color green (#00FF00)
q.getContext('2d').fillStyle='#0F0';
p.map(
// this function will be called 256 times - once for each element of array p,
function(v,i){
// map over the array p
// v is the value in the array p, which represents the y-coordinate of the text going down
// i is the index of the array p, which represents the x coordinate
// start from unicode char code 30,000 (0x7530) then add a random number from 0-33
// from wikipedia: http://en.wikipedia.org/wiki/List_of_CJK_Unified_Ideographs,_part_2_of_4
// U+753x 田 由 甲 申 甴 电 甶 男 甸 甹 町 画 甼 甽 甾 甿
// U+754x 畀 畁 畂 畃 畄 畅 畆 畇 畈 畉 畊 畋 界 畍 畎 畏
// U+755x 畐
randomNum = m()*33;
// note how the asian characters are slightly different shades
// of green, this depends on their line thickness etc, and doesn't
// really happen for english characters
randomAsianChar = String.fromCharCode(30000 + randomNum);
q.getContext('2d').fillText(
randomAsianChar,
i*10, // x coordinate - each character is 10 x 10
v // y coordinate
);
// draw at least 758 characters down before reseting to the start
minimumHeight=758
num = minimumHeight+m()*10000;
p[i] = (v>num) ? 0 : v+10 // increment the y coordinate by one character (10 pixels), reset when y-coord gets too big
})
},
33) // call every 33 milliseconds
}
</script>
<body style=margin:0 onload="matrix()"><canvas id=q>
When my eyes follow the raindrops it's impossible to see the Chinese characters. I have really to force myself to stare at one spot to see the characters. Interesting phenomena.
It's pretty simple - the symbols don't move. Their brightness changes. So if you move your view - you jump across many symbols and obviously can't "follow" anything.
I think what apunic is noting is our natural tendency to track movement. If you try to read something too close to the leading bright letter, your eyes get hooked by it and get dragged along for the ride. You have to stay a safe distance back to be able to read anything.
Ah, newer versions of Chrome broke (https://code.google.com/p/chromium/issues/detail?id=180007) the htmlpreview tool. Here's a link that should work with the newer Chrome. Please let me know what you think! It's modeled after xmatrix rather than the original film footage, but I think it's pretty good. Still Chrome-only:
I'm nostalgic too (not about Windows that said) but... Windows XP is the most exploited Windows right now: zombie botnets are made of a huge part of Windows XP PCs. Microsoft ain't patching several critical exploits on XP and it has been demonstrated for a fact that any local hole on XP means admin rights.
I can't. This is a PC that is too slow for SP3 now. I tried it when SP3 was released and it just made it slower. I had to roll back. I use defensive measures and have been able to ward off bots and virii so far (not that they didn't get through a few years ago...).
There is board I'm developing on with serial port, and kernel debug prints so much garbage it literally fills the entire screen in less than couple of seconds. It was because of faulty/broken hardware and there is busy loop that keeps retrying to access the device.
I could enter shell commands but I/O lines get mixed in between the verbose kernel debug lines. After some time my eyes synced to the screen scroll rate and I could follow the output from bottom to top to read it (repeatedly run command until I could catch the output correctly).
For the moment, I saw "blonde" in fast scrolling random code :) Anyone else had to work like this?