Free ace software for linux

ACE short from ADAPTIVE Communication Environment is an object-oriented (OO) C++ framework that can help you develop and deploy high-performance software systems faster and better.
ACE is especially useful for systems that use network and/or inter-process communications and that take advantage of multithreading. While the ACE source code is free, thats not the only way you save money with ACE.
ACEs wrappers and higher-level patterns help you develop your software quickly and portably, helping you to complete your projects on time and within budget.
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.
Enhancements:
- This release adds support for Intel C++ specific optimizations for Linux on IA64.
- It improves support for ACE_OS::fgetc, and adds support for other low-level I/O.
- Shared library builds on AIX now produce a libxxx.so file.
- A workaround has been added for a bugfix in GCC in Fedora Core 7.
- The footprint has been reduced on some platforms.
- Major improvements have been made to IPv6 support.
- TAO DDS enhancements have been added.
- There are assorted bugfixes and other minor enhancements.

The Ace of Penguins is a set of Unix/X solitaire games based on the ones available for Windows(tm) but with a number of enhancements that my wife says make my versions better.

The latest version includes clones of freecell, golf, mastermind, merlin, minesweeper, pegged, solitaire, taipei (with editor!), and thornq (by Martin Thornquist).

Installation:

To install the binaries tar, do this as user root (other platforms are similar):

cd /usr/bin/X11
tar xvfz /tmp/ace-1.2.linux.tar.gz
tar cf - libcards.so* | (cd /usr/local/lib ; tar xf -)
rm libcards.so*

You will need to run ldconfig to notice the new shared libraries.

Then you can open a new shell window and type the name of the program you want at the command line to run it.

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.

XArchive is a generic front end for archives that uses external wrappers around the command line tools. XArchive checks its wrapper directory when it starts, consulting each wrapper found to see what file types are supported.
Thus, a new archive format can easily be supported by just writing a wrapper for it and dropping it in the wrappers directory.
Currently there are bash shell wrappers for: rar, tar, zip, and ace
(ace supported using unace, so only reading and extracting available).
These can easily be copied and modified to have xarchive support other command line tools and file types without having to touch xarchive at all.
Enhancements:
- This version supports adding files to an archive using Drag n Drog, and has a few GUI clean ups.

autovaca is a probabilities simulator for contract bridge with a Web interface. autovaca game helps the user explore the probabilities of the presence of cards in each hand, color, and point lengths, as new information is learned during bidding and playing.
Enter known cards and properties of each hand. Enter for example: AT67 at S of NORTH to say that you know that north has the ace, the ten, the 6 and the 7 of spades.
Use A,K,Q and J for the honor cards. To say that you know positively that north does not have another spade enter both a min and a max of 4, except if you enter all the cards in norths hand.
Click the button below to compute the probabilities for each card to be in each hand, each hand to have any length in any colour or any number of honour points.
Enhancements:
- Produces output compliant with HTML 4.01 Transitional.

It provides all the file-management features you could possibly want.
Plus: extensive archive handling, mounted filesystem support, FTP, advanced search module, viewer/editor, directory synchronisation, file content comparisons, powerful batch renaming and much much more.
It supports the following archive formats: tar, zip, bzip2, gzip, rar, ace, arj and rpm and can handle other KIOSlaves such as smb or fish. It is (almost) completely customizable, very user friendly, fast and looks great on your desktop!
You should give it a try.
Main features:
- extensive archive handling
- mounted filesystem support
- FTP, an advanced search module
- a text viewer/editor
- directory synchronization
- support for file content comparisons
- powerful batch renaming
- It supports the following archive formats: tar, zip, bzip2, gzip, rar, ace, arj, and rpm. It can also handle other KIOSlaves such as smb:// or fish://.
- and much more...
Version restrictions:
- In order to successfully use the most recent Krusader, you need KDElibs >= 3.2.x.
- Krusader uses about 3-4 MByte of memory to run (and about 15 Mbyte shared memory which is also used by more processes), but this may vary depending on your platform and configuration.

Channel is a generic/simple facility with the purpose of making event dispatching and message passing as straightforward to use as data structures:
Channel is a template library, with its major components configurable as template parameters:
template
<
class Id_Type,
class Id_Trait = IdTrait ,
class SynchPolicy = ACE_MT_SYNCH,
class AllocPolicy,
class Router = MapRouter
>
class Channel
By replacing Id_Type, Id_Trait and Router with various concrete classes, Channel can support table/linear message routing, hierarchical routing and associative routing (Linda style) at the demand of user. The same way, we can use integer, string, POD structs or any class as message ids (provided that proper operations are defined with Id_Trait)
Channel provides complete publish/subscribe interface for channel members (peer threads in message passing and objects in event dispatching) to pub/sub message/event ids/types and send/receive messages/events
Channels are process local entities which can be "connected" to allow transparent distributed communication between members in different channels (Connectors based on tcp socket and unix domain socket are provided as samples)
Namespace control:
The ids published/subscribed by channel members constitute channels namespace.
Channel provides publish/subscribe scope control; When ids are published/subscribed, peers can specify desired scope (LOCAL, REMOTE, GLOBAL)
When 2 channels are connected, their namespaces are automatically "merged", which is transparent to both channel members and programmers. Members can communicate with members in remote channels the same way as with local members (by pub/sub ids).
Namespace merge/integration is controlled by:
Id scope specification
filters and translators defined at channel connections
Channel communication are peer-2-peer; there are no central daemons required for message passing.
Channel support both asynchronous message passing and synchronous event dispatching models.
Channel is built on top of
ACE (Adaptive Communication Environment) to gain platform independence.
Enhancements:
- The framework was ported to Windows XP with VC8.
- Dispatching policy was added as a Channel template parameter to support various dispatching algorithms.
- Broadcast and simple RoundRobin dispatching policies were implemented for testing.
- Callback was changed to functor style so that normal functions and functors can be directly used as callbacks.