Free reliably software for linux

Eikazo is a GTK and Python based frontend for Sane.
Main features:
- To maximize throughput, a new scan is started immediately after a former scan has been finished, if an automatic document feeder is used. Postprocessing and saving of the old scan is done, while the new scan is running.
- more than one output per scan is possible: You can simultaneously save the scanned image into a file and send it to a printer.
- plugin mechanisms for special devices features, for post-scan image processing and for other "storage options".
The device plugin mechanism allows to implement functions to support special device features.
Image enhancement plugins allow to automatically post-process the image. Currently, three plugins exist:
adaptive threshold
"dirt removal"
ImageMagick
The combination of adaptive threshold and dirt removal can give better scan results for "problematic" originals, for example, if you want to extract the text from a paper with "shaded background", from an stained original, or if you cant reliably predict the density of the ink of the text. See the sample images samples/1.tif (simple fixed threshold, set in the scanner), samples/2.tif ("automatic threshold" from another scanner), samples/3.tif (grayscale scan) and samples/4.tif (adaptive threshold).
The ImageMagick plugin is probably not very useful in many cases; some of the provided options are procesed very slow -- in other words: it is mostly intended to show how to integrate an external image filter than to be directly useful.

Ibis is an open source Java grid software project of the Computer Systems group, which is part of the Computer Science department of the Faculty of Sciences at the Vrije Universiteit, Amsterdam, The Netherlands.
Using Ibis, software can be developed which runs reliably and efficiently on a grid. Programs can, through Ibis, make use of high speed networking hardware while still remaining portable.
Ibis project is possible to write Ibis programs using multiple programming models, including standard Java RMI, models which support group communication, a divide-and-conquer model, and message passing.
Ibis is designed as a multi layer system. See the picture of the Ibis design below. On top of the system are the applications. These applications can use any of the programming models present in Ibis.
Available models include standard Java RMI, a divide and conqueror model called Satin, and GMI, a version of RMI enhanced with group communication. The next layer is the Ibis Portability Layer, or IPL.
The IPL acts as a common interface for the different programming models to the bottom implementation layer. Multiple implementations are available.
Some using 100% Java code to ensure portability, and some taking advantage of local high speed networks such as Myrinet using native code.
Enhancements:
- This release adds MPJ/Ibis, a pure Java implementation of the MPJ programming interface that has been defined by the Java Grande forum to provide MPI-like message passing for Java applications.
- Shared objects for Satin were added.
- This is a replacement (and major improvement) of the TupleSpace.
- The TupleSpace is still there, but it is deprecated and will probably not be there anymore in the next Ibis release.
- The connection setup code was improved and rewritten.
- Various scalability issues were fixed, mostly in the nameserver.
- Ibis now scales up to at least a thousand nodes.

SpamTestBuddy is a simple, light-weight, multiple-input spam scoring tool. SpamTestBuddy project is standalone and can be used with simple procmail rules without root access or daemons. Features built-in support for simple DNS checks including DNSBL (DNS-based blocklist) queries, and can scan headers from filters such as SpamProbe, QSF, DSPAM that you already use.
The configuration is flexible and easy to edit in a human readable file. Different tests can add or remove from the total score.
(I am not trying to re-invent SpamAssassin. That is a very powerful piece of software with all the features you need. It is also somewhat large and is a greater challenge to install. SpamTestBuddy will just help you bring together existing scores from filters you already use, with a few useful extra tests thrown in. For an all-in-one solution, try SpamAssassin).
Tested under Linux, FreeBSD, and NetBSD.
COMMON USES
1) Combining more than one external filter:
If you have a number of filters that output a numeric probability or score, you can combine them together using +TestHeaderFloat and make a decision on the total (floating point) score. Examples of filters which integrate seamlessly are SpamProbe, QSF, DSPAM, CRM114.
2) Querying DNSBL (DNS based blocklists, real time lists) or local IP files:
Typically this is done by mail servers at the time of mail receipt. However, there are advantages to doing these "RBL" lookups later. SpamTestBuddy will let you query multiple real-time lists for fresh data on known spam sources, abusive networks, etc. You can combine the results with your other statistical body-reading filters. You can also use TestFileIP to look up the IP in a local text file, such as a custom whitelist or blacklist.
3) Reducing false positives from other filters:
You can use SpamTestBuddy as a secondary filter to interpret existing scores differently. Alternatively, you can make a more conservative configuration by combining scores. This may be helpful for revisiting classification errors
4) Parsing the IP address of the sender
The IP address of the SMTP server which relayed mail is always visible in the Received headers, but parsing and extracting the correct IP address is hard to do reliably with procmail recipes alone. SpamTestBuddy can pick out the correct address by applying SkipReceived, a list of networks you define to consider local and ignore. The resulting IP address is conveniently displayed in the new X-SpamTestBuddy header, simplifying your procmail recipes.
Enhancements:
- This is the first public release of this software.
- The configuration file was enhanced for ease of use.
- DNSBL (RBL) support was added.

Eleven is a programming language for creating robust, scalable web applications quickly and easily.

It offers a 20x programmer productivity increase over traditional server programming languages like ASP, PHP, and JSP by automating state management and taking control of the applications look and feel.

From high-level source code with a simple, C-like syntax, the compiler generates complete, ready-to-run implementations in PHP or mod_perl. Applications generated by Eleven maintain their state in a relational database and are inherently fault-tolerant, secure, and scalable.

Most interactive web applications today are primitive. Of course there are shining exceptions such as Amazon.com, TurboTax, and others. But by and large, most web applications are crudely designed and not especially reliable. Have you ever entered data into a web application, then lost it due to a browser crash? Have you ever gotten part way through an e-commerce transaction, then had the session go into never-never land while waiting for your credit card to be validated? Have you ever reloaded a web page and found that you just duplicated a transaction by accident? Web applications are server based, so in theory they ought to be as reliable as traditional mainframe applications. But they arent.

The problem is that there are two ways of creating web applications. Theres the expensive way, in which massive amounts of engineering are dedicated to making the sites reliable and scalable. These applications tend to keep most of their state in server-side databases, which run in controlled environments and are carefully managed. If your browser crashes during a session, you can usually log in from another computer and pick up where you left off.

Then theres the cheap way (often seen in corporate intranets and extranets). These tend to keep their state on the client (in hidden form fields or HTTP cookies), in the web servers memory, or in the web servers filesystem. These applications tend to be fragile. They dont handle system failures well, and get confused easily if the user presses the back button, restarts the web browser, etc.

The Eleven project solves this problem by making it quick and easy to create robust, scalable, database-backed web applications. Applications are expressed in a high-level language with a syntax similar to C and a conceptual structure similar to BASIC. Here is a simple example.

The code is self-explanatory:

statesafe var first, last;

display
{
print ("Please enter your name.");
edit ("First name: ", first);
edit ("Last name: ", last);
}

display
{
print ("Thank you, ", first, " ", last, ".");
}

Here is another example; the worlds smallest to-do list application. Where the code invokes the edit function on the table data type, the compiler automatically fills in a table editor:

statesafe table
{
var deadline "Task deadline";
var description "Task description";
} todolist;

display
{
edit ("Enter your tasks: ", todolist);
}

The point is that the Eleven compiler takes over the job of state management. The programmer doesnt need to worry about how the variables first and last are passed from one display to the next, how to represent the to-do list in the relational database, how to deal with the back button, how to enable a session to be seamlessly resumed if the computer crashes, and so on. All of those problems are taken care of automatically.

Whats more, those benefits are achieved without any special runtime support. The Eleven compiler translates source code into complete PHP or mod_perl programs that run under the Apache web server. The only runtime support needed is a standard installation of Apache with PHP or mod_perl, and a relational database such as MySQL for the back end. Furthermore, the generated code is fairly readable, and can be inspected before uploading to the web site. This is a great benefit for security-minded system administrators who are wary of installing yet another "framework" onto their production machines.

All applications generated by Eleven automatically save their state to the relational database after every user action. The web browser and web servers are stateless. Thus, the applications have three important characteristics:

1. They are bulletproof, meaning that the applications are resilient to failures of any runtime component. Sessions cannot be derailed by browser crashes, web server crashes, bookmarking or tampering with URLs, etc. as long as the integrity of the relational database is maintained.

2. They are secure, meaning that all application data is safely kept private. It is stored in the database, never in hidden form fields or HTTP cookies where it is vulnerable. Consider the example of a web application that is being used from a laptop. If the laptop is stolen, then any private data stored in HTTP cookies is compromised. This is an important factor in medical applications, for example.

3. They are scalable, meaning that system performance can be increased by replicating the application across a load-balancing server farm. HTTP requests can be directed to random web servers even within a single user session, and the applications will still work reliably. The only performance bottleneck is the database, and there are existing commercial solutions for scaling databases.

We introduce the term statesafe to describe web applications that achieve these three benefits using this architecture. All web applications generated by the Eleven compiler are statesafe.

polyBSD is a "multi"-purpose (hence "poly") framework for building embedded systems based on NetBSD.

Of the three major *BSD flavors, FreeBSD and OpenBSD are often in the spotlight.
FreeBSD is touted for its stability, while OpenBSD usually claims the title of
the most secure operatin system available.

However, the third flavor (NetBSD) is what many consider to be the unsung hero - it has features that rival those of both FreeBSD and OpenBSD however is not often seen in the news. NetBSD has arguably the cleanest code base of all open source operating systems this fact has unforseen effect on its overall features. The reason for
NetBSDs clean code is the its stated goal to run on as many hardware architecture
as possible. In order to do that, the team behind NetBSD has been forced to write
code that is portable and easy to debug.

Portable code is achieved by using mostly libraries and functions that are likely to compile and run well on most platforms. In addition, in order to be able to reliably port the code to over 40 different architecture, the code has to be well written so that a large group of people can look at and understand it well so they can modify it easily and port it to a new architecture. But how does that translate into stability and security touted by FreeBSD and OpenBSD respectively. Well, clean code usually translates directly into stability - one cant expect a messy code to perform well or be easy to debug.

Clean code also leads to improved security - security bugs are easy to spot and
correct. Also the portability of the code ensures that only standard libraries
and functions are used. However, those standard libarries and functions are the
ones that have been around longer, which means they have been well tested and are
likely to contain the fewest number of security bugs.

The one feature that FreeBSD had long been able to claim exclusively is that in
terms of performance it blows all other *BSD flavors out of the water when it
comes to the i386 architecture.

However, this crown was recently captured by NetBSD thanks to an extensive performance benchmarking, the results of which are referenced on the section "NetBSD tools" on this site. So to sum it all up, NetBSD is no longer simply the portability prodigy on the block. It is a fast, rock-solid and secure operating system that can successfully meet the demands of the modern enterprise. Thats the reason for it being used by the people behind this project to build some tools that will hopefully be useful.

MantaRay project is an innovative open-source data messaging project that was designed to address the continuously changing structure of todays IT environments. MantaRay uses a new approach ? peer-to-peer serverless architecture ? that allowed its development team to create a solution that is significantly more powerful and more efficient than traditional systems.
Being lightweight and OS-agnostic, MantaRay is ideal for heterogeneous, distributed, high-traffic environments. It is highly scalable, providing much faster performance than traditional messaging systems, such as buses and brokers. MantaRays serverless design can also help IT organizations dramatically reduce hardware and operational costs.
While traditional messaging systems such as brokers, buses and home-grown solutions were appropriate for monolithic IT environments, MantaRays design takes into account the continuously changing structure of todays IT environments. By using a peer-to-peer serverless architecture, it provides distributed environments with significantly faster performance and a higher level of robustness, as well as a comparatively rapid implementation time.
MantaRays flexible and lightweight design enables it to be embedded at the application level, thus bringing all functionality to the edges and eliminating the problem of having a single point of congestion and failure. The solution brings high reliability, scalability and availability to enterprise-grade messaging, and is capable of supporting multiple components, business partners, and locations.
The open-source, OS-independent, standards-based MantaRay solution combines cutting edge technologies such as XML, enterprise-grade communication services, and Service Oriented Architecture. Building on the MantaRay framework, developers can cost-effectively create real-time data messaging solutions that reliably connect applications and provide guaranteed delivery, security and transactions.
As a Java Messenger Service (JMS) provider, MantaRay is written in 100% pure Java, supports JMS 1.x & RMI APIs, provides TCP, UDP & SSL transports, and integrates with WebLogic & WebSphere. MantaRay features publish/subscribe (topic) and point-to-point (queue) messaging services, automatic discovery, persistent/non-persistent and durable messages, and message filtering using selectors.
Main features:
- Significantly faster messaging transport performance, particularly in high-traffic applications
- Theoretically infinite scalability
- No single point of failure or congestion
- Robust architecture, such that new applications can be added without changes to the other applications
- Support of heterogeneous environments
- Ease of use and fast deployment
- No application modification necessary
- No redesign of network topology required for every change
- Open source costs and low TCO
Enhancements:
- The MantaRay open source license has been changed to MPL instead of GPL
- High availability features have been fully tested and documented

Network technology evolves quickly, but available bandwidths are still not sufficient for fast transfers of big files to a bunch of clients (for example populating operating systems installation images).

This paper describes Multicasting Master-Slave Network Filesystem (mmsnfs) -- a new method of distributing entire filesystem among several client-machines simultaneously and efficiently.

Moreover it provides mechanisms for modifying distibuted filesystem structure reliably and securing it against introducing inconsistencies. It is designed to be used in small networks of similarly-configured machines, for instance university labs or internet cafes.

Jagacy VT is a VT100/ANSI screen-scraping library written entirely in Java. Jagacy VT includes a special emulator designed to help create screen-scraping applications. It excels at creating screen-scraping applications reliably and quickly.
Jagacy 3270 is a 3270 screen-scraping library written entirely in Java. It also includes a special TN3270 emulator designed to help create screen-scraping applications. Jagacy 3270 is faster, easier to use, and more intuitive than HLLAPI. It excels in creating screen-scraping applications reliably and quickly.
Jagacy 3270 can be used in a stand-alone application, in an applet, or in an N-tier client/server environment, where the screen-scraping server is the data/resource tier.
Main features:
- 100% pure Java.
- Extended TN3270 (TN3270E) support.
- 17 different terminal types (including 132 columns).
- Internationalization support. Over 30 different code pages supported.
- Small footprint (less than 100K). Runs efficiently within the Eclipse and NetBeans IDEs.
- Can display the 3270 session in a window while an application is running.
- Configurable using properties, if desired. No code changes necessary when screens change.
- Includes a 3270 emulator tailored to developing and debugging applications.
Enhancements:
- VT220 support has been added.