Free 2.3.0 patch software for linux

KTouch is a program for learning how to touch-type. KTouch is FREE software and offers you an easy way to learn to type on a keyboard quickly and correctly. Every finger has its place on the keyboard with associated keys to press.
Starting with only a few keys to remember you will advance through the levels of the training lecture while more and more keys are introduced. And finally you will be able to type very fast and accurate, because you no longer need to search for the keys on the keyboard (and because you will definitely use more then just two fingers).
KTouch shows the keys you need to press and the finger you need to use for that key on the screen. You neednt to look down on the keyboard to search the key. Therefore you will get used to looking at the screen only and thus you will learn touch typing much faster.
Main features:
- KTouch supports various keyboard layouts and you can easily add own keyboard layouts
- A number of training lectures are included by default (english, german, french ... etc)
- You can add and modify training lectures using the built-in lecture editor
- Detailed training statistics help you to find possible typing problems (keys that you typed wrong very often)
- The program calculates typing speed and your accuracy on-the-fly and displays them while you type
- Many settings (including the colour scheme of the program) can be modified by the user
- During training the level can be adjusted automatically according to your typing skill: if you type fast and correctly you will move a level up, otherwise stay in the level or even move down. So you will learn touch typing like playing a game.
Enhancements:
Patch provided by Gavin:
In trying to help a linux user group member compile ktouch 1.6.0
standalone version, I encountered a few errors.
o Only version 2.5 of autoconf was acceptable, 2.6 not allowed
o autoconf was checked for in --version output of the autoheader check
o ktouch/keyboards/Makefile.am had a trailing slash but no new line
Some minor changes all resulted in a successful `make -f Makefile.cvs`
Ive attached these changes in the patch attached and in a modified tar.gz.
I also noted that there are some .svn directories in the release. You
probably already know but, svn export will help you with that.

Cons is a Software Construction System.

Cons is a system for constructing, primarily, software, but is quite different from previous software construction systems. Cons was designed from the ground up to deal easily with the construction of software spread over multiple source directories. Cons makes it easy to create build scripts that are simple, understandable and maintainable. Cons ensures that complex software is easily and accurately reproducible.

Cons uses a number of techniques to accomplish all of this. Construction scripts are just Perl scripts, making them both easy to comprehend and very flexible. Global scoping of variables is replaced with an import/export mechanism for sharing information between scripts, significantly improving the readability and maintainability of each script.

Construction environments are introduced: these are Perl objects that capture the information required for controlling the build process. Multiple environments are used when different semantics are required for generating products in the build tree. Cons implements automatic dependency analysis and uses this to globally sequence the entire build. Variant builds are easily produced from a single source tree. Intelligent build subsetting is possible, when working on localized changes. Overrides can be setup to easily override build instructions without modifying any scripts. MD5 cryptographic signatures are associated with derived files, and are used to accurately determine whether a given file needs to be rebuilt.

While offering all of the above, and more, Cons remains simple and easy to use. This will, hopefully, become clear as you read the remainder of this document.

Why Cons? Why not Make?

Cons is a make replacement. In the following paragraphs, we look at a few of the undesirable characteristics of make--and typical build environments based on make--that motivated the development of Cons.

Build complexity

Traditional make-based systems of any size tend to become quite complex. The original make utility and its derivatives have contributed to this tendency in a number of ways. Make is not good at dealing with systems that are spread over multiple directories. Various work-arounds are used to overcome this difficulty; the usual choice is for make to invoke itself recursively for each sub-directory of a build. This leads to complicated code, in which it is often unclear how a variable is set, or what effect the setting of a variable will have on the build as a whole. The make scripting language has gradually been extended to provide more possibilities, but these have largely served to clutter an already overextended language. Often, builds are done in multiple passes in order to provide appropriate products from one directory to another directory. This represents a further increase in build complexity.

Build reproducibility

The bane of all makes has always been the correct handling of dependencies. Most often, an attempt is made to do a reasonable job of dependencies within a single directory, but no serious attempt is made to do the job between directories. Even when dependencies are working correctly, makes reliance on a simple time stamp comparison to determine whether a file is out of date with respect to its dependents is not, in general, adequate for determining when a file should be rederived. If an external library, for example, is rebuilt and then ``snapped into place, the timestamps on its newly created files may well be earlier than the last local build, since it was built before it became visible.

Variant builds

Make provides only limited facilities for handling variant builds. With the proliferation of hardware platforms and the need for debuggable vs. optimized code, the ability to easily create these variants is essential. More importantly, if variants are created, it is important to either be able to separate the variants or to be able to reproduce the original or variant at will. With make it is very difficult to separate the builds into multiple build directories, separate from the source. And if this technique isnt used, its also virtually impossible to guarantee at any given time which variant is present in the tree, without resorting to a complete rebuild.

Repositories

Make provides only limited support for building software from code that exists in a central repository directory structure. The VPATH feature of GNU make (and some other make implementations) is intended to provide this, but doesnt work as expected: it changes the path of target file to the VPATH name too early in its analysis, and therefore searches for all dependencies in the VPATH directory. To ensure correct development builds, it is important to be able to create a file in a local build directory and have any files in a code repository (a VPATH directory, in make terms) that depend on the local file get rebuilt properly. This isnt possible with VPATH, without coding a lot of complex repository knowledge directly into the makefiles.

PyDNS project provides a module for performing DNS queries from python applications.

Im making this release because there hasnt been a release in a heck of a long time, and it probably deserves one. Id also like to do a substantial refactor of some of the guts of the code, and this is likely to break any code that uses the existing interface. So this will be a release for people who are using the existing API...

There are several known bugs/unfinished bits

- processing of AXFR results is not done yet.
- doesnt do IPv6 DNS requests (type AAAA)
- docs, aside from this file
- all sorts of other stuff that Ive probably forgotten.
- MacOS support for discovering nameservers
- the API that I evolved some time ago is pretty ugly. Im going to re-do it, designed this time.

The Exim DSN patch adds delivery status notification support to Exim 4.xx.

DSN Support for Exim. This patch allows Exim 4.xx to support the sending of email Delivery Status Notifications.

iBATIS project provides a very simple and flexible means of moving data between your Java and .NET objects and a relationaldatabase. Use the full power of real SQL without a single line of JDBC or ADO.NET code!

The Data Mapper framework (a.k.a. SQL Maps) will help to significantly reduce the amount of Java and .NET code that is normally neededto access a relational database. This framework maps classes to SQL statements using a very simple XML descriptor. Simplicity is the biggest advantage of iBATIS over other frameworks and object relational mapping tools.

To use iBATIS you need only be familiar with your own application domain objects (basic JavaBeans or .NET classes), XML, and SQL. There is very little else to learn. There is no complex scheme required to join tables or execute complex queries. Using iBATIS you have the full power of real SQL at your fingertips. The iBATIS Data Mapper framework can map nearly any database to any object model and is very tolerant of legacy designs, or even bad designs. This is all achieved without special database tables, peer objects or code generation.

iBATIS Data Access Objects

iBATIS Data Access Objects is an abstraction layer that hides the details of your persistence solution and provides a common API to therest of your application.
When developing robust Java and .NET applications, it is often a good idea to isolate the specifics of your persistence implementationbehind a common API. Data Access Objects allow you to create simple components that provide access to your data withoutrevealing the specifics of the implementation to the rest of your application.

Using DAOs you can allow your application tobe dynamically configured to use different persistence mechanisms. If you have a complex application with a number of differentdatabases and persistence approaches involved, DAOs can help you create a consistent API for the rest of your application.

For Java users, the Data Access Objects framework is bundled as part of the iBATIS Database Layer, which includes the SQL Maps Framework. Although packaged together, the DAO Framework is completely independent and can be used without SQL Maps. .NET users can download the DataAccess framework seperately from the DataMapper framework.

Spotter is a program that lets students check their answers to math and science questions. It handles symbolic as well as numerical answers.
Spotter application is free and open source.
I got the idea for Spotter from LON-CAPA, which is also free and open-source. The programs are alike in some ways and different in others. There is another program called WeBWorK that also does similar things; it doesnt cost money, but Im not sure if its open-source or copylefted.
Enhancements:
- This version adds a general mechanism for creating qualitative questions using JavaScript, and uses that mechanism to implement multiple-choice questions.

GKrellM application is a GTK-based stacked monitor program that charts SMP CPUs, disks, load, active net interfaces, and internet connections.
There are also builtin monitors for memory and swap, file systems with mount/umount feature, mailbox checking including POP3 and IMAP, clock/calendar, laptop battery, sensors (temperatures, voltages, and fans), and uptime.
It has LEDs for the net monitors and an on/off button and online timer for PPP. There is a GUI popup for configuration, plugin extensions can be installed, and many themes are available. It also features a client/server monitoring capability.
Main features:
- Hostname/systemname display.
- Clock/calendar.
- SMP CPU monitor that can chart individual CPUs and/or a composite CPU.
- Temperature, fan, and voltage sensor monitors if supported by the kernel and the mainboard hardware (Linux requires lm_sensors to be installed).
- Each sensor monitor has a configurable alarm and warning.
- Process monitor with a chart for load and forks and a display of number of current processes and users.
- Disk monitor that can chart individual disks or a composite disk.
- Internet monitor (http, ftp, ...) that displays current tcp port connections and charts historical port hits for over two days.
- Net interface monitors with charts for all routed net interfaces. Data rx/tx LEDs and a timer button that can be linked to a ppp or isdn net interface and displays on line time.
- Memory and swap space usage meters, and a swap page in/out chart.
- File system meters which show capacity/free space and can mount/umount.
- A mailbox monitor which can launch a mail reader, a mail fetch/check program, and a sound notify command. Builtin new mail message checking for mbox, maildir, MH, POP3, and IMAP mailboxes.
- APM laptop battery meter with a configurable alarm and warning for low battery time left.
- Uptime display.
- Multiple monitors managed by a single process to reduce system load.
- Charts have auto scaling or fixed scaling modes.
- Commands can be configured to run when monitor labels are clicked.
- gkrellm can run in client mode and collect data from a gkrellmd server running on a remote machine.
- Both gkrellm and the gkrellmd server are plugin capable so special interest monitors can be coded.