I denne rapport præsenteres resultaterne af et kvalitativt studie om koncentration ved forretningsorienterede opgaver med IT. Koncentration er evnen til at fokusere eller rette opmærksomhed mod ét punkt med udelukkelse af uvedkommende punkter.

Målet med undersøgelsen er at afdække hvilke faktorer der indvirker på koncentration, hvilke sammenhænge der er imellem disse faktorer samt at danne teori ud fra disse observationer.

Undersøgelsen tager udgangspunkt i grounded theory som præsenteret i Bacis of Qualitative Research af Anselm Strauss og Juliet Corbin. Målet er altså at danne teori fremfor at validere eksisterende hypoteser. Teoriudviklingen er baseret på otte semistrukturerede enkeltpersoninterviews af en halv til en hel times varighed. Informanterne består af tre kvinder og fem mænd i aldrene 24 - 43 år med forskellig grad af uddannelse.

Resultaterne viser en klar forskel på koncentrationsopgaver imod almindelige opgaver. Der er evidens for at koncentrationsopgaver er relativt mere kognitivt krævende eller har højere kvalitetskrav i forhold til almindelige opgaver. Desuden præsenteres en lang række faktorer som har både negativ og positiv indflydelse på muligheden for at kunne koncentrere sig om en given opgave. Disse faktorer kan opdeles i to kategorier - praktiske forhold og omstændigheder. De praktiske forhold vedrører de håndgribelige ting omkring opgaveløsning; dette er faktorer som miljø, situation og programmel. Omstændighederne er de faktorer som danner rammerne for opgaveløsning generelt - dette er faktorer som opgaveløserens personlighed, arbejdsrolle, selve opgaven samt hvilke foranstatltninger der tages i brug for at reducere negativ indvirkning fra de praktiske forhold.

Herudover viser resultaterne to interessante egenskaber ved personers forhold til koncentrationsopgaver. Opgaveløserne er i høj grad begrænset af evnen og viljen til at være koncentreret over længere tid - informanterne benytter sig af bevidste strategier som at opdele opgaver i brudstykker, og en ubevidst trang til overspringshandlinger.

De gjorte observationer omkring faktorerne og deres sammenhænge benyttes afslutningsvis til at udarbejde et bud på en samlet model for koncentration i forretningsorienterede opgaver med IT.

I alle disse ovenstående resultater spiller IT en stor rolle. Det argumenteres at IT og især computere danner et rammeværk for opgaveløsning generelt; computere er altså ikke et tilvalg, men et krav for opgaveløsning i vores samfund. Det er altså vigtigt at være bevidst om denne rolle for at kunne reducere den overvejende negative indvirkning som teknologien har, på muligheden for at vi kan fordybe os i udfordrende opgaver.

Download the comlete paper

This is my masters thesis completed in january 2009.

Abstract

The use of wall-size displays are becoming increasingly popular due to declining prices and high availability. However, many questions about how to effectively interact with and utilize wall-size displays still exist. Based on insight from the literature I have developed a novel interaction technique and tailored information visualization for wall-size displays. The technique utilizes users’ embodied resources such as opportunity of physical navigation and increased peripheral vision. The user is tracked relative to the display and her position and movement are used as primary method of interaction. Results of a empirical study comparing two approaches to physical navigation with a gyroscopic mouse show no significant difference between the approaches in terms of efficiency, accuracy or satisfaction. Analysis suggest that technical issues with the implementation hindered the two user tracking approaches from exploiting their full potential.

Download the complete thesis with high quality photos, 33.2 mb

Donload the complete thesis with low quality photos, 1.9 mb

In a multiscale interface like PAD++, normal, geometric zooming simply changes the size of objects in the view. In semantic zooming, objects change appearance or shape as they change size. For example, a growing dot will become a simple box, then a box with a one-word label, then a box with a longer label, then a rectangle filled with text and pictures. The goal is to give the most meaningful presentation at each size.

This paper (in danish) presents a semantic zooming approach to visualization of data tables - specifically on time series data. The semantic approach uses a technique of collapsing cells, columns and rows to reduce the amount of information visible at one time. Collapsed cells show the underlying data in different formats such as average, average yearly growth rate, etc.

An user study with seven participants has been carried out as to evaluate relative performance of a semantic zooming approach as opposed to a regular geometric zoomable interface.

Below is the report (in danish) and source code for the semantic zoomable prototype application. The prototype application uses Piccolo .NET.

Download the full paper in Danish (PDF)

Download the source code for the SemanticZoomSheet prototype application

Fisheye views is a visualization technique in which information in focus is clear and of normal size, while information surrounding it is progressively miniaturized and distorted, thus allowing presentation of more context within a limited screen size.

This paper describes a novel approach to fisheye visualization of source code. We redefine how elements for emphasization are chosen by using a dynamically defined degree of interest function. We propose a dynamic degree of interest approach, D-DOI, derived from user interaction history.

This report accounts for the development of this D-DOI approach by discussion of alternative approaches, design choices and the construct of dynamic and working sets. An empirical user study with eight participants has been carried out as to evaluate the relative performance of a static approach, S-DOI, and the proposed D-DOI approach.

A video presentation of the implemented interface in action are available in various formats from http://www.thomassidor.com/CodeFish

Download the full report in English

Download the source code for the CodeFish prototype application

Download at: http://sourceforge.net/projects/sdlsand/

The project has been ported to a multitude of platforms - just search google.

This is one of my first shots at writing a extensive form control and the source code may therefore be subject to rich optimization possibilities. The component is open source and can be used free of cost for non commercial projects. Credits to the real author, me, will be much appreciated.

Download the TradeOff demo application

Download the source code for TradeOff and the graphing module

How to use the component

The graphing component consists of two parts - the main graphing area control, implemented in the Graph class in Graph.cs and the data channels (actually the graphs to be shown) implemented in the DataChannel class in DataChannel.cs. The sample application TradeOff is a little game made to demonstrate the use of the graphing component.

The use of the component is straight forward. First of all, insert the control in your form. Hereafter you can use the Graph class’ methods for creating data channels and inserting values and events. Take a look at Game.cs for inspiration.

Methods and fields

DataChannel class

Graph class

Points of clarification

The component include some procedures that might need clarification, which this section is intended to provide.

The working of data channels

A crucial part of the graphing component is the data channels (graphs). These are implemented in the DataChannel class and are basically a feature extended queue (the class inherits from the Queue class). The queue is limited to containing a set amount of data (this property is maintained by the graphing module - and could be disabled if you want to save all inserted data, look in the code piece of the ‘Adjusting y-axis scale’ below, line 11) and a local min and max value is maintained on enqueueing and dequeueing.

Besides the value queue there is visible-, name- and color properties - and the channel can easily be extended to contain even more use specific features.

Lastly there is the event feature of a data channel. This feature allow you to insert special events at a current point in time (it is not possible to add, edit or remove future or past events) like the trading of a good in the TradeOff application. A event is added as a simple string using AddEvent(string) and is stored in a temporarily list. It is therefore possible to insert multiple events at the same point in time. The temporary list is at value enqueueing inserted in the events queue.

Adjusting y-axis scale

The scale of the y-axis is automatically adjusted to display the graphs relative values - ie. the maximum and minimum values of the y-axis corresponds to the maximum and minimum values of all the graphs. Although this will cause the y-axis values to change over time - as new graph values are inserted, this can easily be redesigned to keep a static or partly static y-scale. As for now - with the current implementation there’s a few extra steps to be taken when inserting new data to a graph - that is, we have to update the min. and max. values in the graphing module. This is done easily by comparing to the current min and max to a newly inserted value - in the following method, line 8 and 9.

   1:  // Adding a value to a given graph. (Moving time forward)

   2:  public void Insert(int index, double data)

   3:  {

   4:      DataChannel dc = (DataChannel) _DataSources[index];

   5:      dc.Enqueue(data);

   6:      if ( dc.Display )

   7:      {

   8:          _HighestValue = Math.Max(_HighestValue, data);

   9:          _LowestValue = Math.Min(_LowestValue, data);

  10:      }

  11:      if ( dc.Count >= _TimeSpan )

  12:      {

  13:          double deq = (double) dc.Dequeue();

  14:  

  15:          if ( dc.Display )

  16:          {

  17:              if ( deq == _LowestValue || deq == _HighestValue )

  18:                  FindMaxMinValues();

  19:          }

  20:      }

  21:      this.Invalidate();

  22:  }

Notice also that if the newly inserted value implicitly causes a forward shift in time (Number of inserted values greater than the specified time span - line 11) then we dequeue a element in the data channel. If the dequeued element is either the currently overall minimum or maximum we update these values using the FindMaxMinValues-method. The FindMaxMinValues method iterates through the data channels looking for the overall max and min values - only checking the data channels internal max and min values (which are maintained on enqueueing and dequeueing of data as mentioned above.

The TradeOff application implementation specific parts

The application TradeOff (see below) is used as a test bed for the application, and the component therefore might include code parts specific to this application. These minor implementation specific parts should easily be changed.

Drawing markers and info box

The component, as mentioned earlier, supports real time tracing of graphs using the mouse. The following method is responsible for this:

   1:  // Drawing a marker at the nearest graph value to the mouse pointer

   2:  private void DrawMarker(MouseEventArgs e)

   3:  {

   4:      if ( _MouseDown )

   5:      {

   6:          this.Refresh();

   7:          int xOffsetLocation = (int) Math.Round(e.X / _OffsetX );

   8:          double MinDistance = int.MaxValue;

   9:          int MinDistancePosition = 0;

  10:          bool MarkerFound = false;

  11:          double MinDistanceValue = 0;

  12:          string MinDistanceName = "";

  13:          string[] MinDistanceEvents = null;

  14:          // Looking for the nearest graph and point in time

  15:          foreach ( DataChannel dc in _DataSources )

  16:          {

  17:              if ( dc.Count > xOffsetLocation && xOffsetLocation >= 0 && dc.Display )

  18:              {

  19:                  double CurrentValue = (double) ( dc.ToArray() )[xOffsetLocation];

  20:                  int CurrentYPosition = CalculateY(CurrentValue);

  21:                  int CurrentDistance = Math.Abs(e.Y - CurrentYPosition);

  22:  

  23:                  if ( CurrentDistance < MinDistance )

  24:                  {

  25:                      MinDistance = CurrentDistance;

  26:                      MinDistancePosition = CurrentYPosition;

  27:                      MinDistanceValue = CurrentValue;

  28:                      MinDistanceName = dc.Name;

  29:                      MinDistanceEvents = dc.GetEvents(xOffsetLocation);

  30:  

  31:                  }

  32:                  MarkerFound = true;

  33:              }

  34:          }

  35:          // When point and graph found, draw the marker

  36:          if ( MarkerFound )

  37:          {

  38:              string DrawString = String.Format("Good: " + MinDistanceName +

                                          ", Price: {0:c}", MinDistanceValue);

  39:  

  40:              if ( MinDistanceEvents != null )

  41:              {

  42:                  // adding events to info to be displayed

  43:                  DrawString += "\n";

  44:                  for ( int i = 0; i < MinDistanceEvents.Length; i++ )

  45:                      DrawString += " + " + MinDistanceEvents[i] + "\n";

  46:              }

  47:  

  48:              Graphics g = this.CreateGraphics();

  49:              g.SmoothingMode = SmoothingMode.AntiAlias;

  50:  

  51:              int X = (int) Math.Round((xOffsetLocation+1) * _OffsetX);

  52:              int Y = MinDistancePosition;

  53:              int MSH = MarkerSize / 2; //Marker Size half

  54:  

  55:              g.DrawEllipse(new Pen(Brushes.DarkRed, GraphThickness), X - MSH,

                                                     Y - MSH, MarkerSize, MarkerSize);

  56:  

  57:              SizeF size = g.MeasureString(DrawString, new Font("Arial", 7));

  58:  

  59:              // Making sure that infobox doesn't exceeds control drawing area

  60:              if( (Y + size.Height) > Height )

  61:                  Y -= ((int) Math.Round(size.Height) + MarkerSize);

  62:  

  63:              if( (X + size.Width) > Width)

  64:                  X -= ((int) Math.Round(size.Width) + MarkerSize);

  65:  

  66:              // Drawing info

  67:              g.FillRectangle(Brushes.LightYellow, X + MSH, Y + MSH, size.Width, size.Height);

  68:              g.DrawRectangle(new Pen(Color.Black), X + MSH, Y + MSH, size.Width, size.Height);

  69:              g.DrawString(DrawString, new Font("Arial", 7), Brushes.Black, X + MSH, Y + MSH);

  70:          }

  71:      }

  72:  }

I’ll just explain the procedure used. A x-value at the graphing area corresponding to the current mouse position is calculated (line 7) - hereafter while iterating through all graphs (Data channels) we look for the nearest graph to the mouse position (line 15 - 34) and the data bound to the graph is saved - if a graph is found at the given x-value. Next we simply draw a marker at the graph (line 55), drawing a info box containing some information (including actual y-value) and possibly events belonging to the given point (line 67 - 69).

• Display system fonts or fonts from a selected folder.
• Install fonts
• Character map
• Printing
• Etc.

Download FontVisualizer 1.5 installer

Download the source code for Font Visualizer 1.5

Acknowledgements

Eugene Pankov, ‘MenuExtender’
Christian Tratz, ‘Auto-resize C# ListBox’
Lelieveld, ‘An auto-resize C# Listbox (updated)’
The users at Graphic-Forums.net for ideas and support.

Download Compact FTP Backup installer

Download the source code for Compact FTP Backup

Backups are automatically compressed to an zip-archive and stored locally. The application can run in the background automatically starting backups acording to the recurrence pattern.

Although the project has been on stand by for some time I’ve decided to release the sourse as well as a working install.

To get the source to work you’ll need the following

• Recurrence .NET
• edtFTPnet
• #ZipLib

Changelog

0.6.2.0 - 2005.12.23

• Fixed deletion of wrong activities
• Fixed dialog stating that files had been changed from the outside when saving a project
• Fixed crash when selecting activities and backups with short names

0.6.2.0 - 2005.12.18

• Added check for over due backups
  1. Run backups automatically or display dialog
• Closed connections left open by the FTP Browser
• Created change log and added it to about box
• Added ‘Next backup’ to backup entry editor
• Other bug fixes

Known bugs

• Taking backup of large files takes up memory equvilent to the file size

Source and testing application available for download at SourceForge.net project site: https://sourceforge.net/projects/recurrence-net/

The application is no longer under development, but if you create an updated version you would like to share, please let me know.

Bugfixes

Thanks to Kees van den Broek the following minor bugs have been fixed

• Renamed MontCalendarPlus to MonthCalendarPlus
• Deleted Recurrence.cs as it was empty
• Changed use of ToShortTimeString() to ToString(”HH:mm”) in RecurrenceUI.cs as it parsed times worngly (for instance 18:00 became 6:00 am)

(Friday, November 11th 2006)

Updated with bugfixes and XML serialization capabilities

Thanks to Lüuis Lauri [laluu - at - wmdata.com] the comtrol has been updated with a few bugfixes as well as XML serialization capabilities.

I appreciate any feedback on fixes and enhancements to the code. This XML serialization feature is a great idea.

(Thursdag, April 27th 2006)