Free perl show what modules are installed software for linux

Module::Install::Deprecated are warnings and help for deprecated commands.

One of the nicest features of Module::Install is that as it improves, there is no need to take into account user compatibility, because users do not need to install Module::Install itself.

As a result, the Module::Install API changes at a faster rate than usual, and this results in deprecated commands.

Module::Install::Deprecated provides implementations of the deprecated commands, so that when an author is upgrading their Module::Install and they are using a deprecated command they will be told that the command has been deprecated, and what the author should use instead.

This extension should NEVER end up bundled into the distribution tarball.

ExtUtils::AutoInstall is a Perl module to automatic install of dependencies via CPAN.

SYNOPSIS

In Makefile.PL, with Module::Install available on the authors system:

use inc::Module::Install;

name (Joe-Hacker);
abstract (Perl Interface to Joe Hacker);
author (Joe Hacker );
include (ExtUtils::AutoInstall);

requires (Module0); # mandatory modules
features (
-config => {
make_args => --hello, # option(s) for CPAN::Config
force => 1, # pseudo-option to force install
do_once => 1, # skip previously failed modules
},
Feature1 => [
Module2 => 0.1,
],
Feature2 => [
Module3 => 1.0,
],
);
auto_install();
&WriteAll;

Invoking the resulting Makefile.PL:

% perl Makefile.PL # interactive behaviour
% perl Makefile.PL --defaultdeps # accept default value on prompts
% perl Makefile.PL --checkdeps # check only, no Makefile produced
% perl Makefile.PL --skipdeps # ignores all dependencies
% perl Makefile.PL --testonly # dont write installation targets

Note that the trailing deps of arguments may be omitted, too.

Using --defaultdeps will make Makefile.PL behave similarly to a regular Makefile.PL file with PREREQ_PM dependencies.

One can use environment variables (see "ENVIRONMENT") below to set a default behavior instead of specifying it in the command line for every invocation of Makefile.PL.

Using make (or nmake):

% make [all|test|install] # install dependencies first
% make checkdeps # same as the --checkdeps above
% make installdeps # install dependencies only

Alien Perl module package contains external libraries wrapped up for your viewing pleasure!

SYNOPSIS

perldoc Alien;

Alien is a package that exists just to hold together an idea, the idea of Alien:: packages, so there is no code here, just motivation for Alien.

Why

James and I ended up doing a build system for Fotango, lots of people have done a build system, it is a pretty boring task. The boring task is really all the mindlessly stupid things you need to do to build C libraries that Perl modules require, these C modules usually have unusual installation systems or require vastly different options. So CPAN modules install easy, 3rd party stuff is nasty.
So, suddenly an idea struck me, Alien packages! Imagine a CPAN module that has as its only task to make sure a certain library is installed! That means that you can write all the voodoo in your Build.PL file and then just make sure the module requires the correct Alien module! Then anything that install Perl modules will deal with it automatically!

How

So, what should an Alien module do? It should make sure that the target is installed and it should provide the caller with enough information to use it.
The idea is that you use it to make sure it is there, and you call class methods to find out what to use. These class methods will be individually specified by the stand alone Alien modules.

No Framework!

The reason this is so loosely worded is because we have no idea what common functionality will be needed, so we will let evolution work for us and see what individual Alien packages need and then eventually factor it out into this packages. I would like to avoid a topdown design approach.

Responsibilities of a Alien module.

On installation, make sure the required package is there, otherwise install it.
On usage, make sure the required package is there, else croak.

Bundle the source with the module, or download it.

Allow module authors to access information it gathers.

Document itself well.

Preferably use Module::Build.

Be sane.

Module::Install::Philosophy Perl module contains the concepts behind Module::Install.

SYNOPSIS

This document describes the personal philosophy behind the creation of CPAN::MakeMaker (the predecessor of Module::Install). The views expressed here belong to Brian Ingerson; if they are not of interest to you, you can safely ignore this document.

The above is obviously a mutation of the monumental speech by great Martin Luther King (http://web66.coled.umn.edu/new/MLK/MLK.html). While the contexts are vastly different, I feel that there are some serious parallelisms.
The CPAN has become a place that is not free of injustice. This situation has arisen not out of directed oppression, but from a failure of our community to keep its tools sharp. It is the culmination of many small decisions made in the name of practicality. This is a sad state for an institution that was created to allow all interested people to contribute equally to the best of their ability.

This assertion is rooted in my personal experience as an author. When I created my first Perl module, Inline.pm, I knew that I had done something important. But how was I to make a dent in vast Perl community?

As a complete unknown in the Perl community, my voice did not travel far. I repeatedly tried to get even an acknowledgment from the gurus familiar with XS. No success. I resorted to sending messages with ridiculous subjects to modules@perl.org. (http://www.xray.mpe.mpg.de/mailing-lists/modules/2000-08/msg00078.html) No response. Through sheer determination and shameless self-promotion I eventually got the word out, and I hope the world is a slightly better place for it.
Since then, Inline has won awards and I have had the privilege to meet almost all of Perls finest. But I still remember the pain of starting out, and want to help invite more people into this wonderful world.

One thing I have learned from experience is that the Perl community (and throw in the Python and Ruby people as well) is a small drop in the vast ocean of programming. Its a giant pot of Java out there; and a sea of C. Perl may not be the biggest fish, but with some care and cunning we could become a much bigger school.

These are the current problems that I see with CPAN and the core modules:

New Modules dont help Older Perls
If I were to guess what percent of all Perl5 installations were at the current release level (5.8.0 in October 2002) I would say 3-5%. That may even be generous. Id say that over 40% of installations might still be at 5.005 or earlier.
The biggest problem with adding a module to the core is that it only helps a small subset of Perl users for a long long time. Worse yet, a good module author will still probably avoid using the core additions as prerequisites, because they want their new module to work as well on 5.005 as on 5.8.
CPAN::MakeMaker should be able to help in this regard. For example, instead of putting Inline.pm into the core for 5.9, I can now effectively get it into the core for every version of Perl that Inline supports.
Author Exclusiveness
Not just anybody can get a module into the core. It seems you have to know people in high places. If I were a brilliant new talent with a great new module, it would have a harder time getting the ear of the pumpking, then if I were, say, Damian Conway. In fact, I probably wouldnt even know where to start.
Reduced Competition
One comment Ive heard from some very good Perl programmers is "Everything important has already been done". Their feeling is that even though a module is suboptimal, it would be a waste of time to write a competing module. Who would use it instead of the one already in the core?
When I write a competing module, I know that I have to make it at least twice as good as the existing one to even get noticed. Thats not a bad thing, but should everybody be forced into that situation?
For example, lets say that you have created a really useful CGI script. Lets also say that it makes use of your own CGI::Special module, because CGI.pm doesnt meet your needs. Even though your script might be generally useful and worth sharing, the fact that it requires a non-standard module can only negatively affect its acceptance. Trying to get general acceptance for the superior CGI::Special module will be harder still.
Core modules are assumed by the general public to be "Best of Breed". While this may be true for some modules at some point in time, it keeps talented people from attempting to "breed" something better.
Core Bloat
Every time we add a module to the core it gets bigger and bigger. And we cant ever remove modules from the core, once theyve been added.
If I had my druthers, wed remove all modules from the core that werent necessary for either running Perl or installing modules. Of course, wed need to set things up so that installing modules was so easy, that it could be done on the fly if necessary. Is this easily accomplishable? Nope. Is it impossible? Nope. We have the best language in the world to help us do it!
Maintenance Bitrot
Believe it or not, Perl authors can sometimes acquire a "Life Beyond Perl". They get families or new hobbies or even hit by a bus. (This would be a "Death Beyond Perl".) The fact is, that once somebody writes a piece of code and shares it with the world, they are expected to maintain it for all time.
That is being generous. There are others that think that once their module has become popular or made it into the core, they dont need to keep fixing and improving it. I have personally been guilty of this sin.
And then theres the Damian Conway Effect. This plagues the exceptional authors who are so innovative and prolific they simply dont have time to maintain everything they have written.

I initially formalized these opinions at the YAPC (Yet Another Perl Conference) in June 2001. Since then I have been trying to think of technological solutions to fix these social problems.

One idea was dubbed NAPC. NAPC is CPAN backwards. It is a large system of precompiled modules that can be installed on the fly, with the goal of reducing the number of modules in the core. NAPC hasnt got started yet. Id still like to do it someday, but its a big problem with a lot of issues.

CPAN::MakeMaker (and now Module::Install) on the other hand, is simple and ultimately flexible. It should work with all of the existing CPAN processes without requiring any changes from them. And new features can be continuously added. Even though it doesnt scratch all of my philosophical CPAN itches, its a good start.

Paus is all about controlling "stuff" with easy scripts. You could for example make the light in your house go on and off in the way you specify.

You also could use paus to create a remote controlled mp3box that also has a web-interface at the same time and shows the current song on an LCD display.

With paus you can send and receive "events" from so called "modules":
* There are IO modules to control hardware, like lights and sensors.
* Theres an UI module to control an universal userinterface.
* Theres an IR module to receive events from remote controllers.
* There are many more to come.

Paus is designed to be as flexible and clean as possible. Its very easy to control the modules by using simple perl-scripting.

Its also very easy to create additional modules in perl or C. Modules even can be controlled accros the internet. (it doesnt make a difference at all).

CMF Quick Installer Tool provides a a facility for comfortable activation/deactivation of CMF compliant products inside a CMF.
Therefore it has to be installed as a tool inside a CMF portal, where it stores the information about the installed products.
The requirements for a product to be installable with QuickInstallerTool are quite simple (almost all existing CMF products fulfill them):
.External Product: The product has to implement an external method install in a python module Install.py in its Extensions directory.
.TTW Product: The product has to have a Install folder and have a python script titled install inside that folder.
Products can be uninstalled and QuickInstellerTool removes the following items a product creates during install:
.portal types
.portal skins
.portal actions
.portalobjects (objects created in the root of the portal)
.workflows
.left and right slots (also checks them only for the portal)
Attention: QuickInstallerTool just tracks which objects are ADDED, but not what is changed or deleted.
second Attention: QuickInstallerTool just can uninstall products that are installed via QuickInstallerTool
Enhancements:
- Adjusted installProduct method to be compatible with CMF 2.1
- Refactored ResourceRegistries support not to require the product itself to be installed in QI.
- Added the INonInstallable interface that is used to look up utilities.
- Added an option to omit snapshot creation which defaults to True to speed up.
- We automatically create a GenericSetup snapshot before and after installation.

Shadows Rising project is a Web-based Role Playing Game open to customisation.
Shadows Rising is an RPG game engine. The engine is aimed at enabling users to install a number of game modules which will use the engine to present an RP game to players on the users site.
The basic concept of the game engine is to create a highly configurable and extendable engine to support Role Playing games under a variety of ruleset regimes. The game engine therefore keeps all game content and data stored externally to the engine in what are known as "Game Modules". These Game Modules are basically XHTML and CSS template files, database stored data, content and game items. As a result individual users may create custom Game Modules tailored for specific game types, locations, plots, NPCs and timelines.
This immense ability makes possible a large variety of RPG games, something deeply supported by the ability to configure almost any game engine settings, and add game engine "Plug-Ins" which extend both functionality and support for more complex Game Modules. The game engine is pre-packaged with the "Shadows Rising RPG Game" created by the game engine developers. A primary development objective is making both game engine configuration and Game Module creation as easy a process as possible - including the ability to use alternative RPG rulesets that users may be more comfortable and familiar with.
Shadows Rising is written in the PHP language, with data stored and retrieved using either the MySQL or PostgreSQL Database Management Systems which use SQL (Simplified Query Language). Output conforms to the XHTML 1.0 Strict, XHTML 1.1 and CSS standards. Javascript is used on a limited basis.
Enhancements:
- minor update to 0.0.5 to correct a number of small issues and update any corrupted files hosted by Sourceforge at the last release.