My goal in this article is to answer the following questions.

* Why is not there a standard descriptions language for RESTful applications yet?
* How does a contract for RESTful applications looks like?
* What kind of software do we need to build that can understand and take advantage of such a contract?
* If we decide to come up with a machine-readable description, how might it look like?

Let the Group Members do the Work

Record Faithfully

Use Parallel Processing

Let the Group Members Draw Conclusions

Test for Agreement

Impressive is a program that displays presentation slides. But unlike OpenOffice.org Impress or other similar applications, it does so with style. Smooth alpha-blended slide transitions are provided for the sake of eye candy, but in addition to this, Impressive offers some unique tools that are really useful for presentations. Read below if you want to know more about these features.

Creating presentations for Impressive is very simple: You just need to export a PDF file from your presentation software. This means that you can create slides in the application of your choice and use Impressive for displaying them. If your application does not support PDF output, you can alternatively use a set of pre-rendered image files – or you use Impressive to make a slideshow with your favorite photos.

A collection of scripts for making your daily MySQL DBA responsibilities easier.

* mt-backup-parallel -> runs mysql backups in parallel super fast, has lots of reporting features
* mt-check-replication -> script to report on replication status for slave servers
* mt-rhcluster-check-filesystems -> reports on redhat cluster filesystems (for mysql active/passive clustering)
* mt-rhcluster-script-wrapper -> wrapper script for running any of these scripts on a redhat cluster, chooses the active node to run the script on
* mt-connections-log -> logs connections to mysql to disk, reports on threshold overages
* mt-flush-tables-sequence -> runs through schema.tables to flush in sequence before global flush
* mt-rotate-logs -> rotates general and slow query logs on periodic basis
* mt-my.cnf_xG -> MySQL configuration file for a particular RAM size installation

After this research I came with the following conclusion:

* Use the controllers to handle user input data and choose which view to display.
* If there, remove all business logic from the controllers.
* Let the Model do it's job with the provided data. 
* When handling data to the model, do it as an array of normalized data -or proper objects pertinent to our application-, the model shouldn't know about the request.
* Let helpers or Helper Objects handle the data formating, avoiding script code inside templates.
* Use Propel as a DAL and refactor towards a Model. This means to remove complex business logic from the Propel classes.

CMON is a daemon that aggregates information from MySQL Cluster that earlier was only accessible from the cluster log or the management client, such as:

* cluster state
* node state
* backup statistics
* statistics
* cluster events (cluster log basically)

.. and let's you access the information using SQL, because CMON logs the information into ordinary MYISAM tables! So, it is really easy to use! In the package you also get get php scripts that you can put on your webserver to generate graphs and get a www interface to CMON. CMON can also start ndbd nodes and make decisions on how they should be started (with or without --initial).

CMON starts as a daemon and will automatically create cmon database and install the necessary tables automatically.