GNU/Linux AI & Alife HOWTO, John Eikenberry [best books to read for self development TXT] 📗

programming game, similar to ‘Core War’. To play

TclRobots, you must write a Tcl program that controls a robot.

The robot’s mission is to survive a battle with other robots.

Two, three, or four robots compete during a battle, each running

different programs (or possibly the same program in different

robots.) Each robot is equipped with a scanner, cannon, drive

mechanism. A single match continues until one robot is left

running. Robots may compete individually, or combine in a team

oriented battle. A tournament can be run with any number of

robot programs, each robot playing every other in a round-robin

fashion, one-on-one. A battle simulator is available to help

debug robot programs.

 

The TclRobots program provides a physical environment, imposing

certain game parameters to which all robots must adhere.

TclRobots also provides a view on a battle, and a controlling

user interface. TclRobots requirements: a wish interpreter

built from Tcl 7.4 and Tk 4.0.

 

TKQML

 

� Web site: www.csee.umbc.edu/tkqml/

 

TKQML is a KQML application/addition to Tcl/Tk, which allows Tcl

based systems to communicate easily with a powerful agent

communication language.

 

The Tocoma Project

 

� Web site: www.tacoma.cs.uit.no/

 

An agent is a process that may migrate through a computer

network in order to satisfy requests made by clients. Agents are

an attractive way to describe network-wide computations.

 

The TACOMA project focuses on operating system support for

agents and how agents can be used to solve problems

traditionally addressed by operating systems. We have

implemented a series of prototype systems to support agents.

 

TACOMA Version 1.2 is based on UNIX and TCP. The system supports

agents written in C, Tcl/Tk, Perl, Python, and Scheme (Elk). It

is implemented in C. This TACOMA version has been in public

domain since April 1996.

 

We are currently focusing on heterogeneity, fault-tolerance,

security and management issues. Also, several TACOMA

applications are under construction. We implemented StormCast

4.0, a wide-area network weather monitoring system accessible

over the internet, using TACOMA and Java. We are now in the

process of evaluating this application, and plan to build a new

StormCast version to be completed by June 1997.

 

UMPRS Agent

 

� Web site: http://www.marcush.net/IRS/

 

UMPRS supports top-down, goal-based reasoning and selects goals

and plans based on maximal priority. Execution of multiple

simultaneous goals are supported, with suspension and resumption

capabilities for each goal (i.e., intention) thread. UMPRS plans

have an integrated precondition/runtime attribute that constrain

their applicability. Available plan constructs include:

sequencing, iteration, subgoaling, atomic (i.e., non-interruptable) blocks, n-branch deterministic conditional

execution, explicit failure-handling section, and C++ primitive

function definition.

 

Virtual Secretary Project (ViSe)

(Tcl/Tk)

 

� Web site: www.vise.cs.uit.no/vise/

 

The motivation of the Virtual Secretary project is to construct

user-model-based intelligent software agents, which could in

most cases replace human for secretarial tasks, based on modern

mobile computing and computer network. The project includes two

different phases: the first phase (ViSe1) focuses on information

filtering and process migration, its goal is to create a secure

environment for software agents using the concept of user

models; the second phase (ViSe2) concentrates on agents’

intelligent and efficient cooperation in a distributed

environment, its goal is to construct cooperative agents for

achieving high intelligence. (Implemented in Tcl/TclX/Tix/Tk)

 

VWORLD

 

� Web site: zhar.net/projects/vworld/

 

Vworld is a simulated environment for research with autonomous

agents written in prolog. It is currently in something of an

beta stage. It works well with SWI-prolog, but should work with

Quitnus-prolog with only a few changes. It is being designed to

serve as an educational tool for class projects dealing with

prolog and autonomous agents. It comes with three demo worlds or

environments, along with sample agents for them. There are two

versions now. One written for SWI-prolog and one written for

LPA-prolog. Documentation is roughly done (with a

student/professor framework in mind), and a graphical interface

is planned.

 

WebMate

 

� Web site: www.cs.cmu.edu/~softagents/webmate/

 

WebMate is a personal agent for World-Wide Web browsing and

searching. It accompanies you when you travel on the internet

and provides you what you want.

 

Features include:

 

� Searching enhancement, including parallel search, searching

keywords refinement using our relevant keywords extraction

technology, relevant feedback, etc.

 

� Browsing assistant, including learning your current

interesting, recommending you new URLs according to your

profile and selected resources, monitoring bookmarks of

Netscape or IE, sending the current browsing page to your

friends, etc.

 

� Offline browsing, including downloading the following pages

from the current page for offline browsing.

 

� Filtering HTTP header, including recording http header and

all the transactions between your browser and WWW servers,

etc.

 

� Checking the HTML page to find the errors or dead links,

etc.

 

� Programming in Java, independent of operating system, runing

in multithread.

 

Yampa

 

� Web site: http://www.haskell.org/yampa/

 

FRP system with robotics library and graphical interactive

robotics simulator.

 

Functional reactive programming, or FRP, is a paradigm for

programming hybrid systems �i.e., systems containing a

combination of both continuous and discrete components �in a

high-level, declarative way. The key ideas in FRP are its

notions of continuous, time-varying values, and time-ordered

sequences of discrete events. Yampa is an instantiation of FRP

as a domain-specific language embedded in Haskell.

 

Zeus

 

� Web site: more.btexact.com/projects/agents/zeus/

 

The construction of multiagent systems involves long

development times and requires solutions to some considerable

technical difficulties. This has motivated the development of

the ZEUS toolkit, which provides a library of software

components and tools that facilitate the rapid design,

development and deployment of agent system

7. Programming languages

While any programming language can be used for artificial

intelligence/life research, these are programming languages which are

used extensively for, if not specifically made for, artificial

intelligence programming.

 

Allegro CL

 

� Web site: www.franz.com

 

Franz Inc’s free linux version of their lisp development

environment. You can download it or they will mail you a CD free

(you don’t even have to pay for shipping). It is generally

considered to be one of the better lisp platforms.

 

APRIL

 

� Web site: sourceforge.net/projects/networkagent/

 

APRIL is a symbolic programming language that is designed for

writing mobile, distributed and agent-based systems especially

in an Internet environment. It has advanced features such as a

macro sublanguage, asynchronous message sending and receiving,

code mobility, pattern matching, higher-order functions and

strong typing. The language is compiled to bytecode which is

then interpreted by the APRIL runtime-engine. APRIL now

requires the InterAgent Communications Model (ICM) to be

installed before it can be installed. [Ed. ICM can be found at

the same web site]

 

Ciao Prolog

 

� Web site: www.clip.dia.fi.upm.es/Software/Ciao/

 

Ciao is a complete Prolog system subsuming ISO-Prolog with a

novel modular design which allows both restricting and extending

the language. Ciao extensions currently include feature terms

(records), higher-order, functions, constraints, objects,

persistent predicates, a good base for distributed execution

(agents), and concurrency. Libraries also support WWW

programming, sockets, and external interfaces (C, Java, TCL/Tk,

relational databases, etc.). An Emacs-based environment, a

stand-alone compiler, and a toplevel shell are also provided.

 

DHARMI

 

� Web site: http://megazone.bigpanda.com/~wolf/DHARMI/

 

DHARMI is a high level spatial, tinker-toy like language who’s

components are transparently administered by a background

process called the Habitat. As the name suggests, the language

was designed to make modelling prototypes and handle living

data. Programs can be modified while running. This is

accomplished by blurring the distinction between source code,

program, and data.

 

ECLiPSe

 

� Web site: eclipse.crosscoreop.com/eclipse/

 

ECLiPSe is a software system for the cost-effective development

and deployment of constraint programming applications, e.g. in

the areas of planning, scheduling, resource allocation,

timetabling, transport etc. It is also ideal for teaching most

aspects of combinatorial problem solving, e.g. problem

modelling, constraint programming, mathematical programming, and

search techniques. It contains several constraint solver

libraries, a high-level modelling and control language,

interfaces to third-party solvers, an integrated development

environment and interfaces for embedding into host environments.

 

ECoLisp

 

� Web site (???): www.di.unipi.it/~attardi/software.html

 

ECoLisp (Embeddable Common Lisp) is an implementation of Common

Lisp designed for being embeddable into C based applications.

ECL uses standard C calling conventions for Lisp compiled

functions, which allows C programs to easily call Lisp functions

and viceversa. No foreign function interface is required: data

can be exchanged between C and Lisp with no need for conversion.

ECL is based on a Common Runtime Support (CRS) which provides

basic facilities for memory managment, dynamic loading and

dumping of binary images, support for multiple threads of

execution. The CRS is built into a library that can be linked

with the code of the application. ECL is modular: main modules

are the program development tools (top level, debugger, trace,

stepper), the compiler, and CLOS. A native implementation of

CLOS is available in ECL: one can configure ECL with or without

CLOS. A runtime version of ECL can be built with just the

modules which are required by the application. The ECL compiler

compiles from Lisp to C, and then invokes the GCC compiler to

produce binaries.

 

ESTEREL

 

� Web site: www-sop.inria.fr/meije/esterel/

 

Esterel is both a programming language, dedicated to programming

reactive systems, and a compiler which translates Esterel

programs into finite-state machines. It is particularly well-suited to programming reactive systems, including realtime

systems and control automata.

 

Only the binary is available for the language compiler. :P

 

G�el

 

� Web page: www.cs.bris.ac.uk/~bowers/goedel.html

 

G�el is a declarative, general-purpose programming language in

the family of logic programming languages. It is a strongly

typed language, the type system being based on many-sorted logic

with parametric polymorphism. It has a module system. G�el

supports infinite precision integers, infinite precision

rationals, and also floating-point numbers. It can solve

constraints over finite domains of integers and also linear

rational constraints. It supports processing of finite sets. It

also has a flexible computation rule and a pruning operator

which generalizes the commit of the concurrent logic programming

languages. Considerable emphasis is placed on G�el’s meta-logical facilities which provide significant support for meta-programs that do analysis, transformation, compilation,

verification, debugging, and so on.

 

CLisp (Lisp)

 

� Web page: clisp.sourceforge.net

 

� Alt Web site: clisp.cons.org

 

CLISP is a Common Lisp implementation by Bruno Haible and

Michael Stoll. It mostly supports the Lisp described by Common

LISP: The Language (2nd edition) and the ANSI Common Lisp

standard. CLISP includes an interpreter, a byte-compiler, a

large subset of CLOS (Object-Oriented Lisp) , a foreign language

interface and, for some machines, a screen editor.

 

The user interface language (English, German, French) is chosen

at run time. Major packages that run in CLISP include CLX &

Garnet. CLISP needs only 2 MB of memory.

 

CMU Common Lisp

 

� Web page: www.cons.org/cmucl/

 

� Linux Installation: www.telent.net/lisp/howto.html

 

CMU Common Lisp is a public domain “industrial strength” Common

Lisp programming environment. Many of the X3j13 changes have

been incorporated into CMU CL. Wherever possible, this has been

done so as to transparently allow the use of either CLtL1 or

proposed ANSI CL. Probably the new features most interesting to

users are SETF functions, LOOP and the WITH-COMPILATION-UNIT

macro.

 

GCL (Lisp)

 

� FTP site: ftp.ma.utexas.edu/pub/gcl/

 

GNU Common Lisp (GCL) has a compiler and interpreter for Common

Lisp. It used to be known as Kyoto Common Lisp. It is very

portable and extremely efficient on a wide class of

applications. It compares favorably in performance with

commercial Lisps on several large theorem-prover and symbolic

algebra systems. It supports the CLtL1 specification but is

moving towards the proposed ANSI definition. GCL compiles to C

and then uses the native optimizing C compilers (e.g., GCC). A

function with a fixed number of args and one value turns into a

C function of the same number of args, returning