Free youtube clone video sharing script software for linux

Nodezilla is basically an experimental grid based p2p system available for Windows and Linux (on Intel platforms).
Technically, Nodezilla is a secured, distributed and fault tolerant routing system (aka Grid Network). Its main purpose is to serve as a link for distributed services built on top of it (like chat, efficient video multicasting streaming, File Sharing, secured file store ...).
Nodezilla provides cache features; any server may create a local replica of any data object. These local replicas provide faster access and robustness to network partitions.
They also reduce network congestion by localizing access traffic. It is assumed that any server in the infrastructure may crash, leak information, or become compromised, therefore in order to ensure data protection, redundancy and cryptographic techniques are used.
Main features:
- Anonymous File sharing,
- Hierarchical Multimedia Streaming,
- Digital photo sharing with selected friends.
As this is a quite new and evolved p2p protocol compared to existing products, we welcome any comments on it.
Enhancements:
- Some crashes have been fixed, and there are routing fixes for relayed nodes.
- Performance has been tuned.
- This release uses new features of Vista for services rights restriction and buffer overflow prevention.

HTML::Merge is an embedded HTML/SQL/Perl system.

SYNOPSIS

< HTML>
< $RQ.SELECT * FROM customers WHERE customer_id=< $RVAR.cust_id>>
< $RLOOP>
< $RSQL.name> owes < $RSQL.debt>< BR>
< /$RLOOP>
< A HREF="/cgi-bin/merge.pl?template=main_menu.html">
< /HTML>

Merge is an embedded HTML/Perl/SQL tool for creating dynamic web content. merge.pl compiles HTML with embeded Perl to Perl CGI programs and run them.

All Merge pages are referred to by cgi-bin-dir/merge.pl?template=file.html
(Important: file.html is a HTML template that located in a directory you choose and name it on the merge.conf file. Notice for better security, the web server must not be able to display the templates dirctory). although on CGI mode you can define merge.pl as an handler with the Action directive in Apache.

Using merge.pl under Apache::Registry will utilize Perls built-in caching to cache pages using the do command.

Merge uses a configuration file to retrieve information about paths, database connectivity and debugging. It has an embedded debugging tool and on-line configuration. To turn that option on, set DEVELOPMENT to 1 in the configuration file. Dont forget to set it off before deployment.

Configuration can be changed during development using the toolkit menues, toolkit menues apear as popup windows on your web browser when you open a URL of mrege.pl.

Alternate configuration files can appear in /etc/merge.conf and $HOME/.merge.
As described in the INSTALL document you must set your web server for each appliaction and copy (or create) links to merge.pl and PUBLIC files and templates and create system database tables. If you are using a UNIX system you can use mergecreateinstance that will do thoes tasks for you.

FILES

B< merge.pl> Main script, usually a symbolic link to each instance.

B< merge.conf> Configuration, unique per each instance.

B< $PREFIX/share/merge/private> Internal scripts.

B< $PREFIX/bin/merge.cgi> Main script, central.

B< $PREFIX/bin/merge.conf> Template for configuration files.

B< $PREFIX/bin/mergecreateinstance> Instance creating script.

python-youtube is a simple YouTube API Client for Python.
You can use it to access YouTube metadata in your applications and webapps. This implementation allows you to access the REST interface of the YouTube API.
Example usage:
c = youtube.YouTubeClient( your-dev-id)
for video in c.list_by_user( your-username):
v = c.get_details( video[id])
print video[id]
print v[thumbnail_url]
print v[title]
print v[description]
Enhancements:
- This release has been updated to include support for paging (the "page" and "per_page" parameters), so clients can fetch all data on a per-page basis.

TinyURL is a Konversation script that makes a TinyURL (http://tinyurl.com) from a given URL.

Just copy it to /usr/share/apps/konversation/scripts/ (system wide) or to ~/.kde/share/apps/konversation/scripts/ (for just your user).

Cosmosmash project is a clone of the 1981 Astrosmash video game.

Cosmosmash is a game where you control a base that must destroy rocks before they hit the ground, or you lose points.

You must also prevent "spinners" from touching the ground, or your base will explode.

This game is a clone of the 1981 Astrosmash video game by Mattel Electronics.

Cons is a Software Construction System.

Cons is a system for constructing, primarily, software, but is quite different from previous software construction systems. Cons was designed from the ground up to deal easily with the construction of software spread over multiple source directories. Cons makes it easy to create build scripts that are simple, understandable and maintainable. Cons ensures that complex software is easily and accurately reproducible.

Cons uses a number of techniques to accomplish all of this. Construction scripts are just Perl scripts, making them both easy to comprehend and very flexible. Global scoping of variables is replaced with an import/export mechanism for sharing information between scripts, significantly improving the readability and maintainability of each script.

Construction environments are introduced: these are Perl objects that capture the information required for controlling the build process. Multiple environments are used when different semantics are required for generating products in the build tree. Cons implements automatic dependency analysis and uses this to globally sequence the entire build. Variant builds are easily produced from a single source tree. Intelligent build subsetting is possible, when working on localized changes. Overrides can be setup to easily override build instructions without modifying any scripts. MD5 cryptographic signatures are associated with derived files, and are used to accurately determine whether a given file needs to be rebuilt.

While offering all of the above, and more, Cons remains simple and easy to use. This will, hopefully, become clear as you read the remainder of this document.

Why Cons? Why not Make?

Cons is a make replacement. In the following paragraphs, we look at a few of the undesirable characteristics of make--and typical build environments based on make--that motivated the development of Cons.

Build complexity

Traditional make-based systems of any size tend to become quite complex. The original make utility and its derivatives have contributed to this tendency in a number of ways. Make is not good at dealing with systems that are spread over multiple directories. Various work-arounds are used to overcome this difficulty; the usual choice is for make to invoke itself recursively for each sub-directory of a build. This leads to complicated code, in which it is often unclear how a variable is set, or what effect the setting of a variable will have on the build as a whole. The make scripting language has gradually been extended to provide more possibilities, but these have largely served to clutter an already overextended language. Often, builds are done in multiple passes in order to provide appropriate products from one directory to another directory. This represents a further increase in build complexity.

Build reproducibility

The bane of all makes has always been the correct handling of dependencies. Most often, an attempt is made to do a reasonable job of dependencies within a single directory, but no serious attempt is made to do the job between directories. Even when dependencies are working correctly, makes reliance on a simple time stamp comparison to determine whether a file is out of date with respect to its dependents is not, in general, adequate for determining when a file should be rederived. If an external library, for example, is rebuilt and then ``snapped into place, the timestamps on its newly created files may well be earlier than the last local build, since it was built before it became visible.

Variant builds

Make provides only limited facilities for handling variant builds. With the proliferation of hardware platforms and the need for debuggable vs. optimized code, the ability to easily create these variants is essential. More importantly, if variants are created, it is important to either be able to separate the variants or to be able to reproduce the original or variant at will. With make it is very difficult to separate the builds into multiple build directories, separate from the source. And if this technique isnt used, its also virtually impossible to guarantee at any given time which variant is present in the tree, without resorting to a complete rebuild.

Repositories

Make provides only limited support for building software from code that exists in a central repository directory structure. The VPATH feature of GNU make (and some other make implementations) is intended to provide this, but doesnt work as expected: it changes the path of target file to the VPATH name too early in its analysis, and therefore searches for all dependencies in the VPATH directory. To ensure correct development builds, it is important to be able to create a file in a local build directory and have any files in a code repository (a VPATH directory, in make terms) that depend on the local file get rebuilt properly. This isnt possible with VPATH, without coding a lot of complex repository knowledge directly into the makefiles.