Page Content
1. what is liquid?
1.1 In more detail:
2. Quick Resources
3. Main featureset:
Important NOTE!
** Liquid is a data flow processing reference and specification. Following its guidelines allows you create explicit relationships and associations between your data and sytems. Once setup, the application implicitely update any dependencies. So you can concentrate on your algorithms and forget about much of the maintenance. **
As part of liquid's mission, there are also a few actual implementations of the concept, which serve as the core reference platform.
The goal of liquid is for many developpers to share the specification by either using the reference core or other compliant custom built nodes. This will, in the end, provide an exciting kernel to be used for much higher level applications such as end-user software, clustered databases, or next-generation Operating Systems, with no concept of application.
1.1 In more detail:
- Simple: Up to speed quickly, with examples here, you can acheive results in 30 minutes.
- Small: Optimized and orthogonal code (one class implements many systems).
- Powerfull: Default setup has lazy computing and cyclic redundancy check built in.
- Flexible: Follow the api and allow new and different types of plugs to interconnect.
- Not an academic implementation: Liquid does not attempt to be any one specific DF engine. You may find similarities to several (even conflicting) DF paradigms within the same core engine.
quickstart to core liquid ... see what it does in 15 minutes
introduction to data flow programming
core liquid node - the plug
- VERY EFFICIENT PROCESSING: processing is setup by default to occurs on demand (also called Lazy Evaluation, so you can allocate thousands of nodes without even triggering one processing cycle.
- PULL OR PUSH MODEL: any !plug can be configured to push or pull data and you can even mix and match a network of both together. this allows some data to remain live, and other branches of your computing to only refresh when needed.
- GET UP TO SPEED IN MINUTES: So simple to use and addictive, you'll quickly wonder how you ever coded without it.
- ONE CLASS FOR ALL YOUR NEEDS: Directed Graphs (dg), n-sided trees, Procedural Networks, Multi-Dimensional Synchronisation, Aspect-Oriented Programming, FSM (finite state machines), Signaling, Notification, Associative Sets, Schematic views.
These can all be implemented using liquid plugs depending on how you implement processing, filtering, initialisation, and the way you link your plugs together.
- DATA FLOW CYCLE MANAGEMENT: Cycles allowed, but internal support for automatic detection and prevention of data flow cycles is provided.
- RELATIVELY MEMORY EFFICIENT: Through code sharing and minimal instantiaced needs, your setup can scale to millions of allocated plugs (1 million nodes in under 300MB).
- RELATIVELY FAST: The engine can allocate 25000 nodes a second. (bechmarks based on an average 1.5GHz intel CPU with 768MB RAM).
- FLEXIBLE API There are more than one ways to refer to connections. And several mechanisms allow to breakup the processing. Integrated data integrity steps, allow you to prevent processing from occuring if entrant data is not appropriate.
- DATATYPE NEUTRAL You can link up, distribute, process, any kind of data to any other node. There is no datatype verification beyond any testing you wish to implement yourself (a rich apis is provided to make this very easy).
- INCLUDES THREE LIQUID-BASED APIS: liquid comes with the core !plug which is the root engine, allowing generic dataflow. !Liquid also has two other derived apis: the aspect! automated aspect-oriented engine and stream! higher-performance daisy-chained streaming data processing.
Important NOTE!
This is an alpha release and the api, although in a Stable and Beta Candidate state, might change without notice.
Thus if you upgrade from one version to another, be sure to read the header for its history: all changes are listed there.
page last updated: 2-Jan-2007
