Free 2 x 2 factorial design software for linux

Laughing Man Factorial is the paranormal evil twin of Laughing Man. Factorial also has an unexplained superiority complex, almost exponential you might say, over the original Laughing Man which we will hence forth refer to as Junior for appeasement of currently unwarranted hoity-toity.
Like Junior it is an application for monitoring webpage changes, however it does so using the Objective-C/Cocoa framework as opposed to Java, and leverages Core Data, bindings, and value transformers to produce a smaller code footprint. Less fluff and more meat I say, more meat and less fluff.
Factorial is in a experimental state, it is not recommended that current users of Junior switch completely to this version. You can safely import your data and tinker with Factorial, but it is recommended that any data that you want to remain consistent, be done through old stable Junior.
Factorial may not be forgiving on data when upgrading from one version to the next for the next several releases, hence the adjectives paranormal and evil in the preface.
Junior Equivalent functionality
Splitbar position saved on shutdown
Categories display like junior
New Features
Drag and drop funtionality greatly enhanced
supports dragging to and from Safari and OmniWeb
Change log embedded into application and available through menu.
Enhancements:
- This release fixes several bugs, and provides several feature enhancements, bringing the Factorial branch almost up to par with the original Laughing Man.
- Most notably, a nasty Java to Objective-C, Date to NSDate porting bug in the beta was fixed.
- The beta was usable, but users had to wait a little under 3 years for each site refresh.
- This issue has been fixed in 0.1, but you must reset your data if you used the beta.

Java::Import::Design is the design of the Java::Import Module.

MOTIVATIONS

The original motivation for writing this module came out of a project I was working on during my previous employment. We had built a system in which a major part was implimented using EJBs on a J2EE server. In addition, we had a large component of the system, that already existed, and was written in Perl. We did not want to scrap our Perl work but it was becoming more tedious to maintain two implimentations as more and more things were being added to the system.

So, we decided that the major pieces of business logic would reside on the J2EE server and the Perl would be modified to make calls to the server. After some time and experimentation we began to realize that the memory footprint as well as the amount of time needed to make calls to the server using existing Perl to Java integration sulutions were just not acceptable. We therefore set out to find some other way. We tried all sorts of things but in the end we couldnt find anything that met our requirements and therefore decided to keep the origional system of doing things.

While at that job we never did find a suitable way to integrate our two systems. However, the problem still haunted me. It wasnt until the end of my career at that company that I saw an announcement for Googles first Summer of Code. It just so happened that as Google was announcing their brand new program that I had begun to play with the GNU GCJ suite of Java tools and came up with the idea of taking advantage of their ability to natively compile Java code for use with Perl. This may not have been a new idea but I couldnt find anything that would help me so I decided to write and submit a proposal to Google. Well, I was accepted and you now have Java::Import.

When I began to work on this project I started by creating my own namespace instead of stepping on the toes of the other existing Java/Perl integration project, Inline::Java. I did this primarily because I wanted a clean slate on which I could fully explore the nuances of GCJ, in particular its CNI interface. As I worked my module started to evolve into its own beast and at that point it seemed locigal to keep my own namespace. It is not my intention to replace Inline::Java and I still think that in te future much of the work I have done can be used by Inline::Java as an option to use GCJ specific functionality.

2-Disk X window embedded Linux is a very efficient Linux/xwindows distribution, implementing a net centric operating environment and user friendly GUI
The distribution is intended to be a demonstration of Mungkie assiciates embedded appliance development environment, showing the sort of environment that can be created for small appliance GUI systems using less than 4Mb flash and 4Mb RAM.
The embedded development environment is based around a standard source tree containing all the required utilities for a standard POSIX unix implementation with a number of XML based GUI configuration and compilation tools. Simple GUI utilities are used to configure required components and set compilation options.
The distribution is targeted as a base for:
corporate users to reduce IT costs by deploying X terminals on old or low cost hardware
Or:
embedded OS for handhelds, settop boxes, or communications devices, with full support for bluetooth, wifi, internet, and MMS protocols
Or:
Hobbyist or small companies to develop specialist applications for cheap commodity hardware
Main features:
- kernel 2.0.x/2.2.x/2.4.x
- libc-2.1/libc5/uclibc,
- tcp/ip network support. full protocol stack for wifi, mms
- busybox 0.62,
- tinylogin 1.0,
- ppp, chat, some daemons, inetd, crond. dhcp client and server. iptables
- e3 editor,
- X window system 4.1 vesa
- VNC client
- merlin character recognition
- rdesktop remote windows client
- ssh
- Mungwm : a window manager
- Mungbrowse : a web browser
- Mungterm : a terminal program
- Mungames : a collection of 12 games
- Mungedit : a text editor
- Mungfile : embedded file manager
- NEW Evil bastard operator tools
- NEW Cheese dynamics context apropriation modeling
- NEW Mini Mung beans (beans of mung for all your network environment)
Enhancements:
- Script cleanups were done to the build system.
- Bugs were fixed concerning HTTPS access with the Mweb browser.

DB Designer Fork is a fork of the fabFORCE DBDesigner 4. DBDesigner is a visual database design system that integrates entity relationship design and database creation.

The project generates SQL scripts for Oracle, SQL Server, MySQL, and FireBird.

Math::Combinatorics is a Perl module that can perform combinations and permutations on lists.

SYNOPSIS

Available as an object oriented API.

use Math::Combinatorics;

my @n = qw(a b c);
my $combinat = Math::Combinatorics->new(count => 2,
data => [@n],
);

print "combinations of 2 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
while(my @combo = $combinat->next_combination){
print join( , @combo)."n";
}

print "n";

print "permutations of 3 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
while(my @permu = $combinat->next_permutation){
print join( , @permu)."n";
}

output:

Or available via exported functions permute, combine, and factorial.

use Math::Combinatorics;

my @n = qw(a b c);
print "combinations of 2 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
print join("n", map { join " ", @$_ } combine(2,@n)),"n";
print "n";
print "permutations of 3 from: ".join(" ",@n)."n";
print "------------------------".("--" x scalar(@n))."n";
print join("n", map { join " ", @$_ } permute(@n)),"n";

Output:

combinations of 2 from: a b c
------------------------------
a b
a c
b c

permutations of 3 from: a b c
------------------------------
a b c
a c b
b a c
b c a
c a b
c b a

Output from both types of calls is the same, but the object-oriented approach consumes much less memory for large sets.

Slooze PHP Web Photo Album is a Web-based image/photo album for the display of photos and other pictures on Web sites in an organised, catalogued, searchable manner.
Slooze is simple to set up, structured, and extensible. Object-based design and generation of simple, conforming HTML only (no JavaScript, frames, tables, etc.) allows easy integration with existing sites, including template-based designs.
Enhancements:
- New features in this release include searching of comments (in addition to descriptions), and better compatibility with PHP 5.

WackoWiki provides a small, lightweight, handy, expandable Wiki clone.
WackoWiki is a small, lightweight, handy, expandable Wiki clone.
Its main advantages are a visual (WYSIWYG) editor, an easy installer, full Russian support, many localizations, email notification on changes/comments, several cache levels, design themes (skins) support, XHTML compliance, page rights (ACLs), and page comments.
Enhancements:
- This version is completely compatible with PHP5.
- Many XSS fixes were made.
- Many other bugfixes were made.
- Three new translations were added: Estonian, Portuguese, Bulgarian. Many improvements were made.

Objective Modula-2 programming language is a hybrid between Smalltalk and Modula-2 based on the object model and runtime of Objective-C.

The design is an example how native Cocoa/GNUstep support can be added to static imperative programming languages without implementing a bridge.

The projects scope encompasses the design of the Objective Modula-2 programming language and the implementation of a compiler to implement it. The initial compiler will generate Objective-C source code.