Free skeleton software for linux

Skeleton Engine for MySQL is a full framework to plug in a new storage engine. Comes with prebuild autoconf files, and a full framework to plug in your own design.

The AWS, HTTP, Memcache, Nitro, PBXT, and many other engines were put together from the skeleton engine.

To install, grab a copy of the mysql source code and run this:
./configure --with-mysql=/home/brian/mysql-5.1/ --libdir=/usr/local/lib/mysql/
make install

And then inside of MySQL:

mysql> INSTALL PLUGIN skeleton SONAME libskeleton_engine.so;

mysql> CREATE TABLE `d` (`a` varchar(125), b text, primary key(a)) ENGINE=skeleton DEFAULT
CHARSET=latin1;
Query OK, 0 rows affected (0.01 sec)

You will probably need to edit the Makefile.am in the src/ tree if you want to build on anything other then Linux (and the Makefile assumes that the server was not compiled for debug).

Berkeley Yacc (byacc) is generally conceded to be the best yacc variant available. In contrast to bison, it is written to avoid dependencies upon a particular compiler.
Byacc was written around 1990 by Robert Corbett who is the original author of bison. Originally written in K&R C, I have modified it to conform to ANSI C, and made other improvements.
Enhancements:
- configure.in: add AC_ARG_PROGRAM to make --program-prefix, etc., work.
- makefile.in: first cut of script to support --program-prefix
- configure.in: reorder AC_INIT/AC_CONFIG_HEADER to make this "work" with autoconf 2.52
- makefile.in: modify so DESTDIR works
- makefile.in: use EXEEXT and OBJEXT
- configure.in: use CF_PROG_EXT generate a config.h
- defs.h: make this use the generated config.h
- skeleton.c: add a forward-reference for yyparse()
- aclocal.m4: add CF_CHECK_CACHE, needed for CF_PROG_EXT
- yacc.1: remove the discussion of TMPDIR since it is obsolete
- skeleton.c: fix a couple of minor compiler-warnings in the skeleton
- defs.h: remove action_file_name, etc., since we use tmpfile() now.
- main.c: use tmpfile() for opening the working files. This quiets an idiot-warning advertising the use of mkstemp().
- output.c: Do not close temporary-files here, since they are opened with tmpfile(). Just rewind them, and theyre ready to read back the data stored in them.
- test/grammar.output, test/grammar.tab.c, test/grammar.tab.h: RCS_BASE
- makefile.in: turn on "make check" rule
- test/calc.output, test/run_test.sh, test/calc.tab.h: RCS_BASE
- test/ftp.tab.c: yyparse() is now yyparse(void)
- test/calc.tab.c: RCS_BASE
- test/error.tab.c: yyparse() is now yyparse(void)
- test/README: RCS_BASE
- yacc.1: various typography fixes prompted by Debian #100947
- aclocal.m4, makefile.in, configure.in: RCS_BASE
- README: updated to note that this is not the original

idl2pyext is an IDL compiler to Python extension with C.

SYNOPSIS

idl2pyext [options] spec.idl

OPTIONS

All options are forwarded to C preprocessor, except -h -i -J -v -x.

With the GNU C Compatible Compiler Processor, useful options are :

-D name
-D name=definition
-I directory
-I-
-nostdinc

Specific options :

-h

Display help.

-i directory

Specify a path for import (only for version 3.0).

-J directory

Specify a path for Python package.

-O

Enable old Python object model.

-v

Display version.

-x

Enable export (only for version 3.0).

idl2pyext parses the given input file (IDL) and generates :

a set of Python sources : an optional _spec.py and pkg/__init__.py for each package (in a standard tree)

a C c_pkgmodule.c for each package

a include file hpy_spec.h

a include file spec.h

(following the language C mapping rules)

a C skeleton spec.c (with automatic merge)

setup.py

idl2pyext is a Perl OO application what uses the visitor design pattern. The parser is generated by Parse::Yapp.

idl2pyext needs a cpp executable.

CORBA-Python is a package supplies the following tools : idl2py : IDL compiler to Python.

idl2pyemb : IDL compiler to Python embedded with C idl2pyext : IDL compiler to Python extension with C idl2pycli : RPC-GIOP client stub generator idl2pysrv : RPC-GIOP server skeleton generator

Uncle Unc is an application that provides an integrated view of structured data sources. Using a very flexible and powerful representation model, many services can be represented in Uncle Unc.
Uncle Unc is a framework for network data-sharing, enabling remote administration and access to a range of services from a range of clients, using a simple text-based protocol that isnt tied to any platform, operating system or programming language.
Uncle Unc is a toolkit for agile development of interfaces to network services that are easy to maintain, and will grow as the service grows.
At the heart of Uncle Unc is a small generic specification of what a information-based network service might look like. This specification is very generic, and free of reference to any specific technologies or buzz-words.
It is based on the simple observation that much of the time we spend with computers is spent organising and categorising data, pushing data from one box to another, and invoking actions on that data. Most user interfaces attempt to represent this activity for a single type of data, such as a mailbox, a filesystem, a relational database, a network of computers or a music collection. Uncle Unc provides a framework that makes it easy to interact with any data source.
If you feel constrained by the user interfaces you are using (or developing!), or frustrated by having to use a poorly-designed user interface for a particular task, then Uncle Unc may turn out to be a good friend!
Uncle Unc is based on the simple observation that much of the time we spend with computers is spent organising and categorising data, pushing data from one box to another, and invoking actions on that data. Arguably, we ought to spend less time doing this sort of thing and get out into the fresh air more! At the very least, we should be able to do it efficiently and effectively. The more energy we expend on wrestling with the user interface in order to get these low-level jobs done, the less we will have to deal with the high-level problem-solving tasks that can make the difference between work and gainful productivity.
Lets call this low-level categorisation activity as stamp collecting, at the risk of offending philatelists. Most user interfaces attempt to represent stamp-collecting activities for a single type of data, such as a mailbox, a filesystem, a relational database, a network of computers or a music collection. Uncle Unc provides a framework that makes it easy to interact with any data source at this level.By doing it once, we can take the time and effort to do it well, so that it doesnt intrude on the users activities unduly.
Computing is a rapidly changing field, full of powerful new uses for computers such as digital multimedia, realistic graphics and artificial intelligence. And yet much of the time that we use computers, we are performing essentially the same stamp-collecting tasks that we did twenty years ago.
Even when dealing with the new high-powered uses of computers, this is the case. How much of a digital music player programs code is devoted to playing the music, compared to sorting through and organising album playtracks (and which does the user spend most of their time doing?). 3D graphics and neural network designer applications have a similar requirement to present their internal information in a useful way to the end-user.
There is currently little cohesion in the way that software developers address these tasks. Each application codes its own listings widgets. Some have sortable fields. Some have filters. Some can divide the results into pages. Most do some things quite well, some badly, and some not at all. Most will present the interface in a single medium - as a desktop application, or a HTML web interface, a java applet, a flash movie, or whatever. Most will run on a limited number of platforms, Operating Systems or browsers.
This situation restricts the exposure of the application behind the interface, by tying it to that interface. It also limits the exposure of a front-end to a single application. The proverbial wheel is frequently re-invented, and often under tight pressures of time and resources, with less than desirable results.
Uncle Unc is an attempt to develop a generic component framework that allows many different structured data-sorting tasks to be harnessed in a manageable way. A small central set of open interfaces serve as a broker between any client and any service, giving the owners of the network the maximum degree of flexibility. In the language of Desiogn Patterns, Uncle Unc implements a bridge pattern between list-like clients and list-like servers.
Main features:
- A common set of interfaces are provided in the java programming language, and the framework has been developed to make it easy to expose any java object as an Uncle Unc service, and to control what gets exposed and how.
- Network communication between clients and severs is done using XML, opening the door to non-java programs. Over time, we may develop more detailed frameworks for interoperability using PHP, Python, .NET or other popular programming languages.
- Clients and servers are decoupled. That is, a client that can understand one service can understand any service. A service that can talk to one client can talk to any client. This results in a very efficient path to network-enabling a service across a range of platforms, or allowing access to network resources from a new type of client.
- This increases the incentive for developers to provide new capabilities to the system. A widget set that provides a better view of a list of items does so for files, mail, log file entries, databases, newsgroups, etc. without any reworking. Similarly, a new backend service that delivers an Uncle Unc interface will enjoy exposure on all Uncle Unc client platforms (with plans afoot to cover web front-ends, smartphones, and scripting language access as well as the desktop clients).
- The content of the user interface layer is directly defined by the properties and methods of the back-end service. As the back-end service evolves, there is no need to recode the GUI (or other UI), simplky the skeleton used to support it. Even this can be automatically generated from the back-end systems objects. Agile development is supported and encouraged in this way.
- Defining the UI structure directly from the back-end has the further advantage of providing a good fit between the two. A hand-coded UI may omit certain capabilities of the back-end, because they are hard to express using an ad-hoc composition of low-level widgets such as textboxes, tick boxes and drop-down lists.
- The UI is built around an open-ended description of the structure of the service that one is interacting with, rather than expressing a set of fixed pathways of interaction. As such, it supports a flexible, problem-solving approach by the end-user, rather than a purely mechanistic one.

Willowgarden project is a PHP 5 rapid development platform for that provides an extensible environment for developing Web sites featuring support for pretty REST-style URLs, easy security, observable events, a simple object-based "code + view" rendering system, ActiveRecord-style data access, built-in client/server Ajax, and more.

Application Settings

The application.xml file is comprised of various settings grouped by deployment mode (and you can import settings from one deployment mode to another). Each setting is defined via a define tag with the key attribute being the setting key and the tag contents being the value. So edit the application.xml file like so:

Change rootURL to the base Web address of your application. This is the URL you need to type into your Web browser in order to access the folder (so dont include "index.php" or anything like that).

By default, the index.php file is used for routing all requests through a front controller. If you want to make use of pretty URLs (i. e., you never actually see index.php in the URL), comment out the frontControllerFile setting and rename htaccess.sample in the application folder to .htaccess (youll need Apaches mod_rewrite turned on for this to work).

NOTE: without the .htaccess file denying access to the config folder and other code folders, youll have a huge security hole (i. e., anyone can read the XML config files and see settings, passwords, etc. right in the browser).

For app skeletons, you can change the appName setting to something else as well.

Now edit the index.php file in the main app folder. Youll see that require_once statement I mentioned earlier; change it if necessary so it loads the core/Willowgarden.php file from the right folder.

OK, if the app isnt yet using a database, this is all you need to do to get Willowgarden up and running! Go to your Web browser, type in the base Web address, and you should see the home page in all its glory. If you get an error of some kind, verify that your rootURL and frontControllerFile settings are the way you want them and that index.php is including the right Willowgarden.php file. If you still have errors, please let us know in our community forums.

Database Settings

If the app does need to use a database, and most apps do, then go back to the config folder (and rename database.xml.sample to database.xml if need be). Edit database.xml as follows:

The type setting is the type of database to use. Only "mysql" is supported currently.
The server setting is the server name to use (usually "localhost").
The username and password settings are your login credentials for accessing the database.
The name setting is the name of the logical database containing the tables you need to access.

Willowgarden apps dont yet have a mechanism to set up tables and import database rows during installation, so you may have to import .sql files manually before the app will work (you need to do this for the shopping cart demo, for instance).

eStruts is an Excellent tool to Automatically Generate the Struts Application which has all Action forms, Form Beans, Struts-Config..etc which forms the skeleton for the Web Application.
It automatically generates the Professional JSP pages.
Enhancements:
- This release added enhanced code generation features and auto generated configuration files for connection properties.
- A separate properties file that stores SQL queries is generated automatically.