Free sambar recipe software for linux

The Sambar Server is an open and scalable framework that provides an intuitive, secure and personalizable environment for end-users; rapid development and deployment tools for developers; and an easy-to-use console for administrators.
Main features:
- WebDAV
- Content Management
- Document Versioning
- Search Engine
- Mail Server
- Servlet Runner
- Usage Throttling
- CRON Daemon
- IRC Server
- FTP Server
- TFTP Server
- DNS Server
- DHCP Server
- Proxy Server
- Socks Proxy
- Reverse Proxy

Weight Loss Recipe Book is a free, online, community-built recipe book. Weight Loss Recipe Book contains everything you need to allow your web site visitors to submit recipes and everything your administrator needs to administer the recipes.
When a visitor submits a recipe, the recipe is added to a database and awaits approval from the administrator before being added to the public site.
Main features:
- Community built, meaning you just have to approve entries and watch your web site expand!
- Captcha validation to prevent automated entries into the recipe book.
- Complete administrator system - add administrators, recipe categories, manage recipes and more!
- Best of all, Weight Loss Recipe Book is totally free!

Gourmet Recipe Manager is a simple but powerful recipe-managing application. Gourmet is intended for the GNOME desktop environment, but works on any platform that gtk supports, including windows.
Gourmet allows you to collect, search and organize your recipes, and to automatically generate shopping lists from your collection. Take a look at the screenshots for a sense of how this works.
Gourmet Recipe Manager is free software. If you want to contribute to the project and youre a python programmer, please take a look at the source code and start hacking! If you would like to use Gourmet in a language other than English, you can help translate gourmet using the rosetta web-based tool.
Simple Search
Screenshot of Search viewA simple index view allows you to look at all your recipes as a list and quickly search through them by ingredient, title, category, cuisine, rating, or instructions. Searching happens as you type to save you keystrokes, and multiple kinds of searches can easily be combined from this same view (so you can search for salads (category) with walnuts (ingredient) without having to open a separate dialog. You can easily sort recipes by clicking on the column youd like to sort by. Furthermore, for advanced users, you can search using regular expressions.
Recipe Editor
Screenshot of Search viewA recipe card view allows editing and entering individual recipes easily. It also instantly multiplies ingredient amounts if you need to multiply or divide a recipe, and even adjusts units to keep them as readable as possible (so that 2 tbs. x 4 displays as 1/2 cup). Gourmet aims to make entering ingredients as intuitive and painless as possible, while still allowing for powerful features. Major Features:
A keyed ingredient list which allows searches and shopping-list generation to understand synonyms (like aubergine and eggplant) and ignore ingredient descriptions (i.e. to treat "tomatoes, finely chopped" as "tomatoes" for the purpose of searching and generating shopping lists.
An intuitive spreadsheet-like editing interface
An alternative, fast form-like ingredient entering interface (which allows you to easily type ingredient lists without looking at the screen.
Drag-n-drop support for importing ingredient lists from your web browser or other application.
Support for pasting ingredient lists in from your clipboard.
Support for grouping ingredients within a recipe.
Support for calling another recipe as an ingredient.(Note: this allows you to use a recipe as a menu!)
Support for optional ingredients.
In addition to ingredients and instructions, you can enter information about categories, cuisines, and ratings that you can later use to search for recipes. In each case, Gourmet allows you a drop down menu of standard categories and categories youve used in the past, but also allows you to enter any custom categories you like.
You can also add images to your recipe for an attractive display. Thumbnails will be displayed in the recipe index. Currently, only HTML export supports images.
Import and Export
Gourmet includes simple and powerful import and export filters for a number of formats, including the two most common recipe formats on the web (mealmaster and mastercook).
Gourmet can import the following kinds of files:
Mealmaster Files
MasterCook text files
MasterCook XML files
Gourmet XML files
A number of popular recipe websites, such as epicurious and recipezaar
Gourmet also can import ingredient lists from a regular plain text list, which can be imported from a file, pasted from the clipboard or dragged onto the editing view.
Gourmet can export the following kinds of files:
Mealmaster files
Rich Text Format
Plain Text
Recipe Web Pages
Gourmet XML files
On GNU/Linux systems, gourmet can also export PDF or postscript files via its printing interface.
Gourmet aims to import and export as many common formats as possible. If you have a format youd like to import, please submit a feature request, or, if youre a programmer, go ahead and start writing the filter yourself!
Shopping List Manager
Screenshot of Shopping List ViewGourmet allows you to automatically generate shopping list from your recipes. You can easily multiply recipes when you add them to adjust for the number of people youre cooking for. If the units are convertable, different units used in different recipes will be added up correctly on your shoppings list (Gourmet even knows the density of some common foods to allow volume-to-weight conversions!). If Gourmet cant convert your units, the shopping list will simply display both units -- for example, the screenshot shows both tsp. and cloves of garlic, since these units cant be sensibly combined.
If you already have an item that appears on your shopping list, you can drag it into your "pantry" so it wont be included! Items added to your pantry will be remembered in the future (so you dont have to manually remove items like "water" from your shopping list every time a recipe calls for it). However, since the pantry list is shown next to the shopping list, you will always have a list at hand of all the ingredients called for by your recipes. (You can drag an item back from the pantry to the shopping list if youve run out.)
The shopping list is also automatically sorted into categories. Gourmet knows the basic categories of a number of foods (produce, meat, fish), and you can create whatever categories are convenient for your own shopping -- I use it for sorting out the basic sections and aisles of my local grocery store and those items that I get from specialty stores. You can set up shopping categories as you enter recipes, or you can move ingredients around within the shopping list view by drag and dropping or using a popup menu.
Main features:
- Simple searching and sorting
- Easy recipe editing
- Import and export from various formats
- A shopping list creator and organizer

cap2-mercurial is a Capistrano 2.x plugin that allows you to use Mercurial in your cap recipes. This project enables the use of "set :scm, :mercurial" in your recipe file. The module is included in Capistrano, but this has the latest updates and bonus recipes.
Enhancements:
- This version works with cap2 and Mercurial 0.9.x reasonably enough for the authors needs.

BrewNIX is a brewing software project.

BrewNIX is beer brewing software that will primarily store recipes but also do some minor analysis of the recipes you enter.

It is currently a command line program, requiring curses. Future plans call for recipe compatibility with qbrew and a choice of GUI or CLI interface.

mysqlrowcopy is a tool that generates insert statements from result sets. It produces output similar to what might result from running mysqldump on a single SELECT query.

This project helps eliminate some of the tedium of moving data between QA and production MySQL databases.

Build:

To build mysqlrowcopy, you should run:

./configure
make

A mysqlrowcopy and mysqlrowcopy.debug file are created. They have identical functionality, the .debug version simply has debugging symbols built in (for gdb).

Since mysqlrowcopy is probably going to be I/O bound with modest CPU and RAM usage, the only reason to even build a 64-bit version is to work around potential issues in dynamic linking 32-bit binaries against 64-bit libraries.

RECIPES

1. Migrating a MySQL user account reaper from QA server to a production server.

e.g. MySQL database server qa3.example.com to prod1.example.com:

$ mysqlrowcopy -h qa3.example.com
SELECT * FROM db WHERE User = "reaper" mysql db > reaper.sql
$ mysql -h prod1.example.com mysql < reaper.sql

You could of course simply pipe the output of mysqlrowcopy into mysql and skip the intermediate file.

(Dont forget to RELOAD PRIVILEGES afterwards)

2. Keep your test environment up to date. Populate it with production data every 24 hours. You could run this sequence from cron once a day:

$ mysqlrowcopy -h finance-db.example.com
SELECT * FROM stocks WHERE modified > DATE_SUB(NOW(),INTERVAL 24 HOUR)
finance stocks > day-stocks.sql

$ cat day-stocks.sql | mysql -h finance-test.example.com finance

3. Copy data between tables on different servers that have some similar fields.

Youve got common data in table Zip on a production database:

mysql> desc Zip;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ZIPCode | varchar(5) | | PRI | | |
| ZIPCodeType | char(1) | YES | | NULL | |
| City | varchar(32) | YES | | NULL | |
| CityType | char(1) | YES | | NULL | |
| State | varchar(32) | YES | | NULL | |
| StateCode | char(3) | YES | | NULL | |
| AreaCode | char(3) | YES | | NULL | |
| Latitude | varchar(12) | YES | | NULL | |
| Longitude | varchar(12) | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+
9 rows in set (0.00 sec)

And youve got table ZipPosition in a research database:

mysql> desc ZipPosition;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ZIPCode | varchar(5) | | | | |
| Latitude | varchar(12) | YES | | NULL | |
| Longitude | varchar(12) | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

You want to load data from production Zip into research ZipPosition.

$ mysqlrowcopy -h production SELECT ZIPCode,Latitude,Longitude common ZipPosition > pos.sql
$ cat pos.sql | mysql -h qa research

Note how we specify ZipPosition on the first line to tell mysqlrowcopy what the destination table is going to be.

MARC::Doc::Tutorial is a documentation-only module for new users of MARC::Record.

SYNOPSIS

perldoc MARC::Doc::Tutorial

What is MARC?

The MAchine Readable Cataloging format was designed by the Library of Congress in the late 1960s in order to allow libraries to convert their card catalogs into a digital format. The advantages of having computerized card catalogs were soon realized, and now MARC is being used by all sorts of libraries around the world to provide computerized access to their collections. MARC data in transmission format is optimized for processing by computers, so its not very readable for the normal human. For more about the MARC format, visit the Library of Congress at http://www.loc.gov/marc/

What is this Tutorial?

The document you are reading is a beginners guide to using Perl to processing MARC data, written in the cookbook style. Inside, you will find recipes on how to read, write, update and convert MARC data using the MARC::Record CPAN package. As with any cookbook, you should feel free to dip in at any section and use the recipe you find interesting.

If you are new to Perl, you may want to read from the beginning.
The document you are reading is distributed with the MARC::Record package, however in case you are reading it somewhere else, you can find the latest version at CPAN: http://www.cpan.org/modules/by-module/MARC/. Youll notice that some sections arent filled in yet, which is a result of this document being a work in progress. If you have ideas for new sections please make a suggestion to perl4lib: http://www.rice.edu/perl4lib/.

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.