Next: Kn-Kz Up: Linux Software Encyclopedia Previous: Jn-Jz Contents

Ka-Km

Last checked or modified: Aug. 16, 2000

Kaffe: A virtual machine designed to execute Java bytecode. This machine performs "just-in-time" code translation from the abstract code to the host machine's native code, which will ultimately allow execution of Java code at the same speed as standard compiled code while maintaining the advantages and flexibility of code independence. It generates native code for i386, Sparc, Alpha and M68K processors, and operates in an interpreted mode for PowerPC and MIPS processors. Kaffe is available as source code that is advertised to compile on virtually all UNIX flavours as well as certain non-UNIX platforms that I won't bother mentioning here seeing how this *is* a Linux list. If the Web site is unreachable you might want to try the Kaffe FTP site.
[http://www.kaffe.org/]
Kali Scheme: A distributed implementation of Scheme which permits the efficient transmission of higher-order objects such as closures and continuations. The integration of distributed communication facilities with a higher-order programming language engenders new abstractions and paradigms for distributed computing, e.g. user-specified load balancing and migration policies for threads, incrementally linked distributed computations, and parameterized client-server applications. Kali integrates procedures and continuations into a message-based distributed framework which allows any Scheme object to be sent and received in a message.
The Kali source code is available. It is written in C and Scheme and will compile on generic UNIX boxes with an ANSI C compiler. It is documented in quite a few technical reports and manuals available in PostScript and/or ASCII format.
[http://www.neci.nj.nec.com/homepages/jagannathan/PLS/kali.html]
KANT: The Komputer Algebra Number Theory software is a subroutine package for algorithms from the geometry of numbers and algebraic number theory. The second version, KANT-V2, is built on a foundation consisting of a memory management package, arbitrary precision integer and real number packages, a multivariate polynomial package over arbitrary rings, and a general linear algebra package. The number theoretic algorithms built on top of this foundation are collected in the Anf package which provides the user with: an arbitrary precision integer and real lattice package, an order and number field package, an algebraic number package, an ideal package for fractional ideals of algebraic number fields, and routines to interface lattices and orders.
KANT-V2 is written in ANSI-C and built on the Cayley platform. At present it is freely available as part of a larger package called KASH, which is basically a user-friendly shell built on top of KANT. KASH is available in binary form for HP 7000, IBM RS600, Sun SPARC, SGI IRIX, and Linux platforms. A user's guide and a reference manual are also available via the Web site.
[ftp://ftp.math.tu-berlin.de/pub/algebra/Kant/Kash]
[http://www.math.TU-Berlin.DE/~kant/kash.html]
KAPI: The KQML Application Programmer's Interface is a set of utility functions targeted for KQML-speaking agent builders. The functionality is targeted to provide an abstract interface to a variety of transport mechanisms and protocols to support inter-agent and client/server communication over the Internet. An intended KAPI user is an agent that wishes to communicate with other agents via an asynchronous stream of KQML messages. A single agent can act as a server and/or a client and can exchange messages via several mechanisms including TCP/IP, email, and HTTP.
The library of C functions provided by KAPI provides a wide range of functionality. It enables an agent to either send a message to another agent using a specific transport type or address the message to the target agent's symbolic name which is found by querying an ANS for an appropriate transport and then sent. The KAPI caches agentname-transport pairings to avoid replicated ANS queries, multiplexes received messages from multiple transport types into a single asynchronous stream, and maps between agent and other client/server protocols. The latter capability allows an agent to appear as an HTTP server to HTTP clients as well as allows an HTTP server to be accessed as if it were an agent. A command line interface is provided as well as interfaces for Lisp and Tcl/Tk.
A source code distribution of KAPI is available. It is written in C and can be compiled and used on several UNIX flavors. Suggestions are included for compiling on Sun and SGI platforms, although a brief perusal of the make file shows everything to be sufficiently generic for easy porting to other platforms. The distribution is documented in various text files.
[http://www.cs.umbc.edu/kqml/software/]
Kappa: A parallel database management system based on a nested relational model so that complex structured data such as is found in knowledge or genetic information processing systems can be treated efficiently. Kappa is written in KL1 and can used on any UNIX system on which KLIC has already been installed. The source code distribution includes a user's manual in LaTeX format. This software is part of the ICOT project.
[http://www.icot.or.jp/ARCHIVE/Museum/SOFTWARE/KAPPA/outline-E.html]
KAPPA: The Kernel APplications PAckage is is Starlink Project applications package which comprises over 180 general purpose commands for image processing, data visualization, and manipulation of the standard Starlink data format, i.e. the NDF. It can also process data in other formats using an on-the-fly conversion scheme. KAPPA is designed to integrate with most of the other specialized Starlink packages, and concentrates on image processing as opposed to the FIGARO package which focuses on spectroscopy.
The facilities for data processing in KAPPA include:

FITS readers which generate NDFs and text tables;

the generation of test data and the creation of NDFs from text files;

setting and examining NDF components;

the definition of calculation of a sky coordinate system for use in conjunction with IRAS90 tools;

arithmetic including an application which handles expressions;

pixel and region editing including polygons and circles, reflagging of bad pixles by value or median filtering, and pasting arrays over other arrays;

masking of regions and of pixels whose variances are too large;

configuration changes, e.g. flip, rotate, shift, subset, etc.;

forming image mosaics and the normalization of NDF pairs;

compression and expansion of images;

generalized resampling of NDFs using arbitrary transformations;

filtering by box, Gaussian, and median smoothing and efficient Fourier transform and convolution;

deconvolution by maximum entropy, Lucy-Richardson and Wiener filtering;

2-D surface fitting;

statistics including ordered statistics, histograms, etc.;

inspection of image values;

centroids of features and stellar PSF fitting;

detail enhancement using histogram equalization and Laplacian, convolution, edge enhancement via a shadow effect, thresholding; and

calculation of polarimetry images.

KAPPA applications for data visualization include:

the use of a graphics database to pass information about pictures between tasks;

tools for the creation, labeling, and selection of pictures as well as for obtaining world and data coordinate information from them;

image and grayscale plots with a selection of scaling modes;

creation, selection, saving and manipulation of color tables and palettes;

snapshots of image displays to hardcopy;

blinking and visibility of image display planes; and

line graphics, e.g. contouring including overlay, columnar and hidden-line plots of images, histograms, pie sections and slices through images, vector plots of images, etc.

A binary distribution of KAPPA is available for DEC OSF/1, Linux Intel and Sun Solaris platforms. It is extensively documented in a 440+ page user's guide available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
Karma: A toolkit for interprocess communications, authentication, encryption, graphics display, creating a user interface, and manipulating the Karma network data structure. It contains KarmaLib (the structured libraries and API) and a large number of modules to perform many tasks.
KarmaLib contains routines to: generate random numbers, print general error messages, handle signals, manage callback lists, support work functions, generate periodic events, manipulate associative arrays, manipulate channel objects, manage child processes, provide encryption, compute and write RGB color values into arrays, extract data from strings, produce message digests, manipulate strings, perform optimized vector arithmetic, manage a thread spool, load shared objects, generate icon pixmaps, manipulate X displays and color maps, query X visuals, provide channel encryption, scan directories, convert between image formats, write raw images, write PostScript, scan values from channel objects, interface with PGP, convert between color spaces, interface with the Glish library, support astronomical sky projections, provide Xt support, convert between Karma and other data formats, manipulate viewable images, and much more.
The Karma modules include:

kdump, which converts a Karma file to ASCII-Karma;

kgetslice, which extracts a 2-D slice from a 3-D file;

xray, a volume rendering tool;

mandel, which computes the Mandelbrot set;

knoise, which generates n-dimensional arrays of random data;xi

kregrid, which regrids an image/cube to a different astronomical grid;

c2doc, which extracts function interface definitions from C files;

chlen, which changes the length of a dimension;

histogram, which computes the histogram of scalar data;

chshell, a connection management tool shell;

convert, which converts scalar data with a scaling option;

kminmax, which finds the minimum and maximum of an array;

kpvslice, an interactive position-velocity slice tool;

kview, which displays images or movies; and much more.

Karma is written in C and the source code is available along with binaries for DEC Alpha, Convex, HP, Linux, SGI, DEC Ultrix, IBM, and Sun platforms. Compilation requires an ANSI C compiler and X11. The package is documented in a programming manual available in HTML and PostScript formats. The Sutra visualization software is built on top of Karma.
[http://www.atnf.csiro.au/karma/]
KaRMI: A more efficient drop-in replacement for the Java RMI mechanism. KaRMI is implemented completely in Java without any native code and supports non-TCP/IP communication networks - even those with heterogeneous transport protocols. The features of KaRMI that differentiate it from RMI include:

clear and clearly documented interfaces between the stub/skeleton, reference, and transport layers for improved performance and the capability for adding alternative reference and transport implementations;

vastly improved performance via using native calls only for interacting with device drivers, automatic detection of remote objects that are local to shortcut object access, and less debugging code;

use of the communication technology concept for isolating communication hardware-specific code; and

pluggable garbage collection allowing different methods to be used for each communication technology.

A source distribution is freely available for private, education or research purposes. Documentation is available via technical reports.
[http://wwwipd.ira.uka.de/~hauma/EfficientRMI/]
K-Arp-Ski: A packet sniffer with a GTK interface. The features of K-Arp-Ski include:

automatically finding all of the IP addresses on your network as they are broadcast;

TCP connections tracked per MAC address;

watching multiple connections simultaneously as well as watching an entire MAC address for, e.g. UDP datagrams;

a launch feature, i.e. a plug-in interface which can call any remote program with the IP address of the target as part of its arguments;

finding the vendor associated with the MAC address of each card;

capability of ading an unlimited number of protocols or frame types to the packet recognition engine; and

a cheesy scanning sound from Knight Rider.

A source code distribution of K-Arp-Ski is available. It is written in C and requires GTK 1.0 or greater for compilation and use.
[http://mojo.calyx.net/~btx/karpski.html]
KASH: See KANT.
KASKADE: A C++ toolbox for the solution of linear scalar elliptic and parabolic problems in 1, 2, and 3 dimensions using adaptive finite element methods. The toolbox includes extensions for handling systems of equations as well as example algorithms for nonlinear methods used in obstacle, porous media, or Stefan problems. The core of the program consists of a variety of multilevel/multigrid preconditioners for the linear systems involved.
The iterative solvers included in the package include: conjugate gradient (with and without 3-term recurrence), conjugate residual (with and without 3-term recurrence), several relaxation routines (Jacobi, SSOR, etc.), GMRES, bi-conjugate gradients, BiCGStab, the Sonneveld CGS algorithm, conjugate gradients for normal equations, and a nonlinear relaxation routine. Preconditioner methods include: Jacobi type, symmetric Gauss-Seidel, incomplete LU-factorization, multilevel with Jacobi-type smoothing, multilevel with symmetric Gauss-Seidel smoothing, additive multilevel with Jacobi-type smoothing, and additive multilevel with Gauss-Seidel smoothing. Nonlinear preconditioners are single-grid Gauss-Seidel, multi-level Gauss-Seidel, and truncated multi-level Gauss-Seidel. There are also several error estimators and refinement strategies available.
The KASKADE package includes the source code which is written in C++. It can be compiled with g++ 2.6.3 or later. The package is documented in extensive programmer's and user's guides in PostScript format.
[http://www.zib.de/SciSoft/kaskade/]
[ftp://elib.zib.de/pub/kaskade/]
Kawa: A Scheme interpreter written in the Java programming language. The internal design uses the features of a garbage-collected, object-oriented language like Java to full advantage. Since any Java object is a Scheme object, Kawa will be able to access any Java object within a Scheme environment. The current (8/96) release is preliminary and is intended only for serious programmers should they want to see how it works or contribute. A complete release implementing most if not all of the R4RS standard is planned for eventual release.
[http://www.cygnus.com/~bothner/kawa.html]
[http://www.gnu.org/software/kawa/]
KBackup: An easy-to-use backup package for UNIX systems. The features of KBackup include:

a menu-driven interface as well as a command-line interface for inclusion in scripts;

high reliability via the use of well-tested utilities;

automatic unattended backups;

full or incremental backups;

support for tape drives, floppies, or removable media;

remote backups across a network;

support for compression, encryption, and double buffering;

high portability via a modular shell script; and

extensive documentation.

A source code distribution of KBackup is available as are RPM distributions. Its use is documented in an extensive manual available in HTML and PostScript formats.
[http://www.phy.hw.ac.uk/~karsten/KBackup.html]
[http://sunsite.unc.edu/pub/Linux/system/backup/]
KCL: Kyoto Common Lisp is a Common Lisp implementation written by T. Yuasa and M. Hagiya at the Research Institute for Mathematical Sciences at Kyoto University in Japan. It is written in C to run on UNIX-like systems. KCL is now mostly of historical interest since it has been superseded by the improved AKCL which was itself followed up by the improved GCL, with the latter implementation now the one recommended for use.
[http://sunsite.unc.edu/pub/Linux/devel/lang/lisp/]
[http://www.lisp.org/table/systems.htm]
KDat: A tar-based tape archiver whose features include:

support for SCSI and floppy tape drives;

managing multiple archives on the same tape;

selectively backing up many files/directories at a time;

quickly verifying/restoring selected files within an archive;

backup profiles for frequently used backups;

support for GNU incremental backups; and

a GUI interface.

A source code distribution is available.
[http://sunsite.auc.dk/qweb/kdat/]
KDB: A built-in Kernel DeBugger for Linux. KDB is part of the kernel and provides a means for examining kernel memory and data structures while the system is operational. Additional commands can be added to format and display essential system data structures given an identifier or address of the data structure. The current (8/99) command set allows complete control of kernel operations including:

single stepping a processor;

stopping upon execution of a specific instruction;

stopping upon access (or modification) of a specific virtual memory location;

stopping upon access of a register in the I/O address space;

stack tracebacks for the current active task as well as for all other tasks; and

instruction disassembly.

This is available as a kernel patch for the 2.2.10 source tree.
[http://oss.sgi.com/projects/kdb/]
KDbg: A GUI to GDB that provides an intuitive interface for setting breakpoints, inspecting variables, and stepping through code. The features of KDbg include:

variables inspection via a tree structure;

inspection of important member variables of class types without having to open the variable; and

important debugging functions bound to the function keys.

A source code distribution is available which requires at lesat the runtime libraries of KDE for compilation.
[http://members.telecom.at/~johsixt/kdbg.html]
KDE: A project aimed at building a fast and coherent desktop environment for the X Window system which should be able to run on any platform running X, although it is being developed on Linux platforms. It comprises many small tools, each designed to carry out a specific taks quickly and efficiently with a common look-and-feel. The three parts of KDE are: the desktop, which provides the basic desktop functionality including window and file management, application launching, and a hypertext help system; the libraries, which make a KDE application a KDE application rather than another X or Qt application; and the applications, e.g. kghostview, kvt, kcalc, kview and a number of games. A scripting language may also be eventually included. The first package versions of KDE are available as of 2/97.
The KDE base application suite includes:

kaudio, an audio server;

kcalc, a scientific calculator;

kcontrol, a central control panel;

kdehelp, a help browser;

kdm, an xdm replacement;

kdvi, a TeX DVI file viewer;

kedit, a simple text editor;

kfontmanager, a tool for managing fonts;

kjots, a note taking utility;

kmail, a mail user agent;

kmix, a sound device mixer;

knu, a front-end to several network utilities;

kpaint, a paint program;

kscreensaver, a screensaver package;

kuser, a user administration tool;

kvt, a terminal emulation package;

kwm, the KDE window manager;

kzip, a utility for handling compressed files;

and several more.
Other KDE applications include:

kfourier, an image processing application;

kmandel, a multi-fractal program;

korigin, a scientific data visualization tool;

kpackage, a graphical package manager for RPM and DEB packages;

kppp, a dialer and front-end for PPP;

ksciplot, a function plotter;

ksysmon, a syste monitor; and

ktelnet, a tool for telnet, rlogin, and ssh.

These applications are in various states of completion. See the KDE home site for further details.
[http://www.kde.org/]

KDE Studio

An integrated development environment (IDE) for KDE.
[http://www.thekompany.com/projects/kdestudio/]
kdem: A KDE program for displaying USGS Digital Elevation Models (DEMs). The features include:

interactive feedback in real time;

interruptible rendering, i.e. no waiting for rendering to be completed before doing something else;

reads both older text format and SDTS datasets;

configurable shaders to control the colors used to draw the DEM;

generation of red/blue anaglyphs, i.e. images that appear to have depth when viewed with red/blue glasses; and

support for the SpaceTec Space Orb 360 game controller.

[http://www.mindspring.com/~jamoyers/kdem/]
KDevelop: An integrated development environment for UNIX/X11 platforms. The features include:

project creation and management;

an application wizard offering four different frameworks for creating new programs, i.e. a standard and mini KDE applications, a Qt-only application, and a C++/terminal application;

a selection of four treeviews for easily switching between source/header files, classes and documentation;

an integrated editor with syntax highlighting;

several integrated UNIX development tools for documentation, debugging, making, etc;

an integrated documentation browser for perusing the KDE and Qt documentation;

a built-in help system; and

a class generator for creating classes on the fly.

A source code distribution of this package is available which requires KDE for compilation and usage.
[http://www.kdevelop.org/]
keeper: An archivist's assistant which is designed to offer powerful help for overwhelmed source archive site maintainers. It is an interactive Perl script which automates most of the drudgery involved in maintaining a large archive site. It was originally developed to maintain the Sunsite Linux archive site. Keeper makes it easy for an archiver to maintain an archive by automatically performing tasks after every action by the maintainer, e.g. all derived files that need to change will be properly rebuilt and appropriate e-mail notifications will be sent to the package and archive maintainers.
The source code for keeper is available. It is written in Perl and can be used on any platform which has that language. It is documented in an extensive man page.
[http://www.tuxedo.org/~esr/software.html]
KeLP: The Kernel Lattice Parallelism package is a suite of C++ runtime libraries for implementing parallel programs that need to use broad classes of irregular data structures. It is designed for implementing portable scientific applications on distributed memory parallel computers and intended for applications requiring adaptation to data- or hardware-dependent conditions at runtime. KeLP is the successor to the LPARX package and introduces a new communication model based on the inspector/executor model to provide better communication performance on message passing multicomputers.
KeLP supports a task-parallel computation model that isolates parallel coordination activities from numerical computation - a model that simplifies the design of application software and promotes software reuse. It can be used to plug in existing serial numerical kernels and leverage mature cmopiler technology. The kernels can be written in several languages including Fortran 77 and 90, C and C++. Programmers can avoid specifying interprocessor communication details by providing classes that encapsulate interprocessor communication. The classes describe atomic-array section moves so the programmer can specify elaborate interpolation or coupling functions for handling complicated boundary conditions.
The KeLP package is available as source code written in C++. It is portable across many machines including the IBM SP2, the Cray T3D, the Intel Paragon, and networks of workstations. The documentation is contained within a user's guide and some papers and technical reports, all available in PostScript format.
[http://www-cse.ucsd.edu/groups/hpcl/scg/kelp/]
KEPLEX: The KEPLer EXplicit program is an explicit extrapolation integrator for non-stiff second-order systems of ordinary differential equations of the form

$\begin{displaymath}y''\,+\,{\omega^2}y\,=\,f(t,y)\end{displaymath}$

where $\omega$ is a fixed frequency. This uses Kepler discretization with h-extrapolation. KEPLEX is available as Fortran source code and is documented via comment statements within the source code. This is part of CodeLib. See Deuflhard (1980a).
[ftp://elib.zib.de/pub/elib/codelib/keplex/]
Kerberos: A network authentication based on the key distribution model for use on physically insecure networks, i.e. it provides for mutual authentication and secure communication between principals on an open network by manufacturing secret keys for any requestor and providing a mechanism for these keys to be safely propagated through the network. It allows entities communicating over networks to prove their identify to each other while preventing eavesdropping or replay attacks. It also provides for data stream integrity (i.e. detection of modification) and secrecy (i.e. preventing unauthorized reading) using cryptography. Kerberos works by providing users or services, i.e. principals, with tickets which they can use to identify themselves to other principals as well as secret cryptographic keys for secure communications with other principals. It is mostly used in application level protocols such as Telnet or FTP to provide user-to-host security. It is also occasionally used as the implicit authentication system of data stream or RPC mechanisms.
The most recent (5/98) version is Kerberos V5. This release includes the server, a full-featured administration system including support for password policies, all the libraries needed to integrate Kerberos security into new applications, and secure and encrypting versions of common network utilities, e.g. telnet, rlogin, rsh, rcp and ftp. A source code distribution is available as are binaries for several platforms. It is written in C and has been successfully compiled on almost all UNIX platforms including Linux Intel. It is documented in several technical reports available in PostScript format as well as in a set of man pages. See also the other Athena tools Hesiod, Moira, and Zephyr.
[http://web.mit.edu/kerberos/www/]
[http://www.isc.org/isc/kerberos.html]
[http://nii-server.isi.edu/info/kerberos/]
[http://sunsite.unc.edu/pub/Linux/system/network/]
KerbNet: An implementation of Kerberos V5, the network security protocol for authentication of users and services. The KerbNet toolkit includes an authentication server and several clients including telnet, ftp, rlogin, rcp and rsh. The features of KerbNet include:

the server provides a single sign-on interface which eases administration and simplifies access;

tools for complete authorization components which act as a foundation for network security;

compliance with RFC 1508 and 1510; and

a stand-alone mode that operates independently of firewalls so it can be used to enhance existing security measures.

Implementations of KerbNet are available for most UNIX platforms and Windows NT platforms. Binaries are available as well as a source distribution. Documentation is available in a separate tar file.
[http://packetstorm.securify.com/crypt/kerbnet/]
[http://cryptography.org/]
Kermit: See C-Kermit.
kernel: The kernel is the heart of Linux - it is what Linus began building all those years ago when he wanted to circumvent the limitations of Minix on X86 platforms. Its basic functions are to arrange the memory management for all the running programs and to provide a portable interface for programs to talk to various pieces of hardware (e.g. disk drives, monitors, network cards, etc.). While most Linux distributions contains gigabytes worth of programs from various source, the kernel is fundamentally the Linux OS. This is not all at an attempt to downplay the importance of the ancillary programs, though, since they (especially the GNU packages) are what make a Linux system useful.
Relevant information can be found at/in:

The Linux Kernel Archives
[http://linux.kernel.org/]

kernelnotes.org
[http://www.kernelnotes.org/]

The Linux Kernel
[http://www.redhat.com/mirrors/LDP/LDP/tlk/tlk.html]

Linux Kernel Hacker's Guide
[http://www.redhat.com/mirrors/LDP/LDP/khg/HyperNews/get/khg.html]

Linux Kernel Module Programming Guide
[http://www.redhat.com/mirrors/LDP/LDP/lkmpg/mpg.html]

Kernel Traffic
[http://kt.linuxcare.com/index.epl]

Linux Memory Management
[http://humbolt.geo.uu.nl/Linux-MM/]

Related packages or entries include:

KDB, a kernel debugger;

LKCD, a package for examining kernel crashes;

LKM, a description of loadable kernel modules (LKMs);

International Kernel Patch

Export regulations prevent the Linux kernel source distribution from containing cryptography. The IKP provides this missing functionality in the form of a unified patch.
[http://www.kerneli.org/]
KeyKit: A programming language and graphical user interface (GUI) for MIDI useful for both algorithmic and real-time musical experimentation. KeyKit is an Awk-like language designed specifically for manipulating MIDI data with the full system including a multi-window and multi-tasking GUI. The language itself has only a few built-in functions for graphics, but the entire user interface is written in KeyKit itself and is thus completely customizable and extensible by the user.
The features of the KeyKit language include:

multi-tasking which allows any number of tools and operations to be simultaneously used;

object-oriented features that allow the definition of classes containing methods and data and the adding of data elements within a class on the fly;

the recording of MIDI input is always on;

phrases of MIDI data are treated as first-class data types which allows merging, concatenation, selection, and looping using built-in language operators and syntax;

variables are not declated and the type of data within a variable is determined on the fly; and

function references can be passed as arguments which allows parameterized operations to be specified in a flexible way.

The GUI is built in KeyNote using the small number of graphical primitives available within the language, and the interface defines a standard for Tools that can run all simultaneously. The Tools can exchange MIDI data either through a clipboard or by using object-oriented get/set methods which allow the copying of data between tools by pointing and clicking. The GUI tools include:

an echo tool which monitors MIDI input and creates echos,

volume and tempo sliders,

a mouse matrix which generates chords by dragging the mouse over a grid;

a kboom tool which is a drum pattern editor;

a riff tool which plays a phrase via a mouse click;

a group tool which is a multi-track editor;

a GM control tool which contains sliders for 16 channels of controllers;

and a chord palette tool which lets you play chords by clicking in one of its grid cells.

A source code distribution of KeyKit is available as are executables for Win95 and Linux Intel platforms. It is documented in a tutorial, a language reference manual, a tools manual, and a hacking guide, all of which are available in plain text, PostScript, and PDF format.
[http://www.nosuch.com/keykit/index.html]
Keystone: A Web-based application designed to help a workgroup keep track of issues and tasks via a shared central resource. This was designed for IT departments where quick access to shared data and history is required. The centralized model organizes the department and gives the group the information it needs to server customers. This is written in PHP3 and also requires a database like MySQL.
[http://www.stonekeep.com/
kForth: A programming environment including an implementation of Forth. This implements a subset of the ANSI Forth specification along with some extensions. It can be used as a standalone programming environment or its object code can be interfaced with another program to server as a customizable language for that application. The features include:

floating point extensions for scientific computation; and

performance of type checking for operations involving memory addresses.

[http://ourworld.compuserve.com/homepages/krishnamyneni/ccre/kforth0.html]
KGL: The name of this has been changed to SDPGL.
Khoros: This is now a wholly commercial software package sold by Khoral Research, Inc.
Kibble: A knowledge base program used to organize seemingly unrelated, discursive thoughts into a cohesive engine, i.e. to keep track of random ideas that might eventually be useful. The current (12/98) version works by adding nodes to trees containing related ideas, although more functionality is in the works. Source code and binary distributions are available. Compilation requires the GTK library.
[http://www.bestlinux.net/en/contrib/kibble-0.7.0-1.i386.html]
[http://rpmfind.net/linux/RPM/kibble.html]
Kiev: A language derived from Java initially written in and (mostly) source compatible with the Pizza language. The features Kiev adds to Java include:

multimethods, where the method to be called is selected by run-time argument types;

parameterized types which may have arguments that may be used as virtual types inside the class;

closure, i.e. anonymous functions;

first-order functions;

arithmetic types, type states, and cases;

a foreach statement for simplifying iteration through containers;

a goto statement;

global methods and variable definitions, i.e. imported static methods and fields;

virtual fields, i.e. those that may be accessed only through method calls; and

a variable number of arguments for methods.

Several other features are planned but have not yet (5/98) been implemented.
A source code distribution of Kiev is available. Kiev compiles into Java bytecode and requires JDK 1.1 or greater. The documentation is a bit on the sparse side.
[http://www.forestro.com/kiev/]
KIF: The Knowledge Interchange Format is a language for the interchange of knowledge among disparate programs. KIF is a logic language proposed as a standard for describing things within computer systems, e.g. expert systems, databases, intelligent agents, etc. It has been specifically designed to be useful as a mediator in the translation of other languages. Technically speaking, it is a prefix version of first order predicate calculus with extensions supporting non-monotonic reasoning and definitions, with the language description including specifications for both its syntax and semantics. KIF has declarative semantics, i.e. the meaning of expressions can be understood without using an interpreter to manipulate them, and is logically comprehensive, i.e. provides for the expression of arbitrary sentences in first order predicate calculus. It also provides for the representation of knowledge about the representation of knowledge and for the definition of objects, functions, and relations.
Available related software includes JKP and kifparse.
[http://www.cs.umbc.edu/kse/kif/]
kifparse: A parser for the KIF language written in C++. The available source code can be compiled using Flex, Bison, and G++.
[http://logic.stanford.edu/sharing/programs/kif/]
KIllustrator: A vector drawing program project for KDE whose aim is to provide functionality similar to Corel Draw or Adobe Illustrator. The current (11/98) functionality includes:

several different object types including polylines, circles, ellipses, squares, rectangles, symmetric polygons, freehand lines, Bezier curves and multiline text;

tools for moving, scaling and rotating as well as grouping, ungrouping, aligning, distributing and reordering objects;

zooming and snapping to grids;

dumping drawings to PostScript format;

importation of WMF clipart and Xfig files;

exporting to raster image formats (e.g. GIF, PNG, XPM) and EPS;

graphical layers; and

various line styles, arrows and fill styles.

A source code distribution is available which requires a working KDE environment for compilation and use.
[http://wwwiti.cs.uni-magdeburg.de/~sattler/killustrator.html]
Kimwitu: A system for the construction of programs that uses trees or terms as its main data structure.
[http://wwwtios.cs.utwente.nl/kimwitu/]
kirra-httpd: A small HTTP/HTTPS served built using libwww-perl.
[http://kirra.net/perl/]
KisoCD: A KDE program for creating data CDs. It helps in the composing of the contents while other programs create the filesystem and do the burning.
[http://www.uni-karlsruhe.de/~um12/en/main_index.html]
KLIC: A portable and high-performance parallel implementation of the concurrent logic programming language KL1 which compiles the source code into C. KL1 is a programming language designed for easily writing parallel processing programs. It is a language for parallel symbolic processing which is based on a flat version of the Guarded Horn Clauses (GHC) language. GHC is a member of the committed-choice logic programming family which also includes Prolog, Parlog, Janus and Fleng. The KLIC implementation of KL1 provides, in addition to a range of basic functions, some built-in predicates (e.g. integer and floating point arithmetic); strings, vectors and their primitive operators; tracers (e.g. stepping, spying, etc.); input/output including asynchronous I/O on sockets; priority control mechanisms; and parallel execution mechanisms.
The KLIC distribution includes a sequential and two parallel implementations. The distributed memory implementation is based on PVM and the shared memory implementation can be used on Sun SparcCenter and DEC Alpha platforms. The distribution can be compiled on most generic UNIX platforms including Linux Intel. A KLIC system manual and a KL1 language manual are both available in TeX format. This was developed as part of the ICOT project.
[http://www.klic.org/index.en.html]
Klm: A scripting environment based on the Motif toolkit which uses a Lisp dialect called Klone. Klm can be run in either interactive or batch mode, and a script can be run similarly to shell scripts. It is not intended to be a full Klone binding to the Motif API but rather a small set of functions which allow the quick and easy building of Motif applications. It uses the Knvas widget as a high-level interface to Xlib.
A source code distribution of Klm is available. Compilation requires Motif 1.2 or higher as well as the XPM library. A brief user's guide in HTML format is available online, and a reference manual is available in PostScript format.
[http://www.inria.fr/koala/jml/klm/klm.htmll]

Next: Kn-Kz Up: Linux Software Encyclopedia Previous: Jn-Jz Contents

Manbreaker Crag 2001-03-08