Dan Corkill announced his GBBopen project at ILC03. It is an Open Source variant of his Generic Black Board System (GBB). This is exciting news and combined with FramerD as a frame store it will be a good substrate to build knowledge representation systems like MyZwrap in Common Lisp.

AFAIK Win Schwartau was first to describe do-it-yourself EMP weapons in his book "Terminal Compromise" back in 1991. It had to happen, someone actually built one. To quote from the I-Bomb website:

The rapidly approaching ubiquity of technology and its inevitable but rarely discussed terroristic use demand for immediate exploration and development of technology disruption devices. In the ensuing world dominated by technology and information, the true culmination of power will rest not with the institution controlling the information but the organization, group, or individual capable of disabling, altering, or destroying the underlying support structure of information: electricity, telecommunications, and computers.

I found this nugget while browsing the comp.lang.lisp archives at Google:

Newsgroups: comp.lang.lisp
From: Kent M Pitman 
Subject: Re: new to lisp

"Joe Marshall"  writes:

> "Nils Goesche"  wrote in message
> news:a75o2v$1@ID-125440.news.dfncis.de...
> 
> >  The first program
> > I successfully wrote and ran looked like something along the lines of
> >
> > 10 PRINT "HELLO"
> > 20 GOTO 10
> >
> > That would be
> >
> > (TAGBODY
> >  10 (PRINT 'HELLO)
> >     (GO 10))
> >
> > :-)  I quickly realized that you don't get very far with that...
> 
> Don't be so sure.  Greenblatt *still* programs Lisp this way.

And if you use too many go tags, does the lisp machine compiler error
still say "That's too many go tags, RG!" ?  [1]  Actually, I'm not
sure of the precise message text, and am not in the right room to just
type in a test to my LispM, but I recall it used to mention him by 
name. :-)

[1] RG = Richard Greenblatt

From: "Joe Marshall" 
Newsgroups: comp.lang.lisp

Yep, it works.

Typical Greenblatt code would look like this:

(DEFUN RDSYL (L DF)
  (PROG (LL BRAKP ANS CH)
        (SETQ DF (MERGEF DF '((* *) * *)))
     AA (SETQ LL (SETQ BRAKP () ))
      A (SETQ CH (OR (CAR L) #/_))
        (COND ((OR (= CH #/ ) (= CH #//))     ;"/", " "
               (POP L)
               (SETQ CH (CAR L)))
              ((AND (= CH #/[) (NOT #%(ITSP)))    ;"["
               (SETQ BRAKP 'T))
              ((AND (= CH #/]) (NOT #%(ITSP))) (SETQ BRAKP () )) ;"]"
              ((OR (= CH #/( ) (= CH #/) )) (RETURN () ))  ;Cant have parens here
              ((= CH #/,)     ;Comma
               (COND ((NOT BRAKP)
                      (POP L)
                      (GO RET))))
              ((= CH #/_) (GO RET)))
       (PUSH CH LL)
       (POP L)
       (GO A)
  RET  (SETQ DF (MERGEF (NAMELIST (MAKNAM (NREVERSE LL))) DF))
       (SETQ ANS (NCONC ANS (LIST DF)))
       (AND (= CH #/,) (GO AA))
       (RETURN ANS) ))


~jrm

-----------


XX ITS.1168. PWORD.1733.
TTY 116
3. Lusers, Fair Share = 23%
Due to popular demand, TWENEX has been flushed in favor of
ITS.  Please update your programs.

Diomidis Spinellis wrote a spectacular book (in both it's breadth and depth) about the art of reading (C) source code. Code Reading teaches by example how to read code, identify idioms and sniff out bugs. Someone should write a similar book for Common Lisp. Time to quote Erik Naggum:

Programming cannot grow and learn unless the next generation of programmers have access to the knowledge and information gathered by other programmers before them.
-Erik Naggum

Finally a workable checkpointing solution for all Linux processes!

Checkpointing is the technique of storing a running process's state in such a way that a process can be restarted from the point at which the checkpointing took place. UCLiK is a checkpointing system for Linux. It was designed as a kernel module, and thus requires no modifications to the running kernel's code. UCLiK provides transparent and flexible checkpointing support to the Linux kernel. The ultimate goal is for UCLiK to be able to checkpoint Any Process at Any Point in time.

Neil Stephenson is not the first to highlight the relationship between those three brothers in arms. Though his take on the events that ultimately led to democracy and free markets might be the most enjoyable I have read so far. Quicksilver is, among others, a richly intertwined story about The Machinery of Freedom, as David Friedman described capitalism, the invention of modern financial instruments as described in Against the Gods and the advent of information markets. seen as a gigantic information processing machine.

Neal Stephenson has done it again! I'm halfway through "Quicksilver", his newest opus:

It so good I started to slow down reading in fear I would finish it too fast! So what is it all about? Stephenson tries to answer the question:

"What happened three hundred years ago when technology, science and society suddenly started to change in such a dramatic way?"

Gregor Kiczales gave a good talk about software aspects at ILC03. His book recommendation was AspectJ in Action" by Ramnivas Laddad.

I'm reading it, because we still do a lot of Java at my dayjob and AspectJ might help with code maintenance and debugging. How I miss CLOS!

It is impossible to know exactly how Prince Modupe felt when he discovered a process by which his very thoughts could be trapped and released at will again into speech. But I think his epiphany must be close to what I experienced when, as a young composer, I was first shown how I could use a computer to represent my musical ideas and then “release them” at will into musical compositions. At that time I was a masters student in composition at Stanford University. My teachers John Chowning and Leland Smith had just demonstrated to our introductory computer music class how a music language called SCORE could capture musical ideas and, at the push of a button, trigger an almost magical process in which fantastically complex scores were computed and then realized by instruments unimpeded by the laws of physics. At that instant it became clear to me that there was an entire level of notation above the scores that I had been writing in my regular composition classes, a level I knew nothing about! But I could see that in this level it was possible to notate my compositional ideas in a precise manner and work with them in an almost physical way, as “trapped words” that could be unleashed into musical sound at the push of a button. Equally important was the realization that this new (to me) level was essentially devoid of any preconceived notions of “musical correctness” and so offered me an attractive alternative to the symbols and glyphs of Common Practice music, which I increasing felt were too tied to historical tradition. I too, “shivered with a desire to do this wondrous thing myself” and, as I look back on it now more than twenty years later, I realize that this moment was one in which my life's path was irrevocably altered.

It is said that one cannot understand the true meaning of the Koran without being able to read it in its original language. Similarly, it is said that one cannot truely appreciate a Zen koan that has been translated.

Similarly, Lisp is the only language that the true meaning and appreciation of programming can shine through. All other languages are like a cloudy piece of weathered plexiglass when compared with Lisp's crystal clarity. That is why it is the destination towards which all other languages move and it is the reason why I use it.

I often prefer these days to refer to identity-oriented programming for what we once called object-oriented. To me, and to the original meaning of the term, the very essence of object oriented programming is about the shape of connected structure once programs were written.

So, for example, Lisp's characteristic of redefinable or dynamically loadable functions is a natural result of the fact that definitions are stored in objects (symbols) and that you can, in an object-oriented way, change the object in a way that is possible to model/describe within the language such that a new definition is in effect.

Another might be the characteristic of being inspectable independently of a running program. That is, data has the ability to answer questions about itself because data is not just "procedurally embedded" but is subject to an external use protocol.

Now, I claim, it's not necessary to say how this protocol was created. In some cases, it might be wired in by the system implementors in C or assembly. In other cases, it might be user-programmed. What matters is the access protocol, not the definition protocol.

Java happens to be object-oriented in the sense that it has introspection protocols built into the JVM. But the quality of being organized into a particular organizational theory of programming (that I'd think is better called "object-centric" or even "object-chauvinist") is just a red herring, IMO. Certainly the fact that most or all of your ability to change the 'environment' "compiles out" when you compile Java cripples its object-oriented nature.

And the sense in which there is any object-oriented stuff left after you compile C++ is just a fantasy, so I don't see that as object-oriented at all, no matter how object-centric the programming paradigm tries to make it look.

Now, I agree with MarcS -- I believe that multithreading will go down in history next to manual memory management as one of the biggest sources of bugs ever, and as one of the biggest preventable wastes of programmer time and customer money ever. I am very excited about coding in E because I will never be forced to deal with someone else's multithreading code, to argue with a teammate about the value of multithreading, or to wrap non-blocking APIs on top of blocking APIs to modules that I need to use.