Free process modeling software for linux

Process Viewer is a small utility similar to top which displays all the processes on a linux system. Its written using the FOX Toolkit.

Process Viewer is licensed under the GNU General Public License

QML (Quantity Modeling Language) is a "thing"-based language for scientific and mathematical data modeling.
Each "thing" is a quantity which may be associated with either a structure or physical phenomena.
Quantities, in turn, may hold other Quantities or values (numbers or strings). Higher-level data models, which associate or define meanings to various quantities (such as velocity or position), can be built from QML quantities.
The higher-level data model (XML) schema that inherits from QML may be understood, and its instance documents may be parsed into QML documents and objects by the QMLReader.
Enhancements:
- This release adds partial Xerces2 DOM support, and works with Java 1.4 and Java 1.5 (no JAXP DocumentBuilder/Factory support currently).
- The test procedure is a little less chatty.
- Support has been added for testing either/both Crimson/Xerces DOM support.
- (Note: Crimson support only works with Java 1.4, as Java 1.5 interfaces have DOM lvl 2 and 3, which crimson doesnt support).
- This release adds compilerargs, and better build support for different configurations to build.xml.

Config::Model::WarpedThing is a base class for warped classes.

SYNOPSIS

use base qw/Config::Model::WarpedThing/ ;

This class must be inherited by all classes that can be warped by Config::Model::Value. This class provides a set of methods that are expected by a warp master from a warped class.

Currently this class is inherited by Config::Model::Value, Config::Model::AnyId and Config::Model::WarpedNode.

WarpThing does not provide a constructor.

Apache::Storage is Perl module containing simple functions to store and retrieve information from within the Apache process.

Config::Model provides a framework to help in validating the semantic content of configuration data. The project can also be used to provide a semantic check of options of a complex program like mplayer or transcode.
For most complex software, configuration upgrade is a difficult task for most people. By using Config::Model, a software can provide a smooth upgrade path for their users.
How does this work ?
Using this project, a typical configuration validation tool will be made of 3 parts :
The user interface
The validation engine which is in charge of validating all the configuration information provided by the user.
The storage facility that store the configuration information
Dont we already have some configuration validation tools ?
Youre probably thinking of tools like webmin. Yes, these tools exist and work fine, but they have their set of drawbacks.
Usually, the validation of configuration data is done with a script which performs semantic validation and often ends up being quite complex (e.g. 2500 lines for Debians xserver-xorg.config script which handles xorg.conf file).
In most cases, the configuration model is expressed in instructions (whatever programming language is used) and interspersed with a lot of processing to handle the actual configuration data.
Whats the advantage of this project ?
The Config::Model projects provide a way to get a validation engine where the configuration model is completely separated from the actual processing instruction.
The configuration model is expressed in a declarative form (i.e. a Perl data structure) which is always easier to maintain than a lot of code.
The declaration specifies:
the structure of the configuration data (which can be queried by generic user interfaces)
the properties of each element (boundaries, check, integer or string, enum like type ...)
the default values of parameters (if any)
mandatory parameters
the targeted audience (intermediate, advance, master)
on-line help (for ach parameter or value of parameter)
the level of expertise of each parameter (to hide expert parameters from newbie eyes)
So, in the end:
maintenance and evolution of the configuration content is easier
user will see a *common* interface for *all* programs using this project.
user will not see advanced parameters
upgrade of configuration data is easier and sanity check is performed
audit of configuration is possible to check what was modified by the user compated to default values
What about the user interface ?
Config::Model will also come with a Curses::UI interface that queries the users model and generate the relevant user screens.
What about data storage ?
Since the syntax of configuration files vary wildly form one program to another, most people who want to use this framework will have to provide a dedicated parser/writer.
Nevertheless, this project can also provide a writer/parser for most common format: like ini style file, or provide an interface to the Elektra or debconf projects. This point is open for discussion.
It is entirely possible for a single configuration model to use several parsers and writers so one model will ensure the consistency of several configuration files together.
Enhancements:
- The Xorg model was updated to Config::model version 0.609.
- Some bugs were fixed.

ProM is a new era in process mining tool support.
Process Mining research is concerned with the extraction of knowledge about a (business) process from its process execution logs. Process Mining strives to gain insight into various perspectives, such as the process (or control flow) perspective, the performance, data, and organizational perspective (The processmining.org web site has more in-depth information and scientific publications available).
ProM is an extensible framework that supports a wide variety of process mining techniques in the form of plug-ins. It is platform independent as it is implemented in Java, and can be downloaded free of charge. We welcome and support practical applications of ProM! Note that the ProM framework is issued under an open source license, namely the Common Public License (CPL), and we invite researchers and developers to contribute in the form of new plug-ins.
Currently, there are already more than 90 plug-ins available, and we support the import of (and the conversion between) several process modelling languages, such as:
- Petri nets (PNML, TPN)
- EPCs / EPKs (Aris graph format, EPML)
- YAWL
- (and many more)
There are mining plugins, such as:
- Plugins supporting control-flow mining techniques (such as the Alpha algorithm, Genetic mining, Multi-phase mining, ...)
- Plugins analysing the organizational perspective (such as the Social Network miner, the Staff Assignment miner, ...)
- Plugins dealing with the data perspective (such as the Decision miner, ...)
(and many more)
Furthermore, there are analysis plugins dealing with:
- The verification of process models (e.g., Woflan analysis)
- Verification of Linear Temporal Logic (LTL) formulas on a log
- Checking the conformance between a given process model and a log
- Performance analysis (Basic statistical analysis, and Performance Analysis with a given process model)
- Finally, ProM sports a large array of log filters, which are a valuable tool for cleaning logs from undesired, or unimportant, artefacts.
Enhancements:
- This release features fundamental framework improvements and the addition of a major set of new plugins.
- The performance of log reading has been improved dramatically, introducing live modification of logs and random access.
- More than 70 newly added plugins substantially extend the analysis feature set.

GO::Model::Term is a term or concept in an ontology.

SYNOPSIS

# From a file
use GO::Parser;
my $parser = new GO::Parser({handler=>obj}); # create parser object
$parser->parse("gene_ontology.obo"); # parse file -> objects
my $graph = $parser->handler->graph; # get L object
my $term = $graph->get_term("GO:0001303"); # fetch a term by ID
printf "Term %s %sn", $term->name, $term->acc;

# From a GO Database (requires go-db-perl)
my apph = GO::AppHandle->connect(-dbname=>$dbname);
my $term = $apph->get_term({acc=>00003677});
printf "Term:%s (%s)nDefinition:%snSynonyms:%sn",
$term->name,
$term->public_acc,
$term->definition,
join(", ", @{$term->synonym_list});

Represents an Ontology term; the same class is used for process, compartment and function
currently, a Term is not aware of its Relationships; to find out how a term is related to other terms, use the a GO::Model::Graph object, which will give you the GO::Model::Relationship objects; for example

$rels = $graph->get_parent_relationships($term->acc);