Free file maker software for linux

File::Maker is a Perl module that mimics a make by loading a database and calling targets methods.

SYNOPSIS

#####
# Subroutine interface
#
use File::Maker qw(load_db);

%data = load_db($pm);

######
# Object interface
#
require File::Maker;

$maker = $maker->load_db($pm);

$maker->make_targets(%targets, @targets, %options );
$maker->make_targets(%targets, %options );

$maker = new File::Maker(@options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

When porting low level C code from one architecture to another, makefiles do provide some level of automation and save some time. However, once Perl or another high-level language is up and running, the high-level language usually allows much more efficient use of programmers time; otherwise, whats point of the high-level language. Thus, makes great economically sense to switch from makefiles to high-level language.

The File::Maker program module provides a "make" style interface as shown in the herein above. The @targets contains a list of targets that mimics the targets of a makefile. The targets are subroutines written in Perl in a separate program module from the File::Maker. The separate target program module inherits the methods in the File::Maker program module as follows:

use File::Maker;
use vars qw( @ISA );
@ISA = qw(File::Maker);

The File::Maker methods will then find the target subroutines in the separate target program module.

The File::Maker provides for the loading of a hash from a program module to provide for the capabilities of defines in a makefile. The option pm = $file> tells File::Maker to load a database from the __DATA__ section of a program module that is in the Tie::Form format. The Tie::Form format is a very flexible lenient format that is about as close to a natural language form and still have the precision of being machine readable.

This provides a more flexible alternative to the defines in a makefile. The define hash is in a separate, very flexible form program module. This arrangement allows one target program module that inherits the File::Maker program module to produce as many different outputs as there are Tie::Form program modules.

Guitar Mode Maker is a software will help the guitar player learn scales, modes, chords, and create new scales. Designed to be easy enough for the beginner and comprehensive for the advanced user! Learn Chords and Scales. Review the Chord and Scale List for GMM 3.0. Over 750 Chords and Scales Included in the trial installation!
This program also has the capability of the user sharing their scales with others through a new and improved, unique scale file (.GS2 file)!
Guitar Mode Maker 1.0 for linux comes with hundreds of scales, chords and modes to help you learn! Guitar Mode Maker 1.0 is available only for Linux.
Additionally for BASS GUITAR PLAYERS, Bass Guitar Mode Maker! Now bass players can have all the scales, modes and chords too! Bass Guitar Mode Maker 3.0 available for download now!
Main features:
- Easy scale creation by clicking on the fretboard, note list or piano keyboard
- Easy scale transposition
- Ability to save Guitar Scale files, even in trial version
- Ability to hear your scale played by acoustic guitar, 12-string or piano
- 750 Scales and chords TO START WITH!
- Ability to print guitar scale on printer!
- Easier to use interface (Screen Shot)

Patch Maker helps you manage multiple in-progress source code patches to software. Patch Maker remembers which files are part of which patch, and keeps them disentangled during the development process.
It speeds up common operations and housekeeping tasks, allowing you to focus on writing code. It is a command-line tool written in Perl, and so is usable on (at least) Windows, Linux and Mac OS X.
Enhancements:
- Initial SVN support was added to go with CVS.
- The configuration was moved to the .pmrc file in the home directory.
- Message and error printing were tidied up and standardized.

RPM Package Maker is a frontend for other linux tools in order to help linux users to create RPM packages quickly and easily.
Since version 0.8 minimal spec files are kept in:
/usr/src/packages/SPECS/mini
Enhancements:
- Small improvements and bugfixes

List::Maker is a Perl module that can generate more sophisticated lists than just $a..$b.

SYNOPSIS

use List::Maker;

@list = < 1..10 >; # (1,2,3,4,5,6,7,8,9,10)

@list = < 10..1 >; # (10,9,8,7,6,5,4,3,2,1)

@list = < 1,3,..10 > # (1,3,5,7,9)
@list = < 1..10 x 2 > # (1,3,5,7,9)

@list = < 0..10 : prime N >; # (2,3,5,7)
@list = < 1,3,..30 : /7/ > # (7,17,27)

@words = < a list of words >; # (a, list, of, words)
@words = < a list "of words" >; # (a list, of words)

The List::Maker module hijacks Perls built-in file globbing syntax (< *.pl > and glob *.pl) and retargets it at list creation.

The rationale is simple: most people rarely if ever glob a set of files, but they have to create lists in almost every program they write. So the list construction syntax should be easier than the filename expansion syntax.

Regression mAKEr project is a simple modular application for data investigation.

This is an application to help user (mathematician) to make regression between series of data, draw grpahics, and export them into various formats by means of common graphics packages (i.e., gnuplot, plotutils). It is written in Python.

The user interfeace is built upon the wxPython (wxWindows) widget set.

The idea of usage is as follows: the user builds a project which is represented as a tree of modules; modules can generate data variables, as well as consume them. Essentialy, such a tree represents an algorithm of data analysis.

The system is intended to educate students.

Test::STDmaker is a Perl module to generate test scripts, demo scripts from a test description short hand.

SYNOPSIS

#######
# Procedural (subroutine) interface
#
use Test::STDmake qw(find_t_roots get_data perl_command);

@t_path = find_t_paths()
$date = get_date();
$myperl = perl_command();

#####
# Class interface
#
use Test::STDmaker

$std = new Test::STDmaker( @options ); # From File::Maker

$success = $std->check_db($std_pm);
@t_path = $std->find_t_paths()
$date = $std->get_date();
$myperl = $std->perl_command();

$std->tmake( @targets, %options );
$std->tmake( @targets );
$std->tmake( %options );

######
# Internal (Private) Methods
#
$success = $std->build($std_driver_class);
$success = $std->generate();
$success = $std->print($file_out);

The Test::STDmaker program module provides the following capabilities:
Automate Perl related programming needed to create a test script resulting in reduction of time and cost.

Translate a short hand Software Test Description (STD) file into a Perl test script that eventually makes use of the Test module.

Translate the sort hand STD data file into a Perl demo script that demonstrates the features of the the module under test.

Provide in the POD of a STD file information required by a Military/Federal Government Software Test Description (STD) document that may easily be index and accessed by automated Test software. ISO, British Military require most of the same information, US agencies such as the FAA. The difference is that ISO, British Military do not dictate detail format. US agencies such as FAA will generally tailor down the DOD required formats.

Thus, there is an extremely wide variation in the format of the same information among ISO certified comericial activities and militaries other than US. Once the information is in a POD, different translators may format nearly exactly as dictated by the end user, whether it is the US DOD, ISO certified commericial activity, British Military or whoever. By being able to provide the most demanding, which is usually US DOD, the capabilities are there for all the others.

The Test::STDmaker package relieves the designer and developer from the burden of filling out word processor boiler plate templates (whether run-off, Word, or vi), counting oks, providing documentation examples, tracing tests to test requirments, making sure it is in the proper corporate, ISO or military format, and other such extremely time consuming, boring, development support tasks. Instead the designers and developers need only to fill in a form using a test description short hand. The Test::STDmaker will take it from there and automatically and quickly generate the desired test scripts, demo scripts, and test description documents.

Look at the economics. It does not make economically sense to have expensive talent do this work. In does not even make economically sense to take a bright 16 year, at mimimum wage and have him manually count oks. Perl can count those oks much much cheaper and it is so easily to automated with Perl. And something like this were you are doing it year in and year out, the saving are enormous. To a program manager or contract officer, this is what programming and computers are all about, saving money and increasing productivity, not object oriented oriented programing, gotos or other such things.

The Test::STDmaker class package automates the generation of Software Test Descriptions (STD) Plain Old Documentation (POD), test scripts, demonstrations scripts and the execution of the generated test scripts and demonstration scripts. It will automatically insert the output from the demonstration script into the POD -headx Demonstration section of the file being tested.