Free humans software for linux

Humanzip is a compression program that operates on text files. Unlike most compression algorithms, its output is human readable. Indeed, it is explictly meant to be read by humans and might even be easier to read than the original.

This application compresses files by looking for common strings of words and replacing them with single symbols. The idea is to reduce the screen and print size of documents. humanzip does not explictly try to reduce the size of the file as measured in bytes, although this usually happens incidentally.

Installation:

There is no configure script. I assume that you have a modern GNU/Linux (or similar) system that has the usual libraries and so forth. Nothing unusual is required, just a C++ complier (g++, probably). If you want to change the install location, edit the very simple Makefile.

To compile, say "make".

To install, say "make install".

To uninstall, say "make uninstall".

HTML::Clean module cleans up HTML code for web browsers, not humans.

SYNOPSIS

use HTML::Clean;
$h = new HTML::Clean($filename); # or..
$h = new HTML::Clean($htmlcode);

$h->compat();
$h->strip();
$data = $h->data();
print $$data;

The HTML::Clean module encapsulates a number of common techniques for minimizing the size of HTML files. You can typically save between 10% and 50% of the size of a HTML file using these methods. It provides the following features:

Remove unneeded whitespace (begining of line, etc)
Remove unneeded META elements.
Remove HTML comments (except for styles, javascript and SSI)
Replace tags with equivilant shorter tags (< strong > --> < b >)
etc.

The entire proces is configurable, so you can pick and choose what you want to clean.

uml2svg is an XSLT-based tool for converting XMI-compliant UML Diagrams into SVG.
We started the developing uml2svg with six main goals in mind:
- Standard conformance
- Good Documentation
- Modularity
- Extensibility
- Comprehensible SVG
- Multiple diagrams per XMI-file
SVG is a standard language for describing two-dimensional vector graphics in XML. As the open SVG standard gains in popularity and gradually replaces proprietary formats for vectorial graphics, the support provided by the Web browsers is getting better.
Plugins to display SVG exist for most browsers and it is most likely that the next generation of Web browser will provide built-in support for SVG. When that happens there will be no better way to distribute vector graphics on the web. Furthermore, not only web browsers can process SVG in a meaningful way; in fact that is just the tip of the iceberg. SVG can be easily read in, processed, and then transformed into many other formats, being well suited for both text and graphic tools as well as for web agents and screen readers.
UML diagrams are composed of lines, polygons, ellipses and text labels, so they are inherently vectorial. However, the SVG is not very well suited for direct use by UML tools. While some of them can in fact export UML diagrams directly to SVG, they do that by discarding all the information about structure, and converting everything into a shape. Moreover, some tools use the screen-capture function provided by their environment (such as java2d) and then they apply a filter to generate SVG out of the "screenshot".
What comes out of that is a pile of meaningless information, which by accident happens to draw a gorgeous diagram. How will a screen reader interpret such a file? How will a web crawler be able to index it? How will a web agent process it in a meaningful way? A program needs the semantic information that the humans can extract just by looking at a picture. For a machine, an obfuscated SVG file is not easier to process than a PNG file or any other image.
Although for humans it is better to be able to scale the image, for a program this is irrelevant. Programs need a way to "understand" the semantics of the UML models to be able to process and interchange them in a meaningfull way. This was the main idea behind the XML Metadata Interchange (XMI), an OMG specification for model interchange. And probably the best use that XMI has found so far is the exchange of UML models between different modeling tools. And while the XMI provides a standard way for tools to represent models as XML documents, it is still limited to the model elements only.
With the introduction of the UML 2.0 Diagram Interchange Specification as part of the upcoming UML 2.0 standard, it will become possible for tools to exchange the models together with the layout of the diagrams. We think that, once this specification appears, XMI will be used averywhere. Not only will the tools be able to exchange diagrams, but could even represent them internaly as DOM trees. Have you ever considered drawing your UML diagrams online, using only a web browser? This could be done even now by using a custom SVG syntax for the DOM tree, but a solution based on XMI could do even better and be a standard at the same time.
Therefore, we believe that with the advent of UML 2.0 and the increase in the use of SVG, the need for transformations between XMI and SVG will be great. Nevertheless when the uml2svg project was started, there was hardly any good open-source solution to convert XMI diagams into SVG.
The UML 2.0 Diagram Interchange Adopted Specification in its current incipient form references a set of XSL transformations. Although the standard draft covers them to a large extent, the link is actually broken (you can try for yourself). It has been broken for more than a year and most likely it will stay like that forever.
The personal webpage of Professor Mario Jeckle provides an online transformation service capable of dynamically generating SVG from XMI-compliant XML files. The XSL files accomplishing the transformations are also available on that website. These transformations are monolithic and not well documented (the only documentation is in the code, and it is generally written in German). With the tragic accident that took the life of Professor Jeckle, the transformations have no longer been maintained.
Finally, the STZ-IDA research center in Karlsruhe had to convert UML diagrams to SVG, as part of one of their projects. The XSLT stylesheet they created for this purpose was named xmi2svg and is available under the terms of the MIT license. At the time we started work on uml2svg the only type of diagrams supported was class diagrams.
Recently the package reached version 0.2 and it supports more diagram types, without major changes in the code (the opposite of what we were expecting). Andreas Junghans, the author of xmi2svg, provided us with a lot of insightful hints which helped us eliminate many glitches in uml2svg. It looks that the development of uml2svg and xmi2svg will continue in parallel, at least for a while. The good thing about this is that the two (quite different) implementations prove each others validity and the features tend to propagate freely from one side to the other. However, this comes with the prize of having to maintain two different code-trees and possibly confusing some users.
We did not like the two existing solutions because they were:
incomplete - just prototypes, not well suited for production environment
monolithic - hard to maintain and extend
not documented - hard to understand
At first sight, we thought we could find a way to improve one of the existing solutions and just add the features we needed. However, we slowly came to the conclusion that it would be better if we started anew. There are things one can fix in a project, but that does not include what we thought is was bad design. The fact that the two implementations presented above are open source helped us get quickly on the way with our own project.
Enhancements:
- Two annoying bugs were fixed.
- The site and documentation were updated.

Microracers is a fun 2D top-view racing game.

Microracers aims to be a fun 2D top-view racing game. It is inspired on the old Micromachines game, but it isnt meant to be a clone of it.

For now, it only has a racing gameplay where you have to beat computer vehicles (or other 3 humans on the same seat) by completing 2 laps the first.

The game is under the GPL. Everyone is free to contribute! Contact us.

Dark Lands project is an ANSI based RPG game.
Dark Lands is a multiplayer RPG made fully with ANSI graphics. The source code is in Pascal. Currently, this game has probably no point except exploring the areas and killing monsters. It can be used as a BBS door game.
Main features:
- Door.sys, doorfile.sr and chain.txt support
- up to 115200 bps speed and up to 99 comports
- Easy setup and installation
- Local mode play
- 12 major races and over 60 subraces, including Humans, Dragons, Elf, Undead and Lycanthropes.
- 9 character alignement combinaison are possible
- 12 god to chose from, and player can be atheist
- over 100 different rooms
- over 15 monsters
- over 200 racial skills and 13 racial disadvantaged (most are still not implemented)
- Require a Fossil driver to work
- Online help system
- Players can build their own cities, raise armies and manage it
- And, best of all, this is emailware, just complete the form in the email section and youll receive your registration key at no charge at all.
Enhancements:
- BBS independant operation (optionnal)
- Internal login system
- Max time on
- Daemon operation DPMI + Linux are now functionnal ports.
- Faster Disk i/o
- Sysop can disable the sysop keys in the setup. (security)

maRBL project is a policy daemon for Postfix that lets you trigger any Postfix action as a result of an RBL match.

There are only a couple good, practical options for spam filtering, but none of them are 100% effective. Statistical filters can come very close to perfection, but at the cost of CPU time -- you cant filter something until youve received it and spent some time analyzing it -- and there are few good options for blocking hosts outright.

What about RBLs?
RBLs are simple, fast and efficient but they frequently have false positives. Theres an implicit level of trust required: you have to trust RBL administrators to add and remove hosts in a timely and accurate fashion from their lists. The problem is that only a fraction of lists are entirely automated, mosts have humans involved in the process, and humans are fallible. Worse, humans are vindictive, many lists go for collateral damage by blocking large ranges of IP addresses in an effort to arm-twist ISPs into being more responsive about their spam problem.

What about Greylisting?
Greylisting relies on the fact that most spam is no longer sent through real mail servers, and instead is sent from subpar SMTP engines. Greylisting forces senders to wait for a period of time and retry, something many of these engines are incapable of. The problems are that it fares poorly when handling mail from large ISPs that have SMTP clusters (theres no guarantee that the retry will come from the same IP address), that it introduces more delay to the process of receiving an email, and that occasionally you will run across non-RFC compliant mailservers that treat a temporary delivery failure as a permanent one.