Free lazy software for linux

Test::Lazy is a quick and easy way to compose and run tests with useful output.

SYNOPSIS

use Test::Lazy qw/check try/;

check(1 => is => 1);
check(0 => isnt => 1);
check(a => like => qr/[a-zA-Z]/);
check(0 => unlike => qr/a-zA-Z]/);
check(1 => > => 0);
check(0 => < => 1);

try(qw/a/ => eq => a);
try(qw/a/ => ne => b);
try(qw/a/ => is => [a]);
try( < stmt >, < cmpr >, < expected >, [ < msg > ] )

Evaluate < stmt> and compare the result to using < cmpr>. Optionally provide a < msg> to display on failure. If < msg> is not given, then one will be automatically made from < stmt>, < cmpr>, and < expected>.
try will also try to guess what representation is best for the result of the statement, whether that be single value, ARRAY, or HASH. Itll do this based on what is returned by the statement, and the type of < expected>. See `perldoc -m Test::Lazy` for more detail.

Note, if < expected> is an ARRAY or HASH, this function will convert it to its JSON representation before comparison.

try("2 + 2" => == => 5);

# This will produce the following output:

# Failed test 2 + 2 == 5
# at __FILE__ line __LINE__.
# got: 4
# expected: 5
check( < got>, < cmpr>, < expected>, [ < msg> ] )

Compare < got> to < expected> using < cmpr>. Optionally provide a < msg> to display on failure. If < msg> is not given, then one will be automatically made from < got>, < cmpr>, and < expected>.

Note, if < got> or < expected> is an ARRAY or HASH, this function will convert them to their JSON representation before comparison.

check([qw/a b/] => is => [qw/a b c/]);

# This will produce the following output:

# Failed test ["a","b"] is ["a","b","c"]
# at __FILE__ line __LINE__.
# got: ["a","b"]
# expected: ["a","b","c"]
template( ... )

Convenience function for creating a Test::Lazy::Template. All arguments are directly passed to Test::Lazy::Template-new>.

See Test::Lazy::Template for more details.

Returns a new Test::Lazy::Template object.

cmpr

< cmpr> can be one of the following:

ok, not_ok, is, isnt, like, unlike,
, =, lt, gt, le, ge, ==, !=, eq, ne,

Lazy8 Ledger is a completely free program runs on most operating systems. It is "open source" and will give you all you need to do accounting for any business or personal use. You can enter any type of bookkeeping activity and break out the activities to any number of accounts.
There are numerous standard reports that are the basis of accounting needs and then there are tools to make your own reports.
Furthermore, this program is 100% unicode compatible in all respects so you could change any texts that appear anywhere in this program to any language on this planet.
Currently this program is available only in English, Swedish and partially Estonian and Slovenian. Other languages should soon become available as more and more kind users will be using this program and sending me their translations.
Main features:
- General Ledger - Lazy8 Ledger is mainly categorized as a general ledger program.
- Multicompany - you can do bookkeeping for as many different companies as you want.
- Chart of accounts - you may enter your own chart of accounts and break out each account into different catagories for project or customer.
- 100% Unicode compatible - All fields can be set to any language.
- Operating system independent - Written in Java which means that any operating system that can run Suns Java 1.4, can run this program. That means most operating systems.
- Reports - Their is a print preview of all reports and all reports may be saved in PDF, Excel, HTML, CSV, or text format.
- Balance/result report - Summerized by assets, debts, incomes and expenditures.
- Transaction report - List of all transactions.
- Account summary report - Summary of each account.
- Chart of accounts report - List of all defined accounts.
- Customer/project report - List of all defined Customers/projects.
- EU BAS 2003 Result report - Summerized by several categories according to swedish law.
- EU BAS 2003 Balance report - Summerized by several categories according to swedish law.
- EU BAS 2003 VAT report - Somewhat limited yet fully functional. It may be customized to your needs.
- Tools to make your own report defintions - There is a user-friendly report generator and an SQL report generator.
- Financial analysis
- Bar charts, 3D bar charts, line graphs, pie charts.
- Show trends in any single account per day, week, bi-weekly, monthly, bi-monthly, quarterly, half-year, yearly.
- Accounts may be grouped together in any combination in the trend graphs.
- Predefined groups for trends - profit, assets, debts, incomes, expenses ...
- Several periods may be compared. For example, last years profit may be compared to this years profit per month in a bar chart.
- Import/Export - Compatibility with other accounting systems
- All tables may be exported and imported in a Comma seperated variable (CSV) format.
- All types of Standard import export (SIE) formats are supported for import and export. This is a common standard in Sweden for accounting systems.

MySQL Backup for lazy sysadmins (mysqlblasy) is a Perl script for automating MySQL database backups. It uses "mysqldump" for dumping mysql databases to the files sytem. MySQL Backup for lazy sysadmins program was written with automated usage in mind.
For example, it is silent during operation, and only produces noise on errors/problems. It rotates backups automatically to prevent the backup disk from getting full when the administrator is on vacation (or is lazy).
Main features:
- syslog facility
- unix output (loglevels, errors to stderr)
- dump some or all databases from a database instance
- compress dumps (using gzip,bzip2 or perl modules)
- backup rotation to avoid disc overflow
- no shell on external commands!
- can be run as unpriviledged user
- perfect for cron jobs

LISa is a small daemon which is intended to run on end user systems. It provides something like a "network neighbourhood", but only relying on the TCP/IP protocol stack, no smb or whatever. The information about the hosts in your "neighbourhood" is provided via TCP port 7741.

LISa supports two ways of searching for hosts, the first method is to send ICMP echo request packets to the hosts, the second one is to send NetBIOS broadcasts using nmblookup. In order to keep network load low various strategies are implemented. There is also a basic security mechanism. For environments with stricter security rules there is also a restricted version, resLISa. LISa should compile and work under the usual unix flavours (linux, *bsd, solaris,...), it might have problems on 64 bit machines and it definitly doesnt work with IPv6. It provides some special support for KDE , but it is completely independant, it requires neither the Qt library nor any KDE stuff.

In the configuration file of LISa you provide a range of IP-addresses which LISa should check wether they are running. In the most simple case this could be your network address/subnetmask, then LISa would check every possible host of your network wether it is up. The hosts are checked using ICMP echo requests. To be able to send and receive ICMP echo requests and replies the program has to open a so called "raw socket". Therefor it needs root privileges. This socket is opened right after the start of the program, after successfully opening the socket root privileges are dropped immediatly (see main.cpp and strictmain.cpp). If you configure LISa this way, that it also uses nmblookup, it will popen("nmblookup "*""); and then parse the results.

Since the ICMP requests and the broadcasts can cause some network traffic if there are more than one such server running in one network, the servers cooperate with each other. Before they start pinging (or nmblookup), they send a broadcast on port 7741.
If somebody answers this broadcast, they will retrieve the complete list of running hosts via TCP port 7741 from this host and will not start to ping (or nmblookup) theirselves. If nobody answers, the host which sent the broadcast will start pinging the hosts (or nmblookup) and then open a socket which listens for the mentioned broadcasts. If the host received an answer to his broadcast, it wont have the socket for listening to the broadcasts open. So usually exactly one of the servers will have this socket open and only this one will actually ping (or nmblookup) the hosts. In other words, the servers are lazy, they work like "I will only do something if nobody else can do it for me".

There is another feature which reduces the network load. Lets say you configured LISa to update all 10 minutes. Now you dont access your server very often. If nobody accessed the server during the last update period, the server will update (either itself or from the one which actually does the work) and then double its update period, i.e. the next update will happen after 20 minutes. This will happen 4 times, so if nobody accesses the server with update period 10 minutes for a long time, its update interval will grow up to 160 minutes, almost three hours. If then somebody accesses the data from the server, he will get an old list ( up to 160 minutes old). With accessing the server will reset its update interval to its initial value, i.e. 10 minutes and immediatly start updating if the last update is more than these 10 minutes over. This means if you get a very old list, you can try some seconds later again and you should get a current version. This will have fast effect for the servers, which dont ping (or nmblookup) theirselves, since only one user usually accesses them, and it will have less effect for the server which does the pinging (or nmblookup), since this server is accessed from all other servers in the network.

This way it is possible that many hosts in a network run this server, but the net load will remain low. For the user it is not neccessary to know wether there is a server (i.e. a name server or fileserver or whatever) in the network which also runs LISa. He can always run LISa locally and LISa will detect if there is one existing, transparently to the user.

If you dont want that your LISa takes part in the broadcasting, but always does the pinging itself, make it use another port with the command line option --port or -p. This is not recommended !

If you send SIGHUP to LISa, it will reread its configfile. If you send SIGUSR1 to LISa, it will print some status information to stdout.

classesfaq is a Perl module with frequently asked questions about the Perl classes pragma.
Main features:
- Compile-time classes, no base class required
- Dynamic classes, alter or create at run-time
- Attributes, class and object, private, read-only, public
- Mixins, methods by name or regx, attributes also
- Single and multiple inheritance
- Accessors, optimized, overridable with read-only
- Accessor dispatch methods set and get
- Method declaration, delegation, ABSTRACT and EMPTY
- Separate new and clone methods, overridable
- Optional initialize method, aggregation
- Utility methods: dump, load, CLASS, SUPER
- Dynamically preserved declaration and mixin tracking
- Simplified exceptions, one line exception classes with inheritance trees
- Base exception class, light, robust, traceable
- 8 reusable exception classes in X:: namespace
- Compatible standard internals, easy porting, no surprises
What is the classes pragma?
A simple, stable, fast, and flexible way to use Perl 5 classes. If you look at no other Perl OO module look at this one, really. If you have done OO in Perl you will find this comfortably familiar. If not you may save yourself time and pain learning the classes pragma first or as you learn Perl OO--many have already.
Why should I use the classes pragma?
- Relevant: fills real-world need for conventional Perl OO
- Lazy: 100+ conventional lines reduced to 1
- Simple: standard readable terms, UML friendly
- Stable: 1000+ unit test points, used reliably in large applications
- Portable: OS independent, single file, 100% pure perl
- Fast: benchmarks faster or equal to the long way
- Light: only standard deps, requires greater than 5.6.1
- Sustainable: tag model, clean, commented
- Open: Perl artistic license, multi-language friendly
- Supported: mailing list, site, documented, actively maintained
If for no other reason because it is a new approach.

Scalar::Defer is a Perl module to calculate values on demand.

SYNOPSIS

use Scalar::Defer; # exports defer and lazy

my ($x, $y);
my $dv = defer { ++$x }; # a deferred value (not memoized)
my $lv = lazy { ++$y }; # a lazy value (memoized)

print "$dv $dv $dv"; # 1 2 3
print "$lv $lv $lv"; # 1 1 1

my $forced = force $dv; # force a normal value out of $dv

print "$forced $forced $forced"; # 4 4 4

This module exports two functions, defer and lazy, for building values that are evaluated on demand. It also exports a force function to force evaluation of a deferred value.

defer {...}

Takes a block or a code reference, and returns a deferred value. Each time that value is demanded, the block is evaluated again to yield a fresh result.

lazy {...}

Like defer, except the value is computed at most once. Subsequent evaluation will simply use the cached result.

force $value

Force evaluation of a deferred value to return a normal value. If $value was already normal value, then force simply returns it.

NOTES

Deferred values are not considered objects (ref on them returns 0), although you can still call methods on them, in which case the invocant is always the forced value.

Unlike the tie-based Data::Lazy, this module operates on values, not variables. Therefore, assigning into $dv and $lv above will simply replace the value, instead of triggering a STORE method call.

Also, thanks to the overload-based implementation, this module is about 2x faster than Data::Lazy.

Slisp project is written in C, and I recently added a header file lisp.h that contains an array of common-used lisp functions, so if you want to extend SLISP programming in Lisp you are allowed too.
Enhancements:
- Added Bignums support (GMP)
- Added a lot of functions
- Added let, and backquote. Is possibly to define some simple macro by defmacro
- Now function evaluation is ``lazy`` or correctly speaking, if an argument is really don`t needed, then is not evalled
- Added an user abort menu to stop some operations
- Now numeric operations (Using GMP) returns what it has to:
- >> (+ 2 3)
- => 5
- ... (you have to find the rest)

Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way.
Scala smoothly integrates features of object-oriented and functional languages including mixins, algebraic datatypes with pattern matching, genericity, and more.
It is well integrated with Java and .NET: the Scala compiler produces standard Java class files or .NET assemblies, and Java/.NET libraries and frameworks can be used without glue code or additional declarations.
Scala is a pure object-oriented language in the sense that every value is an object. Types and behavior of objects are described by classes and traits. Class abstractions are extended by subclassing and a flexible mixin-based composition mechanism as a clean replacement for multiple inheritance.
Whats New in 2.6.0 RC1 Development Release:
- This version introduces some language changes (existential types, lazy values, structural types, etc.) and fixes many bugs.