[ art / civ / cult / cyb / diy / drg / feels / layer / lit / λ / q / r / sci / sec / tech / w / zzz ] archive provided by lainchan.jp

lainchan archive - /λ/ - 8007

File: 1438207195941.png (549.53 KB, 300x196, image.jpg)


What are your favorite programming folklore stories? Stuff like the 300 mile email, the MIT magic/more magic switch, the first computer bug, etc. Here's a fresh one straight from my job:

We were working on a kernel-level video codec driver for Windows. Our demo method was to stand in front of a camera and move around, holding up different objects to see how it looked on our sample application. It worked great when it was just us, but whenever our boss's boss came over and stood in the frame, the PC would bluescreen. He would give us some time to work on stability and come back, and inevitably, the driver would crash as soon as he came in to demo.

After several occurrences of this, we finally figured it out. Our bosses boss, you see, typically wore bright striped shirts. Our codec was variable bitrate and performed best with simple colors and few patterns. Somebody brought in a shirt with bright stripes and put it in front of the camera. Instant crash.

We budgeted a buffer of 100 or so milliseconds of video with little wiggle room. When bright colors and patterns were encoded, the bitrate increased dramatically and the buffer overflowed, crashing the driver and bringing Windows with it. We increased the buffer size and the problem went away.

I'd love to hear if my fellow /lam/das have any similar experiences.


The Story of Mel was pretty good.

I love low-level stuff, especially something like Forth or TIS-100


There's a lot in here.

Found the site looking for the ones named ITT, so I don't have any favorites.


I like this the most because I don't really get it:

In the days when Sussman was a novice, Minsky once came to him as he sat hacking at the PDP-6.

“What are you doing?”, asked Minsky.
“I am training a randomly wired neural net to play Tic-Tac-Toe” Sussman replied.
“Why is the net wired randomly?”, asked Minsky.
“I do not want it to have any preconceptions of how to play”, Sussman said.

Minsky then shut his eyes.

“Why do you close your eyes?”, Sussman asked his teacher.
“So that the room will be empty.”

At that moment, Sussman was enlightened.


This is another favourite of mine:

A novice was trying to fix a broken Lisp machine by turning the power off and on.

Knight, seeing what the student was doing, spoke sternly: “You cannot fix a machine by just power-cycling it with no understanding of what is going wrong.”

Knight turned the machine off and on.

The machine worked.


And then there is the lore of Stallman single-handedly replicating all functionality of both Symbolics and that other Lisp Machine company products with PDP11.


If the net is wired randomly, it still has preconceptions of how to play, only Sussman does not understand those preconceptions. Hence the closed eyes - empty room analogy.


>Interesting Hacks To Fascinate People: The MIT Gallery of Hacks


My pick would be the first computer virus ever, though it's regarded as a legend.
It was in Xerox labs at Palo Alto, some programmer wanted to try out self-replication in a computer program. So he wrote it, it was the "creeper". Technically, it wasn't a virus, it was a worm. But the terms hadn't been coined by then. Anyway the creeper would stick itself to some program or login shell (I don't really know) but whenever it was run it would print "I'm the creeper, catch me if you can!" and then proceed to copy itself over the local network of the company and delete itself from the source.
Of course, since it copied itself randomly to some other computer it was real hard to track and people grew sick of the little creeper. So some dude used the same technique to kill it, it's name was the reaper and it would go around the network trying to find the creeper and delete it, deleting itself as well when it found it.
That story inspired A.K. Dewdney, columnist at Scientific American (computer recreations) to make a game in which programs written in a special purpose assembly-like language would track and kill each other in virtual memory. The name is Core Wars.


The story of Lisp's genesis is a good one. Long ago John McCarthy released his paper "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I" (there is no part 2) in which he defined the core of lisp. mccarthy believed that his language would take a team of researchers years to implement.

instead, steve russell found mccarthy's paper and implemented it in assembly on an IBM 704 in a single night.


>mccarthy believed that his language would take a team of researchers years to implement.
Part of the reasoning for that was due to the syntax and grammar of the language, which was significantly simplified by Steve Russel simply using S-expressions for data and code.

M-expressions, the original notation, have been implemented by Racket, but no one really uses them.


In 1994 JPL started working on the Remote Agent (RA), an autonomous spacecraft control system. RA was written entirely in Common Lisp despite unrelenting political pressure to move to C++. At one point an attempt was made to port one part of the system (the planner) to C++. This attempt had to be abandoned after a year. Based on this experience I think it's safe to say that if not for Lisp the Remote Agent would have failed.

We used four different Common Lisps in the course of the Remote Agent project: MCL, Allegro, Harlequin, and CLisp. These ran in various combinations on three different operating systems: MacOS, SunOS, and vxWorks. Harlequin was the Lisp that eventually flew on the spacecraft. Most of the ground development was done in MCL and Allegro. (CLisp was also ported to vxWorks, and probably would have been the flight Lisp but for the fact that it lacked threads.) We moved code effortlessly back and forth among these systems.

The Remote Agent software, running on a custom port of Harlequin Common Lisp, flew aboard Deep Space 1 (DS1), the first mission of NASA's New Millennium program. Remote Agent controlled DS1 for two days in May of 1999. During that time we were able to debug and fix a race condition that had not shown up during ground testing. (Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem. The story of the Remote Agent bug is an interesting one in and of itself.)

The Remote Agent was subsequently named "NASA Software of the Year".


I really enjoy the material found on this page:

It's been a while since I've read the page, but The HACTRN has to be one of my favorites. It's one of the only pieces there I remember well.


RRR of x
always equals 1.
R is dimension, RR, rank.
APL is fun!

-- RMS December 1973

It's a great view into the history of computing and what these older systems were like. ITS sounded amazing to use.
There's also the sad realization that a culture like this is probably lost for good by now. We're just different.
I want to write poems like this one day.



I can't remember where I read this anecdote. I think it was someone who commented on a story.

The story everyone was reading about the developers of Crash Bandicoot. It was getting close to crunch-time but the game still took up too much memory for the hardware. So they set about ruthlessly cutting out extraneous details, mangling the code so it would fit. Someone wrote a machine learning algorithm to try and re-arrange or re-write parts of the program into a different form that was semantically equivalent, desperately trying to fit it within the hardware. In the end, with a week to go, they had something like a few bytes to spare when the game shipped.

On the comment thread, someone relayed a story about a software company they worked at. He worked in a similar kind of field where the hardware is really constrained and every byte of memory counts. The engineers are frantically trying to reduce their memory footprint as the deadlines loom near. The boss calls him into the room to discuss what they're to do.

"We've tried everything we can. We may have to do a massive refactor, or push the deadline back."

The boss motioned him over to his computer. He located an array which had been allocated but wasn't being used at all. He deleted the line.

"All done, let's go for lunch."

The lead engineer had allocated some unused 1mb block so the team would be forced to program to be memory-efficient. After deleting, they were well within the constraints of the hardware.


Can't find it, but the story about the memory was on trenchescomic. http://trenchescomic.com/tales


File: 1442284128404.png (775.59 KB, 200x150, Molten Core made in a week.png)

Sort of reminds me of the Corrupted Blood debuff in World of Warcraft. Basically one of the bosses in the game had a communicable disease that damaged the player. Even though the debuff only lasted a few seconds, The disease could jump back and forth between the players, eventually killing them. It was taken out of the dungeon by a pet through an unfortunate game mechanic. Eventually it spread all the way to the major cities and killed pretty much everyone. They resolved the problem by resetting the servers a few times and applying emergency patches.
More reading: https://en.wikipedia.org/wiki/Corrupted_Blood_incident

On that same topic, I watched the World of Warcraft documentary Looking for Group recently, so I guess I will post about that too since it provided some interesting insights into how software development / project management is done at the very top of a successful software company. Between all these clips there are probably 7-10 minutes of content, though I couldn't specify on this particular video where to stop. So you'll have to use your own judgement. The main take-away is that they "just did it." Their design process was much further from perfectionism than I expected. Many of the formative ideas behind WoW were created almost spontaneously or frivolously.

What the cofounders looked for in their developers:

The developers were willing to occasionally scrap a well-developed zone and restart from scratch:

How the world map (Azeroth) was made:

Cramming at the deadline - Molten Core was 'made' in a week. Sort of like >>9402

A look inside a WoW datacenter - sysadmin holds realm in his hand

How some of the formative characters in Warcraft were made:

How one of the odder races in WoW was created:

The Project Director for Cinematics at Blizzard got his start at Blizzard by making a Machinima movie:

"Worse is Better"-ish project management in Blizzard:

How boss encounters are tuned (longish):

The design principles behind World of Warcraft's economy (sort of like Bitcoin):

120 buildings later:


that is fuarrrking hilarious, i never really played WoW but hearing some of the stories is really fun

also kiting bosses into major cities for trolling purposes seems to have been a thing too?


File: 1442377146187.png (258.01 KB, 200x125, A uhh... blacksmith.jpg)

Once a monster was engaged in the world, they had a certain radius which, when exited, reset the monster's combat status and forced them to return to their original position with full health. You could reset that radius to their current position by incapacitating the monster using one of many abilities. In some cases, monsters could be strung across several zones. A raid boss wouldn't have caused much of a problem in a major city, but I do recall one incident of someone finding a monster (Servant of Allistarj) with an invulnerability buff and bringing it to a major city. It was just standing there while a group of roughly 30 level-capped players beat on it for a couple hours.

Here's a screenshot that I took a long time ago that non-player lains might enjoy. During the Burning Crusade I spontaneously got this glitch that mangled all the buildings in very strange ways. Relogging fixed it.

As fun as an "immersive world" is, I really enjoyed those times when we were able to pull back the curtain and see brief insights into how the game was made - to see into how the developers did it all.


Relatively harmless maybe
>If you don't kill this guy in the first three minutes, he casts a spell that lets him regen 70,000 hp for every kill he gets - making him pretty much invulnerable. The results are hilarious.


Want to test your codec to the max?
Leafy trees blowing in wind - zoom into branches/tops filling the frame.
Or rippling water at a distance in the sunlight filling image. These things are always a killer test for video (as they approach, slightly, white noise like image conditions).


Man i remember this bug, i had it all the time.

rip those times ;-;


Here are links to some of my favorite CS/computer stories:

1.) http://localroger.com/prime-intellect/mopiidx.html

2.) http://qntm.org/responsibility


File: 1448337670283.png (63.42 KB, 200x164, AI.png)

John McCarthy's Stanford website is full of cool stuff:


Gosh! I wish this thread doesn't get abandoned. :\


I do also.

Here's some interesting Forth material:

These pages and others on that site explain some old experiences with Forth and whatnot. It really paints ANSI Forth in a different light for me.

ANSI Forth is one of the smallest feasible languages I use, but it's still gargantuan and ugly in comparison to a more optimized, but less portable Forth.

It was very interesting to read and think about.


>What are your favorite programming folklore stories?
What about the Morris Worm? https://en.wikipedia.org/wiki/Morris_worm

It was basically the first computer worm to ever be distributed across the net. Its creator, Robert Tappan Morris tried to hide his involvement in the worm's creation which results in the first felony conviction under the 1986 Computer Fraud and Abuse Act.


Long time ago as a warlock you could "release" captured demons. Don't know if its still the case but I would release an infernal in the goldshire ina and it would kill low levels in one shot when entering the inn.

Vanilla wow was best wow.


There are a couple of stories in my university's CS folklore file: http://klaxon.hacksoc.org/uni_history/compsci.html

I particularly like the story of the DECWRITER.


File: 1464753850077.png (451.82 KB, 200x157, boat.jpg)

Another amusing WoW story was back in Vanilla there was a major event where the gates of Ahn'Qiraj opened up for the first time and almost the entire server showed up to battle their way inside. What ended up happening though is there were so many players in the same place that the server went nuts resulting in many crashes as well as some bizarre never seen before bugs. The strangest and most amusing of these bugs were the boats instead of taking people to a dock on the other continent they decided to fly out of the water into a zone they were never meant to be in. Despite the complete meltdown of the servers many players cherish the AQ opening as one of their favorite moments in WoW.


This isn't surprising or folklore, as it's been confirmed, but the syntax for make requiring a newline and tab was created because the author was experimenting with simple patterns in the parser generator.

It was kept because 10 people were already using this syntax.



This is one of the strangest quirks that always bothered me.


Reminds me of some earlier MMORPG where the bosses got stronger the more heroes they killed. Someone got to the final boss and instead of killing it, started a cult where players would instead sacrifice themselves to the demon to make it stronger and defend the boss from non-believers.

The devs eventually suited up themselves with self made equipment to defeat the cult and hired some other players too. One of those players betrayed the devs and they were defeated.


I suppose stories out of Microsoft are interesting.

Excel having its own compiler, custom tools to build custom build systems to build parts of Windows, Windows containing DLLs from every previous version, the hidden APIs Microsoft uses instead of the gimped APIs everyone else knew of, font rendering and other code in the kernel for speed, the Windows kernel's apparently good support for concurrency and permission systems, and many engineers dying or retiring to leave fewer and fewer actually knowing how to manage their systems, to name a few.

The list goes on and on.



That culture isn't dead as long as you keep your sense of humor. So long as you continue to find joy in the quirkiness of software. So long as we keep the fun in computing.

Oh, by the way, ITS is pretty neat. Instructions of emulation are at http://its.victor.se/wiki/. You can also go try the public access system at http://up.update.uu.se/.


Best piece of programming folklore is definitely The Story of Mel. No comparison. After that? I dunno.

The tale Joe Ossanna's C code for troff is pretty good as well. Also, Alice's PDP-10 https://www.hactrn.net/sra/alice/, and the tale of how 0x5f3759df (//what the fuarrrk?) came to be (to the surprise of many, it actually wasn't Carmack's).



Dr. Joe Popp


>During the whole project, we were required to work 12 hours a day, 7 days a week. Our lunch and dinner were take out - paid for by the company, which was great, but the purpose was to keep us from going out and having an hour long lunch or dinner break away from our desks. Every meal was a "working" meal, meaning we would have meetings in the conference room as we ate to keep from interfering with the "real" work. If we were late to work, or left early, we would be threatened with having some of our $25,000 bonus docked. The "carrot" had become a big baseball bat we were beaten with almost daily. One guy walked out after having his bonus docked for coming in at noon, and he quit on the spot. The next day he was placated and he came back. I remember this moment vividly--working away at 3:30 a.m. one morning. I was so physically exhausted that I casually leaned over to the garbage can and vomited, after which I went right back to tapping away. My fingers never left the keyboard.


Do you remember the name, by chance?


>And then there is the lore of Stallman single-handedly replicating all functionality of both Symbolics and that other Lisp Machine company products with PDP11.
That's not what was happening. He was replicating Symbolics' improvement to MIT Lisp Machine for LMI. It's recollected in Steven Levy's "Hackers: Heroes of the Computer Revolution" book and also in one of Stallman's essays.


Window's source code must be the Kowloon Walled City equivalent for codebases. Just rammed with legacy code and design choices that only made sense once upon a time


Maybe this is old here, but here's the "original jargon file", at least that's what they claim
I didn't know it originated with lisp culture and esr butchered it. It's an interesting read too


ESR took over from GLS as maintainer. He did alright for a while (adding what needed to be, etc: JARGON is, in theory, a living document), but ESR is, as we all should know, fuarrrking batsoykaf insane, so he started to fuarrrk it up eventually.

It's still mostly intact, though.


This is a good docudrama about the British computer industry, sort of the brit version of Revenge of the Nerds