Free automated teller machine software for linux

Visual Turing Machine project is a program that lets you create Turing machines with a point and click interface instead of using esoteric languages.
You can pack your complex machines into small boxes, and then reuse them as part of a bigger machine. VTM also features an infinite length tape.
Enhancements:
- New features include an n-ary set of symbols, multiple windows (MDI), a huge workspace (10000x10000 pixels) without a memory issue, the ability to edit your own machines, the ability to execute machines n times (where n is undefined), the ability to use expressions (like n+5) to execute machines, the ability to execute machines at desired speeds, statistics to see how many instructions were executed and how much tape was "used", and an easy wasy to translate the program to other languages.

This program is a port of the famous BSD game fortune.
This program currently can only be run via the command line. It is ideal for use with various e-mail clients like pine,mutt etc. to insert random quotes at the end of your e-mail or for displaying a random quote when a user logs into your unix box. A more advanced application could be to display random tips in your program.
Main features:
- Written in Java, hence Platform Independent
- Handles multiple quote files.
- Supports fortune style cookie files.
- Supports passing various command line options. More options are being integrated in.
- Easily integrable into other JAVA programms.
- Easy and straighforward code.
- Licensed under GPL which means you can access the source code and make it better according to your likes.

State Machine Compiler takes a state machine stored in an .sm file and generates the state pattern classes in nine programming languages.
Its features include default transitions, transition arguments, transition guards, push/pop transitions, and Entry/Exit actions. State Machine Compiler requires Java SE 1.4.1 or better.
Enhancements:
- This release cleans up C# and VB.net debug output using System.Diagnostics.Trace.
- It fixes a number of minor bugs.

Ragel State Machine Compiler compiles finite state machines from regular languages into executable C/C++/Objective-C code. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language.
Ragel can also be thought of as a finite state transducer compiler where output symbols represent blocks of code that get executed instead of written to the output stream.
When you wish to write down a regular language you start with some simple regular language and build a bigger one using the regular language operators union, concatenation, kleene star, intersection and subtraction.
This is precisely the way you describe to Ragel how to compile your finite state machines. Ragel also understands operators that embed actions into machines and operators that control any non-determinism in machines.
Ragel FSMs are closed under all of Ragels regular language, action specification and priority assignment operators. This property allows arbitrary regular languages to be described. Complexity is limited only by available processing resources.
For example, you can make one machine that picks out specially formatted comments in C code, another machine that builds a list all function declarations and a third that identifies string constants then "or" them all together to make a single machine that performs all of these tasks concurrently and independently on one pass of the input.
Main features:
- Describe arbitrary state machines using regular language operators and/or state tables.
- NFA to DFA conversion.
- Hopcrofts state minimization.
- Embed any number of actions into machines at arbitrary places.
- Control non-determinism using priorities on transitions.
- Visualize output with Graphviz.
- Use byte, double byte or word sized alphabets.
- Generate C/C++/Objective-C code with no dependencies.
- Choose from table or control flow driven output.
Enhancements:
- The documentation and the Ruby code generator were improved.

Joeq is a virtual machine and compiler infrastructure designed to facilitate research in virtual machine technologies such as Just-In-Time and Ahead-Of-Time compilation, advanced garbage collection techniques, distributed computation, sophisticated scheduling algorithms, and advanced run time techniques.
Joeq is entirely implemented in Java, leading to reliability, portability, maintainability, and efficiency. It is also language-independent, so code from any supported language can be seamlessly compiled, linked, and executed -- all dynamically.
Each component of the virtual machine is written to be independent with a general but well-defined interface, making it easy to experiment with new ideas.
Joeq is released as open source software, and is being used as a framework by researchers on five continents on topics ranging from automatic distributed virtual machines to whole-program pointer analysis.
Joeq is a virtual machine and compiler infrastructure designed to be a platform for research in compilation and virtual machine technologies. We had three main goals in designing the system. First and foremost, we wanted the system to be flexible. We are interested in a variety of compiler and virtual machine research topics, and we wanted a system that would not be specific to researching a particular area.
For example, we have interest in both static and dynamic compilation techniques, and in both type-safe and unsafe languages. We wanted a system that would be as open and general as possible, without sacrificing usability or performance.
Second, we wanted the system to be easy to experiment with. As its primary focus is research, it should be straightforward to prototype new ideas in the framework. With this in mind, we tried to make the system as modular as possible, so that each component is easily replaceable. Learning from our experience with Jalapeno, another virtual machine written in Java, we decided to implement the entire system in Java.
This makes it easy to quickly implement and prototype new ideas, and features like garbage collection and exception tracebacks ease debugging and improve productivity. Java, being a dynamic language, is also a good consumer for many of our dynamic compilation techniques; the fact that our dynamic compiler can compile the code of the virtual machine itself means that it can dynamically optimize the virtual machine code with respect to the application that is running on it. Javas object-oriented nature also facilitates modularity of the design and implementation.
Third, we wanted the system to be useful to a wide audience. The fact that the system is written in Java means that much of the system can be used on any platform that has an implementation of a Java virtual machine. The fact that Joeq supports popular input languages like Java, C, C++, Fortran, and even x86 binary code increases the scope of input programs. We released the system on the SourceForge web site as open source under the Library GNU Public License.
It has been picked up by researchers on five continents for various purposes, among them: automatic extraction of component interfaces, static whole-program pointer analysis, context-sensitive call graph construction, automatic distributed computation, versioned type systems for operating systems, sophisticated profiling of applications, advanced dynamic compilation techniques, system checkpointing, anomaly detection, secure execution platforms and autonomous systems. In addition, Joeq is now used as the basis of the Advanced Compilation Techniques class taught at Stanford University.
Joeq supports two modes of operation: native execution and hosted execution. In native execution, the Joeq code runs directly on the hardware. It uses its own run-time routines, thread package, garbage collector, etc. In hosted execution, the Joeq code runs on top of another virtual machine. Operations to access objects are translated into calls into the reflection library of the host virtual machine.
The user code that executes is identical, and only a small amount of functionality involving unsafe operations is not available when running in hosted execution mode. Hosted execution is useful for debugging purposes and when the underlying machine architecture is not yet directly supported by Joeq. We also use hosted execution mode to bootstrap the system and perform checkpointing, a technique for optimizing application startup times.
Joeq system consists of seven major parts:
- Front-end: Handles the loading and parsing of input files, such as Java class files, SUIF files, and binary object files.
- Compiler: A framework for performing analyses and optimizations on code. This includes the intermediate representation (IR) of our compiler.
- Back-end: Converts the compilers intermediate representation into native, executable code. This code can be output to an object file or written into memory to be executed. In addition, it generates metadata about the generated code, such as garbage collection maps and exception handling information.
- Interpreter: Directly interprets the various forms of compiler intermediate representations.
- Memory Manager: Organizes and manages memory. Joeq supports both explicitly-managed and garbage-collected memory.
- Dynamic: Provides profile data to the code analysis and optimization component, makes compilation policy decisions, and drives the dynamic compiler.
- Run-time Support: Provides runtime support for introspection, thread scheduling, synchronization, exception handling, interfacing to external code, and language-specific features such as dynamic type checking.

Wayback Machine is an open source java implementation of the The Internet Archive Wayback Machine.
The current production version of the Wayback Machine is implemented in perl, and lacks in maintainability and extensibility. Also, the code is not open source. Primary motivation for the new version is to address these three issues, enabling public distribution of the application, and easy experimentation with new features and access technologies.
The current Java version of the Wayback Machine supports two access, or replay modes of operation: "Archival Url" mode and "Proxy" mode.
Archival URL mode provides a user experience very close to the current production Wayback Machine. All query and replay access requests can be expressed as URLs.
In Archival Url replay mode, HTML documents are delivered with additional Javascript embedded in the page. This Javascript alters the document within the browser, attempting to make links and embedded content refer back to the Wayback Machine by rewriting them as Archival URLs.
Proxy URL mode allows replaying of archived documents within a client browser by configuring the browser to proxy all HTTP requests through the Wayback Machine. This has the strong advantage that no Javascript page markup is required to coerce the client browser to request additional URLs and embedded content from the Wayback Machine -- content just works as-is. One major disadvantage of this mode is that there is no way to forward temporal information with each replay request. Because of this limitation, only the most recently archived version of any resource is accessible thru the Wayback Machine in proxy Url mode.
Another limitation of the Proxy URL mode is that it requires special configuration of the client web browser to access the Wayback Service. This browser configuration is not complex, but it means that content cannot be accessed as a global URL.
See the User Manual to learn more about access modes.
The current Java version is intended to operate as a standalone webapp, maintaining an index on the machine hosting the webapp. This index contains records of the resources within a set of ARC files, which are also assumed to be stored on the same machine hosting the webapp.
This software includes the capability to scan for ARC files in a specified location, and to automatically index and serve content in newly discovered ARC files as they appear. Directing the Wayback Machine to look for ARC files in the directory where an instance of the Heritrix web crawler is writing ARC output should provide the capability to browse content archived by Heritrix as it is crawled.
Future versions of this software may integrate more tightly with the Heritrix web crawler application.
Enhancements:
- A sorted CDX flat file ResourceIndex implementation was added, allowing for much larger data sets.
- Support for ArchivalUrl Date-Range requests was added.
- Character set detection was improved so pages are not mangled when server side modification occurs.
- Several new command-line tools were added for generating and updating each ResourceIndex type.
- Indexing and merging processing were separated into different threads.
- Bugfixes were made to allow integration with NutchWax full-text searching.