Sony claims they created a running robot. Go QRIO, go!

From their press announcement:

The new 'walking, jumping, running movement control' technology which Sony has developed this time accomplishes motion involving both feet losing contact with the floor at the same time, which means it is a motion control technology enabling stable running and jumping. The seamless addition of motion control based on this new technology enabling running and jumping, has lead to the development of a robot having outstanding motion capabilities.

Furthermore, together with this new control technology, in addition to powering-up and enhancing the output torque of Sony's original and unique robot actuator, ISA (Intelligent Servo Actuator), a new hardware unit suitable for the running feature has been developed. By implementing this newly developed ISA in QRIO and optimizing the new control system, Sony has successfully created the world's first running feature for a humanoid robot.

And here's a photo of the OSPNL development team. And here's Intels introduction to the PNL.

Intel today announced the OSPNL at Neural Information Processing Systems 2003, a tool for working with graphical models. It supports directed and undirected models, discrete and continuous variables, various inference and learning algorithms. That means Bayesian networks most of the time. They haven't published any files for download yet.

When you create web applications, there's always this trouble with designing and integrating the actual front end. I've finally found a really good book about stylesheet design. "Cascading Stylesheets" by Ulrike Häßler gives a useful, entertaining and beautiful overview of CSS use from a designers point of view. It clearly shows how to move from a "paper idea" to a working screen design using CSS. Highly recommended!

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.

At least three people argued, that it shouldn't be to difficult to write an emulator similar to the one that was done for the DEC Alpha systems. The vision of having Open Genera running on a AMD Opteron platform excited all participants. Is it just a dream? I don't think so. (all images copyright Ralph Moeller)

It's on display at the MIT museum. Of course the Arthur Ganson exhibition at MIT museum is worth a visit too. His Machine with Concrete is mind blowing:

Alberto Rivera talked about a Lisp system that will analyze genome data.

Oliver Obst talked about the open source 3D Robocup Simulation League.

Taiichi Yuasa gave a spectacular talk about Lego Lisp. A tiny Lisp system that runs on Lego Mindstorm robots. Amazing!

Manuela Veloso from CMU talked about their RoboCup technology. They're able to do cross field kicks and get emergent team behaviour.

Following Schwartz, J.T talked about SETL, which he invented.

Right now Greg Chaitin is talking and shouting:

"I'm interested in the conceptual complexity of a program. Lisp ist my Turing machine."

"Lisp is a better expression of recursive function theory than what the mathematicians usually use."

"The real thing is not the theory, which has been around for quite some time, but that you can now actually run it as a program."