Free constraint software for mac

Splendid City Team Sports Scheduler, and Sports Scheduling Software System is useful for people who organize team sports or game events. Use it to manage and publish sports schedules of any size and complexity. Automatically create high quality double or single elimination tournament brackets, round-robin league schedules, swiss round tournaments, cross divisional or practice schedules for any sport that requires pairings.
It features options that include the ability to set team and field constraints, game lengths; configurative time management utilities to help you organize events the way you would like; object constraint sharing; automatic schedule generation and re-generation; configurative project web site creation, tournament brackets; publishing via FTP, export to HTML, CSV, iCalendar, XML; import from CSV; standings support with tie-breaker formulas; contact management; import teams, fields, officials, players and player rosters from other users projects ; constraint and conflict checking and resolution.
Users can freely exchange all data associated with projects with other users who have a free copy of Splendid City Lite installed regardless of platform. The application comes with an integrated e-mail client that can aid with the exchange of object files among organization members. There is also a simple FTP client for direct uploading to web domains from within the schedule view frame.
The scheduler gives you complete control over all aspects of the schedule, and creates solutions effortlessly and elegantly in accordance with the user data entered. It can be custom-tailored, and with repeated use via a plugin interface, can be made to automatically accomplish users unique scheduling needs.
The user experience is interactive and straight forward. The application comes fully documented with a built in searchable help system to provide answers to implementation questions. Several tutorials are also provided.

ACE is a platform-independent, collaborative text editor. It is a real-time cooperative editing system that allows multiple geographically dispersed users to view and edit a shared text document at the same time.

ACE is a program that allows multiple geographically dispersed users to view and edit a shared text document at the same time, thus facilitating efficient teamwork.

According to available knowledge, there is only one such application; it works well and has reached widespread use. Unfortunately, it is limited to the Mac platform. ACE is the first collaborative text editor that runs across all major platforms, including Windows, Linux, and Mac.

First of all, ACE is a simple text editor with standard features such as copy/paste and load/save. Multiple documents can be edited at the same time. Furthermore, ACE can share documents with other users on different computers, connected by communication networks.

ACE also discovers users and their shared documents automatically in a local area network. Users can opt to join any discovered shared document. For all this, no configuration is necessary because it is based on zero-conf networking (also known as Bonjour or Rendezvous).

Once a user has joined a shared document, he can freely edit the document at the same time with all participants as a virtual team. So-called awareness information helps to avoid unnecessary conflicts (i.e. two users editing at the same time and text location).

Awareness information includes the cursor and the currently selected text of the other users marked with the color of the respective user.

The heart of the application is a concurrency control algorithm based on the innovative concept of Operational Transformation, which allows for lock-free editing of a document by multiple users. It imposes no editing constraints and resolves all conflicts automatically.

The algorithm overcomes one of the most significant challenges in designing and implementing real-time collaborative editing systems, namely consistency preservation. That is to ensure that at quiescence (i.e. when no messages are in transit) the shared document is identical for all participants.

This algorithm was implemented as part of the semester project and forms the foundation of ACE.

ACE builds upon open technologies such as BEEP (RFC 3080) and zero-conf networking; all this leaves the possibility open to communicate even with different applications that understand the public protocol of ACE.

Senor Staff 0.8.2 offers you an open-source music composition app for Mac OS X. It features a staff-based interface (rather than a tracker interface) for natural entry and readability, and supports playback to any MIDI device. Emphasis is placed on user efficiency and automated enforcement of musical constraints.

WareSeeker Editor

ManyDesigns Portofino is a free and open source solution that will offer you the most integrated set of features you can find in a framework, out of the box.

Main features:
Data modeling:
- You can create the database schema using classes (tables), attributes (fields), relationships (both one-to-many and many-to-many) and inheritance. You work at the logical level, while Portofino takes care of mapping it to the physical level of the database.
Forms and user interface:
- Portofino automatically generates the user interface based on your model definition. CRUD forms, navigation of relationship, powerful search pages, full-text searches, breadcrumbs, and cascaded selection boxes are all available immediately.
Security and permissions:
- You can assign different roles and responsibilities to the users of the system. Portofino can be integrated in your existing single sign-on technology.
Workflows:
- Through workflows, you can define your business processes, procedures and life-cycles. You can use states, transitions, guards, custom actions and automatic email notifications.
Algorithms and calculations:
- Perform mathematical, logical and string calculations within the application model without writing code.
Validations:
- You can define validations and integrity constraints on data entered by users. This ranges from simple validations of type, format and range to complex constraints on the relational model.
Reports:
- On-line and printable reports are very easy to define. They provide an aggregate view over large amounts of data and highlight information of particular relevance.
Speed:
- Building a new application or changing an existing one is very fast. Make a change to the model (upstairs level) and see the change instantly applied to the application (downstairs level). There is no compilation or transformation latency.
Changes and integrity:
- Changes never break the application. Portofino makes sure that all the parts of the system work together despite changes to any of them. This is an ideal situation for agile development. You get features and quality right from the start.
Database compatibility:
- Portofino supports all major commercial and open source database technologies.

System requirements:
- Single processor system with 512MB RAM and 800MB free disk space.
- JDK/JRE 1.5 or later

Enhancements
- First public open source release of ManyDesigns Portofino.

NMRView is a program for the visualization and analysis of NMR datasets.
Main features:
- Multiple views on one or more NMR spectra.
- Unlimited number of spectral windows.
- Windows may be in any size or position on the screen.
- Unlimited number of data files.
- Generic reader for block structured files.
- Corresponding cursors in different windows track each other automatically.
- Contour plots of any plane of any 2, 3, or 4 dimensional spectra.
- 1D vector plots ina any orientation of 1 to 4 dimensional spectra.
- Spectral displays may be transferred from one window to another using a Copy/Paste protocol.
- Automatic peak picking.
- Peak searching.
- Facilitated peak analysis and interactive peak editing.
- Spin-system tabulation
- XY data plotting and non-linear regression analysis.
- Powerful command language (Tcl, tool command language).
- Programmable user interface.
- Flexible database.
- Comprehensive NOE constraint generation and analysis.
- Structure analysis including rmsd superpositions and constraint violation analysis.
- Contextual help.
- On-line hyper-text documentation using Web browsers such as Mosaic or Netscape.

Logtalk is a mature Open Source object-oriented logic programming language that can use most Prolog implementations as a back-end compiler.

Main features:
- Predicate directives (declarations) may be contained inside protocols (interfaces), which may be implemented by any object.
- Object names can be compound terms containing free variables that can be used to parametrize object predicates. This allows us to treat any predicate as an instantiation of a parametric object. I.e. through parametric object we can associate any number of methods with a compound term.
- You may have, in the same application, class-based hierarchies (with instantiation and specialization relations) and prototype-based hierarchies (with extension relations). Moreover, fundamental language features such as protocols (interfaces) and categories (components) can be used simultaneously by classes, instances, and prototypes.
- No need to be constrained to a single, lengthy hierarchy rooted in some generic object.
- Logtalk supports private, protected, and public inheritance in a way similar to C . Moreover, any entity relation can be qualified using a scope keyword. E.g. an object can privately implement a protocol, thus making all protocol declared predicates private.
- Set the scope of your object predicates to match your protocol design and let the runtime system enforce your choices.
- Objects can be either static or dynamic. Static objects are defined in source files which are compiled and loaded in the same way as Prolog files. Dynamic object can be either defined in source files or created at runtime.
- Any static object may contain both static and dynamic predicates.
- Logtalk uses standard Prolog syntax with the addition of a few operators and directives for a smooth learning curve. Prolog code can be easily encapsulated inside objects with little or no changes. Moreover, Logtalk can transparently interpret most Prolog modules as Logtalk objects for easy reusing of existing code (e.g. libraries).
- Predicates can be implicitly called when a spied event occurs, allowing programming solutions which minimize object coupling. In addition, events provide support for behavioral reflection.
- Predicates can be encapsulated inside categories, which can be virtually imported by any object, without any code duplication and irrespective of object hierarchies. Thus, objects may be defined through composition of categories, which act as fine-grained units of code reuse.
- High level multi-threading programming is available when running Logtalk with selected back-end Prolog compilers, allowing objects to support both synchronous and asynchronous messages. Easily take advantage of modern multi-processor and multi-core computers without bothering with the details of creating and destroying threads, implement thread communication, or synchronizing threads.
- Logtalk supports multi-inheritance of both protocol and implementation. An object may implement several protocols and extend, specialize, or instantiate several objects. Multi-inheritance conflicts are solved implicitly by the Logtalk lookup algorithms or explicitly by using predicate directives.
- Logtalk code is compiled using the same technics that you use to write efficient Prolog code. In addition, Logtalk supports both static binding and dynamic binding (with method lookup caching), greatly improving performance. Benchmark results for some Prolog compilers are available here.
- Logtalk is designed for smooth integration with any Prolog compiler that conforms or closely follows the ISO Prolog Standard.
- Logtalk interfaces with a specific back-end Prolog compiler via a minimal configuration file making it compatible with almost any modern compiler.
- Logtalk automatically generates a documentation file in XML format for every compiled object, protocol, or category. The system includes all the necessary XSL(T) files and scripts to convert documenting files to (X)HTML and PDF.

System requirements:
- Prolog

Enhancements
- Added support for declaring and defining object and category multifile predicates. This new feature is primarily intended to facilitate migration of Prolog code to Logtalk and should be used with caution as multifile support is spotty among back-end Prolog compilers (easily leading to portability problems). Multifile predicates can be both static or dynamic.
- Added support for compiling clauses for module multifile predicates within objects and categories in order to provide better integration with CLP(FD) and similar constraint packages.
- Added support for parsing module/2 directives whose export list contains operator declarations.
- Improved Logtalk compiler error-checking of file-level op/3 directives.
- Updated the Logtalk compiler to try to detect calls to proprietary built-in meta-predicates not declared in the config files. Detection may fail due to the lack of standardization of meta-predicate specifications.
- Updated the Logtalk compiler to avoid unexpected compilation errors when querying predicate properties due to the lack of standardization of the Prolog predicate_property/2 built-in predicate.
- Improved runtime error-checking for meta-calls whose closure argument is either Object:Closure or Module:Closure.
- Corrected a Logtalk compiler bug where a redefinition of a proprietary built-in meta-predicate (declared in the config files) would be ignored.
- Corrected a bug in the implementation of the Logtalk