Free data from quantitative research are best expressed by software for linux

Amiga Research Operating System (AROS) is a portable and free desktop operating system aiming at being compatible with AmigaOS 3.1, while improving on it in many areas. The source code is available under an open source license, which allows anyone to freely improve upon it.

Goals

The goals of the AROS project is it to create an OS which:

1. Is as compatible as possible with AmigaOS 3.1.
2. Can be ported to different kinds of hardware architectures and processors, such as x86, PowerPC, Alpha, Sparc, HPPA and other.
3. Should be binary compatible on Amiga and source compatible on any other hardware.
4. Can run as a standalone version which boots directly from hard disk and as an emulation which opens a window on an existing OS to develop software and run Amiga and native applications at the same time.
5. Improves upon the functionality of AmigaOS.

To reach this goal, we use a number of techniques. First of all, we make heavy use of the Internet. You can participate in our project even if you can write only one single OS function. The most current version of the source is accessible 24 hours per day and patches can be merged into it at any time. A small database with open tasks makes sure work is not duplicated.

History

Some time back in the year 1993, the situation for the Amiga looked somewhat worse than usual and some Amiga fans got together and discussed what should be done to increase the acceptance of our beloved machine. Immediately the main reason for the missing success of the Amiga became clear: it was propagation, or rather the lack thereof. The Amiga should get a more widespread basis to make it more attractive for everyone to use and to develop for. So plans were made to reach this goal. One of the plans was to fix the bugs of the AmigaOS, another was to make it an modern operating system. The AOS project was born.

But exactly what was a bug? And how should the bugs be fixed? What are the features a so-called modern OS must have? And how should they be implemented into the AmigaOS?

Two years later, people were still arguing about this and not even one line of code had been written (or at least no one had ever seen that code). Discussions were still of the pattern where someone stated that "we must have ..." and someone answered "read the old mails" or "this is impossible to do, because ..." which was shortly followed by "youre wrong because ..." and so on.

In the winter of 1995, Aaron Digulla got fed up with this situation and posted an RFC (request for comments) to the AOS mailing list in which I asked what the minimal common ground might be. Several options were given and the conclusion was that almost everyone would like to see an open OS which is compatible to AmigaOS 3.1 (kickstart 40.68) on which further discussions could be based upon to see what is possible and what is not.

So the work began and AROS was born.

Hierarchical Data Format is a general purpose library and file format for storing scientific data.
HDF5 can store two primary objects: datasets and groups. A dataset is essentially a multidimensional array of data elements, and a group is a structure for organizing objects in an HDF5 file. Using these two basic objects, one can create and store almost any kind of scientific data structure, such as images, arrays of vectors, and structured and unstructured grids. You can also mix and match them in HDF5 files according to your needs.
Efficient storage and I/O.
HDF5 was created to address the data management needs of scientists and engineers working in high performance, data intensive computing environments. As a result, the HDF5 library and format emphasize storage and I/O efficiency. For instance, the HDF5 format can accommodate data in a variety of ways, such as compressed or chunked. And the library is tuned and adapted to read and write data efficiently on parallel computing systems.
Software.
NCSA maintains a suite of free, open source software, including the HDF5 I/O library and several utilities. The HDF5 user community also develops and contributes software, much of it freely available. Unlike HDF4, there is little commercial support for HDF5 at this time, but we are successfully working with vendors to change this.
Emphasis on standards.
Data can be stored in HDF5 in an endless variety of ways, so it is important for communities of users to standardize on how their data is to be organized in HDF5. This makes it possible to share data easily, and also to build and share tools for accessing and analyzing data stored in HDF5. The NCSA HDF team works with users to encourage them to organize HDF5 files in standard ways.
Large and varied user community.
HDF5 users range across a variety of engineering and scientific fields, and even some non-technical fields. Data stored in HDF5 is used for a wide range of applications, from computational fluid dynamics to film making.
Main features:
- Parallel HDF5 - Information on installing and using Parallel HDF5
- SZIP Compression - Information about SZIP Compression in HDF5
- Thread Safe HDF5 - Information on thread-safe capabilities of HDF5 and how to install
- The High Level HDF5 APIs, previously distributed separately, are now distributed as part of the main HDF5 Library:
- High Level HDF5 APIs - Information on installing and using the High Level HDF5 APIs
Applications:
- HDF Java Products - HDF4/HDF5 Java interfaces and viewer, HDFView.
- HDF Web-browser Plug-in - The HDF Web-browser plug-in is a windowed browser plug-in that is launched from a web browser to display HDF4 and HDF5 files.
- netCDF-4 - The NCSA and NetCDF groups are collaborating on a version of NetCDF built on top of HDF5.
- HDF5 XML Information Page - DTD and tools for using HDF5 with XML
- HDF5 WRF I/O Module - I/O module that reads HDF5 datasets for the Weather Research and Forecasting Model
- HDF5 Mesh API (prototype) - API for storing and retrieving structured and unstructured mesh data
Enhancements:
- The default Fortran was switched to G95 when using GCC.
- The autoconf build tools were updated. Fortran interfaces were added for the Image, Table, and Lite APIs.
- A Dimension Scale API (H5DS) was added.
- FreeBSD is now supported on AMD64 with GNU C and Fortran compilers.
- Support for sequential and parallel libraries was added for Intel 64 Linux clusters.
- Several bugs with writing fill values for datasets that have a variable-length datatype or component datatype were fixed.

Security Officers Best Friend (SOBF) is a Security Management and Analysis tool designed to be placed right ontop the SOMAP.org Repository. The SOBF Tool is currently in development and there is no public download at the moment.
Architecture:
The SOBF tool is written in Java. To run the SOBF Tool you need a Java VM version 1.5 or later. The data used within the tool is stored locally and can be protected accordingly.
It is a main goal to build the tool like an extendable toolset. While all the needed functionality is built into the SOBF tool, it is possible to extend that standard feature set with your own scripts and extentions.
Data Abstraction:
To abstract the database and to access the data more easily the SOBF tool makes use of the Cayenne Framework. The configuration informations are accessible and it is possible to enhance that configuration with your own data views. Such data views can then be used from within your own scripts to enhance the feature set of the SOBF tool.
Database / Storage:
The SOBF Tool currently uses the hsqldb Database engine to store the data. Updates to the Repository can be done without a hassle for the data records are identified by UUIDs as described on the Repositories information page.
The hsqldb stores the data in human readable form. If need be, the data can be extracted from the filesystem accessing the data files directly.
Since the SOBF tool uses the Cayenne Framework to abstract the database layer it is no problem to exchange the hsqldb with any other database system like Derby or PostgreSQL in future releases. This is an important feature for the SOBF tool should help a security officer with his work and not stand in his way. For this reason the SOBF tool should be as integratable into an environment as possible.
Reporting:
We use the Jasper Reports engine to render and print reports
Enhancements:
- This version contains the implementation of the complete Risk Assessment Workflow as described in the SOMAP.org Guide.
- The backup and restore mechanism was enhanced.
- Some changes and updates were made to the Dynamic Reports.
- The application experienced a general spring cleaning.

Local Data Manager (LDM) is a collection of cooperating programs that select, capture, manage, and distribute arbitrary data products.
The system is designed for event-driven data distribution, and is currently used in the Unidata Internet Data Distribution (IDD) project. The LDM system includes network client and server programs and their shared protocols.
An important characteristic of the LDM is its support for flexible, site-specific configuration.
Enhancements:
- Fixes for timestamp bugs.

Algorithm::Pair::Best is a Perl module to select pairings (designed for Go tournaments, but can be used for anything, really).

SYNOPSIS

use Algorithm::Pair::Best;

my $pair = Algorithm::Pair::Best->new( ? options ? );

$pair->add( item, ? item, ... ? );

@pairList = $pair->pick( ? $window ? );

After creating an Algorithm::Pair::Best->new object, add a list of items (players) to be paired. add connects the new items into a linked list. The linked list must consist of an even number of items or youll get an error when you try to pick the pairs.

Pairings are determined partially by the original order items were added, but more importantly, items are paired based on scores which are determined by an info hash used to attach any random data to the item, and user supplied functions to provide a score for each item in relation to other items. It may be convenient to add access methods to the Algorithm::Pair::Best package from the main namespace (see the scoreSubs option to new below for an example).
Algorithm::Pair::Best->pick explores all combinations of items and returns the pairing with the best (highest) score. This can be an expensive proposition - the number of combinations goes up very fast with respect to the number of items:

items combinations
2 1 (1)
4 3 (1 * 3)
6 15 (1 * 3 * 5)
8 105 (1 * 3 * 5 * 7)
10 945 (1 * 3 * 5 * 7 * 9
12 10395 (1 * 3 * 5 * 7 * 9 * 11)
14 135135 (1 * 3 * 5 * 7 * 9 * 11 * 13)

It is clearly unreasonable to try to pair a significant number of items. On my system it takes about 2 seconds to pair 12 items (6 pairs), and 20 seconds to pair 14 items (with no negative scores only optimization). Trying to completely pair even 30 items would take too long.

Fortunately, there is a way to get pretty good results for large numbers, even if theyre not perfect. Instead of trying to pair the whole list at once, Algorithm::Pair::Best->pick pairs a series of smaller groups to get good local results. The new method accepts a window option to limit the number of pairs in each window. The window option can also be overridden by calling pick with an explicit window argument:

$pair->pick($window);

See the description of the window option below.

Common Data Format is a self-describing data abstraction for the storage and manipulation of multidimensional data in a platform- and discipline-independent fashion.
It consists of a scientific data management package (known as the "CDF Library") that allows programmers and application developers to manage and manipulate scalar, vector, and multi-dimensional data arrays.
Enhancements:
- Adds new sets of APIs to allow Standard Interface to interact with zVariables and other CDF-related information.
- Adds MingW and FreeBSD ports.
- Adds support for Intel C++ and Fortran for Linux.
- Adds the ability to create legacy CDF 2.7 files.
- Fixes a bug that prevented directories from having .cdf or .skt extensions.

TAO project is a standards-compliant, real-time implementation of CORBA that provides efficient, predictable, and scalable quality of service (QoS) end-to-end.

Unlike conventional implementations of CORBA, which are inefficient, unpredictable, non-scalable, and often non-portable, TAO applies the best software practices and patterns to automate the delivery of high-performance and real-time QoS to distributed applications.

Over the past decade, my research group has worked with many collaborators on large-scale distributed application R&D projects in diverse domains, including command and control systems, telecom, datacom, medical engineering, distributed interactive simulations, and financial services. Regardless of the domain and application requirements, weve found that software developers wrestle with the same core infrastructure challenges. Key challenges focus on OS platform portability, connection management and service initialization, event demultiplexing and event handler dispatching, multi-threading and synchronization, fault detection and fault tolerance, and various quality-of-service (QoS) issues, such as controlling latency, throughput, and jitter end-to-end.

Unfortunately, its very costly, time consuming, and error-prone for researchers and developers companies to independently rediscover and reinvent ad hoc solutions to these core distributed application software development challenges. Fortunately, we have identified a relatively concise set of patterns and framework components that can be applied systematically to eliminate many tedious, error-prone, and non-portable aspects of developing and maintaining distributed applications.

A decade of intense R&D on these topics has yielded ACE, which is an object-oriented framework that implements many core patterns for concurrent communication software. We have applied the patterns and components in the ACE framework to develop The ACE ORB (TAO), which is our standards-based, CORBA middleware framework that allows clients to invoke operations on distributed objects without concern for object location, programming language, OS platform, communication protocols and interconnects, and hardware. TAO is designed using the best software practices and patterns that we have discovered in our work on ACE in order to automate the delivery of high-performance and real-time QoS to distributed applications.

Data::SimplePassword provides a simple random password generator.

SYNOPSIS

use Data::SimplePassword;

my $sp = Data::SimplePassword->new;
$sp->chars( 0..9, a..z, A..Z ); # optional

my $password = $sp->make_password( 8 ); # length

Its a very easy-to-use but a bit strong random password generator.