Free expression language software for linux

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.

Plone Language Tool is a product which allows you to set the available languages in your Plone site.
PloneLanguageTool allows you to set the available languages in your Plone site, select various fallback mechanisms, and control the use of flags for language selection and translations.
When installed, a new Plone control panel action will allow you to select various language options, such as the default and list of allowed languages.
PloneLanguageTool is shipped with Plone beginning in version 2.1 and up.
Enhancements:
- Bug fix release included in Plone 2.5.2.

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!

regular expression parser is a C++ regexp parser that accomplishes The Open Group specification Issue 6, IEEE Std 1003.1, 2004 Edition.

regular expression parser allows you to parse input using regular expressions, and to retrieve parsed sub-expression matches in a few steps.

Open Dice Language project is a language for describing dice rolls.

Open Dice Language is a language for describing dice rolls.

The language is nearly identical to what you see in most role-playing game texts (e.g., "1d20"). It provides several interfaces to the language.

To run in CLI interface mode:

# pushd $ODL_HOME
# java -jar ODL.jar

To run as Widget:

build using `ant widget`
widget is now installed in users widget directory

PATH is a very different programming language than what you are probably used to if youre an average programmer. If youve programmed in the language Brainf*ck, youll recognize the memory cell architecture. Also, Befunge programmers will recognize the two-dimensional way that PATH programs are laid out.

PATH programs are laid out on a two-dimensional grid. It follows a path of instructions on the program grid, turning 90 degrees when instructed to (hence the name). A character recognized by the interpreter is called an instruction symbol.

To show you what a PATH program actually looks like, heres a simple program that coincidentally spells out the word "PATH" in large ASCII art letters. (You may recognize it from the PATH program homepage, and its also included with the interpreter.) All it does is make the console beep. Ill explain it in detail later, once you know what all the instruction symbols do.

The interpreter starts at the first "$" symbol it finds and starts heading right. Every time it encounters a valid instruction symbol, it executes it. When it encounters certain special symbols, it may turn in another direction.

The interpreter keeps going until it reaches a "#" symbol. If it encounters a character that is not a valid instruction symbol, it ignores it and skips over it.