Just finished a nifty experimental educational stunt at the Santa Fe Complex (SFX): taking the UNM CS590 course taught by Ed Angel .. but given in Santa Fe at SFX to a group of folks interested in a wide variety of topics, from GPU programming to game programming to high performance parallel computation to ambient computing combining projectors and cameras to do computing in your spatial environment .. your whiteboards, rooms and domes.

Ed had just finished a major rewrite of his textbook to be Shader based.  Shaders are programs running in your computer’s GPU chip with very fast matrix manipulations of huge number of vertices.  Not only were shaders a new addition to CS590, but OpenGL itself had morphed considerably .. including not only the desktop C/C++ version, but also GLES, the Embedded Systems (phones and tablets, mainly) but the HTML5 WebGL variant.  Within the class we had all versions being used.

I chose to use WebGL, mainly using Google Chrome, WebKit (Safari’s developer build), and Firefox .. all of which have most of HTML5 implemented.  The documentation was pretty raw but fortunately the Learning WebGL site is extraordinarily useful.

We had three fascinating homework assignments, plus a final project if taking the course for graduate school credits:

• Homework 1: Tessellation and Introduction to WebGL.
• Homework 2: Rubik’s Cube
• Homework 3: Maze Traversal
• Final Project: GPU Intensive Agent Based Model: Before and After.
• Final Project Min Series: Several Minimal WebGL Experiments for the final project.

I kept stumbling over unsuspected surprises while doing these:

• Javascript: Holy cow, its Lisp without parens!  Closures etc.  Start with Crockford and Good/Bad/Ugly.
• Self Documenting: Wow, WebGL is in a web page, I can do my write-up next to the 3D model!
• HTML5: Not just 2D/3D Canvases but way way more!
• GPU Programming: Thinking about 100′s of processors so dumb they can’t share data!
• Interpreter: Because JS and all its libraries are just text, you can read the code and libraries easily.

That’s all for now, just wanted to finally get this stuff posted.  All the source can be gotten from the CS591 directory.  The zip files make downloads easy as well.

This year we added a new section: our Bag Of Tricks which is a set of downloadable NetLogo files showing standard techniques such as:

• Ant pheromone techniques
• Craig Reynolds style Flocking simulation
• Using two graph layouts to create a bouncing ball
• How to have agents travel on links rather than patches
• The n-body problem, both 2D and 3D
• Use of NetLogo’s GIS extension.

The tutorial session was given in the evening at the Santa Fe Complex, an arts and technology non-profit here in Santa Fe, NM.

Note: the gisagents blog gave this a good mention.

• First it was just HTML .. crafted by Netscape!  Remember the great HTML editor available in the Netscape browser?
• Next I converted to Textpattern, a brilliant CMS/Blog engine.
• Finally, because the  Santa Fe Complex is using WordPress, I’m converting to using it.

This is not because I dislike Textpattern.  Indeed, I believe it to be the best blog/CMS combination I’ve seen.  Extraordinarily sophisticated.

But we, our 501c3 non-profit, chose WordPress for our site due to its huge popularity.  We have several professional web designers on our webteam who have extensive experience with WordPress.

So I decided to convert my website to WP so that I could better understand what we are doing.

The current page as of Thursday, September 3, 2009 is simply WP Classic (not Kubrick!) with my old site’s CSS.  It’ll change quite a bit over time as I begin to better understand WP.

Why Classic and not Kubrick?  Here’s a hint: try running

grep ‘{‘ style.css | wc

.. in both the themes.  Here’s what you’ll see:

wordpress/wp-content/themes/classic:  60     190    1102
wordpress/wp-content/themes/default: 130     458    2683

More than double the CSS for Default/Kubrick.  No brainer.

Math Is A Second Class Citizen On The Web!

The Math Typesetting for the Internet page has a good discussion on the issues.

So what to do?! MathML? HTML/CSS? ASCII stunts? Equation Editors? LaTeX Tools? JavaScript?

The fact is that it’s not at all easy to make a choice. So here’s the road I took:

1. Notation: I decided on TeX notation. It’s the standard and I decided I’d be ignorant not knowing it!
2. Tools: LaTeXiT, TextMate and similar tools are good at equation creation, producing images/pdf helping visualize/debug the LaTeX source.
3. Plugins: I decided to not use plugins: I’d need a different one for each blog, wiki, forum and so on. They also often require root access.
4. Images: I similarly decided not to use static images: they are inflexible and hard to manage, and also loose the basic TeX source.
5. LaTeX2HTML: I did not want to use LaTeX2HTML (or similar) because my blog (and wiki and forum) all have their own markdown language that I did not want to “escape” by inserting raw HTML.
6. LaTeX Source: I wanted to retain the LaTeX source in the HTML so that in the future I might use the equation in a different tool.

This led fairly quickly to a very nifty solution: CodeCogs has created a LaTeX Equation Editor and a web service for rendering the results! Sixth Form Mathematics & Law blogs on using the CodeCogs facility for dynamic images created by a server.

The idea is quite elegant: send a LaTeX equation in a URL to a server which converts it, dynamically, to a tiny image. The LaTeX segment below is rendered into the equation following it.

\int_{-\infty}^{\infty}e^{-x^{2}}dx=\sqrt{\pi}

Click on the LaTeX code above to see the CodeCogs URL used and the result of its use as a stand-alone image.

Here’s the Textile markdown used in this article:

!http://www.codecogs.com/eq.latex?
int_{-infty}^{infty}e^{-x^{2}}dx=sqrt{pi}!

The following can be used instead and allows blanks in the LaTeX source:

== <img src=

http://www.codecogs.com/eq.latex?

int_{-infty}^{infty}e^{-x^{2}}dx=sqrt{pi}
/> ==

Note that the line breaks after the “?” in the above URLs are used to fit on the page, they do not occur in the HTML/Textile source.

Why?? Well, our group uses Blender quite a bit, and Blender uses Python as its scripting language. More generally, Python is quite popular within our scientific community.

Jython, a Python implementation using the JVM, has been surprisingly successful, having most of what we like about CPython. And its Java integration made it a natural for Processing. This presentation is a good overview.

Java

Here’s the Java 1.4 code we’re starting with, the Processing .java file created when creating the applet above. A few notes:

1. The two methods setup() and draw() are required by PApplet.
2. Class Box is an inner class, as is usual for Processing, because:
3. Several utilities are in PApplet like color(), random() and all drawing methods. Use of inner classes lets you “inherit” these.

public class RandBoxes extends PApplet {
  int numBoxes = 1000;
  ArrayList boxes = new ArrayList();

  public void setup() {
    size(600, 500, JAVA2D);
    while(boxes.size() < numBoxes)
      boxes.add(new Box(random(width), random(height)));
    println("number of boxes = "+boxes.size());
  }
  public void draw() {
    background(128);
    for (int i = 0; i < boxes.size(); i++)
      ((Box) boxes.get(i)).step();
    if (frameCount%10==0)
      println("frameRate="+frameRate+" frameCount="+frameCount);
  }

  class Box {
    int c = color(255, 255, 0);
    float x, y;
    Box(float x, float y) {
      this.x = x;
      this.y = y;
    }
    public void step() {
      x = max(min(x+random(-1, 1), width), 0);
      y = max(min(y+random(-1, 1), height), 0);
      paint();
    }
    public void paint() {
      noStroke();
      fill(c);
      rect(x-2, y-2, 5, 5);
    }
  }
}

Jython

Here’s the Jython I eventually came up with. Note this is not “pythonic” yet, but at least runs. Goals:

1. Be able to run as an applet if possible
2. Avoid a “proxy class” subclass of PApplet even though that’s a common stunt to make Jython usage simpler .. i.e. hide any Processing or Jython “warts”! See the Thoughts for an example.
3. Run easily in the standard Jython environment

To run,

export CLASSPATH=~/local/processing/lib/core.jar:.

then put this in any file other than RandBoxes.py (see notes). I use RandBoxesTest.py :

from javax.swing import JFrame
from processing.core import PApplet
from random import uniform

winWidth=600
winHeight=500
numBoxes = 1000
boxes = []

class RandBoxes (PApplet):
  def __init__(self):
    pass
  def setup(self):
    self.size(winWidth, winHeight, self.JAVA2D)
    while len(boxes)<numBoxes:
      boxes.append(
        Box(self, uniform(0,winWidth),uniform(0,winHeight)))
    print "number of boxes = %d" % len(boxes)
  # rqd due to PApplet's using frameRate and frameRate(n) etc.
  def getField(self, name):
    return self.class.superclass.getDeclaredField(name).get(self)
  def draw(self):
    self.background(128)
    for b in boxes: b.step()
    if self.frameCount % 10 == 0:
      print "frameRate=%f frameCount=%i" %
      (self.getField('frameRate'), self.frameCount)

class Box(object):
  def __init__(self, p, x, y):
    self.p = p
    self.x = x
    self.y = y
    self.c = p.color(255,255,0)
  def step(self):
    self.x = max(min(self.x+uniform(-1,1),winWidth),0)
    self.y = max(min(self.y+uniform(-1,1),winHeight),0)
    self.paint()
  def paint(self):
    self.p.noStroke()
    self.p.fill(self.c)
    self.p.rect(self.x-2,self.y-2,5,5)

if __name__ == '__main__':
  frame = JFrame(title="Processing",
    resizable = 0,
    defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
  panel = RandBoxes()
  frame.add(panel)
  panel.init()
  while panel.defaultSize and not panel.finished:
    pass
  frame.pack()
  frame.visible = 1

Notes:

• My first try did not use the 4 “global” variables: winWidth, winHeight, .. but it was pointed out to me that its more pythonic to use globals like this, and avoids overuse of “self”.
• Similarly, to avoid way too many uses of “self.random()” and so on, I migrated to using Python utilities for max, min, random.uniform, and so on. You can tell I was beset with way, way too many uses of self.foo()!
• I tried using inner-classes within Jython, but apparently that doesn’t work, even with __future__ nested_scope. The ASPN Cookbook discusses solutions, but I decided simply to pass in the PApplet instance to the Box constructor. Not sure what the most pythonic solution would be, but being explicit doesn’t hurt.
• I chose to use JFrame for putting my PApplet subclass in an application even though PApplet has a main() that I could call. (PApplet, like many Java Applets, has a main for running as an application). I did this for three reasons: to learn Jython’s Java integration, to use the Python “if __name__” cliche, and to avoid having to use jythonc to create a .class file everytime I made a change. The latter was a subtle point caused by the main() in PApplet actually running your class file.
• The getField() utility was needed to disambiguate frameRate, a variable, and frameRate(), a method, both in PApplet. This was a gift from Jeff Emanuel on the jython-users list
• I did succeed in building an Applet, see below. This used jythonc to build a true Java .class file, and has facilities for including the Jython core libraries as well your Jython source.
• The .py file cannot be RandBoxes.py due to a jythonc convention which creates a main() for the outermost Jython code. This main throws an exception, which does not match the standard Java main() signature. Because PApplet has its own standard Java main(), jython flags an error and stops. And, yes, you can bet this took a long time to fine!

Applet

To build the Applet, I used this jythonc command:

jythonc -J-g:none --core --deep --jar RandBoxes.jar RandBoxesTest.py

The applet tag looks like:

  <applet code="RandBoxesTest$RandBoxes"
         archive="RandBoxes.jar,core.jar"
         width=600 height=500>
  </applet>

The Applet, and similar links, are here:

• The Jython Applet
• The build shell script
• index.html file
• RandBoxesTest.py

Thoughts

• Jython is for real: It interoperates well with Java, implements a recent enough version of the Python language, has a good support forum and documentation.
• This wasn’t easy, but was made possible due to the Jython community and website, and the Jython books (I used Jython for Java Programmers)
• There is friction between Jython and Java, and is likely to remain there. This will require Jython users trying to integrate with Java to smooth the way somehow. Reflection, like in getField(), can help. Also, Proxy classes are a very reasonable approach. I used this initially, and then had the Jython code subclass PAppletProxy rather than PApplet :

        import processing.core.*;
        public class PAppletProxy extends PApplet {
          public float getFrameRate() {
            return frameRate;
          }
        }

• Python: well, there’s good and bad. Its a well crafted language, but I certainly made all the blunders newbies make: I got my indentation wrong, found myself using self.foo() way, way too much, and wished for standard lexical scoping. But boy is the code clean.
• Performance: Java’s RandBoxes runs at about 40fps, while the Jython version runs at about 6-7fps, around 7 times slower, give or take. This is really unfair in a way, I’m such a Jython newbie, and this is definitely a difficult task. And for rapid prototyping, that sort of decrease may easily be acceptable. I think if it were more like 2-3 times slower, that would be fine. Any suggestions welcome!

Processing is more than a graphics library, it has a delightful IDE which makes Java much easier, especially for the Java novice. The IDE has great tools such as a web-page builder with the project as an applet. It also can build an application version for Mac, Windows and Linux.

One difficulty we faced however, was that we wanted to commit to fairly complicated models that would benefit from Java 1.5 (Processing uses an earlier version) and an IDE familiar to Java programmers. We also are interested in interfacing Java to other languages such as Groovy, Python/Jython, Ruby/JRuby, and even JavaScript/Rhino.

So I decided to experiment with Processing, using Eclipse and Java 1.5. To do this, I made two models: RandBoxes, which is really simple .. just showing 1000 boxes and randomly jiggling them each step. The second model, RoadGrid, is more complicated: it draws a rectangular road grid and has “cars” (rectangles) moving along the roads. At each intersection, the cars randomly chose a new road segment.

By a very fortunate coincidence, the Processing team had just done a fairly major cleanup, making their system work nicely in Eclipse. So I built a new Eclipse project, including the Processing core.jar file and the Processing JavaDocs, and using the Java 1.5 SDK.

The Processing IDE puts its code fragments into .pde (Processing Development Environment) files which the web-page builder includes in the applets above. Here’s the RandBoxes .pde file. Note that there is no Class defined, nor imports. The Processing IDE handles that for you by generating a java file automatically. Here’s the RandBoxes.java file before and after formatting by Eclipse. Note how the IDE “wraps” the .pde file in a class and adds a Main(), as per the Java norm. It also does other preprocessing like changing the “color” type to a Java “int”.

Well, imaging my surprise when after dumping the above file into Eclipse, although it had many warnings, it none the less compiled and ran, both as an applet and as an application! Here’s what Eclipse looked like:

The next step was to upgrade the .java file to be 1.5 savy: removing unnecessary imports, migrating to generics, using the for/in loop and so on. This resulted in the RandBoxes1.java file.

Some code examples:

Using generics, this:

ArrayList cars = new ArrayList();
for (int i = 0; i<cars.size(); i++)
     ((Agent) cars.get(i)).step();

.. converted to:

ArrayList<Agent> cars = new ArrayList<Agent>();
for (Agent car : cars) car.step();

Converting to the new printf() facility, using a “static import”, this:

println("frameRate="+frameRate
        +" frameCount="+frameCount);

.. converted to:

import static java.lang.System.out; // NOTE Static Import
...
out.printf("frameRate=%.2f frameCount=%dn",
            frameRate, frameCount);

Another nifty 1.5-ism was using Generic methods. Their syntax is a bit odd, but it sure is great not having to use casts all over the place! Here’s an example taken from the second demo, RoadGrid. This old-style method:

public Object randomOneOf(ArrayList a) {
    return a.get(randomInt(a.size()));
}

now looks like:

public <T> T randomOneOf(ArrayList<T> a) {
    return a.get(randomInt(a.size()));
}

After “modernizing” to 1.5, Eclipse shows no warnings:

So Processing with Eclipse is working like a charm, and lets us use the latest Java version, use the JavaDocs easily, and even browse the Processing code. And with a little hand tweaking of Processing’s IDE-generated web page, we can even use the new Java 1.5 applet.

One downside: many browsers are not yet using 1.5 so will not be able to view the newer version. But a solution is RetroWeaver which converts a 1.5 class back to its 1.4 format, thus potentially letting us use Eclipse, Java 1.5, Processing .. yet deploying for 1.4 browsers.

We’ll follow up shortly with some other experiments with Processing with other languages .. stay tuned!

The core idea of the Prisoner’s Dilemma is a game where two folks choose to cooperate or not (defect). The scoring is such that if you cooperate and your opponent defects, you (the “sucker”) get quite a low score. If you both cooperate, however, you get a reasonable score but not as high as a defector gets against a cooperator. This classic in game theory poses the paradox that your best move is to defect, even though if you both defect, you both get a very poor score. Grim.

Robert Axelrod was puzzled by this, and suggested that if the game were repeated (iterated), the best outcome would could vary according to the strategy of the players. This resulted in his now famous computer tournament pairing strategies against one another. The sweet result was that a firm but friendly strategy, Tit for Tat, which cooperated initially, then simply repeated the opponent’s previous move from then on, was the overall winner.

Nick, looking at this, thought that it’d be nuts to stay in a series of Prisoner’s Dilemma games if the opponent was clearly no fun to work with. Thus he introduced the idea of leaving the tournament. MOTH, My way Or The Highway, builds a new suite of strategies which have the additional capability of leaving an unpleasant encounter. This creates a pool of strategies without partners, so they are re-paired randomly, and the tournament continues.

The result is that Nick, along with several of our local Friam group here in Santa Fe, worked on a NetLogo model exploring this new approach. This model expanded upon and validated earlier work done by Nick and his colleagues David Joyce and John Kennison. This resulted in a paper delivered to the Lake Arrowhead Conference on Human Complex Systems.

The NetLogo Model we created is viewable by you, gentle reader. The explanation provided with the model presents considerable detail about the ideas behind the Moth strategy.

Not surprisingly, a quite successful strategy is a variation of Tit for Tat: play Tit for Tat and on the first defection by your opponent, leave the tournament to be paired with a (hopefully!) more cooperative player!

Here is the resulting paper. It’s also available in PDF and Word format.

I should note that considerable editorial help came from Sherrie Bolin, making it a much cleaner read!

Imagine my surprise when I found that the cruddy table based mess the .com sites used to achieve their unnatural, pixel perfect goals had been replaced by a very clean separation of content and structure (xhtml) and the looks and style of the page (css).

I put together several examples for a talk to our local technical team. Here’s the talk’s “slides” .. pages of reference material and demos.

Note: The talk included considerable CSS magic by making simple changes in the style sheet using CSSEdit and having immediate response in the preview page. So some of that is missing for folks just looking at these pages.

The Basics

Here we look at old html and new xhtml and css.

• Basic & Simple HTML
• DocTypes
• New XHTML/CSS
• Our Basic XHTML Doc
• Our Doc’s Structure
• Mozilla’s Editor’s Structural View

Before we start: Some of The Heros

These folks, and many others, brought order back from the chaos of the early, table-centric (read “Gawd Awful”) mess our poor web wandered into. Notice how design played a strong role in achieving this revolution. Techies — be humbled.

• A List Apart
• Jeffrey Zeldman
• Eric Meyer
• Eric Costello
• Zen Garden
• Web Standards Group

The Tutorial

Note: During this part, I used the very simple document discussed above, simply changing its style sheet. Between step 1 and 2 I added a bit more material to show the impact of the styling.

• Play0.html, our starting point
• Styling 101 – The CSS Box Model
• Play1.html styled with Play1.css
• Play2.html styled with Play2.css
• Play3.html styled with Play3.css
• Play4.html styled with Play4.css

Help: The Great CSS Community

Here’s the tip of the help iceburg. My recent experiences converting to xhtml/css and then Textpattern as a CMS really made me appreciate all the help out there. Angels, we thank you!

• The CSS Forum
• CSS Browser Support Charts
• CSS Layout Techniques: Eric Costello
• Drop-Down Menus, Horizontal Style: A List Apart
• CSS Design: Taming Lists: A List Apart
• The CSS Edge: Eric Meyer
• CMS and the Single Web Designer: A List Apart
• WordPress
• Textpattern

This is a writeup on recent findings I’ve made in the web & internet world as I explored it to upgrade my web site and to begin thinking about development issues we’ve been discussing at WedTech and other venues like Ars Publica, RedfishGroup, and other opportunities.

First and foremost is a huge change in the core web world itself. Html has been regularized into being xhtml, a subset of xml. (Xhtml is simply html with ballanced tags and other xml regularities. We’ll use “html” from now on but mean xhtml) In addition, the MVC style (Model, View, Controller) has become a core value, promoting an extremely clean separation of content from layout/looks.

The xml direction has prompted several new capabilities such as news feeds and added web semantics. Robert’s recent posting on his web site’s use of feeds was quite interesting. Google, Yahoo and other sites have dynamic interfaces letting you use the xml world to programmatically query their huge repositories.

While becoming immersed in all this, I tried some new tools.

One was Textpattern, a content management system (CMS) which makes it quite easy to manage and update a web site. It provides easy access to html/css, and makes it easy to incrementally modify both the content and looks of the site. It provides a browser based “dashboard” for doing all this in a very simple way. It manages fragments of content (articles) and html (forms), integrating them into pages for you.

Textpattern is based on PHP and MySql, two interesting core web technologies. PHP is a server based dynamic page generation technology, while MySql is a freely available, well supported SQL server. HostGo, our popular hosting service, provides both. And there is an excellent phpMyAdmin web application for managing and viewing your MySql database.

Templating is a widespread technology for separating the php programming from the html content. It works by custom defined html tags. For example, the tag <txp:page_title /> will generate a reasonable page title for the current page based on the section/category/article contents of the page. It invokes this php function:

    function page_title($atts) {
        global $sitename,$id,$c,$q,$parentid,$pg;
        if (is_array($atts)) extract($atts);
        $sep = (!empty($separator)) ? $separator : ': ';
        $s = $sitename;
        if ($id)       return $s.$sep.fetch('Title','textpattern','ID',$id);
        if ($c)        return $s.$sep.$c;
        if ($q)        return $s.$sep.gTxt('search_results').$sep.' '.$q;
        if ($pg)       return $s.$sep.gTxt('page').' '.$pg;
        if ($parentid) return $s.$sep.'comments on '.
            fetch('Title','textpattern','ID',$parentid);
        return $sitename;
    }

All extensions to Textpattern are done via these tags. Thus your article and form fragments have no php programming, keeping programming separate from content and form. It is possible to use Textpattern with absolutely no knowledge of PHP and MySql.

Textpattern is installed on your server (hostgo for many of us) and the site is directly managed from there. You need not have a local “mirror” of the site on your computer. Because html/css is used, the actual content you add to the site is trivial html with none of the complex table layout, and embedded font, color, etc styling. This leads to using a “MarkDown” style of data entry. By markdown I mean any of several simple text-to-html schemes. Wiki’s use a simple scheme of * bold *, _ italic _, CamelCase or [http://foo/bar.html] links, and so on. Several blogs use this text-to-html. Textpattern comes with Textile, a similar markdown. There are others as well.

There are several very interesting Java/XML CMS systems too. Carl’s presentation on XML and XSLT was quite an eye-opener. Combined with Ant, the Java/Apache build tool, an entire site can be maintained from a command-line interface! Very impressive and it has the advantage of being closer to the core xml used to have sites communicate with each other.

I view the Java/XML – PHP/MySql split as a positive thing, and something that brought about several Cathedral and the Bazaar discussions. Some sites combine both technologies. The http/webservices protocols provide clean separation.

Another tool I’ve begun using is jEdit, another interesting open source project. It has become a favorite among folks wanting an editor that runs on Windows, Mac, and Linux systems and which is easily modified via plugins and mode scripts. I think the most interesting thing for us is its ability to manage all its plugins directly within jEdit via a GUI that directly interacts with the plugin website without having to download and install. This surprising design, including the network directly in the application, makes sense for us as we consider complexity applications.

Because html/css usage promotes very simple html, I find jEdit handles content creation, when I’m not using Textile directly, quite adequately, with the bonus of being a good xml editor (for Ant and most modern configuration scripts). I use a separate css editor to very dynamically experiment with page style. So with Textpattern, I generated a simple page, cut/paste it to a local html file, and started styling with a css editor. Extremely simple and understandable, and very rapid design cycles.

During all these explorations, I found that the web communities have grown considerably in sophistication. First and foremost were the Forum sites with easy to use “bulletin board” style posts. The Textpattern forum (and WordPress, a blog system I also was exploring) are very active and useful. Because Textpattern is meant for more than just blogging, it is a bit more complex to install and use. The community was/is a huge help .. I visit daily and am starting to contribute help and plugins.

This community approach was used brilliantly by several open source projects. One example is MySql’s on-line manual. It allows readers to leave comments on each page! This has lead to very rapid discovery of problems and interesting usages. PHP uses the same style. Some projects use this as a way to build the manual itself: the core developer(s) create an outline for a manual in an open Wiki, and the community fills it in. This was used by the single Textpattern developer to document user-supplied plugins. All this documentation is very dynamic, often to pointers to the discussions which lead particular decisions.

I find myself making choices of which software to start using based on their community. A vibrant community often makes for a successful project. So when looking for Java based systems recently, I found myself guided considerably by the community activities around the project.

These experiences led to suggesting that we have an explicit “portal” section part in the Ars Publica grant proposal.

My most recent plunge into a new system is Eclipse, the open source IDE based on a plugin architecture which prompts considerable community activity. What captured me was it superb integration into the Mac desktop and its ease of configuration. No IDE is easy to use, but getting rid of barriers makes it much simpler.

My interest in Eclipse was not just as an IDE. Roger and others had found that it hoped to be used as an application framework. It is called the Rich Client Platform (RCP). So I’m currently going through a couple of RCP tutorials to see if it could be used as an integration platform for agent based modeling.