The Daily WTF: Curious Perversions in Information Technology

2013-07-25 Reply Admin

Morry:
You whippersnappers don't even know the algorithm for drawing a circle on a x,y grid using sine and cosine, do you? that's some seriously intense computation there. Modern computers only can do it using approximations of circles and bitmap images. Otherwise your precious 'windows' operating system would come crashing around your knees too.

Sine and cosine? The square root function is faster, plus you need one call to square root to get the y-value for a known x-value vs. two calls (sine and cosine) to convert from radians to Cartesian x and y coordinates. You don't have to worry about figuring out an appropriate step value to make a crisp circle without wasting cycles: your step value is 1px.

You also can calculate fewer points where pixels are plotted adjacent to each other. By stepping in the direction of most change, you can get the most return for the least amount of computation (i.e. if you step x by 1px and y doesn't change, that was a waste of a computation; you should've stepped y by 1px instead).

If you just want a plain vanilla circle, you only have to compute 1/8 of the circle; each point you compute can be plotted a total of 8 times due to symmetry (of course, it would be slightly more complicated to plot an ellipse or an arc).

In all, to plot a circle you only need to call square root about (1-sin(45º))radius times (about 0.3radius; to plot a circle with a radius of 100, the square root function is called 30 times).

Someone posted a comment mentioning a Bresenham algorithm and saying that it requires no floating-point operations. Since I'm not familiar with it, here's my go at an optimized circle-plotting algorithm that uses square root (much faster if it was implemented in assembly rather than this HTML5 demo, obviously).

<html>
<body>
<canvas</span> id="canvas" width="640" height="400"></canvas>
<script </span>type="text/javascript">
var ctx = canvas.getContext("2d");
ctx.fillStyle = "#000";
ctx.fillRect(0, 0, canvas.width, canvas.height);

function pset(x, y, c) {
    ctx.fillStyle = c;
    ctx.fillRect(x, y, 1, 1);
}

function circle(cx, cy, r, c, fill) {
    // outline is 1px wide, so increase radius by 0.5px
    r += 0.5;
    var x, y = 0, oy = -1, r2 = r * r, yy;
    
    // computes enough points to plot 1/2 quadrant and
    // uses symmetry to generate a complete circle
    for (x = Math.floor(r); x + 0.5 > y; -- x) {
        // the formula for a circle is x^2 + y^2 = r^2
        // r and x are knowns, solve for y
        y = Math.round(Math.sqrt(r2 - x * x));
        
        if (typeof debug != "undefined") {
            pset(cx - x + 1, cy - y + 1, c);
        } else {
            oy = fill ? 0 : oy - (y == oy);
            for (yy = oy + 1; yy <= y; ++ yy) {
                // points in first 1/2 quadrant and mirrored on x and y axes
                pset(cx - x + 1, cy + yy - 1, c);
                pset(cx + x - 1, cy + yy - 1, c);
                pset(cx - x + 1, cy - yy + 1, c);
                pset(cx + x - 1, cy - yy + 1, c);
                // same points mirrored on 45º axes (x = y and x = -y)
                pset(cx - yy + 1, cy + x - 1, c);
                pset(cx + yy - 1, cy + x - 1, c);
                pset(cx - yy + 1, cy - x + 1, c);
                pset(cx + yy - 1, cy - x + 1, c);
            }
            oy = y;
        }
    }
    if (fill) {
        // fill the empty square left in the middle
        for (-- y; x > 0; -- x) for (y = yy; y > 0; -- y) {
            pset(cx - x + 1, cy + y - 1, c);
            pset(cx + x - 1, cy + y - 1, c);
            pset(cx - x + 1, cy - y + 1, c);
            pset(cx + x - 1, cy - y + 1, c);
        }
    }
}

// track the number of times Math.sqrt() is called
var sqrt = Math.sqrt;
Math.sqrt = function (n) {
    ++ Math.sqrt.count;
    return sqrt(n);
};

//debug = true;
Math.sqrt.count = 0;
circle(319, 199, 100, "#fff");
//circle(319, 199, 100, "#fff", true);
alert("Sqrt was called " + Math.sqrt.count + " times");
</script>
</body>
</html>

2013-07-25 Reply Admin

anonymous:
Sine and cosine? The square root function is faster, plus you need one call to square root to get the y-value for a known x-value vs. two calls (sine and cosine) to convert from radians to Cartesian x and y coordinates. You don't have to worry about figuring out an appropriate step value to make a crisp circle without wasting cycles: your step value is 1px.

Google for "Bresenham" which will get you to the Bresenham circle drawing algorithm. Works just fine with integer add, subtract, and compare only, so it is perfectly suited to any 1990's computer that is probably a bit weak in the floating-point department.

2013-07-25 Reply Admin

gnasher729:
anonymous:
Sine and cosine? The square root function is faster, plus you need one call to square root to get the y-value for a known x-value vs. two calls (sine and cosine) to convert from radians to Cartesian x and y coordinates. You don't have to worry about figuring out an appropriate step value to make a crisp circle without wasting cycles: your step value is 1px.

Google for "Bresenham" which will get you to the Bresenham circle drawing algorithm. Works just fine with integer add, subtract, and compare only, so it is perfectly suited to any 1990's computer that is probably a bit weak in the floating-point department.

I figured, but I went ahead and posted my code anyway.

Basically, I meant to show that some simple algebra can yield a much more efficient solution than stepping an angle and computing x and y coordinates with slow trig functions.

Note that with slight modification, the code I posted could be modified to use only integers, including a fast integer square root function (since a fractional result isn't needed anyway):

<html>
<body>
<canvas</span> id="canvas" width="640" height="400"></canvas>
<script </span>type="text/javascript">
var ctx = canvas.getContext("2d");
ctx.fillStyle = "#000";
ctx.fillRect(0, 0, canvas.width, canvas.height);

function pset(x, y, c) {
    ctx.fillStyle = c;
    ctx.fillRect(x, y, 1, 1);
}

function circle(cx, cy, r, c, fill) {
    r = (r << 1) | 1;
    var x, y = 0, oy = -1, r2 = r * r, yy, xo, yo;
    
    // computes enough points to plot 1/2 quadrant and
    // uses symmetry to generate a complete circle
    for (x = r - 1; x > y; x -= 2) {
        // the formula for a circle is x^2 + y^2 = r^2
        // r and x are knowns, solve for y
        y = int_sqrt(r2 - x * x);
        
        xo = x >> 1;
        yo = y >> 1;
        if (typeof debug != "undefined") {
            pset(cx - xo + 1, cy - yo + 1, c);
        } else {
            oy = fill ? 0 : oy - (yo == oy);
            for (yy = oy + 1; yy <= yo; ++ yy) {
                // points in first 1/2 quadrant and mirrored on x and y axes
                pset(cx - xo + 1, cy + yy - 1, c);
                pset(cx + xo - 1, cy + yy - 1, c);
                pset(cx - xo + 1, cy - yy + 1, c);
                pset(cx + xo - 1, cy - yy + 1, c);
                // same points mirrored on 45º axes (x = y and x = -y)
                pset(cx - yy + 1, cy + xo - 1, c);
                pset(cx + yy - 1, cy + xo - 1, c);
                pset(cx - yy + 1, cy - xo + 1, c);
                pset(cx + yy - 1, cy - xo + 1, c);
            }
            oy = yo;
        }
    }
    if (fill) {
        // fill the empty square left in the middle
        for (-- yo; xo > 0; -- xo) for (yo = yy; yo > 0; -- yo) {
            pset(cx - xo + 1, cy + yo - 1, c);
            pset(cx + xo - 1, cy + yo - 1, c);
            pset(cx - xo + 1, cy - yo + 1, c);
            pset(cx + xo - 1, cy - yo + 1, c);
        }
    }
}

function int_sqrt(n) {
    // fast integer square root
    // calculates the square root of n; fractional part is discarded
    var res = 0, bit = 0x40000000;
    while (bit > n)
        bit >>= 2;
    
    while (bit) {
        if (n >= res + bit) {
            n -= res + bit;
            res = (res >> 1) + bit;
        } else {
            res >>= 1;
        }
        
        bit >>= 2;
    }
    
    return res;
}

//debug = true;
circle(319, 199, 100, "#fff");
//circle(319, 199, 100, "#fff", true);
</script>
</body>
</html>

I might try implementing the Bresenham circle drawing algorithm, too. HTML5 wouldn't be a very good way to compare the two, though... the pset() method is too slow.

2013-07-25 Reply Admin

are you sure you mean german city of dresden and not us city of dresden? because i happen to live some time of the year in german dresden and i was curious and started googling, but i've found only us plant...

2013-07-25 Reply Admin

You have not experienced the pipes screen saver on Windows NT?

2013-07-26 Reply Admin

No name:
I'd be 0st, but my display cannot draw circles.

Please let me know if you find any other numbers ending with 0 that need the "st" suffix. Up until now, I was certain they all should have "th". Your obvious superiority in this area has convinced me to rethink my ways :-)

2013-07-26 Reply Admin

JustSomeGuy:
No name:
I'd be 0st, but my display cannot draw circles.
Please let me know if you find any other numbers ending with 0 that need the "st" suffix. Up until now, I was certain they all should have "th". Your obvious superiority in this area has convinced me to rethink my ways :-)

Secost or secoth? Thist or thith? Didst though rethinketh propermotht?

2013-07-26 Reply Admin

Norman Diamond:
Didst though rethinketh propermotht?

Thou obeyed my law. I taut thee well.

Hatshepsut · 2013-07-26 Reply Admin

Steve The Cynic:
Like my mother used to tell me back in the 70s - she wrote software in the early 60s on the LEO III...

Ah, the LEO.

While the Yanks built ENIAC to aim bombs, the Poms built LEO to run tearooms.

no laughing matter · 2013-07-26 Reply Admin

mx:
are you sure you mean german city of dresden and not us city of dresden? because i happen to live some time of the year in german dresden and i was curious and started googling, but i've found only us plant...

http://en.wikipedia.org/wiki/List_of_nuclear_reactors#Germany AKR II – Ausbildungskernreaktor II, Technische Universität Dresden; rating: 2 W, commissioned 2005 Ausbildungskernreaktor II in German wikipedia German website from TU Dresden

2013-07-26 Reply Admin

I'll just leave this here:

https://www.youtube.com/watch?v=rp8hvyjZWHs

2013-07-26 Reply Admin

Steve The Cynic:
Even in the 80s, knowledge of Bresenham's work would have been sufficiently widespread for circles to be blindingly fast and to require no floating point operations. And the Soviet-bloc mainframes were reverse-engineered clones of the IBM System/360 and System/370 mainframes, which date to the late 60s as well.
So in your weird world, these "new cool" algorithms are now nearly fifty years old. And even at the time the supposed events of the story supposedly took place, these algorithms were twenty years old. "New cool" evidently means "twenty years old".

"The technique had been around for 20 years and there were many people in the world who knew who to do it" is not at all the same as "this particular person here knew how to do it".

Smart as I like to think I am, I'm sure there are many many things that other people know that I don't. I'm sure that there are many things that I do a hard way because I not only don't know how the easy way, but because it just doesn't occur to me that there might be an easier way, and so I blunder ahead.

2013-07-26 Reply Admin

belzebub:
You're so smaart :) Only you probably don't know that "Czechoslovakia" means "Czech Republic" and "Slovak Republic" federation. Same as USA, but only 2 states instead of 51. And when the article said "Czech Republic" I just followed, because there WAS Czech Republic in 80's, it was only part of the CzechoSlovakian Socialistic Republic (CSSR). The same way Texas exists in USA.

Bad example. "Texas" is just a myth invented by Tea Party folks to scare liberals.

2013-07-26 Reply Admin

no laughing matter:
However Ulrich is programming for very obsolete hardware, so he should have good knowledge about how to avoid wasting resources.

The operative word being "should".

eViLegion:

no laughing matter:
* The story is still implausible, because there is no reason that a czech company still provides support for soviet-era mainframes.

Why do you say there is no reason? If the mainframes are still in use, then there is a market for their support. A tech company from the former soviet bloc would be exactly the kind of company to support it.

Not much of a market, if you think about it: After the end of the soviet bloc corporations (if still in business) then had access to much cheaper and more powerful hardware, so why keep the old ones in operation?

In any cases, a key point in the story was that the Czech company was NOT supporting the computer any more, they dumped him off on another customer.

2013-07-27 Reply Admin

Thanks for making me laugh. Now for the reality check - it's nice that you've done something or your mother did, but you've both still done it on computers. Real computers, working ones, worthy the name "computer". Russian copies of s/360 and subsequent IBM mainframes were completely different beasts, impossible to imagine for a lowly Westerner whose Capitalism-opressed mind simply can't fathom the advanced reality of Socialist industrial production. Simple payroll programs were always run twice and if the results were the same, the run was correct. If they differed, than you had to run it for the third time and if the result was equal to one of the previous ones, those were correct. Not sure what was the procedure for three different outputs but I guess something along the lines of drinking lethal amount of tetrachlorine based cleaning liquid (alcohol based was originally used, but the techs and programmers drowned too much sorrows with it).

2013-07-27 Reply Admin

Krigl:
Simple payroll programs were always run twice and if the results were the same, the run was correct. If they differed, than you had to run it for the third time and if the result was equal to one of the previous ones, those were correct. Not sure what was the procedure for three different outputs

So the Russian copies worked better than the American copies that were used in the space shuttle.

Four of the space shuttle's computers, based on IBM 360 with modifications, produced the same result but it was wrong. One computer, programmed by a different team, produced a different result and it was right. The Americans didn't even let the majority rule but they scrubbed the mission until they figured out what happened.

2013-07-28 Reply Admin

Aah, thats why some company+ today uses circles!

2013-07-29 Reply Admin

faoileag:
there is one nuclear reactor operating in Eastern Germany, the training reactor "Dresden 2"

"Oh Dresden 2 why can't you be more like Dresden 1?"

captcha: duis "duis quoting from the Simpsons."

2013-07-29 Reply Admin

And here's my x86 assembly code version of the midpoint circle algorithm, using the optimized algorithm from Wikipedia.

MOV             AX,             0012            ;mode 12 (640x480x16)
INT             10                              ;set video mode
MOV             AL,             0F              ;c = 15 (white)
MOV             BX,             0078            ;r = 120
MOV             CX,             013F            ;cx = 319
MOV             DX,             00EF            ;cy = 239
CALL            0120                            ;_circle
MOV             AH,             08
INT             21                              ;wait for a key
MOV             AX,             0002            ;mode 2 (80x25x16 text)
INT             10                              ;set video mode
MOV             AH,             4C
INT             21                              ;return to DOS
;_circle
PUSH            DX                              ;SP+0A = cy
PUSH            CX                              ;SP+08 = cx
MOV             SI,             BX              ;SI = x
NEG             BX
PUSH            BX                              ;SP+06 = error
XOR             BH,             BH
XOR             DI,             DI              ;DI = y
PUSH            DI                              ;SP+04 = y
PUSH            SI                              ;SP+02 = x
MOV             AH,             0C
PUSH            AX                              ;SP+00 = c
MOV             BP,             SP
;_cir_while
CMP             SI,             DI
JA              0139                            ;+2
JMP             01F0                            ;_cir_done
SUB             CX,             SI              ;cx -= x
ADD             DX,             DI              ;cy += y
INT             10
MOV             CX,             [BP+08]         ;cx
ADD             CX,             [BP+04]         ;+ y
MOV             DX,             [BP+0A]         ;cy
ADD             DX,             [BP+02]         ;+ x
MOV             AX,             [BP]
INT             10
MOV             CX,             [BP+02]         ;x
CMP             CX,             0000
JZ              0177                            ;_cir_x_is_0
ADD             CX,             [BP+08]         ;+ cx
MOV             DX,             [BP+0A]         ;cy
SUB             DX,             [BP+04]         ;- y
MOV             AX,             [BP]
INT             10
MOV             CX,             [BP+08]         ;cx
ADD             CX,             [BP+04]         ;+ y
MOV             DX,             [BP+0A]         ;cy
SUB             DX,             [BP+02]         ;- x
MOV             AX,             [BP]
INT             10
;_cir_x_is_0
MOV             DX,             [BP+04]         ;y
CMP             DX,             0000
JZ              01C5                            ;_cir_y_is_0
MOV             CX,             [BP+08]         ;cx
ADD             CX,             [BP+02]         ;+ x
ADD             DX,             [BP+0A]         ;+ cy
MOV             AX,             [BP]
INT             10
MOV             CX,             [BP+08]         ;cx
SUB             CX,             [BP+04]         ;- y
MOV             DX,             [BP+0A]         ;cy
SUB             DX,             [BP+02]         ;- x
MOV             AX,             [BP]
INT             10
MOV             DX,             [BP+02]         ;x
CMP             DX,             0000
JZ              01C5                            ;_cir_y_is_0
MOV             CX,             [BP+08]         ;cx
SUB             CX,             [BP+04]         ;- y
ADD             DX,             [BP+0A]         ;+ cy
MOV             AX,             [BP]
INT             10
MOV             CX,             [BP+08]         ;cx
SUB             CX,             [BP+02]         ;- x
MOV             DX,             [BP+0A]         ;cy
SUB             DX,             [BP+04]         ;- y
MOV             AX,             [BP]
INT             10
;_cir_y_is_0
MOV             AX,             [BP]
MOV             CX,             [BP+08]         ;cx
MOV             DX,             [BP+0A]         ;cy
MOV             DI,             [BP+04]         ;y
ADD             [BP+06],        DI              ;error += y
INC             DI                              ;++ y
ADD             [BP+06],        DI              ;error += y
MOV             [BP+04],        DI
JNS             01E0                            ;+2
JMP             0132                            ;_cir_while
MOV             SI,             [BP+02]         ;x
SUB             [BP+06],        SI              ;error -= x
DEC             SI                              ;-- x
SUB             [BP+06],        SI              ;error -= x
MOV             [BP+02],        SI
JMP             0132                            ;_cir_while
;_cir_done
MOV             CX,             [BP+08]         ;cx
SUB             CX,             SI              ;- x
MOV             DX,             [BP+0A]         ;cy
SUB             DX,             DI              ;- y
MOV             AX,             [BP]
INT             10
MOV             CX,             [BP+02]         ;x
CMP             CX,             0000
JZ              0215                            ;_cir_skip
ADD             CX,             [BP+08]         ;+ cx
MOV             DX,             [BP+0A]         ;cy
ADD             DX,             [BP+04]         ;+ y
MOV             AX,             [BP]
INT             10
;_cir_skip
MOV             DX,             [BP+04]         ;y
CMP             DX,             0000
JZ              0241                            ;_cir_exit
MOV             CX,             [BP+08]         ;cx
SUB             CX,             [BP+02]         ;- x
ADD             DX,             [BP+0A]         ;+ cy
MOV             AX,             [BP]
INT             10
MOV             CX,             [BP+02]         ;x
CMP             CX,             0000
JZ              0241                            ;_cir_exit
ADD             CX,             [BP+08]         ;+ cx
MOV             DX,             [BP+0A]         ;cy
SUB             DX,             [BP+04]         ;- y
MOV             AX,             [BP]
INT             10
;_cir_exit
POP             AX
POP             SI
POP             DI
POP             BX
POP             CX
POP             DX
RET

chubertdev · 2013-07-29 Reply Admin

Here's my optimized version:

//it's in the library
makeCircle(x, y, radius);

Pawprint · 2013-07-29 Reply Admin

Norman Diamond:
JustSomeGuy:
No name:
I'd be 0st, but my display cannot draw circles.
Please let me know if you find any other numbers ending with 0 that need the "st" suffix. Up until now, I was certain they all should have "th". Your obvious superiority in this area has convinced me to rethink my ways :-)
Secost or secoth? Thist or thith? Didst though rethinketh propermotht?

What part of "any other numbers ending with 0" slipped past you? Oh, wait, I bet it was "ending with 0."

2013-07-30 Reply Admin

Pawprint:
Norman Diamond:
JustSomeGuy:
No name:
I'd be 0st, but my display cannot draw circles.
Please let me know if you find any other numbers ending with 0 that need the "st" suffix. Up until now, I was certain they all should have "th". Your obvious superiority in this area has convinced me to rethink my ways :-)
Secost or secoth? Thist or thith? Didst though rethinketh propermotht?
What part of "any other numbers ending with 0" slipped past you? Oh, wait, I bet it was "ending with 0."

Close. It was the ending with. My finger slipped and made it look like than. Thoughs were the same fingers that made thou look like though.

2013-07-30 Reply Admin

Boom - headshot!

Captcha - haero - a chocolate bar with bubbles and a hair in

2013-07-30 Reply Admin

belzebub:
* Not many people working with OLD computers were familiar with "new cool" algorithms, like the Bresenham's circle algorithm.
So, when a programmer in Czech Republic was working on mainframe in 80's (they was not manufactured after the fall of communism), and he had to write circle drawing function, he would probably do something like this:
function draw_circle(xc, yc, radius, color)
  for i = 0 to 2*Pi by 0.01
    x = xc + radius * cos(i)
    y = yc + radius * sin(i)
    draw_pixel(x, y, color)
end
it uses very fine step, to make sure circles are smooth.

The ZX Spectrum, which came out in 1982, used to approximate a circle with a polygon. But not in the way you might think (i.e. by changing draw_pixel to line_pixel in the algorithm above and changing the step to K/radius). No, it would draw one side as a straight line, and then invoke the arc-drawing function to draw the rest of the circle. The resulting circles generally weren't very symmetrical.

To be fair, they did use the Bresenham algorithm for their lines.

2013-07-30 Reply Admin

chubertdev:
Here's my optimized version:
//it's in the library
makeCircle(x, y, radius);

Oh, come now. What's wrong with reinventing the circle every now and then?

2013-07-30 Reply Admin

chubertdev:
Here's my optimized version:
//it's in the library
makeCircle(x, y, radius);

Well, that's great -- just great. You just caused the entire mainframe to go down. Now what, genius?

Seriously, it's like you didn't read the story at all.

chubertdev · 2013-07-30 Reply Admin

anonymous:
chubertdev:
Here's my optimized version:
//it's in the library
makeCircle(x, y, radius);
Well, that's great -- just great. You just caused the entire mainframe to go down. Now what, genius?
Seriously, it's like you didn't read the story at all.

Where in the story did it say that it referenced a library?

2013-07-30 Reply Admin

chubertdev:
anonymous:
chubertdev:
Here's my optimized version:
//it's in the library
makeCircle(x, y, radius);
Well, that's great -- just great. You just caused the entire mainframe to go down. Now what, genius?
Seriously, it's like you didn't read the story at all.
Where in the story did it say that it referenced a library?

The part where he thought the system was supposedly capable of drawing circles and used a bunch of them in his screens.

I can't say with 100% certainty that he didn't write the circle function himself, but I'd put very high odds on him not. He read the documentation, found the part that said "to draw a circle:", and said "ooh pretty" and proceeded to use the function provided, which blew up.

chubertdev · 2013-07-30 Reply Admin

Possibly, even likely. But we don't have that info. So I'm fine with just making a sarcastic comment.

2013-07-30 Reply Admin

The computer's behaviour was perfectly logical. Circular logic caused an infinite loop.

chubertdev · 2013-07-31 Reply Admin

Norman Diamond:
The computer's behaviour was perfectly logical. Circular logic caused an infinite loop.

And the infinite loop caused circular logic.

2013-07-31 Reply Admin

chubertdev:
Norman Diamond:
The computer's behaviour was perfectly logical. Circular logic caused an infinite loop.
And the infinite loop caused circular logic.

And the circular logic caused the infinite loop.

2013-08-06 Reply Admin

Isn't that photo from Slovakia? From Jaslovske Bohunice?

2013-08-13 Reply Admin

TRWTF is changing the UI from what's familiar to the engineers to "fancy cool circles" and assuming that it will be an improvement, when his job was to fix Y2K bugs. At worst, it'll confuse the engineers enough so they'll start making mistakes.

Sure, there's a lot to say about testing in production, and no rollback plan, and having an undergraduate mess about the control room software. This is inexcusable but there's no reason it couldn't have happened in countries with low level of regulatory enforcement (US, France, etc). Either way, "Ulrich" doesn't mean the story happened in Germany - this could be Belgium, Spain, Switzerland or it could even be in Argentina. Romania has a plant designed in the 80s, and the equipment could be delivered way back then. Slovenia has a reactor that would fit the picture. Slovakia as well.

The country of origin for the reactor design doesn't matter, since the I&C might have been bought from another supplier, or lowest bidder. Anyway, my money's on Hungary.

However I can guarantee you, even without knowing which plant is in question, that the actual control of the plant is elsewhere, and given the setting implemented by hard controls. Besides, the protection system will have been relay based and completely separated. Relay automation is still widely used anyway in 2013.

Too bad that with some current designs, everything is networked so the scenario in the story has potential to screw up all the systems in one fell swoop.

2014-07-29 Reply Admin

Circle of WANK!

2017-04-08 Reply Admin

this reminded me of a quote in a magazine: "how many nuclear power plant employees does it take to change a light bulb? 53." that is NOT A JOKE! when replacing the bulbs in the warning lights on the main console, they are required by FEDERAL LAW to use a ridiculously complicated procedure that takes 53 people to perform. (in the USA)

The Circle of Fail

Leave a comment on “The Circle of Fail”