Free jscape llc software for linux

Spread is an open source toolkit that provides a high performance messaging service that is resilient to faults across local and wide area networks. Spread functions as a unified message bus for distributed applications, and provides highly tuned application-level multicast, group communication, and point to point support. Spread services range from reliable messaging to fully ordered messages with delivery guarantees.
Spread can be used in many distributed applications that require high reliability, high performance, and robust communication among various subsets of members. The toolkit is designed to encapsulate the challenging aspects of asynchronous networks and enable the construction of reliable and scalable distributed applications.
Spread consists of a library that user applications are linked with, a binary daemon which runs on each computer that is part of the processor group, and various utility and demonstration programs.
Main features:
- Reliable and scalable messaging and group communication.
- A very powerful but simple API simplifies the construction of distributed architectures.
- Easy to use, deploy and maintain.
- Highly scalable from one local area network to complex wide area networks.
- Supports thousands of groups with different sets of members.
- Enables message reliability in the presence of machine failures, process crashes and recoveries, and network partitions and merges.
- Provides a range of reliability, ordering and stability guarantees for messages.
- Emphasis on robustness and high performance.
- Completely distributed algorithms with no central point of failure.
Enhancements:
- Improve manageability by allowing dynamic configuration of sets of daemons without requiring a restart;
- Improve performance;
- Ease the development of Spread based applications with better membership reporting;
- Support multi-threaded forking client applications;
- Integrate a Virtual Synchrony interface;
- Provide simpler membership APIs;
- Organize and improve the software build for both Windows and Unix systems.

Jifty::Script::Help is a Perl module to show help.

OPTIONS

Optionally help can pipe through a pager, to make it easier to read the output if it is too long. For using this feature, please set environment variable PAGER to some pager program. For example:

# bash, zsh users
export PAGER=/usr/bin/less

# tcsh users
setenv PAGER /usr/bin/less

help_base

Jiftys help system also looks in Jifty::Manual and the subdirectories for any help commands that it cant find help for.

FLASH-PLAICE is a powerful in-circuit development tool that combines the features of a flash programmer, an emulator, and a high speed multi-channel logic analyzer into one device. The project runs uClinux.

The logic analyzer features up to 200MHz sampling rates and up to 32 input channels. The logic analyzer Java client features support for up to 200MHz sampling rates, user controlled filtering operations, time line in diagram, metadata (size, rate, and trigger position) stored in files, an ID command for device identification, configurable serial port transfer rate, user configurable drawing modes (logic level, hex value, and scope), and Java client access via almost any PC with a serial port.

The Java client uses the RXTX serial library with support for 34 platforms including Linux, Windows, and Solaris. Java client plugins include an SPI and I2C bus protocol analyzer, timing analysis to state analysis conversion, and post-processing functions.

Schevo project is a next-generation DBMS that focuses on the following:
- Database Integrity: Schevo is designed from the ground up to protect your data. All changes to a Schevo database must be done using transactions, and Schevo ensures that those transactions always leave the database in a consistent state.
- Rapid Development: Schevo includes features to make it easy and fun to create even the most complex of databases. Not only is the schema syntax easy to write and understand, you can also quickly place initial values in your schema that are required by your database, and use the same syntax to create sets of sample data to use during development.
- User Interface Generation: Schevo provides user interface toolkits that take advantage of the richness of the database schema. You can use the full-featured Schevo Navigator to interact with your database without writing a single line of code outside of your database schema. A PyQt-based toolkit is already available, and TurboGears and NuFox toolkits are in the works.
- Rich Schema Definition: The schema for a Schevo database is written in concise, easy-to-read Python code. Not only does the schema describe how information in the database is structured, but also defines all transactions and rules that ensure database integrity.
- Assisted Schema Evolution: Once a Schevo database is deployed and is used to store valuable data, you will inevitably make further changes to the structure of the database. Schevo assists you in this task and makes it easy to restructure a database and facilitate the migration of data from one schema version to the next.
The main problem that Schevo was designed to address is that Relational databases, which use Structured Query Language (SQL), do not match well with object-oriented programming languages, such as Java, Python and Ruby.
This situation has been labeled the "object-relational impedance mismatch" problem, and it is a significant barrier to the rapid development and evolution of database applications.
Because of this mismatch, database applications tend to have three distinct layers of code: SQL within the database, object-oriented code within the application, and an object-relational mapping (ORM) layer to mediate between the SQL and the object language.
These extra layers add additional complexity and inflexibility to what are already complex and inflexible databases. Schevo eliminates these extra layers.
Schevo solves the object-relational impedance mismatch problem by combining relational features with the object-oriented programming language Python.
A database schema defined in Schevo results in a database that enforces the same integrity constraints supported by the Relational model, with the added benefit of Python objects.
The benefit of this is that application developers can create their entire application using the full power of the Python language without having to introduce another language (SQL) that has its own language constructs, its own datatypes, and a limited set of behavior. Instead, a Schevo database stores Schevo objects which use native Python datatypes and include any behavior defined for those objects.
In addition, Schevo objects contain a great deal of metadata that is available for introspection to support the development of rich user interfaces with a minimal amount of code.
In fact, Schevo includes a GUI Navigator that can display a fully interactive interface into any Schevo database. The Navigator is constructed on-the-fly based solely on the metadata available within the Schevo database file.
The Navigator allows you to display, create, update, and delete any object within the database, within the rules and constraints defined for that database.
Enhancements:
- Many minor changes were made.
- All supporting packages that used to be included with Schevo itself are now broken out into subpackages.

Contact Form Killer is a free tool you can use to generate contact forms for your site, or let your web site visitors add contact forms themselves.
Contact Form Killer script takes care of messy form validation with both JavaScript and PHP, just in case they have JavaScript disabled. The contact forms it generates are nicely formatted and can be further edited to match the look and feel of your site.
Main features:
- Easy to install. Just unzip and upload, or if youre using it on a local server, just unzip!
- Quick generation of contact forms that usually take hours to code.
- JavaScript validation of each input for ultimate usability.
- PHP validation to make sure JavaScript-disablers dont slip the radar.
- Over 10 inputs to pick and choose from.
- Form generation is really easy, just click the checkboxes next to the inputs you want, click submit and youre done!

NetPacket::LLC is a Perl module to assemble and disassemble IEEE 802.3 LLC protocol packets.

SYNOPSIS

use NetPacket::LLC;
use NetPacket::SpanningTree;

$llc_data = NetPacket::Ethernet->strip($raw_packet);
$st_data = NetPacket::LLC->strip($llc_data);
$st_obj = NetPacket::SpanningTree->decode($st_data);

NetPacket::LLC provides a set of routines for assembling and disassembling packets using the IEEE standard LLC protocol layer.

Methods

NetPacket::LLC->decode([ST DATA])
Decode the LLC packet data and return an object containing instance data. This method will probably decode garbage input, but it wont mean much.

NetPacket::SpanningTree->encode($st_hash)

Encode the hash into a raw data stream that may be appended to ethernet packet data. This allows the user to create his/her own LLC protocol packet and subsequently send it out on the wire (though sending on the wire isnt a function of this module).

Servsys is a Web application that allows an HVAC technician or salesperson to create customer records, invoices, inspection reports, worksheets ,and proposals.

It can also export flat rates to the Team Management System (TMS) and email all paperwork back to office staff from techs on the road.

Servsys project features a point and click environment and will also work for plumbers and electricians.