1. Go to your mobile phone’s dialer pad
2. Enter **61*1389**30# and then press the Call button. (Change ’30′ to whatever number of seconds you want the rings to last, up to 30.)
3. No call will be made but you should see a text confirmation.

Some bloggers indicate that one can go up to 60 seconds if one disables voicemail. (If you are a business, please don’t disable your voicemail. Providing your hours of operation in your voice greeting is very helpful.)

I’ll focus here on Motion Computing’s M1400 tablet. I found one for $99 on eBay with its original digitizer pen and Windows XP installed. One or two owners before me had experimented with it, because there was no apparent way to open the Input Panel to use handwriting rec, the device buttons didnt work (except the power button), and the virtual keyboard would open only if I booted with an external keyboard attached and entered Ctrl+U during boot to activate the Utility Manager and turn on the virtual keyboard. A further problem with the hardware itself was that it got quite hot while in use, too hot to keep in one’s lap.

Installing Windows7 (the lowly Home Premium variant is sufficient) solved all of the software problems, and the device no longer gets more than mildly warm.

One new problem is that the display cannot be rotated to portrait orientation, because Intel refuses to release an updated video driver for this CPU chip for Windows7. However, some people have had success running the video driver in XP Compatibility mode, which requires installing the Professional or Ultimate variants of Windows7. I recommend installing Comodo Time Machine after the OS install and before any changes to drivers or registry settings, so you don’t have to reinstall the OS in case of an error.

By the way, I had never heard of Motion Computing before buying this device, but I am very impressed by them. They provided free tech support for a product they hadn’t sold in 5 years, it was very quick, and very thorough. If they offer a 12+ inch Windows8 tablet, especially if it has a color eInk/LCD dual display, it’ll be the first one I consider buying.

If landscape-only orientation is okay with you (and possibly no audio), here’s what you need:

• Motion Computing M1400 tablet
• Windows7 Home Premium installer software
• external usb-connected keyboard with arrow keys
• CD/DVD external usb-connected drive (or 4GB usb drive + laptop/desktop with CD/DVD drive)
• Ethernet cable to your router

Follow these steps:

1. The following procedure will NOT leave your files on the tablet in place. Many of them will be moved to c:\windows.old, but you should probably make a backup copy of any that you would hate to lose.
2. If you use PDF XChange 4.0 (but not the portable version), and if you have a session that you want to remember (i.e. a set of open PDFs), then be sure to note down the filepath of each (in addition to backing up the file itself in step 1 above). Although this PDF viewer is great, they don’t yet support session backup (nor syncing).
3. If you don’t have an external CD/DVD drive, you’ll need to make the usb drive bootable. Don’t forget to copy all the installer software to it.
4. Connect the external keyboard and the external drive.
5. Make sure that the tablet can boot from the external drive:
   1. Reboot the tablet and the white Motion Computing screen appears, hold the digipen tip to the screen. A context menu should appear; select Launch System Setup.
   2. The PhoenixBIOS Setup Utility should open. Tap the Boot tab along the top.
   3. If you’ll be using an external CD/DVD drive, then “CD-ROM Drive” should be listed higher than “+HDD”. If it’s not, then look at the bottom and tap the white down arrow to the left of Select Item until CD-ROM Drive is highlighted in white, then tap the + to the left of Change Values to move it up the list.
   4. If you’ll be using a bootable usb external drive, then tap the white down arrow until +HDD is highlighted in white. Tap the white Enter to the left of “Select > Sub-Menu”. A submenu should open below HDD, and the external usb drive should be listed above the hard drive; if it’s not, tap the white down arrow until the usb drive is highlighted in white, then tap the + to move the usb drive higher in the submenu.
   5. When finished, tap the white F10 at bottom right to save and exit. A yes/no confirmation dialog will appear. Click yes. A beep will sound and you should exit to the Windows bootup process on your external drive.
6. At this point, the digipen was no longer recognized for me, but the arrow keys on the external keyboard did.
7. When you are prompted whether to enable WindowsUpdate, I recommend not doing so. It’s a great feature, but when I did this procedure the first time and turned this feature on, the installation of Windows7 SP1 introduced a bug that made several applications give errors about not having the right permissions, or not having enough space on disk, and I could not uninstall some apps like Comodo Time Machine, either.
8. During the install process your machine will reboot, and if you booted from a usb drive, you’re going to boot from it again (unless you’re quick and yank it). If you do boot back into the install dialog again, just move the power switch to off, yank the usb drive, and power on. Installation will pickup from where it should.
9. Once Windows7 is installed, use the Ethernet cable to connect to your router so you can get drivers, especially a wifi driver. The external usb drive and keyboard can be disconnected.
10. To get drivers, go to Start | ControlPanel | DeviceManager, hold down the pen button while clicking on Display Adapters (i.e., do a right-click), and select “Scan for hardware changes”. This should trigger a search on Microsoft/manufacturer sites for all the drivers you need, not just display adapters. If you turned off WindowsUpdate during install, you’ll get no drivers at this point and should click the Change Setting button, then the Yes radiobutton. You should get drivers for:
    • Intel PRO Wireless 2200BG Network
    • Motion Computing Tablet PC Buttons
    • AuthenTec AES2501 (fingerprint sensor)

    Even with this, I could not get drivers for:

    • Video controller
    • Multimedia Audio Controller
    • PCI Modem
11. You should now have wifi connection ability, so the Ethernet cable can be removed.
12. By default, if one holds the digipen to the screen for a short while, it will be interpreted as a right-click. This is a problem if one uses a multi-level dropdown menu and wants to select anything other than the first item in one of its submenus. To disable this, go to Start | ControlPanel | Pen And Touch | Pen Options, highlight “Press and hold” in the list, and click Settings. Turn off the “Enable press and hold for right-clicking” checkbox.

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)