Free help desk software comparison software for linux

Help Desk Reloaded is a Web-based helpdesk customer support system. Help Desk Reloadeds users can quickly log help desk tickets, and customer support representatives can track calls, assign priorities, etc.
Main features:
- Free Help Desk Software, No cost to you.
- Easy to Install with the help desk installation wizard.
- Based on PHP and using the free database software MySQL
- No programming or database knowledge required. We have built in all the features you need in the help desks web based GUI.
- Updated Frequently we normally release new version each week.
- We are interested in implementing your ideas. If you have a good idea for a feature on the help desk software, let us know. We listen.
Enhancements:
- A new serial number tracking system is included in property management, for each computer device.

Bio::SAGE::Comparison module compares data from serial analysis of gene expression (SAGE) libraries.

SYNOPSIS

use Bio::SAGE::Comparison;
$sage = Bio::SAGE::Comparison->new();

This module provides several tools for comparing data generated from serial analysis of gene expression (SAGE) libraries.

BACKGROUND

Serial analysis of gene expression (SAGE) is a molecular technique for generating a near-global snapshot of a cell population’s transcriptome. Briefly, the technique extracts short sequences at defined positions of transcribed mRNA. These short sequences are then paired to form ditags. The ditags are concatamerized to form long sequences that are then cloned. The cloned DNA is then sequenced. Bioinformatic techniques are then employed to determine the original short tag sequences, and to derive their progenitor mRNA. The number of times a particular tag is observed can be used to quantitate the amount of a particular transcript. The original technique was described by Velculescu et al. (1995) and utilized an ~14bp sequence tag. A modified protocol was introduced by Saha et al. (2002) that produced ~21bp tags.

PURPOSE

This module facilitates the comparison of SAGE libraries. Specifically:

1. Calculations for determining the statistical
significance of expression differences.
2. Dynamically convert longer-tag libraries to
a shorter type for comparison (e.g. comparing
a LongSAGE vs. a regular SAGE library).

Both regular SAGE (14mer tag) and LongSAGE (21mer tag) are supported by this module.

Statistical significance in library comparisons is calculated using the method described by Audic and Claverie (1997). Code was generated by directly porting the authors original C source.

PHD Help Desk provides help desk registry and follow-up software.
PHD Help Desk is software conceived for the registry and follow-up of help desks incidents. Registry of incidents allows classification in two levels (type and subtype), the state of the incident, a description, ticket assignment and priority, historical registry, and an audit.
Information can be reported in consultation format, to give reports or export the information for later processing in a database or spreadsheet.
Enhancements:
- Now the operators belong to a sector, in the same way that the users belong an area.
- The database update proccess will insert the sector table with the areas that belong to the operators in version 1.21.
- The ticket is now initialized as "private" by default.
- Only the operators can change this state.
- Two bugs in the support request that prevented the input of the request into the ticket database were corrected.

Menus de ElOtroLado provides a menu with access to EOL and Cineol Forums is created near the Help Menu.

SYNOPSIS

use Array::Compare;

my $comp1 = Array::Compare->new;
$comp->Sep(|);
$comp->Skip({3 => 1, 4 => 1});
$comp->WhiteSpace(0);
$comp->Case(1);

my $comp2 = Array::Compare->new(Sep => |,
WhiteSpace => 0,
Case => 1,
Skip => {3 => 1, 4 => 1});

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

$comp1->compare(@arr1, @arr2);
$comp2->compare(@arr1, @arr2);

If you have two arrays and you want to know if they are the same or different, then Array::Compare will be useful to you.
All comparisons are carried out via a comparator object. In the simplest usage, you can create and use a comparator object like this:

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

my $comp = Array::Compare->new;

if ($comp->compare(@arr1, @arr2)) {
print "Arrays are the samen";
} else {
print "Arrays are differentn";
}

Notice that you pass references to the two arrays to the comparison method.

Internally the comparator compares the two arrays by using join to turn both arrays into strings and comparing the strings using eq. In the joined strings, the elements of the original arrays are separated with the ^G character. This can cause problems if your array data contains ^G characters as it is possible that two different arrays can be converted to the same string.

To avoid this, it is possible to override the default separator character, either by passing and alternative to the new function

my $comp = Array::Compare->new(Sep => |);

or by changing the seperator for an existing comparator object

$comp->Sep(|);

In general you should choose a separator character that wont appear in your data.

You can also control whether or not whitespace within the elements of the arrays should be considered significant when making the comparison. The default is that all whitespace is significant. The alternative is for all consecutive white space characters to be converted to a single space for the pruposes of the comparison. Again, this can be turned on when creating a comparator object:

my $comp = Array::Compare->new(WhiteSpace => 0);

or by altering an existing object:

$comp->WhiteSpace(0);

You can also control whether or not the case of the data is significant in the comparison. The default is that the case of data is taken into account. This can be changed in the standard ways when creating a new comparator object:

my $comp = Array::Compare->new(Case => 0);

or by altering an existing object:

$comp->Case(0);

In addition to the simple comparison described above (which returns true if the arrays are the same and false if theyre different) there is also a full comparison which returns a list containing the indexes of elements which differ between the two arrays. If the arrays are the same it returns an empty list. In scalar context the full comparison returns the length of this list (i.e. the number of elements that differ). You can access the full comparision in two ways. Firstly, there is a DefFull attribute. If this is true then a full comparison if carried out whenever the compare method is called.

my $comp = Array::Compare->new(DefFull => 1);
$comp->compare(@arr1, @arr2); # Full comparison

$comp->DefFull(0);
$comp->compare(@arr1, @arr2); # Simple comparison

$comp->DefFull(1);
$comp->compare(@arr1, @arr2); # Full comparison again

Secondly, you can access the full comparison method directly

$comp->full_compare(@arr1, @arr2);

For symmetry, there is also a direct method to use to call the simple comparison.

$comp->simple_compare(@arr1, @arr2);

The final complication is the ability to skip elements in the comparison. If you know that two arrays will always differ in a particular element but want to compare the arrays ignoring this element, you can do it with Array::Compare without taking array slices. To do this, a comparator object has an optional attribute called Skip which is a reference to a hash. The keys in this hash are the indexes of the array elements and the values should be any true value for elements that should be skipped.

For example, if you want to compare two arrays, ignoring the values in elements two and four, you can do something like this:

my %skip = (2 => 1, 4 => 1);
my @a = (0, 1, 2, 3, 4, 5);
my @b = (0, 1, X, 3, X, 5);

my $comp = Array::Compare->new(Skip => %skip);

$comp->compare(@a, @b);

This should return true, as we are explicitly ignoring the columns which differ.

Of course, having created a comparator object with no skip hash, it is possible to add one later:

$comp->Skip({1 => 1, 2 => 1});

or:

my %skip = (1 => 1, 2 => 2);
$comp->Skip(%skip);

To reset the comparator so that no longer skips elements, set the skip hash to an empty hash.

$comp->Skip({});

You can also check to see if one array is a permutation of another, i.e. they contain the same elements but in a different order.

if ($comp->perm(@a, @b) {
print "Arrays are permsn";
else {
print "Nope. Arrays are completely differentn";
}

In this case the values of WhiteSpace and Case are still used, but Skip is ignored for, hopefully, obvious reasons.

Ctcompares project purpose is to allow you to compare several sets of C code trees on a token basis, rather than on a line by line basis. The programs help to identify similarities between snippets of code in both trees.
Enhancements:
- The comparison method has been completely rewritten.
- A database is now used to hold 16-token "tuples" as keys; the result attached to each key is the list of source files which have that tuple.
- Tuples with multiple files from different source trees indicate potential code similarity.
- These are then fully tested to find actual code similarity.

Komparator is an application that searches and synchronizes two directories. Komparator project discovers duplicate, newer or missing files and empty folders.
It works on local and some network / kioslave protocol folders (like smb:/ and media:/).
It is still in an early stage; please try on test directories first.
Main features:
- ftp et alii supported (might still be buggy!).
- Keyboard shortcuts (popup menus didnt work, unfortunately) fixed.
- Drag & drop missing / newer files from left to right side & vice versa.
- Special characters in URLs fixed.
- Cancel button isnt locked any more if md5-summing / binary comparing remote files.
- Status bar including progress of kompare and about / help button.
- Source code cleanups.
- GUI cleanups.
- Resize list view columns to original width.
- Binary comparison wont store the complete file in RAM any more.
- First documentation attempt.
Enhancements:
- Filters to display only specific files
- Regex that the file name may not contain
- In-/Exclude hidden items
- Some bug fixes