Several folks answered that they had no experience with Java, thus could not respond intelligently.[Gang: As part of my project, I'll be making three surveys, of which this is the first.] Survey Question One: Java Annoyances for Scientific/Complexity programming. Please let me know what are your issues with the Java programming languages for work like we are doing here at the complex systems summer school. Example: Does not have operator over-loading so that if I create a complex class, I have to call c1.add(c2) rather than c1 + c2.
Several others felt Java worked quite well for scientific programming, and that there was a tendency toward Java for this sort of work based on its universality. Here is an example:
One important difficulty mentioned by more than one person was the difference between different Java/JDK implementations. This tended to reduce the effectiveness of the portability of Java due to the work-arounds needed to be truly multiplatform. The Mac and Linux systems were the key concerns. Note that this was NOT differences between versions, such as JDK 1.1 and JDK 1.2. Rather differences between Mac, Linux, and PC versions of Java for the same version. Example:I have been using Swarm with Java for multi-agent simulation, and I haven't felt the Java environment to be in any way responsible for modelling/conceptual difficulties so far, on the contrary. Agent-based modeling seems to be a very natural extension of OO programming; ie: a very suitable basis for ABM. Issues like lack of operator overloading are in my view, a small side-issue and don't in any way impair ABM modeling. Give me another year or so and I might have come up against something!
There were two rather interesting responses focusing on language issues and design for scientific programming. Here is one:The biggest gripe I have with Java is that it is not consistent between Macs and PCs. They don't seem to keep the versions consistent between platforms so the software is not really portable at all.
And here is a second:Well, let's look at a language that is explicitly designed for scientific computing. Matlab is a good example. Java simply does not have the huge collection of built-in numerical methods that matlab does. Matlab is a much higher- level language. One drawback of matlab can be speed. But, this drawback can usually be overcome through the C foreign- function interface. Java also has a speed problem, for which a real solution requires extra work (like finding jit compilers, etc.). Matlab has built-in visualization methods. Java does not.
The most important reason why Java is not suitable for scientific programming is because that is not one of its purposes. Java is a general-purpose programming language, and can be used for simple computational purposes, but it was not designed to be a serious scientific programming language. Describing this difference as an "annoyance" is to miss the point. One might as well describe the "annoyance" at how difficult it is to use a screwdriver to drive nails. To illustrate my point, consider the floating point primitive types in Java. By definition, the types float and double correspond to IEEE-754 standard types, so the results will always be identical on all machines, regardless of floating point hardware. (Well, if you use the strictfp modifier; without it, internal computation might use a different format, giving results that differ slightly among different machines, but that's beside the point.) Although IEEE-754 floating point hardware is common on desktop computers (Macs, Wintel, many workstations), it is less common on main frames and supercomputers. If you run your Java program on a Cray, you will get the same result as if you run it on a PC, but the Cray must perform all floating point operations in software, or perform numerous conversions to and from its native floating point format. You might end up with performance similar to a PC, too, which is a waste of a few million dollars. And don't hold your breath waiting for a vectorizing Java compiler. Java I/O classes follow a clean, theoretical model that appeals to some computer scientists, but is utterly unusable for rapidly loading and saving large data sets. Even simple I/O tasks can be burdensome in Java unless one writes custom I/O classes. "No programming language solves all your problems. You should be glad to have one that doesn't add any." -- Edsgar Dijkstra.
The two most mentioned systems were StarLogo and Swarm. MatLab was also popular and is quite widely available. StarLogo also comes in a variety of forms: the Tufts Mac version (StarLogoT) as well as their soon to be available Java multiplatform version, and the current MIT multiplatform StarLogo written in Java. Although written in C, Swarm has a very effective Java API available. Two additional Swarm resources were made available during the class:[Gang: Thanks for the great response to the first survey. This is the second of the three surveys I'll plague you with!] Survey Question Two: MultiPlatform/Java Tools for Complex Systems. Please list tools that you know of for programming complex systems that are multiplatform .. i.e. run easily on Mac, PC, Unix/Linux. Example: StarLogo. These are typically Java based due to portability issues, but non-Java tools welcome too!
One response mentioned MicroSoft Excell as a good complexity tool! Initially I thought it was a typo, but no; it turns out a considerable number of people do use it for complexity work, see the Excel section at the mathtools.net site below, for example. Its not quite multiplatform, but possibly if the various other office suites are compatible, it would qualify.
Quite a large set of links were sent in which reside on the mathtools.net site which appears quite active:
Four other packages sent in are:http://www.mathtools.net/ This months additions can be found in Applications/Finance/Industry_Stories/ Learning/Newsgroups/Matlab/ Learning/Seminars_and_Tradeshows/Matlab/ Matlab/Finance/Application_and_Industry/ Matlab/Finance/Industry_Stories/ Matlab/Image_Processing/C_and_C++/ Matlab/MEX/ Matlab/Optimization/Excel/ Excel/Newsgroups/Matlab/ Excel/Optimization/IDL+PVWave/ C++/Finance/Industry_Stories/ C++/Newsgroups/Excel/ C++/Newsgroups/Matlab/ C++/Optimization/Excel/ Fortran/Finance/Industry_Stories/ Fortran/Newsgroups/Java/ Fortran/Newsgroups/C_and_C++/ Fortran/Newsgroups/Excel/ Fortran/Newsgroups/Matlab/ Fortran/Optimization/Excel/ Java/Newsgroups/C_and_C++/ Java/Newsgroups/Excel/ Java/Newsgroups/Matlab/ Java/Optimization/Excel/
1. A good Java CA simulatorAll in all, the availability of multiplatform tools for complexity appears to be quite high. Encouraging!
http://www.mirwoj.opus.chelm.pl/mjcell/mjcell_srs.html2. Excellent nonlinear systems analysis tool
http://www.physics.gatech.edu/chaos/research/NDT.html
[Note: This is currently only available for Windows and NT but a Unix port is underway]3. The Java based RePast website:
http://repast.sourceforge.net/4. The Java based Ascape website:
http://www.brook.edu/es/dynamics/models/ascape/
Survey Question Three: Computers/Networking as Complex Systems We've been using computers to study complex systems. Now I want to consider computers and networking as complex systems themselves. Stephanie's evening talk was one example of this sort of thing: considering computers in the light of the immune system. Cosmo pointed me to some excellent Small World ideas. Stephanie suggested David Ackley's work. I'd like two responses from you all: 1 - Pointers to work (papers/books) using complex systems to study computing and networking. 2 - Send me your own ideas about possible explorations. For example: - Scaling (as per this week's lectures) applied to scaling computer hardware, networks and software. - Entropy/Information study of software as it matures through successive refinements via SCCS revisions. - Small World approach to autonomous services. Ex: DNS done as a ring of neighbor/friend systems. - Napster/Gnutella failure analysis using complex systems tools. - Agent tools like Swarm/StarLogo applied to computer users as well as hosts. - Economic analysis of scarce resources in computing environments. I'd appreciate your thoughts here .. especially from the faculty; nudge, nudge. Also feel free to forward this to others, or send me addresses of folks to bother.
I received several interesting messages, which I include (w/ some
editing) here.
This is on the Collective Intelligence (Coin) project:
This takes aim at decentralized control:You might want to look at David Wolpert's work on what he calls ``collective intelligence,'' which he's been applying to network routing problems, among others. Looking him up at arxiv.org gives a couple of promising-looking papers; I remember liking the ``Intro. to Collective Intelligence'' when I read it. URLs for Wolpert papers: http://arxiv.org/abs/cs.LG/9908014 http://arxiv.org/abs/cs.LG/9908013 http://arxiv.org/abs/cs.MA/9912011 http://arxiv.org/abs/cs.LG/9905004
Another interesting response:One of the most obvious candidates for self-organising systems on a network is something like IBM's aglets. Agent-based distributed programming is best implemented using a complex systems approach. The simple agent approach without any overall control has not yet really been implemented to exploit global optimization by simple local rules. Computing without a central CPU is also interesting - ala Genghis robot built at MIT. This robot had a cpu for each leg and no central control - feedback interactions between the 6 leg controllers allowed it to learn a number of complex gaits observed in real cockroaches. Ant colony modeling of telecommunications distribution problems has been used successfully I believe. Computer networks don't fill 3D space so there scaling laws are probably quite different. I wonder if they are actually efficient. Maybe Geoffrey West's work would suggest modifications to the size and branching structure of internet's 'pipes'. In general, giving up central control usually simplifies the complexity of the programming problem, but leads to (both good and bad) unexpected results. In a way it is kind of analogous to programming a recursive algorithm. You don't really write a top-down description of the problem. Instead you just say what should be done in each particular situation (n = 0, n > 0 for example). This is often a much more simple way for the programmer to formulate a problem. One of the cooler distributed programs I have seen is a model in which the sub-problems were fish and these sub problems were collected and joined together by sharks which were collected and joined together by bigger sharks until the head honcho in the food chain spat out the final answer. They all swam around on a bunch of CPUs. Of course only some problems work this easily!
This is more directly oriented toward computing methodologies that are evolving in this area:In regard to scaling: I can tell you that scaling of systems is one of the banes of AI research. One reason why the field of evolutionary computation has come into existence is the belief that no intelligent machine system can be human engineered -- it's too big. That is, if we were to build it by hand, we would find that gradually more and more of the effort was going into debugging and less into adding new functionality. Thus, there may be a limit to how "complex" (as opposed to large or redundantly deployed via network) a program we can write, in general. This may be analogous to G. West's discussion of how much energy goes into sustaining an individual vs. growth. Surely, software design methodologies such as OOP provide help in eliminating certain types of bugs, but no one would claim that OOP is the key to solving the AI problem. The problem is that, without knowing the final form of the system _a priori_, design decisions made at one stage of construction will be found to conflict with newly-discovered needs at a later stage. Evolution faces this problem, too -- it just has a different method of debugging. (Even if we were to have a blueprint of the complete system, would we be able to comprehend it?) In regard to economic analysis of scarce resources: These sites might be of interest to you. http://www.ipmag.com/monthly/99-july/pollack.html http://www.jordanpollack.com/softwaremarket/
I think I mentioned Bernardo Huberman's book, "The Ecology of Computation". > Computers as community: using tools like Small Worlds and > 6-degrees of separation as a tool for understanding both computer > users and communities, and sets/communities of computers. There's a professor at UNM named Dave Ackley who is looking at this. He has a recent paper called "Real artificial life: Where we may be". It's on his web site: http://www.cs.unm.edu/~ackley/ Jeff Kephart at IBM is looking at "information economies" (market economies composed of multiple intelligent agents): http://www.research.ibm.com/infoecon/