+log4cl
Add a psmacro which will load javascript libraries, and their dependencies prior to running the code in the body.

Add d3js.lisp which shows how to use d3js in a similar manner to the plot example; this isn't in the asdf system at this point.

Fix a bug in the log4cl conversion that broke things badly.
Add examples of a number of large javascript widgets: mapping, rich text editor, syntax highlighting.

Because I'm hoping to create a plugin framework put each of these into their own ASDF project.

Plot-window-examples is loads them all and defines a little demo function.

Change things to conform to the typical javascript approach of having a single global in the window,
in our case this window.bah, which consists of an object with presumably useful things in it.  So
far that includes: the websocket stream, the message sending function, and a logging function.

Log4cl logging is more widely used, and i'm now letting it name the loggers more.

A very casually written log4cl appender can be found in the epilog of main.lisp, really
just a doddle.  I'm playing with the idea of logging to an in memory data structure where
I can then browse analyse etc. after the fact.
Move the code for the d3js widget into examples.

Start restructuring d3js so I can have widgets accumulate, rather than widgets that replace the whole page content.

For debugging set *last-global-eval* to the text last sent for evaluation.

Remove a print stm from utils.
Add to the define-javascript-library/with-js-libraries scheme a way
to avoid reloading libraries we have already go.  This involves defining
a predicate for each library that detects if it is present.

Put log4cl::memory-accumulator into it's own file.

Change the default window so it's only got a bit-o-text in it,
move the plot/flot example into examples.

Add an optional bollean arg to the demo function that makes
it run faster, to fast for viewers but better for testing.
Introduce an interpolate macro in both lisp and parenscript.  In the Lisp case it invokes the code inside of cl-interpol; this avoids the use of readmacro.  I don't like readmacros.  In Parnscript it calls the cl-interpol code to expand the interpolated string into Lisp code; it then walks that code to rewrite it into Parenscript.  Needly to say this works only for a very limited subset of cl-interpol's functionality; but it's still quite useful.  Also add optima to our ASDF.

Introduce a parenscript macro cprogn that can be when a series of continuations are needed to do something.  This was a fun idea which I probably didn't actuall need, time will tell.

Introduce with-new-element, which is a precursor of an insertion point for adding wdgets to the page.  Getting the animation on this thing to work was, ah, educational.

Misc other junk that probably ought to be stripped back out.
Use uoip:getenv rather than ccl:getenv.
Large refactor.
- Move some simple parenscript utilities into ps-modules
- Introduce ps-modules, a way to define both 3rd party and out own modules
- Revise a lot stuff to use the new ps-modules architecture.
- Generate javascript files from ps-modules' javascript-code-modules, commit them.
- the javascript-code-modules dw (for display window) is where we are now accumulating
  the functionality; this is in dw.lisp
ws
ps module defining forms are now eval-when'd, so that's good.
fix weirdness in the flot example.
Fix a serious error in ps-modules so that defvar-javascript works now, and allow code fragments to be scalars.

Rework dw.lisp so it actually works.

Make catching errors optional in ps-eval-in-client.
Hack around a compile order problem so this works on first run.
Fix insert pointer mechanism and convert all the examples so they use
the default insertion pointer.  Also eliminate all use of ID on
elements.

Start using named-readtables and cl-interpol.

Add a little example to show a random city's map.
Add another widget, a data grid, using slickgrid.
Introduce add-element, as shorthand.
Include some spring layout play.
Merge branch 'develop'