approach to
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 484
Xprobe2 0.3
Xprobe2 is an active operating system fingerprinting tool. more>>
Xprobe is an alternative to some tools which are heavily dependent upon the usage of the TCP protocol for remote active operating system fingerprinting.
Xprobe I combines various remote active operating system fingerprinting methods using the ICMP protocol, which were discovered during the "ICMP Usage in Scanning" research project, into a simple, fast, efficient and a powerful way to detect an underlying operating system a targeted host is using.
Xprobe2 rely on fuzzy signature matching, probabilistic guesses, multiple matches simultaneously, and a signature database. Xprobe2 is an active operating system fingerprinting tool witch has a different approach to operating system fingerprinting.
<<lessXprobe I combines various remote active operating system fingerprinting methods using the ICMP protocol, which were discovered during the "ICMP Usage in Scanning" research project, into a simple, fast, efficient and a powerful way to detect an underlying operating system a targeted host is using.
Xprobe2 rely on fuzzy signature matching, probabilistic guesses, multiple matches simultaneously, and a signature database. Xprobe2 is an active operating system fingerprinting tool witch has a different approach to operating system fingerprinting.
Download (0.52MB)
Added: 2006-03-03 License: GPL (GNU General Public License) Price:
1342 downloads
Trac 0.11.5
Trac offers an innovative wiki and issue tracking system for software development projects. more>>
Trac 0.11.5 offers an innovative wiki and issue tracking system for software development projects. Trac uses a minimalistic approach to web-based software project management. The mission is to help developers write great software while staying out of the way. Trac should impose as little as possible on a team's established development process and policies.
Major Features:
- It provides an interface to subversion (or other version control systems), an integrated Wiki and convenient reporting facilities.
- Trac allows wiki markup in issue descriptions and commit messages, creating links and seamless references between bugs, tasks, changesets, files and wiki pages. A timeline shows all current and past project events in order, making the acquisition of an overview of the project and tracking progress very easy. The roadmap shows the road ahead, listing the upcoming milestones.
Enhancements:
- Implemented pre-upgrade backup support for PostgreSQL and MySQL (#2304)
- Fixed PostgreSQL upgrade issue (#8378)
- More robust diff parsing (#2672)
- Avoid intermittent hangs by not calling apr_terminate explicitly (#7785)
- Fixed display of merge properties for scoped repositories #7715.
Added: 2009-07-18 License: BSD License Price: FREE
1 downloads
Other version of Trac
Trac uses a minimalistic approach to web-based software project management. Our mission; to help developers write great software while staying out of the way. Trac should impose as little asLicense:BSD License
A practical lambda-calculator 2.2
A practical lambda-calculator is a Lambda-calculator with convenient commands and shortcuts. more>>
A practical lambda-calculator is a normal-order evaluator for the untyped lambda-calculus, extended with convenient commands and shortcuts to make programming in it more productive.
Shortcuts are distinguished constants that represent terms. Commands define new shortcuts, activate tracing of all reductions, compare terms modulo alpha-conversion, print all defined shortcuts and evaluation flags, etc.
Terms to evaluate and commands are entered at a read-eval-print-loop (REPL) "prompt" or "included" from a file by a special command. A Haskell branch is an embedding of the lambda calculator (as a domain-specific language) into Haskell. The calculator can be used interactively within Hugs or GHCi.
The present calculator implements what seems to be an efficient and elegant algorithm of normal order reductions. The algorithm is "more functional" than the traditionally used approach.
The algorithm seems identical to that employed by yacc sans one critical difference. The calculator also takes a more "functional" approach to the hygiene of beta-substitutions, which is achieved by coloring of identifiers where absolutely necessary. This approach is "more functional" because it avoids a global counter or the threading of the paint bucket through the whole the process. The integration of the calculator with Haskell lets us store terms in variables and easily and intuitively combine them.
The traditional recipe for normal-order reductions includes an unpleasant phrase "cook until done". The phrase makes it necessary to keep track of reduction attempts, and implies an ugly iterative algorithm. Were proposing what seems to be an efficient and elegant technique that can be implemented through intuitive re-writing rules.
Our calculator, like yacc, possesses a stack and works by doing a sequence of shift and reduce steps. The only significant difference from yacc is that the lambda-calculator "reparses" the result after the successful reduce step. The source and the target languages of our "parser" (lambda-calculator) are the same; therefore, the parser can indeed apply itself.
The parsing stack can be made implicit. In that case, the algorithm can be used for normalization of typed lambda-terms in Twelf.
The following examples show that lambda-calculus becomes a domain-specific language embedded into Haskell:
> c0 = f ^ x ^ x -- Church numeral 0
> succ = c ^ f ^ x ^ f # (c # f # x) -- Successor
> c1 = eval $ succ # c0 -- pre-evaluate other numerals
> c2 = eval $ succ # c1
> c3 = eval $ succ # c2
> c4 = eval $ succ # c3
It is indeed convenient to store terms in Haskell variables and pre-evaluate (i.e., normalize) them. They are indeed terms. We can always ask the interpreter to show the term. For example, show c4 yields (f. (x. f (f (f (f x))))).
let mul = a ^ b ^ f ^ a # (b # f) -- multiplication
eval $ mul # c1 ---> (b. b), the identity function
eval $ mul # c0 ---> (b. (f. (x. x))), which is "const 0"
These are algebraic results: multiplying any number by zero always gives zero. We can see now how lambda-calculus can be useful for theorem proving, even over universally-quantified formulas.
The calculator implements Dr. Fairbairns suggestion to limit the depth of printed terms. This makes it possible to evaluate and print some divergent terms (so-called tail-divergent terms):
Lambda_calc> let y_comb = f^((p^p#p) # (c ^ f#(c#c))) in eval $ y_comb#c
c (c (c (c (c (c (c (c (c (c (...))))))))))
It is amazing how well lambda-calculus and Haskell play together.
<<lessShortcuts are distinguished constants that represent terms. Commands define new shortcuts, activate tracing of all reductions, compare terms modulo alpha-conversion, print all defined shortcuts and evaluation flags, etc.
Terms to evaluate and commands are entered at a read-eval-print-loop (REPL) "prompt" or "included" from a file by a special command. A Haskell branch is an embedding of the lambda calculator (as a domain-specific language) into Haskell. The calculator can be used interactively within Hugs or GHCi.
The present calculator implements what seems to be an efficient and elegant algorithm of normal order reductions. The algorithm is "more functional" than the traditionally used approach.
The algorithm seems identical to that employed by yacc sans one critical difference. The calculator also takes a more "functional" approach to the hygiene of beta-substitutions, which is achieved by coloring of identifiers where absolutely necessary. This approach is "more functional" because it avoids a global counter or the threading of the paint bucket through the whole the process. The integration of the calculator with Haskell lets us store terms in variables and easily and intuitively combine them.
The traditional recipe for normal-order reductions includes an unpleasant phrase "cook until done". The phrase makes it necessary to keep track of reduction attempts, and implies an ugly iterative algorithm. Were proposing what seems to be an efficient and elegant technique that can be implemented through intuitive re-writing rules.
Our calculator, like yacc, possesses a stack and works by doing a sequence of shift and reduce steps. The only significant difference from yacc is that the lambda-calculator "reparses" the result after the successful reduce step. The source and the target languages of our "parser" (lambda-calculator) are the same; therefore, the parser can indeed apply itself.
The parsing stack can be made implicit. In that case, the algorithm can be used for normalization of typed lambda-terms in Twelf.
The following examples show that lambda-calculus becomes a domain-specific language embedded into Haskell:
> c0 = f ^ x ^ x -- Church numeral 0
> succ = c ^ f ^ x ^ f # (c # f # x) -- Successor
> c1 = eval $ succ # c0 -- pre-evaluate other numerals
> c2 = eval $ succ # c1
> c3 = eval $ succ # c2
> c4 = eval $ succ # c3
It is indeed convenient to store terms in Haskell variables and pre-evaluate (i.e., normalize) them. They are indeed terms. We can always ask the interpreter to show the term. For example, show c4 yields (f. (x. f (f (f (f x))))).
let mul = a ^ b ^ f ^ a # (b # f) -- multiplication
eval $ mul # c1 ---> (b. b), the identity function
eval $ mul # c0 ---> (b. (f. (x. x))), which is "const 0"
These are algebraic results: multiplying any number by zero always gives zero. We can see now how lambda-calculus can be useful for theorem proving, even over universally-quantified formulas.
The calculator implements Dr. Fairbairns suggestion to limit the depth of printed terms. This makes it possible to evaluate and print some divergent terms (so-called tail-divergent terms):
Lambda_calc> let y_comb = f^((p^p#p) # (c ^ f#(c#c))) in eval $ y_comb#c
c (c (c (c (c (c (c (c (c (c (...))))))))))
It is amazing how well lambda-calculus and Haskell play together.
Download (0.021MB)
Added: 2005-04-01 License: Public Domain Price:
1672 downloads
AjaxTop 1.0.2
AjaxTop is a framework that uses XML for object binding to simplify Web application development. more>>
AjaxTop is a framework that uses XML for object binding on both the client (JavaScript) and server (Java) to simplify Web application development.
The client side is AJAX-based and supports client-side custom tags embedded in XHTML. A built-in tag library is provided, with a XUL-like box model and a few widgets like Slider, Splitter, and Calendar.
The server side is servlet-based. The project is a symmetric client/server protocol with XML as the command language, and a shared design concept called tag-oriented programming.
The Tag interface specifies three methods that are invoked during construction of the object structure.
- init(): This is called after the XML start tag has been parsed, the object has been instantiated and attributes have been assigned based on the corresponding XML attributes. The default implementation does nothing.
- apply(): This is called after the XML end tag has been parsed and all nested content has been processed. It is the responsibility of the apply() method to perform the main processing associated with the object which could involve transforming the object into a different object or could involve significant side effects. It is the responsibility of the apply() method to insert the object (or its transform) into its parent object if that is appropriate. The default implementation just adds the object to its parent with no side effects.
- add(): This is used to add an element to the content of a Tag. It is typically called by the apply() method of a potential child Tag. The default implementation adds the object to a list of content elements.
Tag Oriented Programming and AjaxTop can be thought of in serveral ways, depending on what you are looking for.
- A way to read and process XML files:
At one level, Tag Oriented Programming is just a thin layer over the SAX Parser.
- A way to make AJAX a little more user friendly:
There are any number of other packages for handling the messy, low level details of doing AJAX. AjaxTop is unique in that it also deals with the issue of how to organize callbacks and cleanly deal with XML (the A and the X in AJAX).
- Another way to do XML transforms:
XSLT is the standard way to handle XML transforms. Some find it awkward, confusing and limiting. AjaxTop provides a simpler, more procedural, approach to the problem.
- A Web Application Framework:
The recognized way to implement Web Applications with Java uses JSP with Struts or JSF in a complex approach based on the idea of mixing static and dynamic content on the Server. With AJAX, we do not have to do that any more. AjaxTop uses a simple and straight forward approach that makes Web Applications more responsive and reduces the load on the Server.
- A new programming paradigm:
In the tradition of Object Oriented Programming and Structured Programming before it, Tag Oriented Programming represents a slight paradigm shift, but builds on the foundation of the past. It makes a lot of things simpler and easier. Principles developed for one purpose carry over into new, unintended problem domains.
That is all there is to Tag Oriented Programming at the conceptual level. Step through the remaining topics for the details.
<<lessThe client side is AJAX-based and supports client-side custom tags embedded in XHTML. A built-in tag library is provided, with a XUL-like box model and a few widgets like Slider, Splitter, and Calendar.
The server side is servlet-based. The project is a symmetric client/server protocol with XML as the command language, and a shared design concept called tag-oriented programming.
The Tag interface specifies three methods that are invoked during construction of the object structure.
- init(): This is called after the XML start tag has been parsed, the object has been instantiated and attributes have been assigned based on the corresponding XML attributes. The default implementation does nothing.
- apply(): This is called after the XML end tag has been parsed and all nested content has been processed. It is the responsibility of the apply() method to perform the main processing associated with the object which could involve transforming the object into a different object or could involve significant side effects. It is the responsibility of the apply() method to insert the object (or its transform) into its parent object if that is appropriate. The default implementation just adds the object to its parent with no side effects.
- add(): This is used to add an element to the content of a Tag. It is typically called by the apply() method of a potential child Tag. The default implementation adds the object to a list of content elements.
Tag Oriented Programming and AjaxTop can be thought of in serveral ways, depending on what you are looking for.
- A way to read and process XML files:
At one level, Tag Oriented Programming is just a thin layer over the SAX Parser.
- A way to make AJAX a little more user friendly:
There are any number of other packages for handling the messy, low level details of doing AJAX. AjaxTop is unique in that it also deals with the issue of how to organize callbacks and cleanly deal with XML (the A and the X in AJAX).
- Another way to do XML transforms:
XSLT is the standard way to handle XML transforms. Some find it awkward, confusing and limiting. AjaxTop provides a simpler, more procedural, approach to the problem.
- A Web Application Framework:
The recognized way to implement Web Applications with Java uses JSP with Struts or JSF in a complex approach based on the idea of mixing static and dynamic content on the Server. With AJAX, we do not have to do that any more. AjaxTop uses a simple and straight forward approach that makes Web Applications more responsive and reduces the load on the Server.
- A new programming paradigm:
In the tradition of Object Oriented Programming and Structured Programming before it, Tag Oriented Programming represents a slight paradigm shift, but builds on the foundation of the past. It makes a lot of things simpler and easier. Principles developed for one purpose carry over into new, unintended problem domains.
That is all there is to Tag Oriented Programming at the conceptual level. Step through the remaining topics for the details.
Download (10MB)
Added: 2007-01-23 License: MIT/X Consortium License Price:
1006 downloads
RAJAX 1.5
RAJAX is an approach to remove the repetitive code that coders need to add for simple AJAX applications. more>>
RAJAX is an approach to remove the repetitive code that coders need to add for simple AJAX applications. RAJAXs main goal is to create a library that at runtime will generate a proxy JavaScript class to a server side Java class allowing the web programmer to invoke remote methods in the local JavaScript object.
The project is composed by an network abstraction layer and other sub components such as a Model-View-Controller Framework totally based in AJAX and JavaScript. Since this the project is quite dynamic other components will be added from research experiences or user requests.
Installation:
- Note: Requires Java Runtime Environment (JRE) 1.5 or higher. Requires a Servlet 2.4 compatible container, Tomcat 5.5.x/6.x recomended.
- Add rajaxlib.jar to your webapp WEB-INF/lib.
- Add js/* to your webapp web/js.
- Alternatively grab the sample webapp from the repository and start from it.
Enhancements:
- A Servlet dispatcher was added, so there is no need to declare each bean as a servlet in web.xml.
- RAJAX objects are POJOs and can be tested with JUnit without running a container.
- Nimble MVC now uses the concept of the Observer pattern for event attaching and detaching.
- The code for the XSLT processor on the server side when the browser cannot handle the action locally was started.
<<lessThe project is composed by an network abstraction layer and other sub components such as a Model-View-Controller Framework totally based in AJAX and JavaScript. Since this the project is quite dynamic other components will be added from research experiences or user requests.
Installation:
- Note: Requires Java Runtime Environment (JRE) 1.5 or higher. Requires a Servlet 2.4 compatible container, Tomcat 5.5.x/6.x recomended.
- Add rajaxlib.jar to your webapp WEB-INF/lib.
- Add js/* to your webapp web/js.
- Alternatively grab the sample webapp from the repository and start from it.
Enhancements:
- A Servlet dispatcher was added, so there is no need to declare each bean as a servlet in web.xml.
- RAJAX objects are POJOs and can be tested with JUnit without running a container.
- Nimble MVC now uses the concept of the Observer pattern for event attaching and detaching.
- The code for the XSLT processor on the server side when the browser cannot handle the action locally was started.
Download (0.025MB)
Added: 2007-06-18 License: GPL (GNU General Public License) Price:
859 downloads
Oculus 0.8
Oculus is a server monitor and a client-server based approach to monitor your servers. more>>
Oculus (The Eye) is a server monitor and a client-server based approach to monitor your servers. All work is aimed at the creation of the server, which is the heart of the system. A simple PHP client will be made first.
Because the ease of the protocol, clients are made easily (using any programming language, operating system, GUI toolkit, or whatever).
Main features:
- XML config files
- Plaintext protocol, so you can even query your servers using telnet
- Plugin support
- Usage of /proc to get system/process information (default plugin)
Installation:
The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.
It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.
Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up
reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).
If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.
If at some point `config.cache contains results you dont want to keep, you may remove or edit it.
The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.
There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
<<lessBecause the ease of the protocol, clients are made easily (using any programming language, operating system, GUI toolkit, or whatever).
Main features:
- XML config files
- Plaintext protocol, so you can even query your servers using telnet
- Plugin support
- Usage of /proc to get system/process information (default plugin)
Installation:
The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.
It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.
Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up
reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).
If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.
If at some point `config.cache contains results you dont want to keep, you may remove or edit it.
The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean.
There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Download (0.034MB)
Added: 2005-10-14 License: GPL (GNU General Public License) Price:
1751 downloads
Java GForge SOAP Interface 0.0.10
Java GForge SOAP Interface is an approach to access the GForge collaboration platform via Java. more>>
Java GForge SOAP Interface (or JaGoSI for short) is an approach to access the GForge collaboration platform via Java. This can be used to put other applications on top of JaGoSI. It may be integrated with other applications like the former MyLar project.
Enhancements:
- A complete working file distribution is available for the GForge platform via an Ant task.
- Many bugs were fixed.
- The Maven build was fixed, so compiling with sub components is working.
- The project structure was changed.
- JUnit was updated to version 4.
<<lessEnhancements:
- A complete working file distribution is available for the GForge platform via an Ant task.
- Many bugs were fixed.
- The Maven build was fixed, so compiling with sub components is working.
- The project structure was changed.
- JUnit was updated to version 4.
Download (MB)
Added: 2007-08-13 License: Perl Artistic License Price:
804 downloads
Compact Filter 0.3
Compact Filter is a network packet filter for Linux. more>>
Compact Filter is a network packet filter for Linux. It features an easy-to-use compact filter representation and high performance.
The main features are: easy to use interface, compact filter representation (memory efficient), and very high performance.
A difference between CF and other firewalls, such as Netfilter, is its representation of the ruleset. In CF the user writes a filter which is then compiled and optimized in user-space. The optimized filter is then loaded into the kernel (using netlink). Consequently the in kernel packet filtering code only needs funtionality for setting up a filter and filtering packets, while the more complex code of optimizing the filter remains in user-space.
Because of the continuous increase of the bandwidth and the security threats, firewalls have to evolve towards more efficient filtering schemes. The truth is that the existing scheme does not scale so well with the combined growth of bandwidth and rulesets.
Our aim is to try another approach to perform packet filtering where we minimize the complexity of the filtering process. This result in, both, a reduction of the required CPU power to filter packets and a simpler (and smaller) kernel code. Of course, we are pushing all the smart and complex part out to the user-space, but, developing in user-space is much simpler and safer.
Enhancements:
- changed -d option to delete all filters
- added -D option to delete a specific filter
- changed default policy to permit rather than deny
- added -l option on flex to support --yylineno on older versions of flex
- new and improved install guide
<<lessThe main features are: easy to use interface, compact filter representation (memory efficient), and very high performance.
A difference between CF and other firewalls, such as Netfilter, is its representation of the ruleset. In CF the user writes a filter which is then compiled and optimized in user-space. The optimized filter is then loaded into the kernel (using netlink). Consequently the in kernel packet filtering code only needs funtionality for setting up a filter and filtering packets, while the more complex code of optimizing the filter remains in user-space.
Because of the continuous increase of the bandwidth and the security threats, firewalls have to evolve towards more efficient filtering schemes. The truth is that the existing scheme does not scale so well with the combined growth of bandwidth and rulesets.
Our aim is to try another approach to perform packet filtering where we minimize the complexity of the filtering process. This result in, both, a reduction of the required CPU power to filter packets and a simpler (and smaller) kernel code. Of course, we are pushing all the smart and complex part out to the user-space, but, developing in user-space is much simpler and safer.
Enhancements:
- changed -d option to delete all filters
- added -D option to delete a specific filter
- changed default policy to permit rather than deny
- added -l option on flex to support --yylineno on older versions of flex
- new and improved install guide
Download (0.092MB)
Added: 2006-06-30 License: GPL (GNU General Public License) Price:
1211 downloads
bplay 0.991
bplay is a buffered sound player and recorder for Linux. more>>
bplay is a buffered sound player and recorder for Linux.
bplay-0.991 is the current stable version. No development work is continuing on this branch of the code, but occasional maintenance releases may be made from this branch.
bplay2 is currently in development. The is a complete and radical rewrite of the original code. Major differences include:
Replaced multiple processes using SYSV shared memory and semaphores with a single multithreaded process (when bplay was first written, Linux didnt really have threads).
Support for transforming audio formats on the fly allows playing of file formats not supported by the hardware in the machine (eg copes with byte-swapped or floating-point formats).
A more modular approach to file format interpretation.
Code now should work on big-endian machines properly (when bplay was first written, x86 was the only architecture supported under Linux).
Currently there is no downloadable version of bplay2 - the code is still in too much of a mess. In particular I need to merge some endian fixes into the code, and Ive also decided to rearrange the source a little to allow adding of non-OSS platforms (AIX is likely to be the first such platform at this stage). I also need to make the code 64-bit clean somehow, which will involve writing some sort of test harness for all of the conversion code since the only 64-bit machine I have access to has no sound hardware.
<<lessbplay-0.991 is the current stable version. No development work is continuing on this branch of the code, but occasional maintenance releases may be made from this branch.
bplay2 is currently in development. The is a complete and radical rewrite of the original code. Major differences include:
Replaced multiple processes using SYSV shared memory and semaphores with a single multithreaded process (when bplay was first written, Linux didnt really have threads).
Support for transforming audio formats on the fly allows playing of file formats not supported by the hardware in the machine (eg copes with byte-swapped or floating-point formats).
A more modular approach to file format interpretation.
Code now should work on big-endian machines properly (when bplay was first written, x86 was the only architecture supported under Linux).
Currently there is no downloadable version of bplay2 - the code is still in too much of a mess. In particular I need to merge some endian fixes into the code, and Ive also decided to rearrange the source a little to allow adding of non-OSS platforms (AIX is likely to be the first such platform at this stage). I also need to make the code 64-bit clean somehow, which will involve writing some sort of test harness for all of the conversion code since the only 64-bit machine I have access to has no sound hardware.
Download (0.018MB)
Added: 2006-07-19 License: GPL (GNU General Public License) Price:
689 downloads
SQL::Generator 0.02
SQL::Generator is a Perl module to generate SQL-statements with oo-perl. more>>
SQL::Generator is a Perl module to generate SQL-statements with oo-perl.
SYNOPSIS
use SQL::Generator;
With this module you can easily (and very flexible) generate/construct sql-statements. As a rookie, you are used to write a lot of sprintf`s every time i needed a statement (i.e.for DBI).
Later you start writing your own functions for every statement and every sql-dialect (RDBMS use to have their own dialect extending the general SQL standard). This SQL::Generator module is an approach to have a flexible abstraction above the statement generation, which makes it easy to implement in your perl code. Its main purpose is to directly use perl variables/objects with SQL-like code.
<<lessSYNOPSIS
use SQL::Generator;
With this module you can easily (and very flexible) generate/construct sql-statements. As a rookie, you are used to write a lot of sprintf`s every time i needed a statement (i.e.for DBI).
Later you start writing your own functions for every statement and every sql-dialect (RDBMS use to have their own dialect extending the general SQL standard). This SQL::Generator module is an approach to have a flexible abstraction above the statement generation, which makes it easy to implement in your perl code. Its main purpose is to directly use perl variables/objects with SQL-like code.
Download (0.013MB)
Added: 2007-04-05 License: Perl Artistic License Price:
932 downloads
ORFEO Toolbox 1.2.0
ORFEO Toolbox (OTB) is a high resolution remote sensing image processing library. more>>
ORFEO Toolbox (OTB) is a high resolution remote sensing image processing library. It contains a set of algorithmic components which allow the user to capitalize on methodological know how, and therefore use an incremental approach to profit from the results of methodological research. The project is made of a set of basic elements (a C++ class API) and utilities (independent programs built upon the base API).
Enhancements:
- This release adds various bugfixes, support for VC++ 7.1 and 8.0, Cygwin, and MinGW, several new image formats (Erdas HFA, Lum), multiscale analysis (morphological pyramid) and spatial reasoning (RCC8), improvement of the visualization, and new applications.
<<lessEnhancements:
- This release adds various bugfixes, support for VC++ 7.1 and 8.0, Cygwin, and MinGW, several new image formats (Erdas HFA, Lum), multiscale analysis (morphological pyramid) and spatial reasoning (RCC8), improvement of the visualization, and new applications.
Download (MB)
Added: 2007-03-16 License: GPL (GNU General Public License) Price:
955 downloads
Python Hypertext Preprocessor 0.92
PyHP is a system to embed Python code in an HTML document in a way similar to how PHP works. more>>
PyHP is a system to embed Python code in an HTML document in a way similar to how PHP works. PyHP allows use of the Python programming language in scripts similar to PHP. PyHP uses the Python 2.0 language to parse elements embedded in an HTML page.
When I started this, I was enamoured with PHP. Ive since discovered that embedding code in HTML does not seem like the most logical way to do things. If someone wants to pick this up, email me. In the mean time, if you want a truely novel approach to web design with Python, check out the very cool Quixote framework.
THis is a small, fast, hypertext preprocessor that used the worlds greatest scripting language, Python, as its base. There was another program out there that did this, PMZ, but I quickly found what I believed to be shortcomings in it.
Namespace polution
My main problem with PMZ is that it does not execute its programs in a seperate name space. If you define a variable name fields in the global namespace then PMZ will crap out because there is a variable of that name that is of vital importance to the interpreter itself. I did not find this to be acceptable, and Python 2.0s InteractiveInterpreter class made it easy to get around this in PyHP.
Speed
PyHP was designed for use with Apaches mod_python. It will run just fine as a standalone program, but it has been designed to be accelerated under mod_python by automatically caching modules that have been imported and supporting the manual caching of variables as well
Header specification
PMZ has a fixed set of headers that cannot be modified by a PMZ script. PyHP allows script writers to specify what headers are attached to their documents, even to do so in the middle of the HTML file.
Enhancements:
- Fixed a critical bug caused by the previous changes
- Added better documentation
- Tested before releasing
<<lessWhen I started this, I was enamoured with PHP. Ive since discovered that embedding code in HTML does not seem like the most logical way to do things. If someone wants to pick this up, email me. In the mean time, if you want a truely novel approach to web design with Python, check out the very cool Quixote framework.
THis is a small, fast, hypertext preprocessor that used the worlds greatest scripting language, Python, as its base. There was another program out there that did this, PMZ, but I quickly found what I believed to be shortcomings in it.
Namespace polution
My main problem with PMZ is that it does not execute its programs in a seperate name space. If you define a variable name fields in the global namespace then PMZ will crap out because there is a variable of that name that is of vital importance to the interpreter itself. I did not find this to be acceptable, and Python 2.0s InteractiveInterpreter class made it easy to get around this in PyHP.
Speed
PyHP was designed for use with Apaches mod_python. It will run just fine as a standalone program, but it has been designed to be accelerated under mod_python by automatically caching modules that have been imported and supporting the manual caching of variables as well
Header specification
PMZ has a fixed set of headers that cannot be modified by a PMZ script. PyHP allows script writers to specify what headers are attached to their documents, even to do so in the middle of the HTML file.
Enhancements:
- Fixed a critical bug caused by the previous changes
- Added better documentation
- Tested before releasing
Download (0.015MB)
Added: 2006-06-22 License: GPL (GNU General Public License) Price:
1220 downloads
rphpMMS 1.00
rphpMMS is a script for xmms that chooses songs at random for xmms for multiple users. more>>
rphpMMS is a script for xmms that chooses songs at random for xmms for multiple users. rphpMMS uses a highest common rating approach to selecting the songs.
This is great for people who have kids, and dont want certain songs with adult themes/cussing being played when the kids are around, or if you were in a college dorm, the chances of a song everyone likes would greatly increase.
Main features:
- Time based history (strict, or flexable)
- Song history
- Artist history
- ices metadata update
- play only specific genres
- move/rename songs user defined database information
- synchronize id3/ogg tags to database mp3
- mplayer support - beta
<<lessThis is great for people who have kids, and dont want certain songs with adult themes/cussing being played when the kids are around, or if you were in a college dorm, the chances of a song everyone likes would greatly increase.
Main features:
- Time based history (strict, or flexable)
- Song history
- Artist history
- ices metadata update
- play only specific genres
- move/rename songs user defined database information
- synchronize id3/ogg tags to database mp3
- mplayer support - beta
Download (0.47MB)
Added: 2006-04-04 License: GPL (GNU General Public License) Price:
1301 downloads
Test::Unit::Procedural 0.24
Test::Unit::Procedural Perl module contains a procedural style unit testing interface. more>>
Test::Unit::Procedural Perl module contains a procedural style unit testing interface.
SYNOPSIS
use Test::Unit::Procedural;
# your code to be tested goes here
sub foo { return 23 };
sub bar { return 42 };
# define tests
sub test_foo { assert(foo() == 23, "Your message here"); }
sub test_bar { assert(bar() == 42, "I will be printed if this fails"); }
# set_up and tear_down are used to
# prepare and release resources need for testing
sub set_up { print "hello worldn"; }
sub tear_down { print "leaving world againn"; }
# run your test
create_suite();
run_suite();
Test::Unit::Procedural is the procedural style interface to a sophisticated unit testing framework for Perl that is derived from the JUnit testing framework for Java by Kent Beck and Erich Gamma. While this framework is originally intended to support unit testing in an object-oriented development paradigm (with support for inheritance of tests etc.), Test::Unit::Procedural is intended to provide a simpler interface to the framework that is more suitable for use in a scripting style environment. Therefore, Test::Unit::Procedural does not provide much support for an object-oriented approach to unit testing - if you want that, please have a look at Test::Unit::TestCase.
You test a given unit (a script, a module, whatever) by using Test::Unit::Procedural, which exports the following routines into your namespace:
assert()
used to assert that a boolean condition is true
create_suite()
used to create a test suite consisting of all methods with a name prefix of test
run_suite()
runs the test suite (text output)
add_suite()
used to add test suites to each other
For convenience, create_suite() will automatically build a test suite for a given package. This will build a test case for each subroutine in the package given that has a name starting with test and pack them all together into one TestSuite object for easy testing. If you dont give a package name to create_suite(), the current package is taken as default.
Test output is one status line (a "." for every successful test run, or an "F" for any failed test run, to indicate progress), one result line ("OK" or "!!!FAILURES!!!"), and possibly many lines reporting detailed error messages for any failed tests.
Please remember, Test::Unit::Procedural is intended to be a simple and convenient interface. If you need more functionality, take the object-oriented approach outlined in Test::Unit::TestCase.
<<lessSYNOPSIS
use Test::Unit::Procedural;
# your code to be tested goes here
sub foo { return 23 };
sub bar { return 42 };
# define tests
sub test_foo { assert(foo() == 23, "Your message here"); }
sub test_bar { assert(bar() == 42, "I will be printed if this fails"); }
# set_up and tear_down are used to
# prepare and release resources need for testing
sub set_up { print "hello worldn"; }
sub tear_down { print "leaving world againn"; }
# run your test
create_suite();
run_suite();
Test::Unit::Procedural is the procedural style interface to a sophisticated unit testing framework for Perl that is derived from the JUnit testing framework for Java by Kent Beck and Erich Gamma. While this framework is originally intended to support unit testing in an object-oriented development paradigm (with support for inheritance of tests etc.), Test::Unit::Procedural is intended to provide a simpler interface to the framework that is more suitable for use in a scripting style environment. Therefore, Test::Unit::Procedural does not provide much support for an object-oriented approach to unit testing - if you want that, please have a look at Test::Unit::TestCase.
You test a given unit (a script, a module, whatever) by using Test::Unit::Procedural, which exports the following routines into your namespace:
assert()
used to assert that a boolean condition is true
create_suite()
used to create a test suite consisting of all methods with a name prefix of test
run_suite()
runs the test suite (text output)
add_suite()
used to add test suites to each other
For convenience, create_suite() will automatically build a test suite for a given package. This will build a test case for each subroutine in the package given that has a name starting with test and pack them all together into one TestSuite object for easy testing. If you dont give a package name to create_suite(), the current package is taken as default.
Test output is one status line (a "." for every successful test run, or an "F" for any failed test run, to indicate progress), one result line ("OK" or "!!!FAILURES!!!"), and possibly many lines reporting detailed error messages for any failed tests.
Please remember, Test::Unit::Procedural is intended to be a simple and convenient interface. If you need more functionality, take the object-oriented approach outlined in Test::Unit::TestCase.
Download (0.074MB)
Added: 2007-06-13 License: Perl Artistic License Price:
863 downloads
Antmod 1.3.2
Antmod is a build management, release management, and repository management tool. more>>
Antmod is a build management, release management, and repository management tool. Its implementation is an Ant-based extensible engine for retrieving, versioning, building, and deploying code to and from Subversion or CVS.
It standardizes build files for Java projects and provides build plugins for various tasks. Antmod project also standardizes tagging and branching for both CVS and Subversion, and its module and repository management can also be used for non-Java projects.
It greatly speeds up Java software development, promotes reuse of Java software, and standardizes the build-test- release cycle.
Main features:
- Standardized out-of-the-box buildfiles
- For Java projects, Antmod places standardized buildfiles on module and release level, in this way standardizing the way each module and release is built.
- Allow customized builds per module and release
- Antmod allows modules and releases to override default behavior in the buildfile by committing a "local.build.xml" in the root of the module with the overridden build logic.
- Enable reuse of components across projects
- It is as simple as adding the module to the release descriptor of the project.
- Modularized approach to software artefacts
- Code, documentation, configuration, etcetera is grouped in modules that are versioned in a consistent way per module.
- Standardize repository usage
- Everything is in a module, the module is the versioning unit, and tagging and branching happens per module. Tag and branch names are standardized.
- Centralized overview across releases and projects
- Release descriptors describe what a release consists of, and are stored centrally in the repository. This provides a centralized view across releases and projects.
- Separate developer and release manager roles
- The release descriptors can be maintained by a release manager, and do not have to be maintained by the developer.
Enhancements:
- This release adds Subversion 1.4 support, improved command-line support, and module-level merge functions for merging to a branch or the trunk.
- With the out-of-the-box War plugin for building Web applications, this release is a must-have.
- All current users are advised to upgrade.
<<lessIt standardizes build files for Java projects and provides build plugins for various tasks. Antmod project also standardizes tagging and branching for both CVS and Subversion, and its module and repository management can also be used for non-Java projects.
It greatly speeds up Java software development, promotes reuse of Java software, and standardizes the build-test- release cycle.
Main features:
- Standardized out-of-the-box buildfiles
- For Java projects, Antmod places standardized buildfiles on module and release level, in this way standardizing the way each module and release is built.
- Allow customized builds per module and release
- Antmod allows modules and releases to override default behavior in the buildfile by committing a "local.build.xml" in the root of the module with the overridden build logic.
- Enable reuse of components across projects
- It is as simple as adding the module to the release descriptor of the project.
- Modularized approach to software artefacts
- Code, documentation, configuration, etcetera is grouped in modules that are versioned in a consistent way per module.
- Standardize repository usage
- Everything is in a module, the module is the versioning unit, and tagging and branching happens per module. Tag and branch names are standardized.
- Centralized overview across releases and projects
- Release descriptors describe what a release consists of, and are stored centrally in the repository. This provides a centralized view across releases and projects.
- Separate developer and release manager roles
- The release descriptors can be maintained by a release manager, and do not have to be maintained by the developer.
Enhancements:
- This release adds Subversion 1.4 support, improved command-line support, and module-level merge functions for merging to a branch or the trunk.
- With the out-of-the-box War plugin for building Web applications, this release is a must-have.
- All current users are advised to upgrade.
Download (6.6MB)
Added: 2006-10-10 License: Common Public License Price:
1109 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above approach to search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
