Free delayed shutdown 2.01 software for linux

livecoding 2.01 is yet another excellent utility for any developers It actually provides code reloading support library for Python.

There are two key facets this library:

• The code reloading functionality it provides.
• The bypassing of the standard module system with a custom one.

The standard module system is still there and continues to work with the custom one, but only the custom one is covered by the code reloading functionality of this library.

In order to decide whether you want the flexibility of the code reloading that this library provides, you need to decide whether you can live with writing the reloadable scripts within the custom module system.

Major Features:

1. Automatic code reloading on script file changes.
2. Less interruptions to developer workflow.
3. Code reloading allows a running application to change its behaviour in response to changes in the Python scripts it uses. When the library detects a Python script has been modified, it reloads that script and replaces the objects it had previously made available for use with newly reloaded versions.
4. As a tool, it allows a programmer to avoid interruption to their workflow and a corresponding loss of focus. It enables them to remain in a state of flow. Where previously they might have needed to restart the application in order to put changed code into effect, those changes can be applied immediately.

Requirements:

• Python

Tk::after can execute a command after a time delay.

SYNOPSIS

$widget->after(ms)
$id = $widget->after(ms?,callback?)
$id = $widget->repeat(ms?,callback?)
$widget->afterCancel($id)
$id = $widget->afterIdle(callback)
$widget->afterInfo?($id)?
$id->time(?delay?)

This method is used to delay execution of the program or to execute a callback in background sometime in the future.
In perl/Tk $widget->after is implemented via the class Tk::After, and callbacks are associated with $widget, and are automatically cancelled when the widget is destroyed. An almost identical interface, but without automatic cancel, and without repeat is provided via Tk::after method.

Internal Details

The internal Tk::After class has the following synopsis:

$id = Tk::After->new($widget, tid, $time, once, callback);
$id = Tk::After->new($widget, tid, $time, repeat, callback);
$id->cancel;
$id->time(?delay?);

$id is a Tk::After object, an array of 5 elements:

$widget is the parent widget reference.

tid is the internal timer id, a unique string.

$time is the string idle, representing an idle queue timer, or a integer millisecond value.

once or repeat specifies whether the timer is a one-time after event, or a repeating repeat event.

callback specifies a Perl/Tk Tk::Callback object.

Changing a repeat timer interval

Its posible to change a repeat timers delay value, or even cancel any timer, using the time method. If delay is specified and non-zero, a new timer delay is established. If delay is zero the timer event is canceled just as if $id->cancel were invoked. In all cases the current millisecond timer delay is returned.

Note: the new timer delay will take effect on the subsequent timer event - this command will not cancel the pending timer event and re-issue it with the new delay time.

The after() method has several forms as follows:

$widget->after(ms)

The value ms must be an integer giving a time in milliseconds. The command sleeps for ms milliseconds and then returns. While the command is sleeping the application does not respond to events.

$widget->after(ms,callback)

In this form the command returns immediately, but it arranges for callback be executed ms milliseconds later as an event handler. The callback will be executed exactly once, at the given time. The command will be executed in context of $widget. If an error occurs while executing the delayed command then the Tk::Error mechanism is used to report the error. The after command returns an identifier (an object in the perl/Tk case) that can be used to cancel the delayed command using afterCancel.

$widget->repeat(ms,callback)

In this form the command returns immediately, but it arranges for callback be executed ms milliseconds later as an event handler. After callback has executed it is re-scheduled, to be executed in a futher ms, and so on until it is cancelled.

$widget->afterCancel($id)

$id->cancel

Cancels the execution of a delayed command that was previously scheduled. $id indicates which command should be canceled; it must have been the return value from a previous after command. If the command given by $id has already been executed (and is not scheduled to be executed again) then afterCancel has no effect.

$widget->afterCancel(callback)

This form is not robust in perl/Tk - its use is deprecated. This command should also cancel the execution of a delayed command. The callback argument is compared with pending callbacks, if a match is found, that callback is cancelled and will never be executed; if no such callback is currently pending then the afterCancel has no effect.

$widget->afterIdle(callback)

Arranges for callback to be evaluated later as an idle callback. The script will be run exactly once, the next time the event loop is entered and there are no events to process. The command returns an identifier that can be used to cancel the delayed command using afterCancel. If an error occurs while executing the script then the Tk::Error mechanism is used to report the error.

$widget->afterInfo?($id)?

This command returns information about existing event handlers. If no $id argument is supplied, the command returns a list of the identifiers for all existing event handlers created by the after and repeat commands for $widget. If $id is supplied, it specifies an existing handler; $id must have been the return value from some previous call to after or repeat and it must not have triggered yet or been cancelled. In this case the command returns a list with three elements. The first element of the list is the callback associated with $id, the second element is either idle or the integer timer millisecond value to indicate what kind of event handler it is, and the third is a string once or repeat to differentiate an after from a repeat event.

The after(ms) and afterIdle forms of the command assume that the application is event driven: the delayed commands will not be executed unless the application enters the event loop. In applications that are not normally event-driven, the event loop can be entered with the vwait and update commands.

Webalizer Xtended is an extension of Webalizer, which adds additional monthly statistics for all "404 Not Found" errors found in your server log-file, including the number of the "404 Not Found" requests and the corresponding 404 URLs.
Webalizer Xtended project also fixes truncated user agent strings in the "User Agents" statistics, so user agent fields can now be grouped more precisely. It is helpful for detecting and correcting broken links or invasion attempts.
Main features:
- Additional monthly statistics for all "404 Not Found" errors found in your server log-file, including the number of the "404 Not Found"-requests and the corresponding 404-URLs
- "404 Not Found" statistics with incremental logfile processing
- Bug-fix for truncated user agent strings in the "User Agents" statistics of Webalizer version 2.01-10 (user agent fields can now be grouped more precisely)
- Bug-fixes for several buffer overflows in the original Webalizer code
Enhancements:
- IPv6 support was added.
- Several third-party patches were implemented.
- General improvements were made, such as an updated "GroupAgent"-list, a "Main"-link for navigation back to the main index, and updated language files.

Webconverger project is an evolution of the hybrid client for deployments in places like offices or Internet cafes where only Web applications are used.
Unlike thin or hybrid clients, Webconverger is faster and more responsive by providing a Web browser that runs locally.
Main features:
- Ideal just for Web applications
- Free & open software
- Low system requirements
- Good security
- Painless to deploy and setup
- Features a Web standards compliant browser
- Cost effective
- Does not require registration or accounts
- Flash and a PDF viewer installed by default
- Easy for new users to learn and use
- Low maintenance costs
- Long term support
Enhancements:
- The latest security updates to Iceweasel (Firefox) rebuild 2.0.0.6 have been applied.
- Previous versions of Webconverger will upgrade nonetheless with somewhat delayed startups.

Funky is an embeddable interpreter and programming language.
When was Fnky created?
The very first version of Funky was created during my daughters nap on a snowy sunday afternoon. It was slightly refined one evening while my daughter and my wife were both sleeping and I was rocking the babys "cozy" with my foot (as I am doing now). The initial programming therefore took about 90 minutes, whereas a bit of fine-tuning and turning the original parser/interpreter into a parser/interpreter with two phases (parsing and interpreting) took another two hours or so.
Why was Funky created?
The original idea wasnt mine: at work, a colleague needed a functional, embeddable programming language and created one from scratch. It took him a few days to do so, but he wrote the parser and the scanner by hand. I heard about his little language and thought it might be a nice idea to have one of those in the free world.
Also, as a personal challenge, I decided I should be able to write one of those in much less time that a few days, but using the right tools. Hence, one sunday afternoon I took my laptop computer and started typing. I decided to use Boost.Spirit to write the parser: I had already read the documentation once while doing some research for the Jail programming language and found it a pretty good framework to build a parser one. 90 minutes later, I had the first working version of a Funky interpreter (but it wasnt embeddable yet and didnt split the parsing and interpreting phases).
So, what exactly is Funky?
As stated, Funky is a tiny, embeddable programming language with almost unlimited extending capabilities. It presents itself as a single class which contains the entire interpreter. Two versions of this class exist: Funky::Funky, which is a floating-point version, and Funky::Groovy, which is an integer version. You can install your own functions in the language as long as your functions take a vector of the built-in type of the interpreter as return an instance of that built-in type (or a vector of those).
Funky is a functional programming language. As such, it treats everything as functions and those functions handle only one type: double in the case of Funky::Funky or int in the case of Funky::Groovy.
Enhancements:
- This release adds support for GCC 4.x by fixing a small error in the declaration of a variable.
- It also comes with more documentation on how to build Funky.

Barcode::Code128 is a Perl module that can generate CODE 128 bar codes.

SYNOPSIS

use Barcode::Code128;

$code = new Barcode::Code128;

EXPORTS

By default, nothing. However there are a number of constants that represent special characters used in the CODE 128 symbology that you may wish to include. For example if you are using the EAN-128 or UCC-128 code, the string to encode begins with the FNC1 character. To encode the EAN-128 string "00 0 0012345 555555555 8", you would do the following:

use Barcode::Code128 FNC1;
$code = new Barcode::Code128;
$code->text(FNC1.00000123455555555558);

To have this module export one or more of these characters, specify them on the use statement or use the special token :all instead to include all of them. Examples:

use Barcode::Code128 qw(FNC1 FNC2 FNC3 FNC4 Shift);
use Barcode::Code128 qw(:all);

Here is the complete list of the exportable characters. They are assigned to high-order ASCII characters purely arbitrarily for the purposes of this module; the values used do not reflect any part of the CODE 128 standard. Warning: Using the CodeA, CodeB, CodeC, StartA, StartB, StartC, and Stop codes may cause your barcodes to be invalid, and be rejected by scanners. They are inserted automatically as needed by this module.

CodeA 0xf4 CodeB 0xf5 CodeC 0xf6
FNC1 0xf7 FNC2 0xf8 FNC3 0xf9
FNC4 0xfa Shift 0xfb StartA 0xfc
StartB 0xfd StartC 0xfe Stop 0xff

Barcode::Code128 generates bar codes using the CODE 128 symbology. It can generate images in PNG or GIF format using the GD package, or it can generate a text string representing the barcode that you can render using some other technology if desired.

The intended use of this module is to create a web page with a bar code on it, which can then be printed out and faxed or mailed to someone who will scan the bar code. The application which spurred its creation was an expense report tool, where the employee submitting the report would print out the web page and staple the receipts to it, and the Accounts Payable clerk would scan the bar code to indicate that the receipts were received.

The default settings for this module produce a large image that can safely be FAXed several times and still scanned easily. If this requirement is not important you can generate smaller image using optional parameters, described below.

If you wish to generate images with this module you must also have the GD.pm module (written by Lincoln Stein, and available from CPAN) installed. Version 1.20 or higher of GD generates a PNG file, due to issues with the GIF patent. If you want to create a GIF, you must use version 1.19 or earlier of GD. However, most browsers have no trouble with PNG files.

If the GD module is not present, you can still use the module, but you will not be able to use its functions for generating images. You can use the barcode() method to get a string of "#" and " " (hash and space) characters, and use your own image-generating routine with that as input.

To use the the GD module, you will need to install it along with this module. You can obtain it from the CPAN (Comprehensive Perl Archive Network) repository of your choice under the directory authors/id/LDS. Visit http://www.cpan.org/ for more information about CPAN. The GD home page is: http://stein.cshl.org/WWW/software/GD/GD.html

Contact Form is a perl script that you can run on your website that will allow others to send you email through a web interface. Unlike other web to email gateways, Contact Form is designed to thwart spammers.
It does not allow email to be sent to unknown addresses, nor does it reveal addresses that it knows.
Main features:
- Allow email to be sent to a list of known email addresses through a web interface.
- Prevent email from being sent to other addresses.
- Never reveal email addresses through the web interface.
- Contain no cross site scripting (XSS) vulnerabilities.
- Do not allow arbitrary code to be run on the host.
- Provide adequate information in email headers to trace any spammers.
- Allow, but do not require, an external form.
- Server side validity checking of all data before email is sent.
- Optional client side validity checking of all data before the form is submitted.
- A default configuration that requires only a list of email addresses to be ready for use.
- A customizable interface that allows arbitrary fields.
- Easy to change the way it looks to integrate into your website
Setup:
- Download the contactform archive.
- Extract the contents of the download.
- Place contact.pl in your webservers cgi-bin directory or another place that allows scripts.
- Edit contact.pl to change the email addresses to which email can be sent.
- Optional - Change any other parameters in contact.pl to taste.
- Point your web browser at contact.pl on your server.
- Send yourself email through the web.