Free find person software for linux

Jind is an interpreter for a toy programming language. The aim of the game is to lead a person out of a labyrinth by giving appropriate textual instructions.

The challenge is to find a general solution by using conditions and loops. Jind can be used to teach the basics of programming in an understandable, entertaining, and instructive way.

Installation

To compile the program, you need a compiler for Java. I recommend to use the Java compiler provided by Sun. Go to http://www.sun.com to download it for free. Follow the instructions in the manual to install the compiler. Then do a

cd Jind-1.0
make

to compile Jind. If anything goes wrong, open the Makefile in your favourite editor and adjust the paths to your configuration.

Open the file "jind.html" in your favourite browser. I recommend to use Microsoft Internet Explorer 4.0, Netscape Navigator 4.0 or Mozilla 0.9x. The applet should load now and you will see an input box immediately.

File::Find is a Perl module to traverse a directory tree.

SYNOPSIS

use File::Find;
find(&wanted, @directories_to_search);
sub wanted { ... }

use File::Find;
finddepth(&wanted, @directories_to_search);
sub wanted { ... }

use File::Find;
find({ wanted => &process, follow => 1 }, .);

These are functions for searching through directory trees doing work on each file found similar to the Unix find command. File::Find exports two functions, find and finddepth. They work similarly but have subtle differences.

find

find(&wanted, @directories);
find(%options, @directories);

find() does a depth-first search over the given @directories in the order they are given. For each file or directory found, it calls the &wanted subroutine. (See below for details on how to use the &wanted function). Additionally, for each directory found, it will chdir() into that directory and continue the search, invoking the &wanted function on each file or subdirectory in the directory.

finddepth

finddepth(&wanted, @directories);
finddepth(%options, @directories);

finddepth() works just like find() except that is invokes the &wanted function for a directory after invoking it for the directorys contents. It does a postorder traversal instead of a preorder traversal, working from the bottom of the directory tree up where find() works from the top of the tree down.

File::Find::Similars is a Similar files locator.

SYNOPSIS

use File::Find::Similars;

File::Find::Similars->init(0, @ARGV);
similarity_check_name();

Similar-sized and similar-named files are picked as suspicious candidates of duplicated files.

What descirbes it better than a actual output. Sample suspicious duplicated files:

## =========
1574 PopupTest.java /home/tong/.../examples/chap10
1561 CardLayoutTest.java /home/tong/.../examples/chap1
1570 PopupButtonFrame.class /home/tong/.../examples/chap6

## =========
22984 BinderyHelloWorld.jpg /home/tong/...
17509 MacHelloWorld.gif /home/tong/...

The first column is the size of the file, 2nd the name, and 3rd the path. The motto for the listing is that, I would rather my program overkills (wrongly picking out suspicious ones) than neglects something that would cause me otherwise years to notice.
By default, File::Find::Similars(3) assumes that similar files within the same folder are OK. Hence you will not get duplicate warnings for generated files (like .o, .class or .aux, and .dvi files) or other file series.

Once you are sure that there are no duplications between folders and want File::Find::Similars(3) to scoop further, specify the first parameter as 1. This is very good to eliminate similar mp3 files within the same folder, or downloaded files from big sites where different packaging methods are used, e.g.:

## =========
66138 jdc-src.tar.gz .../ftp.ora.com/published/oreilly/java/javadc
147904 jdc-src.zip .../ftp.ora.com/published/oreilly/java/javadc

Ignorance is a content filtering plugin for Gaim. If you love Gaim for chat, but find yourself missing the filtering features of clients like zinc, then Ignorance is for you!

File::Find::Parallel allows you to traverse a number of similar directories in parallel.

SYNOPSIS

use File::Find::Parallel;

my $ffp = File::Find::Parallel->new( qw( /foo /bar ) );

print "Union:n";
my $union = $ffp->any_iterator
print " $_n" while $_ = $union->();

print "Intersection:n";
my $inter = $ffp->all_iterator
print " $_n" while $_ = $inter->();

File::Find is the ideal tool for quickly scanning a single directory. But sometimes its nice to be able to perform operations on multiple similar directories in parallel. Perhaps you need to compare the contents of two directories or convert files that are shared in more than one directory into hard links.

This module manufactures iterators that visit each file and directory in either the union or the intersection of a number of directories. Hmm. What does that mean?

Given two directory trees like this

foo
foo/a
foo/b/c
foo/d

bar
bar/a
bar/b
bar/e

you can choose to work with the intersection of the two directory structures:
.
./a
./b

That is the subdirectories and files that the foo and bar share.
Alternately you can work with the union of the two directory structures:
.
./a
./b
./b/c
./d
./e

Still not clear? Well, if you wanted to do a recursive diff on the two directories youd iterate their union so you could report files that were present in foo but missing from bar and vice-versa.

If, on the other hand you wanted to scan the directories and find all the files that are common to all of them youd iterate their intersection and receive only files and directories that were present in all the directories being scanned.

The any_iterator and all_iterator are built on a more general purpose method: want_iterator. If, for example, you want to make links between files that are found in more than one directory you might get your iterator like this:

my $iter = $ffp->want_iterator( 2 );

The apparently magic 2 reflects the fact that if youre going to be making links you need at least two files. No matter how many directories you are iterating over in parallel you will only see files and directories that appear in at least two of those directories.

File::Find::Parallel can scan any number of directories at the same time. Heres an example (on Unix systems) that returns the list of all files and directories that are contained in all home directories.

use File::Glob :glob;
use File::Find::Parallel;

my $find = File::Find::Parallel->new( bsd_glob( /home/* ) );

my @common = ( );
my $iter = $find->all_iterator;
while ( defined my $obj = $iter->() ) {
push @common, $obj;
}

print "The following files are common to ",
"all directories below /home :n";

print " $_n" for @common;

For a complete concrete example of its use see lncopies in the bin subdirectory of this distribution.

Iterators

The iterator returned by any_iterator, all_iterator or want_iterator is a code reference. Call it to get the next file or directory. When all files and directories have been returned the iterator will return undef.

Once created an iterator is independent of the File::Find::Parallel object that created it. If the object goes out of scope and is destroyed during the life of the iterator it will still function normally.

You may have many active iterators for a single File::Find::Parallel object at any time.

SYNOPSIS

use File::Find::Rule;
# find all the subdirectories of a given directory
my @subdirs = File::Find::Rule->directory->in( $directory );

# find all the .pm files in @INC
my @files = File::Find::Rule->file()
->name( *.pm )
->in( @INC );

# as above, but without method chaining
my $rule = File::Find::Rule->new;
$rule->file;
$rule->name( *.pm );
my @files = $rule->in( @INC );