Free objective modula 2 1.00 language definition software for linux

SML is a "toy" machine language intended to teach basic processor concepts. This website contains an explanation and definition of SML, as well as an interpreter and example SML programs. GPLd source code for the interpreter is available, as well as binaries for Windows and Linux.

A machine language defines a set of instructions that a CPU can execute to perform operations. In other words, a machine language defines what you can do with your computer. Modern processors have very complex instruction sets; however, the simple language described here can give you an understanding of what is happening "under the hood" with your computer.

Machine language is the actual data that is directly run by the processor. Writing a program in machine language can therefore be advantageous if you need to save space or highly optimize your code. However, machine language is also not portable and can be difficult to understand and maintain.

Therefore, almost all code is now written in a higher level language, such as C, C++, Java, or scripting languages such as shell or perl. These languages all have their advantages and disadvantages as well, such as varying levels of portability, maintainability, scalability, and execution speed.

One level higher than machine language is assembly language. Assembly language is basically readable machine language. Instead of writing out the code bit-by-bit, you write out the code as a sequence of human readable instructions, which are then compiled almost directly into machine language.

Assembly language is almost always used instead of machine language when such a direct level of control is needed. For example, some games implement part of their code in assembly in order to maximize execution speed. Assembly can be "inlined" into some higher level languages, like C. This means that the assembly is defined as a callable procedure from within the C code.

eXtensible Server Side Markup Language is based on XML and Struts technologies, and allows for an easy and streamlined creation of various technical and business rules with further implementation as Web services and interfaces.

It features the ability to define XML structures and ties such to actual Java code, conditional and flow processing logic, variable definition by value and reference, and logging both at class and custom component level.

The Mozilla Afrikaans Language Pack provides translations of the Mozilla suites Web browser, email program, and editor into Afrikaans.

All functions, errors, menus, and buttons are translated into Afrikaans.

Geometry Description Markup Language (GDML) workpackage is primarly ment to provide geometry data exchange format for the LCG applications. The workpackage consists of the GDML Schema part, which is a fully self-consistent definition of the GDML syntax and the GDML I/O part which provides means for writing out and reading in GDML files.
The GDML Schema does not depend in any way on the GDML I/O packages. In particular, new extensions to the GDML I/O packages can be implemented (interfaces to new application, like for instance visualisation, editors, etc), while the GDML Schema definition remains unchanged.
Enhancements:
- The loop machinery was improved so that any volume can be used in a loop.
- An installation script was added along with support for auxiliary volume information.
- A SimpleExtension example that shows how to extend GDML with custom elements was added.
- The obsolete PyGDML package was removed.

Luban is a component oriented scripting language. Luban is free and open source. Luban is named after a legendary ancient Chinese civil engineer and carpenter two thousand year ago whose constructions are still in use today.
The programming language spectrum seems crowded. Do we have all the tools we need? The author of Luban likes the scripting languages in general because of their usability. Though he always feels the pain for the lack of suitable component model for scripting.
And he personally considers object oriented scripting is too complicated for scripting purpose and will never compete with C++/Java. He eventually created Luban, a scripting language with a robust component model tailored for scripting purpose. Luban is an easy scripting language that is as clean and manageable as Java.
There have been numerous discussions about software component without clear definition. Lubans definition of component is property based object that is similar to Java Bean. User interacts with component by reading and writing property values, and computation could be triggered by the interactions.
The idea of Luban programming language that scripting language needs a different component model other than conventional class hierarchy to fit its scripting environment. A complete mechanism is built in Luban to define, save and categorize components, which is a fundamental feature of Luban.
Enhancements:
- This release adds the new feature to iterate through the elements in Java container objects.
- The following Java types can now be iterated in Luban: Java array, java.util.Collection, and java.util.Map.

V language is a tiny concatenative language implemented for experimentation.
The source is under Public Domain (un-copyrighted.)
The full featured language is on top of JVM, A native version (in alpha state) is also there in the codebase.
To run it, extract the distribution in any directory and do #gmake run.
gmake
gmake run
V
|
The language is a close relative of postscript, forth and joy. and is stack based. ie:
|2 3 *
=6
|2 3 * 5 +
=11
See status for a tutorial and more info.
The Functions available in V are available in this page: functions
(The releases are out of date and multiple fixes have gone in. Please check out and build rather than use them.)
Example functions in V. getting the roots (with out using the stack shuffling word view)
[quad-formula
[a b c] let
[minisub 0 b -].
[radical b b * 4 a * c * - sqrt].
[divisor 2 a *].
[root1 minisub radical + divisor /].
[root2 minisub radical - divisor /].
root1 root2
].
|2 4 -30 quad-formula ??
=(-5.0 3.0)
using view
[quad-root
[a b c : [0 b - b b * 4 a * c * - sqrt + 2 a * /]] view i
].
|2 4 -30 quad-root ??
=(3)
contrast this with the definition in scheme here
(define quadratic-formula
(lambda (a b c)
(let ([minusb (- 0 b)]
[radical (sqrt (- (* b b) (* 4 ( * a c))))]
[divisor (* 2 a)] )
let ([root1 (/ (+ minusb radical) divisor)]
[root2 (/ (- minusb radical) divisor)])
(cons root1 root2)))))
Definition of Qsort.
[qsort
#definitions
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
#args starts for binrec. notice that 2 arguments (termination condition
#and its result) are on first line.
[small?] []
[split_on_first_element]
#binrec recurses on the result of split_on_first_element before applying joinparts.
[joinparts]
binrec].
Some explanations.
The first and second lines (terminated by .) are internal function definitions
(Notice how qsort is also terminated by .) . is the definition syntax in V.
The first function joinparts
============================
The function joinpart contains just an application of the operator view.
view is list translator. It takes a list of the form [template : result]
then it tries to apply the template to the current stack. If it can be applied on the
stack, then the arguments named in the template are bound to values in stack. The result is then processed, and all the bound elements in result are replaced by their values.
[pivot [*list1] [*list2] : [*list1 pivot *list2]] view expects 3 arguments on the stack,
the first a single element pivot, then two lists list1 and list2.
It returns a list that is composed of elements of list1 followed by pivot
followed by elements of list2 (as defined in result - RHS of :).
ie:
44 [1 2 3] [5 6 7] [pivot [*list1] [*list2] : [*list1 pivot *list2]] view ??
=> [1 2 3 44 5 6 7]
(The function ?? is used to print out the elements in the stack now.)
The second function split_on_first_element
==========================================
The definition is [uncons [>] split&]
The uncons splits a list into the first element and the rest of the list.
ie:
[1 2 3 4 5] uncons ??
=1 [2 3 4 5]
split& takes two arguments, the first is the function F to split a list with,
and the second the list itself. All elements in the list that passes the function F
is put into the first list, and all that do not are put into the second list.
ie:
[1 2 3 4 5 6 7] [4 >] split& ??
=[5 6 7] [1 2 3 4]
The function F can also take an argument from the stack. so this also works.
4 [1 2 3 4 5 6 7] [>] split& ??
=[5 6 7] [1 2 3 4]
Thus the split_on_first_element takes the first element of a list, and split that
list based on that element as a filter.
binrec
=======
binrec expects 4 arguments,
Arg1 is the terminating condition,
Arg2 is the result if the terminating condition is met.
Arg3 is an executable statement that returns two entities.
The entire binrec statement is performed on each of the
two entities until the terminating condition is met.
Arg4 is what to do with the result of the previous statement.
Algorithm.
Here, the small? checks if the list is empty or contains just one element.
if it is, then the result is arg2 - []
ie:
[] small? ??
=true
[1] small? ??
=true
[1 2 3 4] small? ??
=false
split_on_first_element takes is executed on all lists that are larger than size 1
and as explained above, splits them into two based on the first element.
on the resultent lists, the entire qsort is performed again due to binrec.
The last joinparts takes these elements (pivot list1 list2) which are present now
on the stack, and combines them to produce a single sorted list.
A slightly friendlier function (with out the binrec.)
[qsort
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
[small?]
[]
[split_on_first_element [list1 list2 : [list1 qsort list2 qsort joinparts]] view i]
ifte].
The binrec and friends are more powerful than the explicit recursion done above, but for people new to concatenative languages, this kind of recursion may look more intuitive.
Enhancements:
- The language has become relatively stable.
- Lots of bugfixes were made in scope handling.
- Tree operations were added.
- Generic combinators were moved out into a separate library.

Translate! (multi-language) is a Google-based, over-the-network translation desktop widget.

It automatically supports all languages translate.google.com supports as of the moment you start the widget.

(Double-)Click the Wrench button on the middle to chose the language pair.