ECLiPSe had a project called Saros on sourceforge that aimed to provide all this functionality, plus a debugger. Unfortunately, I wasn’t able to get any of these features working in its 1.0 version (after installing it as a plugin in the IDE). I’ve also heard that development on Saros has stopped.

However, I would be happy just getting paren-balancing, and I found a way to do that in the Eclipse IDE:

1. Go to Window | Preferences
2. Select General | Content Types in the left pane, and then on the right, select Text in the Content Types list.
3. In the File Associations list below that on the right side, you should see “*.txt (locked)”. Click the Add button and add “.ecl” when prompted for the Content Type. Do this again for .pl files (or .pro files, as I prefer, to distinguish from Perl files).
4. Back in the left pane, select General | Editors | File Associations.
5. On the right side, add “.ecl” and “.pl” (or “.pro”) if they aren’t already present.
6. Select “*.ecl” in the upper list on the right. Then in the lower listbox, if “Standalone Structured Source Editor (default)” isn’t shown, use the Add button to select ”Standalone Structured Source Editor” and then click the Default button.
7. Select “*.pl” (or “*.pro”) in the upper list, and make sure it has the same default editor.
8. Click OK.

Now, if you open an .ecl or .pro file using either the Java or Debug perspective, and you place the text cursor after a ) or ] that is balanced, you will see a blue rectangle around the corresponding ( or [. There is no indicator if the ) or ] is not balanced.

Note that if you quit the IDE and launch it again, you will get a warning dialog about “Unsupported content type in editor.” I believe that’s because we selected “Text” in the Content Types preferences - there being no way to add a content type for ecl and pro files in particular - and that this resulted in our files being “locked” to the generic text editor in the File Associations preference. However, by marking the structured text editor as the default, we override that locking, and you’ll notice that if you dismiss the warning, paren-balancing still works. So, I selected the checkbox for “Do not show this message again” in the warning. Relaunching the IDE again gives me paren-balancing with no warning dialog.

UPDATE: Christian Wirth said on the eclipse-clp-users mailing list: “You have to install the Web Tools Project also.”

He also provides a Mercurial tutorial.

There are at least two plugins for the Eclipse IDE, and the more mature one seems to be HgEclipse.

buildEdges(MiddleNode, RightNode) :-
   LeftNode #< MiddleNode, %ECLiPSe feature: constrain LeftNode to be an int smaller than MiddleNode
   edge(LeftNode, MiddleNode),
   addEdge(LeftNode, RightNode),
   fail.

The reason that putting ‘fail’ at the end leads to iteration is that Prolog automatically searches for other ways of satisfying conditions, unless you tell it not to. So, if there is a fact matching the ‘edge’ pattern, and if ‘addEdge’ also succeeds, then when the interpreter reaches ‘fail’ it “backtracks” to the addEdge call to see if there were any unexplored ways of satisfying it (aka, it checks if there were any other “choicepoints”). If there were such unexplored options in addEdge, the interpreter tries the first one; if this succeeds, we return to ‘fail’; if the first one fails, it tries any others for addEdge. Once the options in addEdge are exhausted, the interpreter takes another step “upward” to see if there were any unexplored matches for the ‘edge’ pattern.

As you can see, forcing backtracking by putting ‘fail’ at the end of your conditions is one way of implementing iteration over a set of matching facts. But what you may not have expected, and what you probably don’t want, is for the interpreter to try calling ‘addEdge’ several times before looking for the next edge match. There are two standard ways of avoiding this:

1. Put a condition at the start of all definitions of ‘addEdge’ that allow it to be entered only under the intended circumstances. (This isn’t a good match for the current example, because you can’t specify a condition that says “only call me once when iterating over edges”.)
2. Put a cut (denoted with an exclamation point, !, in Prolog) at the end of all definitions of addEdge. A cut tells the interpreter to forget about any other choicepoints for this call of this predicate. Other tutorials about fail loops neglect to emphasize that the cut must be put at the end, because otherwise backtracking from the fail loop will explore any choicepoints remaining after the cut, even ones in your definitions of ‘addEdge’.

Side note: One can replace ‘fail’ with a condition to get do-while behavior instead of exhaustive iteration. And if one wanted to isolate a block of code for iteration (say, you want to avoid repeating the #< step), one could put “repeat,” at the start of the block, and then backtracking would never go above that point.

1. The current practice in OSs and browsers of asking the user at install time whether to proceed with the install, as a way of avoiding security threats, just doesn’t work. Users do not have the right kind of information at that time to decide.
2. The threat of compromised systems and data loss is severe enough that consumer and enterprise OSs will have to be designed in a different way to manage installation risks. The widespread acceptance of smartphone apps indicates that smartphones will need such protection, too.
3. Google’s NativeClient project is a good way of handling the risk because it provides a sandbox, and it’s better than alternatives like Java and Flash because it allows apps to run faster (because the apps are compiled natively rather than into bytecode).
4. Palm’s webOS for its new smartphones has a very similar design to NativeClient (and since NativeClient is open source, could be built on top of it, for all I know). Specifically, webOS’ plugin development kit (PDK) will allow allow apps written in C and C++, two languages which by themselves allow altering memory contents almost anywhere in RAM and thus open to abuse by malicious app coders, but the PDK will sandbox apps, apparently in much the same way that NativeClient does. WebOS’ other interface, the Mojo SDK, allows apps written in Javascript to access data on the phone in much the same way that NativeClient’s browser plugin design would allow.
5. Thus, webOS seems to provide a glimpse into what smartphone and desktop OSs will be like in coming years, if they deal with security threats in the inspired way detailed in the NativeClient design.

And there’s another force pushing Google’s Android smartphone OS in the same direction as webOS:

1. Google always seems to prefer keeping its apps as platform-agnostic as it can by leveraging browsers when it can. The exceptions are Google Earth, GTalk, etc which must be installed either for performance reasons or to gain access to “hooks” in the OS that browsers can’t offer.
2. Google’s apps for Android are Java-based (i.e., not browser-based) for apparently no strong reason. In fact, it seems that if Google had had Palm’s insights about how a web-oriented OS could be made back when Android was being designed, then Android would be very much like webOS so that Google wouldn’t have to split its app-building competence and resources across so many platforms (of course, the iPhone and Blackberry platforms would still make their own demands). Google’s efforts to build ChromeOS is another strong bit of evidence of its desire that there be fewer platforms and that they resemble browsers more.
3. Eric Schmidt has said that Android and ChromeOS will eventually merge. I’m not sure if he came to this conclusion before or after learning about the design of Palm’s webOS, but webOS seems like a good hint of what such a merge would result in.

Am I pulling too hard on thin threads, or does this paint the same strong picture for you that Palm’s webOS really is a glimpse of the future? It sure is a fun way for me to stretch my thinking about what smartphones can do and be.

If this is an accurate prediction, then two consequences come to mind:

1. The current unspoken practice of web engineers looking into the Javascript source of their competitors, learning new tricks, and helping the craft of web engineering to improve will suffer because companies will want to shift their presentation and business logic out of Javascript and into compiled native code for greater performance and out of a misguided attempt to protect their intellectual property.
2. Having Google compete in the same idea space will help inspire both toward even better ideas. Of course, Google won’t buy Palm (why would it need to?), and it’s unlikely that having similar platform designs will affect the market share of either of them. As long as Palm can capture a significant share of the growing global demand for smartphones, it should be able to survive. And it’s likely to always have an advantage over Android in the beauty of its UI, given the DNA of the two companies.

UPDATE: Google released an “NDK” for Android way back in June 2009, which sounds like webOS’ planned PDK and also sounds like it was built on NativeClient. So, my prediction above that webOS is the future of Android has things a bit turned around.

Also, although the NDK seems to have a very similar design to NativeClient, and might have been built on NaCl, I’m somewhat doubtful because NaCl relies heavily on a feature known as “segmented memory” in the 386 chip architecture, and I wonder if that same feature is present in mobile CPUs such as ARM.

UPDATE: Other devs are worried that we might lose the ability to view html source and thus lose one of the primary learning and innovation paths for web app devs.

1. Make sure you haven’t hidden any launch configuration types
   1. Go to the top menu bar and select Window | Preferences.
   2. In the left pane, select Run/Debug | Launching | Launch Configurations. On the right side, make sure that Java Application and TestNG are shown and not checked. (You may have to check ‘Filter checked launch types’ temporarily in order to scroll or uncheck some items.)
2. Make sure the class(es) you want to test have @Test annotations in them
   1. If you want to see an example, look at the SimpleTest class definition near the top of the TestNG homepage.
   2. Note that in SimpleTest, it’s not necessary to include an @BeforeClass annotation anywhere, nor is it necessary to include “(groups …)” after the @Test annotations. And rather than importing all of “org.testng.annotations.*”, you may be able to get away with just importing “org.testng.annotations.Test”.
   3. To support the @Test annotation, the IDE will want to add the testng-jdkNN.jar (where NN is 15 if you’re using JDK 1.5) to your project’s classpath.
   4. Any methods you want to be used as tests should be marked as public, so TestNG can invoke them.
      • If you don’t make any test methods public, then when you run your tests, the TestNG tab near the console tab will show that zero tests were run.
3. Create a launch configuration for your test
   1. Go to the top menu bar and click the down-facing black triangle to the right of the Run button (a green circle with a white triangle in it). This should trigger a dropdown menu that includes “Run Configurations…” Select it.
   2. Select TestNG in the left pane, then click the New button in the upper left (the white rectangle with a yellow plus in the upper right). Enter a name for the new launch config; if your test will use just one class of test methods, that class name would probably be a good choice as a memory aid.
   3. Under the Test tab, browse to the “Project” of the test, and then select a “Run…” target. (For example, if you’re trying things out with SimpleTest, you should have created a new empty project, pasted SimpleTest.java into it, and now use the Browse button for Class to select SimpleTest.java.)
   4. If you need to provide any arguments to the JVM before the test is launched, do so under the Arguments tab.
   5. To save your edits, click Apply. When you’re done editing, click Close (or you could execute the test by clicking Run).
4. Verify that the test is setup correctly
   1. Run the test by selecting the black triangle again near the green Run button, and then selecting the launch config you just named.
   2. The Console tab should show

      [Parser] Running:
        pathToYourProject\ProjFolder\temp-testng-customsuite.xml

      The name of the xml file shown here is what TestNG generates if your launch config doesn’t use the “Suite” option and you didn’t provide your own xml file.

      Following that will be any System.out printing your test methods did, plus

      PASSED: testMethodName

      for any of your test methods that passed.

      Finally, there will be a summary report like this

      ===============================================
          SimpleTest
          Tests run: 2, Failures: 0, Skips: 0
      ===============================================

   3. A similar, more graphical view of the summary report should be available under the TestNG tab.
   4. If the report says “Tests run: 0″, double-check that your @Test annotations are on the right methods, and that those methods are public.

As a quick introduction, you might want to read the Wikipedia page on Force dynamics.

[Why do we think Talmy's work might be useful to us? We are looking for folk concepts of space, time, causality, and intention that we can formalize and use in a computer simulation of how people attribute causality and intentionality to figures in simple animations. Talmy's work might provide articulations of the folk concepts we are after. A primary challenge for us is to identify concepts of interest to us (i.e., those that trigger expectations or that are necessary to support explanations) , because most of the concepts that Talmy identifies are powerful generalizations of distinctions made in language but which have little apparent causative power that shapes our thinking. For example, the distinction between moving-to and moving-from seems to have little effect on our expectations of what the moving object will do next, while the distinction between contact and attachment clearly affects our expectations of how two objects will move if rotated, say, around their common center of gravity.]

All page references refer to his book, Toward a cognitive semantics, volume 1.

Glossary (sorted in order of appearance, not alphabetically)

• veridical - appearing to be true (100c)
• factive - When two representations of the same thing are contradictory, the one that appears more true is called “factive” (100d)
• fictive - When two representations of the same thing are contradictory, the one that appears less true is called “fictive” (100d)
• fictivity - there exist multiple conflicting representations of the same thing, some of which seem more true than others
• see vs sense - When two percepts of the same thing are contradictory, and one is less palpable and thus more fictive, Talmy calls the perception of the factive one “seeing” and the perception of the fictive one “sensing”. (102a). For example, a static Pac-Man quasi-circle shape is “seen” while the dynamic alternative of a circle having a wedge cut from it is “sensed”.
• ception - A continuous conceptual space whose dimensions are all related to palpability (aka, the ability to recognize or act on something). (102b)  Intended as a replacement for arbitrary pigeon-holing of phenomena as one of sensation, perception, or conception. (139d)
• constructional vs experienced fictive motion - “Languages systematically and extensively refer to stationary circumstances with forms and constructions whose basic reference is to motion;” however, there are “differences over the degree to which such expressions evoke an actual sense or conceptualization of motion [in their speakers].” (104c)  While some speakers would report a strong sense of movement for a construction that other speakers would report feeling no such sense, there are some constructions that evoke a sense of motion in almost all speakers.
• active-determinative principle - For “some” [119b] emanation types of motion, the source role will usually be attributed to the more active or determinative candidate objects. For example, in a radiation path between the Sun and one’s hand, the Sun is perceived as the brighter of the two, and thus the more active, and thus given the role of source. “This principle accounts for the absence of any linguistic formulations that depict the sun as drawing energy from objects.” (117c) “One’s experience of the characteristics of agency may provide one with the model for the active-determinative principle” (119d)
• extramission - “the notion that sight involves something emerging from the eyes” (124b) “The conceptual model in which the Agent emits a sensory Probe appears to hold sway in the cartoon imagery [of Superman's X-ray vision].” (125b) Similarly, the expression “to look daggers at” or “the evil eye”.

Notes

1. When fictivity is present, the representations often differ in a single dimension. (100e)
   • State of occurrence - whether something is present or absent
   • State of change - whether something changed or was in stasis
     • State of motion - whether something moved or not (”stationariness”)
2. There is a general cognitive bias towards dynamism; i.e., things appear to move when they are in fact still, rather than things appearing to remain still when they in fact have moved. (101b)
   • For example, an utterance and a belief might be contradictory, and where greater credence is given to the belief, and the utterance indicates movement while the belief indicates stationariness: “That mountain range goes from Canada to Mexico.”
3. “Fictive motion in language encompasses a number of relatively distinct categories” (103c), including:
   1. Emanation - ”The fictive motion of something intangible emerging from a source.” (105d) “In most subtypes, the entity continues along its emanation path and terminates by impinging on some distal object.” Note the reliance on distal objects in all the examples below.
      1. Orientation paths - “A continuous linear intangible entity emerging from the front of some object and moving steadily away from it.” E.g., “She crossed in front of the TV.”
         1. Prospect paths - e.g., English verbs “face” and “look out”
         2. Alignment paths - e.g., English verb “lie” with path prepositions “toward” or “away from”
         3. Demonstrative paths - e.g., English verb “point” with path prepositions “toward” or “away from”
         4. Targeting paths - An agent aims an object that has a front so that the front follows a desired path “relative to the object’s surroundings” (109d)
         5. Line of sight - E.g., English verbs “look” and “turn” with path prepositions ”toward” or “away from”
      2. Radiation paths - (skipped pp. 111-116)
      3. Shadow paths -
      4. Sensory paths -
   2. Pattern paths - (skipped pp. 129-138)
   3. Frame-relative motion -
   4. Advent paths -
      1. Site manifestation -
      2. Site arrival -
   5. Access paths -
   6. Coextension paths (e.g., see mountain range example above) -
      1. Talmy83: Virtual motion
      2. Jackendoff83: Extension
      3. Langacker87: Abstract motion
      4. Matsumoto96: Subjective motion
4. “Palmer (1980) and Palmer and Bucher (1981) found that in certain arrays consisting of co-oriented equilateral triangles, subjects perceive all the triangles at once pointing by turns in the direction of one or another of their common vertices. Moving the array in the direction of one of the common vertices biases the perception of the pointing to be in the direction of that vertex.” (123b)
5. Anthropologist Pascal Boyer’s study of “ghost physics” (1994) - Belief systems characteristically permit some exceptions to normal physics, such as invisibility or passing through walls, but not other (barely!) conceivable exceptions such as “reverse causality”.
6. The semi-abstract level of palpability (146)
   1. Sensing of object structure, e.g. envelope/interior similarity across magnitudes of volcano and thimble
   2. Sensing of path structure, e.g., similarity regardless of shape of “across” when a deer runs straight across a field or zig-zags across it
   3. Sensing of reference frames: earth-based, object-based, or viewer-based
   4. Sensing of structural history and future (object is stationary), e.g. a broken flower pot
   5. Sensing of projected paths (object is moving), e.g. a thrown ball currently arcing through the air, or a path through a crowded restaurant
   6. Sensing of force dynamics, e.g. perceived forces among objects thought to naturally be in motion or at rest. Jepson and Richards (93)  found a sideways T is thought to have its two parts “attached” while in an upside-down T, the two parts are perceived merely to be in “contact”. [See Siskind's AI work on attributing support vs attachment.]
7. (skipped pp. 154-172, which is the rest of the chapter on Fictive Motion in Language and “Ception”)
8. Motion-aspect formulas - e.g., Be at, Move to, …, Move from-along (215-6, 245-52)
9. (skipped to 409)
10. Force dynamics (to be continued)

• Easily embedded in a Java application (via a jar that implements a JNI bridge to the native ECLiPSe executable) that allows for loose coupling through queues-and-listeners or even asynchronous queues.
• Similar library support for manipulating terms, strings, lists, etc as other Prolog flavors
• An Eclipse IDE plugin, Saros. (It’s not quite usable for me in its current stage but I hear a new version is imminent. And it has a Tk-based UI including debugger that’s pretty good.)

Here are the changes I had to make to my Amzi code so it would run in ECLiPSe:

• Changed all calls using consult/1 or debug_consult to [...comma-separated filenames...]
• Changed ‘/’ when used in predicate names to ‘_’
• Changed import(list) to import(lists)
• Changed all abolish calls to retractall (although this doesn’t seem absolutely necessary)
• Changed string_term(String,Term) to term_string(Term,String)
• Changed stringlist_concat calls to concat_string
• Discovered that many of my variables were singletons, and changed them to start with ‘_’ (so they would be self-documenting singletons and not trigger a compiler warning)
• Added dynamic declarations for all my dynamic predicates (Amzi probably doesn’t provide a warning when these are asserted or retracted without having been so declared)
• Changed my (retractall(predicate(_,…)) ; true) pattern to just retractall(predicate(_,…)), since retractall never fails in ECLiPSe

I’m grateful to Dennis Merrit and Chip Eastman of Amzi for all their help in getting my initial Amzi app working, and for their excellent documentation of Prolog and Building Expert Systems.

I’ve been evaluating animation toolkits with a few objectives in mind:

1. Creating such 2D animations must be as easy as possible
2. It must be possible to inspect such an animation programmatically to determine where each shape is in each frame. (We are creating a simulation that will “watch” the same animation, but instead of observing pixels it will read such data.)
3. The animations must be easily distributed, such as being able to run in most browsers on most platforms using no plugin or only a commonly installed one

Here are my evaluations.

Adobe CS4 Flash Professional

PROs

• Flash files (SWF file format) are playable on most platforms using the Flash Player browser plugin, which most people already have installed
• There are many online tutorials about how to create animation using this toolkit, and expertise with the tool is widespread (so it would be easy to find help or hire someone)
• The “motion tween” feature available in the CS4 version eliminates the need to copy/paste/tweak each frame into the next frame; instead, one just drags from the starting position to the ending position, and can add arbitrary curvature at many points in between by pulling on edit points.
• Although it’s a binary file format, the SWF format has been documented by Adobe, and there is an open-source Java library, JSwiff, that provides handy wrapper accessors. It even has a forum for questions about JSwiff, but answers seem infrequent.
  • This library is a little out of date, since it refuses to process files using SWF versions after 8, but the code seems capable of handling version 10 just fine (version 10 is what CS4 Flash Pro generates). To use the library with more recent SWF versions, it seems one has to edit the source (included in the download) by changing SWFDocument.setVersion to eliminate the max version check, and then build one’s own jar file. This method refers to private member “header”, so one can’t just subclass SWFDocument and override the method.
  • The JSwiff site also offers a separate download for its inspector.bat, which provides a GUI for inspecting all tag content of a SWF. Surprisingly, it works on SWF version 10; I’m not sure how it gets around the version check.
  • Note: There is another Java library, JavaSWF, but work on it seems to have stopped around 2005 and it doesn’t handle recent updates to the SWF file format such as the DefineShape4 tag. There is a JavaSWF Yahoo group, but it seems answers are rarely provided for any questions in recent years.

CONs

• Adobe’s tool costs US$700.
• There is an option to Export Motion XML, which seems like a good alternative to the Java wrapper, but despite multiple attempts I couldn’t get it to include information about each frame of my test animation.

Alternative SWF toolkits

For example,

AnimeStudio Debut6

Swish MaxMini

Synfig

Toufee

PROs

• At US$50-150, much more affordable than Adobe’s toolkit

CONs

• Harder to use than Adobe’s toolkit because they require copy/paste/tweak of each frame of motion, and there is  no motion guide unless one sketches a path using the drawing tool and then erases that path.
• Toufee’s min frame rate is 1 frame/sec, which is far too slow for my needs. It also has a number of bugs such as having random transition effects on by default, and making it impossible to configure an object to disappear faster than in 5 sec in the first frame
• Although Synfig is an open-source SWF-creating toolkit, which would otherwise make it very attractive, it has such a convoluted install process for Windows that I’m not willing to put my time into evaluating it further. It seems likely that it could just break someday, and there would be too little interest in Windows users to expect them to fix it.

Alternative web-based animation platforms

For example,

HTML5’s canvas element + Javascript

Java

Microsoft Silverlight

PROs

• Inexpensive (free) toolkits
• Easily distributed and demo’d

CONs

• Would require investing significant time or hiring funds into programming animations largely from scratch
• Would require significant effort to design a way that an outside application could inspect what objects are depicted and what is happening

K-Sketch

PROs

• Free, open-source, and allows for easy creation of motion paths
• Allows export to SWF

CONs

• Motion paths aren’t editable — one needs a very steady hand
• Current release won’t run on my XP machine, and on my Vista machine the lasso selection tool doesn’t work, which means I can’t create any motion paths. Not actively supported right now, but that might change soon.

Bottom line: Assuming one can afford Adobe’s Flash toolkit, the combination of it and the Java wrapper seem like a very workable solution.

Tip: If you need to control the playback of an SWF using Java, it seems the best option is a hack where a native SWF player like XULRunner is controlled by Java by injecting Javascript. Have a look at the DJ Native Swing project. It’s hosted on Sourceforge and has discussion forums there.

A font has been developed that reduces the amount of toner used while minimizing loss of readability. The download page includes tips on how to install on a variety of platforms, and here’s a tip for installing a font in Windows 7. Note that after clicking the “Install” button for a font, there is no indication of success beyond the Install button becoming disabled — although you can open the Fonts control panel to verify success.