Free transcription factor software for linux

Convert::Transcribe is a Perl extension for transcribing natural languages.

SYNOPSIS

use Convert::Transcribe;

$t = new Convert::Transcribe();
$t->fromfile(filename);
# or
$t = new Convert::Transcribe();
$t->fromstring("transcription def. containing newlines");
# or
$t = new Convert::Transcribe(filename);
# or
$t = new Convert::Transcribe("transcription def. containing newlines");

$t->transcribe("text");

$t->generated_code(); # for debugging

Factor project is a language based around a programming paradigm that encourages simple, testable and reusable code.
Factors main influences are Joy for the syntax, Forth for the implementation techniques, and Lisp for the object model. The source is released under a BSD-style license. Share it freely.
Main features:
- Runs on FreeBSD, Linux, Mac OS X and Windows.
- Native code compiler for x86 and PowerPC.
- Minimal postfix syntax with an extensible parser.
- Image-based environment offering orthogonal persistence.
- Polymorphism through predicate-based dynamic dispatch.
- Language support for delegation-based design patterns.
- Data structures include linked lists, vectors, and hashtables.
- User-defined types, known as tuples.
- Rich math library including big integers, floating point, ratios, complex numbers.
- Continuations.
- Profiling, tracing, single-stepping, browsing.
- Static stack effect inference.
- HTTP server and continuation-based web framework.
- C library interface.
- SDL graphics library interface.
- Focus on interactive and test-driven development.
- A plugin for the jEdit text editor offers a powerful development environment.
Reflection
Factor is defined in terms of itself as much as possible. Every layer of the system is inspectable and editable at runtime. Everything in the system carries consistent object semantics, and every object can be queried for its type and shape.
Metaprogramming
A powerful meta-level takes advantage of the duality between code and data. The object system, and even tools such as steppers, browsers, inspectors and profilers are built within the language framework.
Transparency
Nothing is hidden from the programmer. Factor is designed not as a black box, but a tool box. The programmer is encouraged to mold the language to fit the problem.
Simplicity
Everything is as simple as possible. The system should be small enough that one person can study the code and understand it completely. Unnecessary code and features are not included.

Tango is a cross-platform open-source software library, written in D for D programmers. The project is structured as a cohesive and comprehensive library for general purpose usage, and is supported by a growing number of recognized D enthusiasts.
As a team, we feel the availability of solid and extensive documentation represents a prime factor in library accessibility, and thus this project is as much about documentation production as it is about top-notch functionality.
Enhancements:
- This release added a Signal and Slots implementation, cleans up the time package, and updates the runtime for DMD 1.014.
- Many bugs were also fixed.

Aggrevator is a cross-platform RSS/Atom aggregator that uses a MySQL 4.1 database for storage. It is designed to make life easier for people who want to subscribe to large numbers of blogs by using scoring, sophisticated search, filtering and sorting.
Its designed for people who are subscribed to many RSS and blog sites and is capable for advanced search, filtering and sorting.
Aggrevators chief distinguishing factor is its use of a MySql database to permanently store every entry fetched from every blog you subscribe to. This means that the user can read offline any of the several thousand blogs theyre interested in. Since Aggrevator is written in Java using the SWT library for its GUI the user can use it on multiple platforms (I have tested it using Linux and Windows) with a single remote database or on one machine with a local database.
Aggrevator offers the user search functionality which lets them track down entries they have read in the past even if theyre offline. The user also has the option of using the filters as a means of finding a particular blog by typing a minimal set of characters and seeing the list of candidates shrink as they type each character.
Main features:
- easy to find in large number of blogs
- filtering capabilities of blogs

Secret::Simple are secure secrets in configurations and code.

SYNOPSIS

# OOP style
my $ss = Secret::Simple->new();
my $ciphertext = $ss->encrypt($plaintext);
my $plaintext = $ss->decrypt($ciphertext);

# procedural style
my $ciphertext = ssencrypt($plaintext);
my $plaintext = ssdecrypt($ciphertext);

This module implements a straightforward interface for encrypting and decrypting secret information such as user IDs and passwords (e.g. database connection or remote account credentials). Secret::Simple can also be used on a limited basis to protect arbitrary data. By default the ciphertext returned is Base 64 encoded so as to be easily embedded within configurations or scripts.

A command-line utility called sstool is included to facilitate easy manipulation of cipher and plaintext snippets. The encryption mechanism utilizes the strong AES algorithm, so any weaknesses in Secret::Simple predominantly lie in how keys are protected. A balance must be struck between key accessibility, key protection, and overall complexity. The calling code can supply a key, series of keys, key files, or a combination. If no key information is explicitly passed, the module will attempt to use the OS users private SSH DSA key file by default if it exists.

The major goal of this module is to be as secure as possible while being simple and convenient enough to encourage its use. Psychology does factor in: simple is a very important consideration. If the security methods are too onerous or complicated to use, many sysadmins or developers may simply use plaintext (no protection other that OS file permissions) or simple ciphers like rot13. The security of the Secret::Simple method is not perfect, but it does represent a significant improvement over commonly-used nonsecure methods of embedding credentials and other secrets in Perl configurations and scripts. If used appropriately, Secret::Simple can greatly improve application and configuration security. Even so, care must always be taken to protect files and file permissions.

GIPSpin is a graphical interface programming system which allows code to be visualized and which can generate threaded code.

The user constructs code segments using visual boxes. The program flow is represented as links between the boxes. Complex elements such as threader boxes are available to implement threading.

Currently, simple C code can be automatically parsed and visualized. The user can also start with the GUI to construct code segments which are turned into C++ code.

Intended Audience:

Researchers and programmers who are interested in visual programming and threading. As stated in the development status, a lot of work remains to be done, and we would be happy for suggestions and comments.

We have found that the GIPSpin approach is also helpful for beginning programmers by reducing the intimidation factor in jumping right to text programming, and also helping develop better mental skills for grasping program flow. Seeing how the structured boxes generate code makes the task of programming seem less daunting.