Literature review is a big part of a scientific underatkening. Thanks to the Internet, most papers are available on line. This resulted (at least for me) in a big number of papers that I read and stored for feature references… Welcome to the age of data mining. As a researcher I have yet another problem on my hands: after I solved the problem of finding information, how do I keep track of it?

This subject was touched upon in other posts (bookmarking, mind maps, references). Given that my major focus of attention (at this moment) is my disertation, I want to be able to have a solution for referencing the information I have found. This basically has some sub-problems: creating references, searching through references, adding them to my documents (thesis, publications, reports), and creating list of references in my documents. I’ll skip discussion of why I was not satisfied with the above mentioned tools. Instead I’ll tell you what I see myself using: Zotero.

Long story short, this is a common scenario: I found a paper using Google Scholar (acm/ieee/etc). Two clicks and my reference is created (with all the author, title, abstract, etc. information added properly). Another click and I’m actually reading the paper. One last click and the pdf is stored with my reference (for feature review). If I found something interesting I can add notes. I can tag the reference (for feature searches). I also can link other references as related. The bottom line: creation of references is a smooth, easy and quick process.

There are plugins for OpenOffice.org Writer and Microsoft Word that allows one to use Zotero reference in the documents. The process of adding references to the text and creating refere lists is a two click deal (also smooth and quick). Installation of both plugins (for firefox and for Writer) was very simple.

For more information take a Zotero tour.

Alexander Shyrokov.

The Electrical and Computer Engineering Department at the University of New Hampshire now has a Facebook page. You can find it here.

Show your support for UNH ECE by becoming a fan! And of course, you can use the page to make plans for Homecoming and the ECE Department’s 100 year anniversary celebration.

Here’s the 10^100 website and a CNN story on the topic.

Andrew Kun

After a couple of days fighting with scarce documentation, the TouchKit project, which I have written about here, is finally operational. It was tested with a helloworld and a drawing application, which came with the system. Here, you can see my colleague Mark operating the touch screen, which reacts by putting a red circle at every location where the fingers touch the display. The size of the circles depend on the amount of force exerted. Very nice!

We have also tested how the system works in dark. It seems that there is not much difference, since the TouchKit camera reacts only to infra-red light. The system appears to be fairly robust in this sense. Here, Matt is experimenting with the multi-touch display:

The installation process was a little bit bumpy, because it is described on the TouchKit web site in a concise manner. After “googling” and downloading the drivers for the firewire camera, the exemplar code had to be edited before it became functional with the hardware. The TouchKit Forum was very helpful in keeping me on the right track.

After the basic functionality of the system was proven, Mark Taipan, Matt Lape (receivers of the SURF award, and distinguished P54 undergrad students) and I figured out, that the temporary screen clamping setup and camera mount are not robust enough to operate the system easily: if any part of the system (screen, projector, camera) moves, it has to be recalibrated. Therefore we began brainstorming about possible mounting solutions. For starts, we came up with a horizontal table-top mount which would allow the system to be securely fastened. Here is Matt with the proposed TouchKit stand:

It would be useful if the table would be “tiltable” for different applications. We are working on modeling and designing such a solution. Further results will follow here, on eceblogger.

Thanks to Matt and Mark for their help!

Oszkar Palinko

Here’s one for the books!  First, let me ask a few questions.  What do you do if your shiny new application causes your previously working system to crash?  Well, that’s simple, you search through your code for days, line by line, until some function returns an error, then correct for it.   What if you’ve searched through your code, turned days of searching into weeks, and your debugging techniques have only made things worse?  What if your system now fails randomly, or in applications which use to work?  What if it fails trying to load, trying to shut down, or at simple COM procedures in which failure is VIRTUALLY impossible?  What you should do is throw your application away and forget the whole thing ever happened, but we thought it would be better to take the other route, so let me shine some light on a very infrequent, system crippling, mobile disaster.

The majority of our deployments have been made on Symbol devices, with some running Window Mobile 2003 upon a Windows CE 4x framework and others utilizing Windows Mobile 5.0 upon Windows CE 5x.  The introductory paragraph held only when our system operated on the older version of Windows Mobile/Windows CE, which ended some of my frustrations since I could blame the failures on a possible limitation of an older operating system.  However, in doing so, my solution rested only upon an assumption, I had no evidence.  In hopes of seeking some expert advice, I created an MSDN forum entitle “Experiencing COM errors using Windows Mobile 2003”.  After some time, Christopher Fairbairn replied and referenced me towards an article entitled “Slaying the Virtual Memory Monster”.  The rest of this post may be a bit technical, but I’ll leave out as many details as I can.

What is virtual memory?  “Virtual memory is a computer system technique which gives an application program the impression that it has contiguous working memory, while in fact it may be physically fragmented and may even overflow on to disk storage.” – Wikipedia.  Basically, it’s a nice way of keeping everything in line.  In Windows CE 4x/5x, only 32 processes are allowed to be running at any one time, and a virtual memory (VM) space of 4GB is partitioned into many sections, allowing for each of the 32 processes to consume a possible 32MB.  These processes reside in locations called slots, where slot 0 houses the current process, slot 1 contains system (execute in place – XIP) DLLs, and the remaining 30 slots contain “resting” processes.  In the figure below, the “Active Process” section represents slots 0 and 1, and the “Reserved” section corresponds to slots 2-31. 

Now this is where things get tricky.  The figure below shows a more detailed layout of slots 0 and 1, and since it covers two slots, it represents 64MB of VM.  As I said before, the process to be executed is paged in from its “resting” slot to slot 0.  The base code of the process (executable – .exe) is loaded first and can be seen at the bottom of the figure, slightly above a small reserved portion.  Above this are various data and resource sections, along with dynamic heap and stack spaces, which grow upward as allocations are made within the process.  At the top of the figure, “COREDLL.DLL” and “Other XIP DLLs” can be found.  XIP DLLs begin loading at the top of slot 1 and continue in a downward manner, possibly overflowing into slot 0 (where the current process is).  Now, process specific DLLs are loaded at the top of slot 0 and also grow in a downward manner (shown by dashed arrows in the figure).  I’ve kept things somewhat simple in my description, so if you find yourself confused or want more VM detail, you may want to reference the articles at the end of this post.  To finish the thought, we have three different VM positions, all of which are moving toward a central location, a good recipe for a bad day.

Following the VM analysis methods proposed in part two of “Slaying the Virtual Memory Monster”, I created a script which visually and numerically organized the VM data of their dumpmem.exe program.  Shown in the upper portion of the figure below is slot 0 of the VM address space of Project54 under Windows CE 5x.  As we can see, there is space between the two blue, vertical lines, which is good!  The leftmost blue line represents the top of the process stack (which grows upward, or in this case to the right), while the blue line to the right marks the lowest DLL position (the lowest VM address occupied by system or process specific DLLs, which grows downward, or in this case to the left).  Segments shown in red are wasted memory segments due to a minimum VM page size, that is, the minimum allowable VM chunk granted when a DLL loads.  The bottom portion of the figure may depict the wasted VM space in a more appropriate manner, and is shown as an “Allocation request/return ratio”.  Confused?  Yes, so was I.

Slot 0 of Windows CE 4x, on the other hand (figure not shown), was entirely exhausted, and the two blue lines collide in VM.  This is what caused the craziness described in the introductory paragraph.  COM and memory related errors were occurring not because we were out of physical memory, but because we were out of VM.  The randomness of the errors was related to the way Project54 loads its applications, randomly.  The imaging application worked fine, it just happen to be that one application which used the last remaining pages of VM (the space between the blue lines). 

So, why would Windows CE 4x fail and not 5x?  Well, 4x has a VM page size of 64KB, compared to 16KB in 5x.  So as more DLLs were loaded, more VM was wasted, because most DLLs were much less than 64KB (remember that ratio I talked about?).  Desktop developers almost never have to worry about their utilization of VM.  They simply are not under the same restrictions.  But not to worry, Windows CE 6x aims to change everything…

References:

Slaying the Virtual Memory Monster - part 1

Slaying the Virtual Memory Monster - part 2

Windows CE .NET Advanced Memory Managment

Effective Memory, Storage, and Power Managment in Windows Mobile 5.0

Check out this video showing the Microsoft Surface in Sheraton hotels:

Apparently there’s one in Boston, and it looks like it’s the Sheraton next to the Prudential.

[via Interactive Multimedia Technology]

Andrew Kun

Today in my ubicomp course we’re discussing Adam Greenfield’s talk on Everyware given at Keio University in 2006. One idea that Adam presented was that of the Panopticon, a prison in which the prisoners never know if they are watched or not. Adam points out that inhabitants of a ubicomp world may feel this way unless we’re careful with how we design this world. Here’s the Panopticon from Wikipedia:

Watch the talk, or even better read the book Everyware, to find out what Adam suggests we should do to avoid a Panopticon-like world.

Andrew Kun

p.s. I had better luck with the 8-part YouTube version of the video (starting here) than with the Quicktime one.

Hello ecebloggers,

In my previous post I wrote about Naturalistic Driving and Analysis Symposium at Virginia Tech University. The most interesting event on the symposium was demonstration of the Smart road, a research facility managed by Virginia Tech Transportation Institute. It is a 2.2 mile twp-lane road with a capability to produce a wide range of weather conditions (see pictures below).

VTTI’s Smart road (just the bridge)

Fog

Rain

Smart road uses 500,000 gallon water tank which supplies 75 water towers to produce rain, a fog like mist, or snow. It is also equipped with variable lighting to study effects of lighting technologies on visibility (see pictures below).

Smart road’s lighting system

Rain by night

Of course, everything needs to be coordinated (weather, traffic, lighting). This is done in control room.

Control room

Control room (downstairs)

VTTI uses real cars in their experiments on the Smart road. They are measuring speed, traveled distance, lighting conditions… Almost anything you can think of. Examples of the equipment you can find in the cars are in the pictures below.

Thousands of hours of on road research have been conducted on th Smart road. It is intended to become a part of the public transportation system connecting Blacksburg, VA to Interstate 81.

Pictures from the conference can be found here.

Have a good one,

Nemanja Memarovic

I was just talking to Mark Taipan and Matt Lape who are working on an indoor navigation project that utilizes handheld computers. Their application allows users to see where they are on a map. Of course the small size of handheld computer displays limits the type of maps you can use. This is even more of a problem for many mobile phones (even smaller displays), which are likely to be the actual devices used in any commercially viable indoor navigation application.

One solution may come from projector phones such as this one. If you had a projector phone you could display a map on the wall and presumably get better resolution, or at least larger characters, than what you can get on a mobile phone display. It would be interesting to see if people would be willing to use such a system.

Andrew Kun

Our lab has recently acquired a TouchKit development system. It serves as a basic building block for creating multi-touch screen user interfaces. The TouchKit consists of an infra-red illuminated projection screen and a FireWire camera board. A projector has to be added to complete the system. Here is the initial setup:

The image shows the projection screen in front which is held upright by an improvised clamping board on its right side. The projector throws the image onto the screen from the back, allowing the user to interact from the front. In this initial setup the camera board is mounted on a box and connected to a PC using FireWire. The system has a really interesting principle of operation: as the user touches the front of the screen, the infra-red illumination coming from the inside of the screen changes. This change is picked up by the camera and is further processed by the software API, which is based on the OpenFrameworks C++ library.

Multi-touch user interfaces have become more popular recently with the introduction of technologies like Microsoft Surface, iPhone and CNN’s Magic Wall created by Peceptive Pixel Inc. The last one claims to be the most advanced multi-touch user interface. Here is a video showing its impressive capabilities.

We are still in the process of setting up and configuring our TouchKit system. We will post more information about it here when it becomes operational. Once this is done, it will be a great asset for students in the UbiComp course this fall at UNH taught by Prof. Andrew Kun. Students will be developing innovative user experiences based on the TouchKit as part of their course projects.

Oszkar Palinko