Free express software for linux

Obfuna is an esoteric programming language designed to minimise the instruction set, the length of code necessary to express a program, and the readability while still remaining vaguely useful.

To achieve these goals, all Obfuna operations are assigned one-character names and take exactly one argument. In fact, the name Obfuna is derived from obfuscated (Obfuna code is, at least initially, difficult to read) and unary (All operations have exactly one argument).

There are twenty six variables and one random-access unbounded array. All variables are dynamically typed as this cuts down on the code length.
Obfuna has 26 standard variables which are represented by the lower-case letters a to z.

There is one random-access array which is infinitely extendable (well, in theory anyway; in practice this will be limited by your machines memory) which is represented by a number (indicating the position in the array - starting at 0) or a function returning a number surrounded by round brackets, i.e. ( and ). For example, the first element in the array is represented by (0). The size of the array increases as you assign to higher locations. The initial size of the array is 0.

There are two special variables used to ascertain the current size of the array. $ holds the index number of the last element in the array and % holds the number of elements in the array. From above, it will be obvious that initially $ will be -1 and % will be 0. Assigning to these variables can grow or shrink (in which case you will lose data) the array to a specified size. These are of particular use as ($) can used to reference the last element in the array and (%) will reference one element beyond the end, allowing you to add a new element, treating the array like a stack.

In addition, there are three special variables which act as I/O pipes. Passing a value to ?, prints the value to the standard output. Assigning a variable from ?, reads from the standard input. ! acts similarly except that in the case of output, it appends a newline (return) character to the value, and in the case of input, it preserves the newline from standard input. # works in exactly the same way as ? but inputs and outputs from and to the currently open file.

The syntax of Obfuna is extremely simple. There are only two types of instruction: function calls and assignments. Assigments take the form of and function calls look like or . Note you can nest functions in this way.

As an example, to assign the number 10 to the variable n, you simply write n10. There is no = operator.

Strings are quoted using the angle brackets, < and >. Anything between curly brackets, { and }, is considered a comment and will be ignored by Obfuna. These are particularly useful for naming variables more helpfully. Instead of just n10, you could write n{umber}10.

The only other syntactic element of Obfuna is the square brackets, [ and ]. Any code between a pair of square brackets will be considered a block to be processed as one instruction. This is of particular use when using flow control functions which skip or repeat only the next instruction.

Shoot UFOs. Save city. Get highscore.

Prevent aliens from destroying your city and your cannons.

You are "TheHuman" and by that you have the power to control two of the lousiest cannons in universe using them to defend yourself against the alien attackwaves. Trying to express it in a more precise way: "Kill EVERYTHING!"

PHLAK is a modular live security Linux distribution. PHLAK comes with two light guis (fluxbox and XFCE4), many security tools, and a spiral notebook full of security documentation. PHLAK is a derivative of Morphix, created by Alex de Landgraaf.
PHLAK is distributed freely. Some of the software included with PHLAK may not be GPL/GNU but can be distributed freely.
The developers of PHLAK express no warranty of any kind. Creators of PHLAK are not responsible or liable for an damages, criminal activity, misuse, or misrepresentations of PHLAK. USE AT YOUR OWN RISK!
Enhancements:
- removed XPDE and XFCE4
- removed security documentation
- removed all under /usr/share/doc/
- removed other unnecessary packages
- added iDesk to fluxbox
- updated fluxbox menus
- upgraded all applicable packages
- added usb modules to linuxrc script in miniroot.gz and new path for usb booting
- updated grub menu.lst, options.lst, and lang.lst files
- updated grub message
- updated bootsplash
- removed debian orphan packages
- purged all removed package data
- cleaned up minimod
- removed unnecessary files from base module
- modified usb pen drive install script for PHLAK compatibility
- modified PHLAK Security Panel tools and Control Panel tools

Jukebox4 is a collection of reusable components allowing to create a flexible server side middleware framework.

Save time for drinking coffee instead of architecting, designing and coding the same stuff again, and again, and again.

The project originated in 1990, when the first commercial C++ compiler became available. At that time, it was a combination of a collection framework a-la Smalltalk with the smart pointer infrastructure allowing not to bother with pointers any more.

In 1992, it was ported to MS Windows (3.x at that time). In 1993, a banking operations division support system was written using this projects codebase as a foundation. That was the first time the semaphores and multithreading were introduced.

In 1994, it was ported to OS/2, the semaphore model was redesigned, and true multithreading was achieved for the first time. A countrywide project tracking system was written using Jukebox as a foundation.

In late 1995, Java arrived. At that time it was a sad event, because with it came the realization of the fact that all the collection framework was no longer necessary, so was the smart pointer framework, and most of the semaphore and multithreading code. Well, theres no cloud without a silver lining, the thorough redesign was long overdue anyway, so the project was ported into Java during 1996. Another distributed system, this time related to securities trading, was created on top of Jukebox.

In 1998, Ive started working with Apache JServ team, and eventually sneaked my logging infrastructure into JServ, and got a nickname: "Captain Log" ;) At the same time it has become obvious that the attempt to make Jukebox a "multiprotocol distributed framework" failed, because Sun had more manpower and could release APIs much faster than I did.

In 2000, Jukebox was chosen to become the foundation for the project at American Express. That was the first take at high-load mission-critical application. Surprisingly, no major problems emerged, thus giving me some ego boost.

Then, starting in 2001, Jukebox was used at another Open Source project, DIY Zoning. This ongoing project is an attempt to scale the framework down, rather than up. The work is not yet finished, but the results, of course, will be visible.

R2cl compiler is a minimal, proof of concept translator from the R or S language into Common Lisp.

An increase in speed of over 1000 times can then be achieved using the free CMU Common Lisp native code compiler on the resulting code, making it comparable to FORTRAN, Ada or C.

Installation:

To install you need first to install cmucl (the CMU Common Lisp) and R. Both come with most Linux distributions by default but you must select them for installation. I think most recent (after 2000) versions will work. I have R 1.5.1 and cmucl x86-linux 3.0.8 18c+ running on Debian 3.0 (woody). You must be running the bash shell (which is the default) and have gnu make on your system (which you normally have).

Just untar the distribution archive:

tar xvzf R2cl-0.1.tgz

It will create the directory R2cl. Type:

cd R2cl
make

and watch translation, compilation and duration of execution of benchmarks. Thats all, except if you want to have a look at the code.

R is a reimplementation of the S language for statistical processing. It is a free project, see r-project.org. R is a highly expressive matrix language (it makes extensive use of matrix and vector operators) with a huge library of statistical functions. However, expressivity requires a dynamic execution engine based on an infinite memory model which is slow.

It also requires that expressions and function can be constructed by a program or introduced by an operator at runtime thus enforcing the an interpreted approach. This makes strighforward implementations of it slow. For programs that might have an equivalent in FORTRAN, that FORTRAN equivalent would be over 1000 times faster.

Lisp is a language with the same execution model, except the that it is even more general, and include extensive macro and object oriented feature. There are may flavors, but the main currents are Scheme (which is reductionist, favoring simplicity) and Common Lisp (the ISO standard which is extensive and highly concerned with efficient compilation).

None of these languages would be easy to fully translate, say, in C. To have the complete language you need, at least in part, to have the intepreting engine and the infinite memory machine intimately combined with the generated code.
However, there is no reason for pieces of code which make no use of the generality (such as source code generation and execution at runtime) not to be compilable to code as fast as FORTRAN. In practice, this is a huge task. Nevertheless, it was achieved in a free implementation, for example in CMU CommonLisp, as I was delighted to learn when trying these benchmarks.

The semantics of R is a subset of the semantics of Scheme. It also includes, of course, a wealth of data types suitable for statistics. The semantics (expressive mechanisms) of CommonLisp are probably a superset of Scheme. This means that R is easy to express in Scheme (actually the engine of the free implementation is a Scheme engine) and perhaps easy to translate in CommonLisp. This later is interesting because of the availability of the efficient compiler.

So I arrived at this toy project, to check if such a route for the efficient compilation of R is possible.

Many R applications dont need speed. You can describe the job you need done so quickly that you rarely mind to wait a couple of seconds for the system to do it. However, there are also whole classes of applications where speed is necessary and if a complete porting of R on CommonLisp (really big project) would be done they would all become feasible for R users like myself.

American Express Expense Report to QIF Converter project is a utility that converts American Express expense reports into QIF.
There are three main reasons:
1. American Express only offers QIF files for the last 6 months of activity whereas the expense reports go back 2 years. You can also run a report with a custom 1- to 12-month time period within 24 months of the current calendar month.
2. American Express QIF files have limited to no "categorization" whereas the expense report categorizes each transaction with a "Merchant Category" and "Subcategory".
3. American Express QIF files do not indicate which credit card in a multi-card account performed the transaction.
Main features:
- Inserts card owner and last 5 digits of the credit card in the memo field
- Reads config file for user defined rules so transactions can be automatically mapped to different accounts in your accounting software. Mapping can be based on:
- Credit card owner
- Vendor name
- AMEX "Merchant Category" and "Subcategory"
- Any combination of the above
- Sanitizes and cleans up vendor names
- Has the ability to add a prefix to all vendor names

NeoMail project is a web-based mail client which can be installed on any UNIX mail server that is also running a web server. With thousands of installations worldwide, anyone who has used their share of webmail has probably used NeoMail at some point.
In fact, theres a good chance that you arrived at this page by clicking a link on your NeoMail providers login page. Welcome! Feel free to browse around and see what others are saying about the webmail interface youve used for years.
But be advised: we cant help you with end-user issues such as login timeouts, password reset requests, and the like. We dont administer your e-mail server, we just provide the webmail software that powers it!
Main features:
- Sending/receiving messages with multiple attachments
- Inline image attachment display
- Friendly, attractive, icon-based user interface -- If you dont agree, you can create your own using the built-in interface template support!
- Multiple language support, including English, Spanish, German, French, Hungarian, Italian, Dutch, Polish, Portuguese, Norwegian, Romanian, Russian, Slovak, and more can be added easily
- Configurable limits on outgoing attachment size, folder disk usage, addressbook size...
- Users can import their address book from Outlook Express or Netscape Mail in CSV format.
NeoMail is not related to the web-based messaging service at NeoPets.com.
Enhancements:
- This release has a fix to check the session before a folder add/delete in case of a maliciously constructed request.
- This upgrade is highly recommended for all users.

Bridging the worlds of NNTP clients and RSS feeds, nntp//rss is an application that will enable you to use your existing favorit. nntp//rss works like a bridge between RSS feeds and NNTP clients, the content extracted being read by the NNTP newsreader. RSS feeds are represented as NNTP newsgroups, providing a simple, straightforward and familiar environment for news reading. nntp//rss contains both an NNTP server and an RSS aggregator, with a web interface for administration and monitoring. Installation is as simple as unpacking the distribution and running the application. It has been tested against popular NNTP newsreaders, including Mozilla, Outlook Express, MT-NewsWatcher, Free Agent, and text-based readers such as Gnus, tin and nn.