Free communications classes software for linux

Ice, the Internet Communications Engine, is middleware for the practical programmer. A high-performance Internet communications platform, Ice includes a wealth of layered services and plug-ins. Ice means simplicity, speed, and power.
Ice is available under the terms of the GNU General Public License (GPL). Commercial licenses are available for customers who wish to use Ice with proprietary products. Please contact sales@zeroc.com for more information.
Ice is currently available for C++, Java, C#, Visual Basic, Python, and PHP, and is supported on various operating systems. Additional operating systems and languages will be supported in future releases.
Ice consists of the following packages:
Slice The Specification Language for Ice. Slice establishes a contract between clients and servers, and is also used to describe persistent data.
The Slice Compilers Tools to compile from Slice into target languages, such as C++ and Java, or to automatically generate documentation from Slice files.
Ice The Ice core library. Among many other features, the Ice core library manages all the communication tasks using a highly efficient protocol (including protocol compression and support for both TCP and UDP), provides a flexible thread pool for multi-threaded servers, and additional functionality that supports extreme scalability with potentially millions of Ice objects.
IceUtil A collection of utility functions, such as Unicode handling and thread programming. (C++ only.)
IceBox An application server specifically for Ice applications. IceBox can easily run and administer Ice services that are dynamically loaded as a DLL, shared library, or Java class.
IcePack A sophisticated server activation and deployment tool. With IcePack, the complex task of deploying applications in a heterogeneous computer network is dramatically simplified. Simply write a deployment descriptor in industry-standard XML, and IcePack handles the rest.
Freeze Freeze provides automatic persistence for Ice servants. With just a few lines of code, an application can incorporate a highly-scalable evictor that efficiently manages persistent objects.
FreezeScript It is common for persistent data types to change, especially in large software projects. In order to minimize the impact of these changes, FreezeScript provides inspection and migration tools for Freeze databases. The tools support an XML-based scripting capability that is both powerful and easy to use.
IceSSL A dynamic SSL transport plug-in for the Ice core. It provides authentication, encryption, and message integrity, using the industry-standard SSL protocol.
Glacier One of the most difficult challenges for object middleware systems is security and firewalls. Glacier, the firewall solution for Ice, greatly simplifies the deployment of secure applications. Glacier authenticates and filters client requests and allows callbacks to the client in a secure fashion. In combination with IceSSL, Glacier provides a powerful security solution that is both non-intrusive and easy to configure.
IceStorm A messaging service with support for federation. In contrast to most other messaging or event services, IceStorm supports typed events, meaning that broadcasting a message over a federation is as easy as invoking a method on an interface.
IcePatch A patching service for software distributions. Keeping software up-to-date is often a tedious task. IcePatch automates updating of individual files as well as complete directory hierarchies. Only files that have changed are downloaded to the client machine, using efficient compression algorithms.
Enhancements:
- Various additions, including redundant IceGrid registries.

Objective-C Foundation Classes is an Objective-C library.
It contains general purpose classes for easier development of applications, in areas such as data types, network, C library wrappers, collections, and compound classes.
The classes in the library are grouped in five clusters:
- DataTypes - integer, text string, fraction, bitarray, date/time, random generators, big integer, big double ...
- Collections - array, list, hash table, AVL and n-tree, circular array, graph ...
- Network - TCP/UDP server and client, HTTP client, Telnet client ...
- C-library wrappers - DBM, socket, MD5, regular expression, timer, file, directory, gzip and bzip2 file, text screen ...
- Compound - Argument parser, calendar, finite state machine, tokenizer, XML tree, discrete distribution, objective-c source tokenizer ...
Enhancements:
- A new class (DBigFraction) and a new protocol (DBitArithmetic) have been added to the library.
- There are also several bugfixes related to 64-bit platforms.
- The copy-constructor support has been improved, and as a result all collections can now be (deep) copied.
- There are some small bugfixes, and several classes have been extended with new methods.

ETH Lecture Communicator is a tool to improve classroom interaction between an instructor and their students.
ETH Lecture Communicator enables the instructor to create and carry out in-class online assessments, and facilitates organized instant communication for large classes.
It is intended to improve the overall quality of a lecture by providing the instructor with continuous feedback on the students understanding of the material.
Enhancements:
- The remaining known bugs were fixed.
- The most annoying of these was the seemingly random resending of no longer existing questions.
- Some GUI ugliness was cleaned up as well, especially for Linux systems.

RJCE allows all methods or variables of user defined classes to be altered at runtime. These alterations are then applied to a single instance, a collection of instances (i.e. list, set or map), or an entire class.

This helps you to test your application in an interactive way; altering running programs helping a trial and error approach to programming; testing code and saving it when it’s correct. Long running algorithms, such as simulations, can also easily be refined without the need for restarts or lose of data.

RJCE can be used to write a program from within itself ensuring high coupling between testing and development, with no delay before the outcome of any alterations.

RJCE allows scripts to run from within your application, allowing users to configure or extend an application dynamically, bypassing normal language access rules controlled by public, private and protected. This can be done by easily instatiating an instance of CodeEditorFrame from the rom.gui package.

RJCE permits faster development of applications by allowing easy migration from scripts to Java programs.

Object::Relation::Meta::Class::Schema is a Perl module for Object::Relation database store builder.

This module is provides metadata for all Object::Relation classes while building a storage schema. Loading Object::Relation::Schema causes it to be used instead of Object::Relation::Meta::Class. This is so that extra metadata methods are available that are useful in constructing the schema, but are not otherwise useful when an application is actually in use.

At this point, those attributes tend to be database-specific. Once other types of data stores are added (XML, LDAP, etc.), other attributes may be added to allow their schemas to be built, as well.

Test::Class is a Perl module that allows you to easily create test classes in an xUnit/JUnit style.

SYNOPSIS

package Example::Test;
use base qw(Test::Class);
use Test::More;

# setup methods are run before every test method.
sub make_fixture : Test(setup) {
my $array = [1, 2];
shift->{test_array} = $array;
};

# a test method that runs 1 test
sub test_push : Test {
my $array = shift->{test_array};
push @$array, 3;
is_deeply($array, [1, 2, 3], push worked);
};

# a test method that runs 4 tests
sub test_pop : Test(4) {
my $array = shift->{test_array};
is(pop @$array, 2, pop = 2);
is(pop @$array, 1, pop = 1);
is_deeply($array, [], array empty);
is(pop @$array, undef, pop = undef);
};

# teardown methods are run after every test method.
sub teardown : Test(teardown) {
my $array = shift->{test_array};
diag("array = (@$array) after test(s)");
};
later in a nearby .t file
#! /usr/bin/perl
use Example::Test;

# run all the test methods in Example::Test
Test::Class->runtests;

Outputs:

1..5
ok 1 - pop = 2
ok 2 - pop = 1
ok 3 - array empty
ok 4 - pop = undef
# array = () after test(s)
ok 5 - push worked
# array = (1 2 3) after test(s)

KinoSearch::Util::Class is a Perl class building utility.
PRIVATE CLASS
This is a private class and the interface may change radically and without warning. Do not use it on its own.
SYNOPSIS
package KinoSearch::SomePackage::SomeClass;
use base qw( KinoSearch::Util::Class );
BEGIN {
__PACKAGE__->init_instance_vars(
# constructor params / members
foo => undef,
bar => {},
# members
baz => {},
);
}
KinoSearch::Util::Class is a class-building utility a la Class::Accessor, Class::Meta, etc. It provides four main services:
- A mechanism for inheriting instance variable declarations.
- A constructor with basic argument checking.
- Manufacturing of get_xxxx and set_xxxx methods.
- Convenience methods which help in defining abstract classes.