Free binhex basic software for linux

Vista Basic provides a theme similar to Microsoft Vista.

window borders similar to those of Microsoft Vista when using non Aero compatible software (such as JRE 6 or Photoshop CS 2)

Agora BASIC is a BASIC compiler for POSIX systems. Agora BASIC aims to implement all of Standard Full BASIC (ANSI INCITS 113-1987), with useful but compatible extensions. It does not do that quite yet. What it does is implement a small subset of the language, enough that simple programs can be written in it. A lot of work expanding the support of the language is still required.
Agora BASIC specifically does not aim to be a "modern" BASIC dialect. There are enough of those already, even as free software. The only way for Agora BASIC to acquire classes or other similar things is if the standard is thus updated. Minor extensions, mainly lifting senseless restrictions in the standard and enabling writing useful programs in the Unix environment are possible.
Agora BASIC is a compiler, not an interpreter, and there is no interactive mode. Furthermore, the compiler uses C as an intermediate language and the system C compiler as the backend (note that the intermediate C code is not intended for human consumption or manual editing).
Enhancements:
- This initial release supports enough of the language to write simple programs.

Set::Infinite::Basic is a Perl module with sets of intervals.

SYNOPSIS

use Set::Infinite::Basic;

$set = Set::Infinite::Basic->new(1,2); # [1..2]
print $set->union(5,6); # [1..2],[5..6]

Set::Infinite::Basic is a Set Theory module for infinite sets.

It works on reals, integers, and objects.

This module does not support recurrences. Recurrences are implemented in Set::Infinite.

METHODS

empty_set

Creates an empty_set.

If called from an existing set, the empty set inherits the "type" and "density" characteristics.

universal_set

Creates a set containing "all" possible elements.

If called from an existing set, the universal set inherits the "type" and "density" characteristics.

until

Extends a set until another:

0,5,7 -> until 2,6,10
gives
[0..2), [5..6), [7..10)

Note: this function is still experimental.

copy

clone

Makes a new object from the objects data.

Mode functions:

$set = $set->real;

$set = $set->integer;

Logic functions:

$logic = $set->intersects($b);

$logic = $set->contains($b);

$logic = $set->is_null; # also called "is_empty"

Set functions:

$set = $set->union($b);

$set = $set->intersection($b);

$set = $set->complement;
$set = $set->complement($b); # can also be called "minus" or "difference"

$set = $set->simmetric_difference( $b );

$set = $set->span;

result is (min .. max)

Scalar functions:

$i = $set->min;

$i = $set->max;

$i = $set->size;

$i = $set->count; # number of spans

Overloaded Perl functions:

print

sort,

Global functions:

separators(@i)

chooses the interval separators.

default are [ ] ( ) .. ,.

INFINITY

returns an Infinity number.

NEG_INFINITY

returns a -Infinity number.

iterate ( sub { } )

Iterates over a subroutine.
Returns the union of partial results.

first

In scalar context returns the first interval of a set.

In list context returns the first interval of a set, and the
tail.

Works in unbounded sets

type($i)

chooses an object data type.

default is none (a normal perl SCALAR).

examples:

type(Math::BigFloat);
type(Math::BigInt);
type(Set::Infinite::Date);
See notes on Set::Infinite::Date below.

tolerance(0) defaults to real sets (default)
tolerance(1) defaults to integer sets

real defaults to real sets (default)

integer defaults to integer sets

Internal functions:

$set->fixtype;

$set->numeric;

BASIC-256 is an easy to use version of BASIC designed to teach young children the basics of computer programming. The BASIC-256 project uses traditional control structures like gosub, for/next, and goto, which helps kids easily see how program flow-control works.
It has a built-in graphics mode which lets them draw pictures on screen in minutes, and a set of detailed, easy-to-follow tutorials that introduce programming concepts through fun exercises.
BASIC-256 is licensed under the GNU public license, which means that its free to download, modify, and share.
Enhancements:
- Version 0.9.2 fixes some minor bugs, adds anonymous arrays and a sound command for Windows versions.
- Translations have been updated, and a command line option -l lets users select the language at run time.

PerlPoint::Tags::Basic is a Perl module that declares basic PerlPoint tags.

SYNOPSIS

# declare basic tags
use PerlPoint::Tags::Basic;

This module declares several basic PerlPoint tags. Tag declarations are used by the parser to determine if a used tag is valid, if it needs options, if it needs a body and so on. Please see PerlPoint::Tags for a detailed description of tag declaration.

Every PerlPoint translator willing to handle the tags of this module can declare this by using the module in the scope where it built the parser object.

# declare basic tags
use PerlPoint::Tags::Basic;

# load parser module
use PerlPoint::Parser;

...

# build parser
my $parser=new PerlPoint::Parser(...);

...

It is also possible to select certain declarations.

# declare basic tags
use PerlPoint::Tags::Basic qw(I C);

A set name is provided as well to declare all the flags at once.

# declare basic tags
use PerlPoint::Tags::Basic qw(:basic);

CGI::WeT::Modules::Basic is a basic rendering engine extensions.

SYNOPSIS

use CGI::WeT::Modules::Basic ();

This module provides basic rendering constructs for the engine. Please be aware that the code supersedes the documentation. While I have tried to be accurate there are times that words fail me and a look at the code is far more enlightening than anything I could cobble together. This is especially true when trying to write a theme. Download a theme and see how someone else did it. Then try making modifications and see what happens.

Perl::Metric::Basic is a Perl module that can provide basic software metrics.

SYNOPSIS

# first construct a PPI::Document object to pass in
my $document = PPI::Document->load("t/lib/Acme.pm");

# then retrieve metrics on the document
my $m = Perl::Metric::Basic->new;
my $metric = $m->measure($document);

# $metric will consist of something like:
# Acme => {
# new => {
# blank_lines => 1,
# comments => 1,
# lines => 7,
# lines_of_code => 6,
# numbers => 0,
# numbers_unique => 0,
# operators => 3,
# operators_unique => 2,
# symbols => 5,
# symbols_unique => 2,
# words => 7,
# words_unique => 6
# },
# ...

When constructing software one often produces code of vastly differing quality. The Perl::Metric::Basic module leverages the PPI module to provide some interesting software metrics for Perl code, mostly measuring size and maintainability.

A metric is some sort of measurement which is intended to help you make a decision about a piece of code. There arent any hard rules about metrics, but the ones provided should allow you to make decisions about modules or subroutines which are outliers. Abnormal measurements in a subroutine are a warning sign that you should reexamine that routine, checking for unusually low quality.

This module uses the PPI module, and thus can parse Perl code without evaluating it.
If youre interested in software metrics, I highly recommend "Code Complete" (Second Edition) by Steve McConnel (Microsoft Press).

METHODS

new()

The new() method is the constructor:
my $m = Perl::Metric::Basic->new;

measure()

The measure() method measures some metrics and returns a hash reference. Files in Perl can contain more than one package, and it is interesting to seperate metrics by package. The key for the hash reference is the name of the package, and the value is another hash reference.

Perl packages are seperated into subroutines, and it is interesting to seperate metrics by subroutine. The key for the second hash reference is the name of the subroutine, and the value is another hash reference containing metrics.

There are various metrics applied to the subroutine. The key for the third hash reference is the name of the metric, and the value is the value of the metric. The metrics are:

blank_lines

The number of blank code lines.

comments

The number of lines containing comments.

lines

The total number of lines.

lines_of_code

The number of lines of code.

numbers

The total number of numbers used (eg "$z = 42 * 3" would have 2 numbers).

numbers_unique

The number of unique numbers used (eg "$z = 2*$x + 2*$y" would have 1 unique number).

operators

The total number of operators used.

operators_unique

The number of unique operators used.

symbols

The total number of symbols used (eg "$z = $x*$x + $y*$y" would have 5 symbols).

symbols_unique

The number of unique symbols used (eg "$z = $x*$x + $y*$y" would have 3 unique symbols).

words

The total number of words (operators) used.

words_unique

The number of unique words used.