Free current time software for linux

Slicetime is a program that helps you track time you spend on projects. Slicetime is designed to make it easy to switch between different projects, the main window is in the shape of vertical sidebar that makes it convenient to keep it always visible on the side of the screen. In short, continuous tracking of time taken on projects is made as effortless as possible.
The purpose of the program is to make you aware of which tasks take more time, and which take less; it can also be used to keep track and charge time if youre working for someone on hourly basis. The advantage of the program is that it lets you switch back and forth very easily, letting you keep a very accurate account of how much a task took even if you have to stop it frequently and work on something else.
The results can be very surprising, something may feel like it took only a few minutes whereas it took almost an hour in real time; the reverse is sometimes true although not as often.
Slicetime main window is a vertical bar with a row of buttons, each button representing a project. When the button is pressed in, the project is active, the rest of projects are inactive. Each project button shows the time taken on the project today. At 12 oclock the daily time is reset and new days count is started.
Time is kept for current day, week, month and total. Example: I may have a slicetime project that has 3:59 time today, 8:00 this week (including today), 17:00 this month (including this week) and 125:00 total time, which may have been accumulated over years.
Slicetime makes it easy to change project time for current day if you forgot to check in or check out. Menu command (add or subtract project time) will add or subtract the time for today. Another command will set all times for total, month, week and day.
Slicetime as of now has two report options, it can report by time taken for each project on a daily, weekly, montly and total basis and the same by percentage. For example, it will show that today project A was 60%, project B - 30% and C - 10%, and will do the same for current week, month and total.
Note that Slicetime does not keep separate time accounting from previous week, month, day, etc. It will not tell you that you spend 5 hours last saturday. It will only tell you total time, time taken on current month, week and day; but it makes perfect sense to keep this data as well, and I will almost certainly add it.
Functionality:
- Add project
- Remove project (deletes all data and button, irrecoverable, use sparingly!)
- Report by time
- Report by percentage
- Set project time
- Add or subtract project time
Version restrictions:
- Number of project buttons is effectively limited by vertical size of screen. On a common 1024 res, you can fit in around 42 projects, which should be enough for anyone, but I will add an option of hiding projects from main window if requested.
- Latest version not tested in Unix, but will most likely work. I will test it soon & fix if needed.
- Could keep time for each past day, week, month, year. Most likely will be added eventually.
Enhancements:
- Several bugs were fixed.
- The interface was changed to be more user friendly.
- Autosave functionality was added to make up for some stability problems on WinXP.

Acme::Time::Baby - tell time little children can understand.

SYNOPSIS

use Acme::Time::Baby;
print babytime; # Prints current time.

use Acme::Time::Baby language => du;
print babytime "10:15"; # Prints a quarter past ten in a way
# little Dutch children can understand.

Using this module gives you the function babytime, which will return the time in the form The big hand is on the ten and the little hand is on the three. If no argument to babytime is given, the current time is used, otherwise a time of the form hh:mm can be passed. Both 12 and 24 hour clocks are supported.

When using the module, various options can be given. The following options can be passed:

language LANG

The language the time should be told in. The following languages are currently supported:

en English (this is the default)
br Brazilian Portuguese.
ceb Cebuano (Filipine dialect)
de German.
de_ch Swiss German.
du Dutch.
es Spanish.
fr French.
it Italian.
no Norwegian.
se Swedish.
swedish chef Swedish Chef (from the Muppets).
warez l44+.

If no language argument is given, English is used.
Note that some languages use accented letters. The returned sentences are correct for an ISO 8859-1 platform.

format STRING

This is the format used to represent the time. It will be passed to sprintf, and it should have two %s formatting codes. The other two arguments to sprintf are the position of the minute hand (the big hand) and the hour hand (the little hand). If you have perl 5.8 or above, you could use %2$s and %1$s to reverse the order.

number ARRAYREF

An array with the names of the numbers one to twelve, to be used in the formatted time.

noimport EXPR

By default, the sub babytime will be exported to the calling package. If for some reason the calling package does not want to import the sub, there are two ways to prevent this. Either use use Acme::Time::Baby (), which will prevent Acme::Time::Baby::import to be called, or pass noimport followed by a true value as arguments to the use statement.

Bookmark Time is an Amarok script that lets you bookmark a point in time in a music file.

When you play it again, you can choose the bookmarked times from the mouse menu.

LabyCube is a labyrinth generator that creates foldable labyrinths. The generated labyrinths by LabyCube, can be printed, cut out, and folded.

The current beta version supports the generation of labyrinth cubes.

pytimeago is a human-oriented representation of time deltas, a Python library.

First, I shall define what time delta is. Since Δ generally means “difference”, we take time delta to stand for difference between two events in time. Quite common, however, is to have the current time for the second event. In pytimeago we deal with time deltas from such a perspective.

Quite possibly, you can make use of this library if your application displays some dynamically generated items to the user, and you are looking for a good way to present information on how long ago specific item was created/processed/whatever.

Below is small code snippet demonstrating how simple it is to embed pytimeago:

from pytimeago.english import english
from time import time, sleep

message = queue.getNextMessage()
delta = time() - message.arrived_time
print "Message arrived %s" % english(delta)

Prints, e.g.
Message arrived 15mins ago

As you see, pytimeago is package, and has individual modules for every language supported. As of 2006-08-13 the only supported language is English. However, you can take a look at rather trivial implementation of English engine, write one for your language, and send it to to me (email at the bottom of page).

Every language should come with a set of doctests (I prefer them to casual unit tests), just like the English version does. Dont be too verbose, but check essential cases.

Time::Skew is a Perl module that computes local clock skew with respect to a remote clock.

SYNOPISI

use Time::Skew

# Init Convex Hull and timing data
my $hull=[];
my $result={};

# Iterate data point introduction
Time::Skew::convexhull($result,$datapoint,$hull);

This module supports the computation of the skew between two clocks: the (relative) skew is the speed with which two clocks diverge. For instance, if yesterday two clocks, at the same time, showed respectively 10:00 and 10:05, while today when the former shows 10:00 the latter shows 10:04, we say that their relative skew is 1 minute/24 hours, roughly 7E-4.

The module contains one single subroutine, which accepts as input a pair of timestamps, associated to a message from host A to host B: the timestamps correspond to the time when the message was sent, and to the time when message is received. Each timestamp reflects the value of the local clock where the operation takes place: the clock of host A for the send, the clock of B for the receive.

Please note that the module does _not_ contain any message exchange facility, but only the mathematics needed to perform the skew approximation, once timestamps are known.

The subroutine takes as argument:

a reference to a hash where values related to the timing of the network path from A to B;
a 2-elems array (a data point in the sequel) containing the timestamp of the receive event, and the differece between the send timestamp and the receive timestamp for one message;
a stack containing some data points, those that form the convex hull.

The usage is very simple, and is illustrated by the following example:

#!/usr/bin/perl -w
use strict;
use Time::Skew;

# Initialize data
my $hull=[];
my $result={};
while ( 1 ) {
# Exchange message and acquire a new data point
my $datapoint = acquire();
# Call the convexhull subroutine
Time::Skew::convexhull($result,$datapoint,$hull);
# After first message some results are still undefined
( defined $result->{skewjitter} ) || next;
# here you can use the results

};
}

The data returned in the "result" hash is the following:

result->{skew} the clock skew;
result->{skewjitter} the variance of the skew estimate, used to estimate convergence;
result->{jitter} difference between the current delay and the previous delay;
result->{delay} the communication delay, decremented by a constant (yet unknown) value, used to compute communication jitter;
result->{elems} the number of data points in the convex hull;
result->{select} the index of the data point in the convex hull used to compute the skew;
result->{itimestamp} the timestamp, first element in the data point just passed to the subroutine;
result->{delta} the timestamp difference, second element in the data point just passed to the subroutine;

The data returned in the "hull" stack is a series of data points, selected from those passed to successive calls of the subroutine. The number of data points in the "hull" stack usually does not exceed 20 units.

The algorithm is very fast: each call consists in scanning at most all data points in the "hull" stack, performing simple arithmetic operations for each element.

The algorithm must be fed with a sequence of data points before returning significant results. The accuracy of the estimate keeps growing while new data points are passed to the subroutine. A rough rule of thumb to evaluate estimate accuracy is to observe the skew jitter, and assume it corresponds to the skew estimate accuracy. Paths with quite regular communication delay (small jitter) converge faster.

Time::Beat is a Perl module to convert between standard time and Swatch ".beat" time.

Time::Beat is a module to convert normal time to and from .beats, of which there are a thousand in a day. It can change normal time in time() format to .beats, and .beats into either 24-hour or 12-hour normal time.

SYNOPSIS

use Time::Beat qw(beat time24 time12);

my $time_in_beats = beats($time);

my $beats_in_24hr_time = time24($beat);

my $beats_in_12hr_time = time12($beat);

METHODS

There are three methods in Time::Beat.

beats($time)

beats will give you the current time in .beats if you do not specify a time string. If you specify a string in time() format it will return that particular time in .beats. The basic algorithm for doing this is to take the time in GMT+1 hour, convert it into seconds, and divide by 86.4.

time24($beat)

time24 takes a 3-digit beat time and outputs a 24-hour time along the lines of "12:34:56". The hours will have leading noughts.

time12($beat)

time12 takes a 3-digit beat time and outputs a 12-hour time along the lines of "12:34:56 am" or "12:34:56 pm". Hours do not have leading noughts.