Free learn russian language software for linux

Russian Language Learning is a Java application that helps you to learn Russian using the Leitner system.

Memorizing words and phrases will not only be more efficient, but the system is a joy to use. Each card also has the phrase spoken by a native russian speaker, to help with pronunciation.

The Leitner system is a way of progressively learning words by placing them in stacks. The words you know are placed in stacks seperate from the words that are still troubling you, for more efficient learning.

And there is one other thing about Tanooshka.com language learning. Each set of cards, are the words to a movie, so when youve learned the set of words, you can watch the movie, and understand it! In Russian!

File Selection Language (FSL) is a descriptive language for file selection. File Selection Language is used to selectively pick files from a directory structure.
FSL is useful for selective backups, for instance. FSL uses glob patterns as the basic building block.
For fine-tuning the selection, inclusion/exclusion rule combinations and conditional expressions are available. File size and modification date can be used in expressions.
Main features:
- FSL can be used with a command line tool (fsltool) or, for Python programmers, with a programmable interface. For the Python interface, see the documentation of Interpreter.py.
- Several FSL rule files can be combined in a cascading manner similar to CSS. The effect is the same as if the rule files were pasted into a single file.
- Support for both Windows-like and Unix-like paths.
- Strict parse-time type checking to catch as many errors as possible before run-time. For example, you cant say EACH f IF size(5) > 1000 because function size expects filename argument.

MetaTrans::Languages Perl module contains a simple "database" of most of the known languages. Extracted from MARC codes for languages, http://www.loc.gov/marc/languages/.

SYNOPSIS

use MetaTrans::Languages qw(get_lang_by_code get_code_by_lang);

print get_lang_by_code(afr); # prints Afrikaans
print get_code_by_lang(Afrikaans); # prints afr

FUNCTIONS

get_lang_by_code($code)

Returns the name of the language with $code or undef if no language with such a $code is known.

get_code_by_lang($language)

Returns the code of the $language or undef if the language is unknown.

is_known_lang($code)

Returns true if the language with $code exists in the "database", false otherwise.

get_langs_hash

Returns the {code_1 => language_1, code_2 => language_2, ...} hash containing all known languages and their codes.

get_langs_hash_rev

Returns the {language_1 => code_1, language_2 => code_2, ...} hash containing all known languages and their codes.

2E Programming Language (two es, as in ee, or expression evaluator) is a simple algebraic syntax language. It natively supports expressions (composed of operators and operands), and function definitions, and basically nothing else. Therefore, it can be fairly straight-forward to learn (assuming you are already familiar with general programming constructs).
The language itself is refered to as 2e, however the interpreter is called ee.
An operand can be a literal, such as a numeric value (integer or floating point), a quoted string, a single-quoted character, a variable or a function call. Operators consist of the standard algebraic operators (i.e., *, /, +, -), assignment ("="), logical operators (, =, ==), sub-expression join operator (";"), and a conditional operator pair ("? :") like in C. Also added, is an iterative conditional pair ("?? :").
Heres a couple of examples:
ee -p 2 + 3 * 7
23
In this case, when called with the "-p" flag, the next parameter is evaluated and the final result printed. The "-c" flag does the same thing, but doesnt print the final result (use this when the expression already contains output statements).
ee -c x = 7; y = 11; z = (x * y); print(z; "n")
77
The ";" operator isnt really a statement terminator, it is actually a join operator. It evaluates the left and right expressions, and returns the result of the right hand side. It has the lowest order of precedence, so in general use you can treat it like a statement terminator (however it can be used in the middle of a larger expression, such as within parentheses grouping). It also does double-duty as a function parameter delimeter, such as the print function in the previous example.
The way that the "?" (conditoinal) operator works is as follows:
result = expr_test ? expr_true : expr_false
If expr_test is true (non-zero), then expr_true is evaluated and returned, otherwise expr_false is evaluated and returned. This is just like the inline conditional in C.
Also supported, is the iterative conditional:
result = expr_test ?? expr_true : expr_false
This will evaluate expr_test repeatedly, and as long as it is true, will evaluate expr_true. Once expr_test becomes false, then the final expr_true value is returned as the result of the whole expression. However, if expr_test never was true to begin with, then and only then is expr_false evaluated and returned. Therefore, expr_false can be used for some error handling, for example.
If an operator of lower precedence than ? or ?? is encounterd such as the ";" (join) operator, then a default false target will automatically be assumed. Therefore,
result = expr_test ? expr_true : 0; ...
result = expr_test ? expr_true; ...
are both the same. Heres a more extensive example, highlighting a few more of the operands avaliable. This example also calls the interpreter using the unix "#!" syntax, same as what is used for other scripting languages.
#!/usr/local/bin/ee
# This is a comment
i = 0;
x = 0;
i < 10 ?? ( # Read this as "while i is less than 10"
j = 0;
j < 5 ?? ( # while j < 5
array[i][j] = x; # here we are assigning a value to a 2-dimentional array
j++;
x++
);
i++
)
This example uses the iterative conditional operator to initialize an array. Notice the missing ";" after x++ and i++. this is because they are not followed by an operand (instead, in this case are followed by a closing parenthese). The ";" operator is a binary operator, no different than +, -, *, /, etc. Therefore, it is only used between to operands or two sub-expressions.
Enhancements:
- This release adds a bunch of functions to round out the string handling capabilities of 2e.
- Also added are "anonymous" functions, bitwise operators, and a few code cleanups.

Arena Scripting Language is a light-weight scripting language. The language uses a syntax and library similar to that of ANSI C, but adds automatic memory management and runtime polymorphism on top of that.
Main features:
- syntax similar to ANSI C
- standard library similar to ANSI C
- automatic memory management
- runtime polymorphism
- support for exceptions
- support for anonymous functions
Enhancements:
- This release changes the system() library function to return the raw exit status as given by the operating system.

Tom is a software environment for defining transformations in Java. TOM programming language is an extension of Java designed to manipulate tree structures and XML documents. It is compatible with Java: a Java program is a correct Tom program.
Data are represented using an efficient tree based data-structure. Java built-ins (int, char, String, etc) can be used. Tom provides pattern matching facilities to inspect objects and retrieve values. A powerful strategy language can be used to control transformations.
Enhancements:
- The Eclipse plugin is now available again.
- In the %match construct, the sort of the subject is now optional.
- It is automatically inferred from the patterns when possible.
- Gom generates congruence strategies and offers new functionalities, such as the length of a list.
- A new "!" construct can be used to denote anti-patterns.
- The strategy library has been extended such that strategy expressions can be matched, like any other term.
- A strategy can now take another strategy in its argument.
- Support for Java bytecode analysis and transformation has been added.

The Hecl Programming Language is a high-level scripting language implemented in Java. Hecl Programming Language is intended to be small, extensible, extremely flexible, and easy to learn and use.

Hecl is intended as a complement to the Java programming language, not a replacement. As such, it tries to do well what Java doesnt, and leaves those tasks to Java for which it is best suited.

Hecl aims to be a very immediate language - you can pick it up and start doing useful things with it quickly. It is also meant to be easy to learn. Where Java is verbose and rigid, Hecl is forgiving and quick to write. For instance, System.out.println("Hello World"); vs puts "Hello World" - 41 keystrokes (shifted letters count double) versus 22. Hecl is built to "scale down".

This makes Hecl ideal for large applications written in Java that would like to provide a user friendly scripting interface, rather than, say, a clunky XML based configuration system.

Hecl is also a small language with a minimal core. The idea is to provide only whats necessary in the language itself, and as needed, add in extensions for specific tasks.

Core Hecl is small enough to run on my Nokia 3100 cell phone as a J2ME application, presenting the interesting possibility of writing scripts, or at some point, maybe even scripting entire applications, for devices running embedded Java. As an example, you can try this MIDlet: Hecl.jar Hecl.jad