Free a o gratuitos software for linux

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.

The Faq-O-Matic is a CGI-based system that automates the process of maintaining a FAQ list. It allows visitors to your FAQ to take part in keeping it up-to-date. A permission system also makes it useful as a help-desk application, bug-tracking database, or documentation system. Jon wrote an article about the FAQ-O-Matic that appeared in the USENIX ;login: newsletter: http://www.usenix.org/publications/login/1998-6/faq.html.

This documentation itself is, naturally, maintained with Faq-O-Matic. Hence the weird title. If you see anything that can use updating, please do fix it! If you just want to play around, check out the (Xref) Playground.

A mailing list is very good because it gets together people who have questions with people who have answers.

A mailing list archive is even better, because it lets thoughtful people with Frequently Asked Questions search for an immediate answer, and avoid bothering the people who have answers. Unfortunately, the answers in a mailing list archive become stale over time, are disorganized, and are hard to sift from the conversational noise of the mailing list.

A Frequently Asked Questions list (FAQ) is even better, because the people with questions can be a little lazier and still find their answer right away. Unfortunately, maintaining a FAQ list requires effort; if the people with the answers become lazy, the FAQ list becomes stale.

I wrote the FAQ-O-Matic when I found myself frequently answering a certain question on a mailing list. The FAQ for the list had become stale (its creators interest had succumbed to laziness), and I knew I was far too lazy to take over maintaining my own FAQ.

So, in a triumph of laziness, I wrote the FAQ-O-Matic. The idea is this:

- People with answers can submit them to the FAQ, but
nobody is responsible for knowing all the answers.

- People with corrections can make them to answers, but
nobody is responsible for coordinating corrections.

This worked pretty well, but the first FAQ-O-Matic tended to become disorganized, since no-one was responsible for its structure. So I added commands to move answers and categories around, plus a Moderator feature that lets one person keep track of changes to the FAQ by e-mail:

- A person can keep a subset of the FAQ organized, but he
or she doesnt have to know all the answers or organize
the whole FAQ.

So a FAQ-O-Matic is something that lets the members of a community share the tasks of entering, correcting, and organizing frequently-asked questions and answers. Many folks have found other uses for FAQ-O-Matic, treating it as a general collaborative editing tool.

Gapcmon is a gtk/glib desktop monitor program for the apcupsd package. Apcupsd interfaces with UPS power systems on local or networked systems. gapcmon connects to apcupsd via the NIS api to collect and displays the current operational state of the UPS.
A Gtk2/GLib2 GUI application used to monitor UPS devices controlled by the APCUPSD package. The program uses the NIS interface from apcupsd to collect event and status information for display to the end-user. Because of this great interface, this program can be executed on any OS supported machine and use the network socket interface to connect back to apcupsd. Of course apcupsd must be compiled with nis support
(i.e. ./configure --enable-nis --enable-gapcmon ...).
The general design model for gapcmon assumes the user has one or more UPSs attached to one or more tcpip/hosts with network connectivity to/from the gapcmon workstation. Gapcmon provides a Preferences panel to capture the hostname, port, and polling cycle for that UPS; along with an "enable" checkbox to indicate if the monitor for this configuration should be active. Gapcmon collects status and event information for each enabled UPS configuration and presents it to the user via a Detailed Information window.
Main features:
- FreeDesktop.org Spec for Notification Area Icons.
- Unlimited support for multiple UPSs.
- Historical Graph of five data points are charted. A total of 40 points are maintained on the graph. The data points are LINEV, BATTV, BCHARGE, LOADPCT, and TIMELEFT.
- Clicking an notification icon will cause the information window for that monitor to become visible or be hidden, if its already visible.
- Monitor tooltips are available when hovering the mouse over the icon, and contain a quick summary of the ups status.
- Icons are dynamically added or removed when enabled in preferences.
- Icon changes to reflect the operational state of the UPS.
- o where state is (online, onbattery, charging, not communicating, no cable)
- History graph supports popup tooltip for data point under the mouse pointer, showing dataseries name, color, time, and value.
- Configuration of the tcpi/ip hostname, tcp port number, and whether that monitor is currently enabled is provided via a central Preferences page.
- background thread for all network io to keep user interface responsive.

Wiki on a Stick is a personal wiki that lives in a single self-modifying HTML file that contains the software, interface, and database.

Its useful for taking notes, for use as a calendar, and for documenting software, etc. Wiki on a Stick currently only works in Firefox

JTAG-O-MAT program provides a simple but highly flexible interface to JTAG hardware. In opposite to similar projects, the focus is on running automatic JTAG sequences. The code has been kept intentionally simple to maintain portability and allow modification without the risk to spoil too many dependant parts.
The program doesnt support debugging and cannot be used with GDB or other debuggers. Well, it can stop the CPU and retrieve register and memory contents, but thats all. And debugging support is not on the todo list.
Instead its mainly intended to bring up a virgin hardware, use it in an automated test environment or to preload boards in a production environment. Or simply to play around with JTAG. In that sense, boundary scan support will appear on the todo list sooner or later.
Supported Hardware
This release had been tested with a Wiggler compatible JTAG adapter for the parallel port and an AT91R40008 based target board named Ethernut 3.
Additionally included is the firmware for a tiny ATmega8L based board named Turtelizer, which can be used as a JTAG adapter for the PC serial port.
Enhancements:
- Memory uploads are now eight times faster.
- Wiggler support for Linux and Intel Hex File support was added.

LINGOT is a musical instrument tuner. LINGOT is easy to use, accurate, and highly configurable. Originally conceived to tune electric guitars, its configurability gives it a more general character. (Tuning another instruments has not been tested).
It looks like an analogic tuner, with a gauge indicating the relative shift to a certain note --found automatically as the closest note to the estimated frequency--, indicating that note and its frequency.
The note will be found automatically, since the program hasnt any manual function mode (indicating the note to tune manually), for mantaining its general purpose.
We recommend using the tuner in conjunction with a sound mixer for selecting the desired recording source and the signal recording levels.
Main features:
- Accurate.
- Easy to use. Just plug in your instrument and run tuner.
- Very configurable via GUI. Its possible to change any parameter while the program is running, without editing any file.
- It works in an automatic way. It isnt necessary specify the note to tune; the program guesses it.
- Its free software. It has GPL license.
- Tuning other instruments than guitars is possible. Since this program guesses the note you are playing, it can be used to tune a piano, a bass, a violin, etc.
Enhancements:
- Files have been reorganized to a more "GNU-like" structure.
- Multi-lingual support has been added.