LinPsk is a program for operating on digital modes running on Linux.
LinPsk supports BPSK , QPSK and RTTY at the moment.
Main features are:
the simultaneuos decoding of up to four channels.
The different digital modes may be mixed
You can define a trigger on each channel to be notified if a text of your choice is detected.
You can log each received channel at a file.
For easy qso'ing you can define macros and for larger texts to be send you can use two files.
You can view the signal as spectrum or in a waterfall display. Both are scalable in the frequency domain.
At the Moment RTTY only supports 45 baud and 1.5 stopbits.
Hawk is a web based utility for monitoring and comparing hosts on your
network with what is in DNS. Hosts that are answering pings but are not
in DNS may be unauthorized, and addresses in DNS which are not answering
may be able to be reclaimed. Hawk monitors all hosts on the networks
you specify and lets you view them via a web page.
Hawk consists of a backend written in Perl that monitors hosts by ICMP
pings and writes the status to a mysql database. The frontend is in
PHP and lets you select which network to view, and how to view it.
This version has several enhancements to the original; including cleaner
Perl code, a user-definable string to designate unused addresses that
are in DNS, testing that the forward and reverse hostnames match, and
the daemon forks one process pre subnet.
This module provides an XPath engine, that can be re-used by other
module/classes that implement trees.
In order to use the XPath engine, nodes in the user module need to
mimick DOM nodes. The degree of similitude between the user tree and a
DOM dictates how much of the XPath features can be used. A module
implementing all of the DOM should be able to use this module very
easily (you might need to add the cmp method on nodes in order to get
ordered result sets).
This code is a more or less direct copy of the XML::XPath module by
Matt Sergeant. I only removed the XML processing part to remove the
dependency on XML::Parser, applied a couple of patches, renamed a
whole lot of methods to make Pod::Coverage happy, and changed the docs.
gaeutilities is a collection of classes to aid in development
on Google Appengine.
The stable version includes the following classes:
Session: An http session class to preserve identity across http requests.
It uses both BigTable and Memcache for performance and reliability.
It also includes middleware to plug in with django.
Cache: A BigTable and Memcache caching class. Any object that can be pickled
can be stored in cache.
Event: A subscribe/fire event system that gives developers the ability to set
callback functions.
Flash: A cookie based messaging library. Using json, data structures can be
stored as a cookie in the browser and retrieved on the next request.
Useful for messages such as "Thank you for logging in."
Nevow (pronounced as the French "nouveau", or "noo-voh") is a web application
construction kit written in Python. It is designed to allow the programmer to
express as much of the view logic as desired in Python, and includes a pure
Python XML expression syntax named stan to facilitate this. However it also
provides rich support for designer-edited templates, using a very small XML
attribute language to provide bi-directional template manipulation capability.
Nevow also includes formless, a declarative syntax for specifying the types of
method parameters and exposing these methods to the web. Forms can be rendered
automatically, and form posts will be validated and input coerced, rendering
error pages if appropriate. Once a form post has validated successfully, the
method will be called with the coerced values.
Gtk2 has a powerful, but complex MVC (Model, View, Controller) system
used to implement list and tree widgets. Gtk2::Ex::Simple::List
automates the complex setup work and allows you to treat the list model
as a more natural list of lists structure.
After creating a new Gtk2::Ex::Simple::List object with the desired
columns you may set the list data with a simple Perl array assignment.
Rows may be added or deleted with all of the normal array operations.
You can treat the data member of the Simple::List object as an array
reference, and manipulate the list data with perl's normal array
operators.
A mechanism has also been put into place allowing columns to be Perl
scalars. The scalar is converted to text through Perl's normal
mechanisms and then displayed in the list. This same mechanism can be
expanded by defining arbitrary new column types before calling the new
function.
Hyperlatex is a package that allows you to prepare documents in HTML,
and, at the same time, to produce a neatly printed document from your
input. Unlike some other systems that you may have seen, Hyperlatex is
not a general LaTeX-to-HTML converter. In Hyperlatex's author's eyes,
conversion is not a solution to HTML authoring. A well written HTML
document must differ from a printed copy in a number of rather subtle
ways. He doubts that these differences can be recognized mechanically,
and believes that converted LaTeX can never be as readable as a
document written in HTML.
The basic idea of Hyperlatex is to make it possible to write a
document that will look like a flawless LaTeX document when printed
and like a handwritten HTML document when viewed with an HTML browser.
The Firm library implements the Firm intermediate representation (IR). libFirm
contains algorithms for construction of the SSA form directly from the
attributed syntax tree. A set of analyses and optimisation phases is provided.
This version includes a complete backend for the IA32 architecture, as well as
some unfinished backends for SPARC, ARM
* support for object oriented type hierarchies
* analyses: dominance, loop tree, execution frequency, control dependencies,
call graph, rapid type, def-use, alias analysis, class hierarchy analysis
* Optimisations: constant folding, local common subexpression elimination,
global common subexpression elimination, code placement, operator strength
reduction, scalar replacement, load/store, control flow optimisations,
if-conversion, partial condition evaluation, reassociation, tail recursion
elimination, inlining, procedure cloning, dead code elimination, ...
* enhanced debugging support: extensive checkers, breakpoints on node creation,
entity creation, graph dumping
* lowering of intrinsics, double word arithmetics, bitfields
* backend with SSA based register allocation including several algorithms for
spilling and copy coalescing. Instruction and block scheduling, support for
ABI handling.
* working ia32 backend with support for x87 and SSE2 floating point
* handwritten recursive descent C90/C99 frontend available (lang/cparser)
Groovy is an agile dynamic language for the Java 2 Platform that has many of
the features that people like so much in languages like Python, Ruby and
Smalltalk, making them available to Java developers using a Java-like syntax.
Groovy is designed to help you get things done on the Java 2 Platform in a
quick, concise and fun way. Groovy brings the power of a scripting language
directly into the Java 2 Platform. For example:
- Shell scripting using Groovy allows the full power of the Java Platform to be
brought to bear to the task at hand.
- Groovy can be used (and indeed is already being used) as a replacement for
Java for small and medium sized applications to execute on the Java 2
Platform.
- Groovy can be used as an embedded language for dynamic business rules or
extension points utilizing the agility of Groovy and saving the cost of
redeploying applications for each change of rule (especially when the rules
are stored in a database).
- Groovy makes writing test cases for unit tests very easy.
As well as being a powerful language for scripting Java objects, Groovy can be
used as an alternative compiler to javac to generate standard Java bytecode to
be used by any Java project.
CryptoFS is a encrypted filesystem for Filesystem in Userspace (FUSE) and
the Linux Userland FileSystem (LUFS). Visit http://fuse.sourceforge.net/
for more information on FUSE, or http://lufs.sourceforge.net/lufs/ for
more information on LUFS.
CryptoFS will use a normal directory to store files encrypted. The
mountpoint will contain the decrypted files. Every file stored in this
mountpoint will be written encrypted (data and filename) to the directory
that was mounted. If you unmount the directory the encrypted data can only
be access by mounting the directory with the correct key again. Like other
FUSE/LUFS filesystems it does not need root access or any complicated setup
like creating a filesystem on a encrypted disk using the loop device.
CryptoFS can be build for FUSE, and LUFS. When you build for FUSE you get
a program to mount the filesystem. For LUFS a shared library will be built
that can be used by LUFS's lufsd. Both methods can use the same encrypted
directory.