Free supportsoft web objects software for linux

Claw framework provides a convenient and intuitive way of developing PHP5-driven object oriented Web applications.
Claw project allows developing tree-structured Web applications with ease.
Main features:
- Clean Code / Database / Display logic seperation with Hierarchial MVC
- Page / method / variable chains (i.e.: /articles/read/10/comment/35)
- Search engine friendly & clean URLs without creating dozens of rewrite rules
- View / Variable inheritance during application flow
- Rapid and intuitive development process
- User permission handling
- Outside variable handling ($_GET, $_POST, $_REQUEST, $_COOKIE, etc.)
- Form handling and processing
- Session handling
- Configuration file handling
- DRY and KISS principles
- Support for web trends (i.e. AJAX)
- Database independance & object persistance
- Human-readable manual and example applications
- Loose-coupled components with possibility of choice and extensions
- Portability, easy setup and configuration (changing app location will not require changing any configs, except for .htaccess RewriteBase, which is optional)
- etc...

AjaxAC is an open-source framework written in PHP, used to develop/create/generate AJAX applications.
The fundamental idea behind AJAX (Asynchronous JavaScript And XML) is to use the XMLHttpRequest object to change a web page state using background HTTP sub-requests without reloading the entire page. It is released under the terms of the Apache License v2.0.
Main features:
- All application code is self-contained in a single class (plus any additional JavaScript libraries)
- Calling PHP file / HTML page is very clean. All that is required is creating of the application class, then referencing the application JavaScript and attaching any required HTML elements to the application.
- Built in functionality for easily handling JavaScript events
- Built in functionality for creating subrequests and handling them
- Allows for custom configuration values, so certain elements can be set at run time
- No messy JavaScript code clogging up the calling HTML code - all events are dynamically attached
- Easy to integrate with templating engine due two above 2 reasons
- Easy to hook in to existing PHP classes or MySQL database for returning data from subrequests
- Extensible widget structure to be able to easily create further JavaScript objects (this needs a bit of work though)
Enhancements:
- Created ArithmeJax sample application
- Replaced JavaScript escape() with encodeURIComponent()
- Changed hook name generator to include __ in front of hookname due to IE6 compatibility error
- Removed redundant AjaxAC class and moved this functionality to AjaxACApplication class
- Updated all examples to reflect removal of main AjaxAC class

Web Sharing is a small tray applet for sharing files on the web.

Publish anything on the Internet or your local area network at home, office or school from a folder on your hard disk with just a few clicks of a mouse!

XAO::Web is a part of XAO open source web services suite. It allows to build dynamic web content using data, templates and external input.
The distinguishing feature of XAO::Web is in its modular design where almost every aspect of functionality can be altered and alterations can be re-used. No complex code is embedded in the templates which allows to upgrade code and templates separately or maintain multiple visual representations of the same functionality at the same time.
Installation
perl Makefile.PL
make
make test
sudo make install
Saying "install XAO::Web" from the CPAN shell is a good way too:
perl -MCPAN -eshell
install XAO::Web
Using CPAN shell is usually the best way because all dependencies will be resolved automatically.
If you do manual installation then XAO::Web depends on at least the following modules (look into Makefile.PL or just watch closely the output of `perl Makefile.PL for additional dependencies):
XAO::Base
XAO::FS
Digest::MD5
Error
MIME::Lite
Test::Unit
When you run "perl Makefile.PL" you will be asked for XAO::Web test database. That database is only used when you do `make test and it have to exist. It does not matter what is inside the database, it will be completely wiped out for each test case.
Normally the database should be the same that you have used for XAO::FS tests and in case of MySQL is usually test or test_fs.
The directory where templates get installed is the same that you gave to XAO::Base when you installed it. Normally that directory is /usr/local/xao -- we will assume that for the rest of the document.
Main features:
- Perl code is not mixed with templates. Templates can be normal HTML files if no processing is required.
- A specific site can replace or modify standard XAO::Web objects if required by overriding or extending their methods. You do not need to re-implement entire object to make a site specific change. In case of system object upgrade or bug fix there is no need to alter site-specific changes normally.
- Site can create any extension objects or embed third-party extensions as well.
- One server can serve arbitrary number of XAO::Web sites each with however extended functionality without creating any conflicts. That includes different modifications to the system objects for different sites.
- Not limited to Web environment, allows to build any dynamic content -- content of mail messages or reports for instance.
- Works with CGI or mod_perl (mod_perl is recommended for production grade sites).
- If used in mod_perl mode improves performance by using caching of configuration, parsed templates, database handlers and so on.
- XAO::Web is by default integrated with XAO::FS (see XAO::FS) as a database layer, but this is not a requrement -- if for any reason a different database must be used for a site it can be easily and gracefully achieved.
- Hosting providers can allow their customers to build very complex sites without allowing them to execute arbitrary code, by allowing to modify only templates.
Enhancements:
- Fixed a problem with Web.pm for mod_perl usage, introduced last minute just before releasing 1.06

WebPython is a Web-application development toolkit written in the Python programming language.
WebPython project contains an object relational database layer, portable over MySQL and PostgreSQL; a document templating engine complete with simple built-in automation; and a mechanism to store Python objects in an SQL database, among other features.
Enhancements:
- This release has database caching through the use of memcached, which greatly speeds up database reads.
- A new version of the Tutorial Blog (using this new feature) has also been released.

WASP is a multi-tier web application framework built on Object Oriented PHP5.
The framework is a simplified Model View Controller architecture. The controller is built by adding content "Chunks" to "UIModules".
The Model portion of the framework wraps PEAR DB_DataObjects in a business object layer. The View portion currently makes use of PEAR Html_Template_Flexy, but can be easly reimplemented using different template managers (or none at all) via the power of OO Interfaces.
WASP was written from the ground up in pure Object Oriented PHP5. WASP fully utilizes all of the OO enhancements made to PHP in version 5 including public/protected/private encapsulation, abstract classes and interfaces, class autoloading, and exception handling.
Enhancements:
- This release included functions to make form validation automatic and easy to do.
- It also included a library of validation functions that you can use to validate common things like phone numbers, zip codes, and dates.
- These functions will conveniently output standard error messages that you can easily override or customize.

Math Objects is a math template library written in C++ using generic programming techniques. In order to use the "Math Objects" library, the user only has to include the header files he needs (e.g. Matrix.h, Polynomial.h etc.).
In order to compile the library the user needs an ISO/IEC 14882:1998 standard compliant C++ compiler (e.g. one that supports partial template specializations).
The math library has math objects like matrices, polynomials, rational functions, extended precision numbers, complex numbers etc. that can be handled in a similar way like basic numerical types (e.g. integers or floating point numbers).
One can access properties of a mathematical type through a (partial) specialization of a traits class for that type (AlgebraicTraits). Having the traits classes to expose properties of mathematical objects, one can define for example matrices of polynomials having extended precision complex coefficients and apply to them basic linear algebra algorithms using normal C++ syntax.
This library also implements two functions using two deterministic algorithms that compute the Smith form for polynomial matrices, and the Smith-McMillan form of a transfer functions matrix also keeping track of the transformation matrices.
These algorithms can be used to describe a MIMO (multi input-multi output) system by means of its zeros and poles and also give the MFD (matrix fraction description) of the system.
Enhancements:
- Recoded the LongInt class aiming for better runtime efficiency.