On 28/08/2012 04:22 PM, Jim Henderson wrote:
> When I was at uni, we had an 'intelligent' air traffic control program we
> were working on.  The first version was written on a machine that used
> lisp as its shell interface - and you could do weird things like reverse
> the direction the instruction pointer ran using a CLI script written in
> Lisp.
>
> Wish I could remember what the machine was.  It wasn't very fast (this
> was in the 1989-1991 timeframe), but it was pretty amazing tech.

Probably one of the various "Lisp machines", I should think... I gather 
there were similar systems powered by Smalltalk.

At uni, we used Smalltalk VisualWorks(tm). The entire environment is 
written in Smalltalk. Which means that with a few simple variable 
assignments, you could TOTALLY SCREW THE SYSTEM. The canonical example is

   Smalltalk := nil.

This causes all the windows to stop repainting and the mouse pointer to 
disappear. The only solution is to terminate the process via Task Manager.

In a less stupid note, one time I was writing an application, and it had 
various "components". Each component is implemented by a class, and I 
tried to add a #name method to return the name of the component...

...oh dears. Yeah, it turns out that Class already *has* a method named 
#name. And by overriding it, I made the system do some *weird* crap... 
It took me ages to figure out what the hell has happening.

A bit like the time I had a method that returns an array constant. It 
turns out it isn't actually constant. So if you mutate the array, you 
now have a method that /appears/ to return one thing, and /actually/ 
returns something completely different. (Until you reload the source 
code from disk...)

Mutable state is evil. :-P

Post a reply to this message