HDTenEightyP/NetNews huggingface dataset:
From: mattias@meryl.csd.uu.se (Mattias Waldau)
Newsgroups: comp.lang.prolog
Subject: Solving 4 queens using boolean constraint
Date: 6 Apr 92 10:57:30 GMT
Article-I.D.: corax.1992Apr6.105730.13467
Distribution: comp.lang.prolog
Organization: /home/meryl/csd/mattias/.organization


I tried to solve the 4 queens problem using the boolean constraint
solver of SICStus 2.1#1 using the cardinality predicate.

I assume that 

:- bool:sat(card([0-1],[A,B,C,D])).

that at most one of the boolean variables A, B, C and D is true.


:- fourQueens(A).

hasn't found a solution in several minutes.


fourQueens(q(r(S11, S12, S13, S14),
	     r(S21, S22, S23, S24),
	     r(S31, S32, S33, S34),
	     r(S41, S42, S43, S44))) :-
	%% rows
	bool:sat(card([0-1],[S11, S12, S13, S14])),
	bool:sat(card([0-1],[S21, S22, S23, S24])),
	bool:sat(card([0-1],[S31, S32, S33, S34])),
	bool:sat(card([0-1],[S41, S42, S43, S44])),
	%% columns
	bool:sat(card([0-1],[S11, S21, S31, S41])),
	bool:sat(card([0-1],[S12, S22, S32, S42])),
	bool:sat(card([0-1],[S13, S23, S33, S43])),
	bool:sat(card([0-1],[S14, S24, S34, S44])),
	%% diag left-right
	bool:sat(card([0-1],[S14])),
	bool:sat(card([0-1],[S13, S24])),
	bool:sat(card([0-1],[S12, S23, S34])),
	bool:sat(card([0-1],[S11, S22, S33, S44])),
	bool:sat(card([0-1],[S21, S32, S43])),
	bool:sat(card([0-1],[S31, S42])),
	bool:sat(card([0-1],[S41])),
	%% diag right-left
	bool:sat(card([0-1],[S11])),
	bool:sat(card([0-1],[S12, S21])),
	bool:sat(card([0-1],[S13, S22, S31])),
	bool:sat(card([0-1],[S14, S23, S32, S41])),
	bool:sat(card([0-1],[S24, S33, S42])),
	bool:sat(card([0-1],[S34, S43])),
	bool:sat(card([0-1],[S44])).


--
Mattias Waldau                              
Computing Science Department                mattias@emil.csd.uu.se
P.O. Box 520, S-751 20  Uppsala, Sweden     Phone: +46-18-181055
From: kwakkel@cwi.nl (Fred Kwakkel)
Newsgroups: comp.lang.prolog
Subject: want a bagoff impl. without assert/retracts
Date: 9 Apr 92 11:07:48 GMT
Reply-To: kwakkel@cwi.nl (Fred Kwakkel)
Organization: CWI, Amsterdam

SWI prolog gives for the following query:

	1 ?- S=[1,2,3,X,4], bagof( Y, member( Y, S ), L ).

	L = [1,2,3,G413,4]
	S = [1,2,3,G325,4]
	X = G325
	Y = G334

But I want L and S to be EXACTLY the same and NOT different
uninstantiated vars:

	L = [1,2,3,G413,4]
	S = [1,2,3,G413,4]
	X = G413
	Y = G334

I think it means that I need a bagof implementation without assert/retracts.
I don't know how to write this, can you help me?

thanks :-)
----------------------------------------------------------------------
Smail:  Fred Kwakkel      Work:	C.W.I.		Email: kwakkel@cwi.nl
	Comeniuslaan 32		Kruislaan 413
	Naarden			1098 SJ Amsterdam
	02159-46835		(+31) 020 592 4059/4151
From: pereira@alice.att.com (Fernando Pereira)
Newsgroups: comp.lang.prolog
Subject: Re: call/n (was finding min/max no. from a list)
Date: 14 Apr 92 13:57:48 GMT
Reply-To: pereira@alice.UUCP ()
Organization: AT&T, Bell Labs

In article <10207@goanna.cs.rmit.oz.au> ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe) writes:
>If you stare at examples like this long enough, you suddenly realise
>that the last two arguments are _exactly_ the CP and CE registers of
>the WAM, and that the only difference between this "optimised" binary
>Prolog and the WAM is that the continuation environments are kept on
>the heap instead of on a special continuation stack.
Rather like the relationship between continuation-passing and stack-based
implementations of a functional language, isn't it? I wonder what
interesting variations for Prolog implementation might be hidden in
the most recent literature on CP-style compilation, such as Andrew Appel's
book... 

Fernando Pereira
2D-447, AT&T Bell Laboratories
600 Mountain Ave, PO Box 636
Murray Hill, NJ 07974-0636
pereira@research.att.com
From: leonardo@dcs.qmw.ac.uk (Mike Hopkins)
Newsgroups: comp.lang.prolog
Subject: Re: Solving 4 queens using boolean constraint
Date: 6 Apr 92 14:06:27 GMT
Distribution: comp.lang.prolog
Organization: Computer Science Dept, QMW, University of London

The problem insists that each row and column contains exactly one
queens: therefore the program should be:

fourQueens(q(r(S11, S12, S13, S14),
	     r(S21, S22, S23, S24),
	     r(S31, S32, S33, S34),
	     r(S41, S42, S43, S44))) :-
	%% rows
	bool:sat(card([1],[S11, S12, S13, S14])),
	bool:sat(card([1],[S21, S22, S23, S24])),
	bool:sat(card([1],[S31, S32, S33, S34])),
	bool:sat(card([1],[S41, S42, S43, S44])),
	%% columns
	bool:sat(card([1],[S11, S21, S31, S41])),
	bool:sat(card([1],[S12, S22, S32, S42])),
	bool:sat(card([1],[S13, S23, S33, S43])),
	bool:sat(card([1],[S14, S24, S34, S44])),
	%% diag left-right
	bool:sat(card([0-1],[S14])),
	bool:sat(card([0-1],[S13, S24])),
	bool:sat(card([0-1],[S12, S23, S34])),
	bool:sat(card([0-1],[S11, S22, S33, S44])),
	bool:sat(card([0-1],[S21, S32, S43])),
	bool:sat(card([0-1],[S31, S42])),
	bool:sat(card([0-1],[S41])),
	%% diag right-left
	bool:sat(card([0-1],[S11])),
	bool:sat(card([0-1],[S12, S21])),
	bool:sat(card([0-1],[S13, S22, S31])),
	bool:sat(card([0-1],[S14, S23, S32, S41])),
	bool:sat(card([0-1],[S24, S33, S42])),
	bool:sat(card([0-1],[S34, S43])),
	bool:sat(card([0-1],[S44])).

This then gives the following result:

| ?- fourQueens(A).

A = q(r(0,_C,_B,0),r(_B,0,0,_A),r(_A,0,0,_B),r(0,_B,_A,0)),
bool:sat(_C=\=_B),
bool:sat(_A=\=_B) ? ;

no
| ?-

This therefore represents the desired two solutions!


--
===================================================
Mike Hopkins
Dept. of Computer Science, Queen Mary and Westfield College,
Mile End Road, London E1 4NS, UK

Tel: 071-975-5241

ARPA:   leonardo%cs.qmw.ac.uk@nsfnet-relay.ac.uk
BITNET: leonardo%uk.ac.qmw.cs@UKACRL.BITNET
===================================================
From: stolcke@ICSI.Berkeley.EDU (Andreas Stolcke)
Newsgroups: comp.lang.prolog
Subject: Re: How to get the n'th element of a list
Date: 7 Apr 92 18:40:30 GMT
Article-I.D.: agate.rsqauINNbn6
Organization: International Computer Science Institute, Berkeley, CA, U.S.A.
NNTP-Posting-Host: icsib30.icsi.berkeley.edu

In article <1992Apr7.172958.5219@ugle.unit.no>, baustad@idt.unit.no (Jostein Baustad) writes:
|> I have a Prolog-predicate that gives me the n'th element of a list:
|> 
|> % list_index(List,Index,Element)
|> 
|> list_index([Head|_],1,Head).
|> list_index([_|Tail],Index,Elt) :-
|> 	Index>1,
|> 	NewIndex is Index-1,
|> 	list_index(Tail,NewIndex,Elt).
|> 
|> This works fine for finding the element when the list and the Index are known
|> (instanciated), but I also want to use the same predicate to find the index
|> (that is the first one) when the list and the element are known. My predicate
|> doesn't work because of the 'is'-operator. Of course, I can use two different
|> predicates, but I have a feeling that it is possible with only one predicate
|> and some fine Prolog-code. Any suggestions anyone? Thanks in advance.

Assuming you have version of append/3 and length/2 that do the Right Thing:

list_index(List, N, X) :-
        append(Head, [X| _], List),
        length(Head, N1),
        N is N1 + 1.

I'm not claiming that is the most efficient way to do things -:)

BTW, technically, your constraint "with only one predicate" is of course
vacuous since your can simulate as many predicates as you want in only
one predicate.

-- 
Andreas Stolcke					stolcke@icsi.berkeley.edu
International Computer Science Institute	stolcke@ucbicsi.bitnet
1947 Center St., Suite 600, Berkeley, CA 94704	(510) 642-4274 ext. 126
Newsgroups: comp.lang.prolog
From: kfm11@cl.cam.ac.uk (Karl MacDorman)
Newsgroups: comp.lang.prolog
Subject: ?: Efficient implementation of HASHING in PROLOG
Keywords: Prolog, Hashing
Date: 8 Apr 92 23:46:24 GMT
Reply-To: kfm11@cl.cam.ac.uk (K. F. MacDorman)
Organization: University of Cambridge


I am looking for an efficient Prolog program to do hashing.

We are working on dynamic programming and memoization in
Prolog (and interested in hearing from others working in
this area).  So rather than doing a simple deterministic check 
for membership in a list, such as
	find(X,[X|_]) :- !.
	find(X,[_|T]) :- find(X,T).
it should do efficient hashing to cache and look up values.
A binary search implementation would also be interesting.

Thank you very much if you can help,
Karl
From: sanjiv@csufres.CSUFresno.EDU (Sanjiv Kapoor)
Newsgroups: comp.lang.prolog
Subject: FAQ is not needed for this newsgroup now
Date: 7 Apr 92 19:07:15 GMT
Article-I.D.: csufres.9204071907.AA28167


Greetings again,

I am no longer in need of a FAQ for comp.lang.prolog.  I have been told that
there isn't one.

Thank You,
 Sanjiv Kapoor
 sanjiv@csufres.csufresno.edu
From: pereira@alice.att.com (Fernando Pereira)
Newsgroups: comp.lang.prolog
Subject: Re: memoization
Date: 12 Apr 92 20:13:45 GMT
Reply-To: pereira@alice.UUCP ()
Organization: AT&T, Bell Labs

In article <1992Apr12.172448.21191@acsu.buffalo.edu> bharat@acsu.buffalo.edu (Bharat Jayaraman) writes:
>
>Regarding 4), may I ask what is a "dynamic-programming solution", i.e.,
>would you not entertain a top-down solution with memoization?   If not, 
>why not?  This is a crucial question,  as it has serious implications for all 
>WAM-based implementations.

Many thanks for the references. As for "dynamic programming" solutions,
I was concerned more specifically with the ability to imitate the best
dynamic programming solutions for problems such as shortest path, not just
with the ability to store intermediate results (which may not be enough).

Fernando Pereira
AT&T Bell Laboratories, Murray Hill
pereira@research.att.com
From: brady@cs.tcd.ie (Brady Michael)
Newsgroups: comp.lang.prolog
Subject: Re: Speed of LP languages - Naive Reverse
Date: 8 Apr 92 11:23:43 GMT
Organization: Computer Science, Trinity College Dublin

In article <ku3iimINNgs3@exodus.Eng.Sun.COM> jyl@burgess.Eng.Sun.COM (Jacob Levy) writes:
>Look, I know - naive reverse is not a good benchmark - please
>don't flame me. Still, I am interested in seeing numbers on the
>speed of this program on various Prolog implementations. Also
>interesting would be some numbers for implementations of
>concurrent languages such as FGHC, Parlog, Strand, PCN, FCP,
>Janus, etc.


This is an interesting idea. I'd like to make the suggestion that people
do their testing with Peter Van Roy's set of benchmarks. He very kindly
sent them to me, and maybe he'd consider giving them to others. They
would give a better idea of the capabilities of some of the systems.

I should say that I haven't asked Peter whether he's agreeable - I hope
he doesn't mind me making the suggestion...

Mike
brady@cs.tcd.ie
-- 
Michael Brady                         brady@cs.tcd.ie
Department of Computer Science
University of Dublin, Trinity College Dublin, Ireland
From: baustad@idt.unit.no (Jostein Baustad)
Newsgroups: comp.lang.prolog
Subject: How to get the n'th element of a list
Date: 7 Apr 92 17:29:58 GMT
Article-I.D.: ugle.1992Apr7.172958.5219
Reply-To: baustad@idt.unit.no (Jostein Baustad)
Followup-To: comp.lang.prolog
Organization: Norwegian Institue of Technology

I have a Prolog-predicate that gives me the n'th element of a list:

% list_index(List,Index,Element)

list_index([Head|_],1,Head).
list_index([_|Tail],Index,Elt) :-
	Index>1,
	NewIndex is Index-1,
	list_index(Tail,NewIndex,Elt).

This works fine for finding the element when the list and the Index are known
(instanciated), but I also want to use the same predicate to find the index
(that is the first one) when the list and the element are known. My predicate
doesn't work because of the 'is'-operator. Of course, I can use two different
predicates, but I have a feeling that it is possible with only one predicate
and some fine Prolog-code. Any suggestions anyone? Thanks in advance.

Jostein.

-- 
*******************************************************************************
* Jostein Baustad                    * E-mail : baustad@idt.unit.no           *
* Norwegian Institute of Technology  *          baustad@solan.unit.no         *
* Division of CS and Telematics      * "Reality is just a convenient          *
* Information and Knowledge Systems  *  measure for complexity."              *
*******************************************************************************
*             Queen's Park Rangers F.C. - SuperHoops !                        *
*******************************************************************************
From: mattias@groucho.csd.uu.se (Mattias Waldau)
Newsgroups: comp.lang.prolog
Subject: Re: Solving 4 queens using boolean constraint
Date: 8 Apr 92 04:49:13 GMT
Distribution: comp.lang.prolog
Organization: /home/meryl/csd/mattias/.organization

In article <1992Apr6.140627.10533@dcs.qmw.ac.uk> leonardo@dcs.qmw.ac.uk (Mike Hopkins) writes:


   The problem insists that each row and column contains exactly one
   queens: therefore the program should be:

   fourQueens(q(r(S11, S12, S13, S14),
		r(S21, S22, S23, S24),
		r(S31, S32, S33, S34),
		r(S41, S42, S43, S44))) :-
	   %% rows
	   bool:sat(card([1],[S11, S12, S13, S14])),
	   bool:sat(card([1],[S21, S22, S23, S24])),
	   bool:sat(card([1],[S31, S32, S33, S34])),
	   bool:sat(card([1],[S41, S42, S43, S44])),
	   %% columns
	:
	:

You have pruned the search space, by coding the fact that two queens
cannot stand on the same row or column. However, this is cheating. 

My original question was why the program was so slow. Are there any
uses of boolean constraints except for digital hardware?
--
Mattias Waldau                              
Computing Science Department                mattias@csd.uu.se
P.O. Box 520, S-751 20  Uppsala, Sweden     Phone: +46-18-181055
From: jyl@burgess.Eng.Sun.COM (Jacob Levy)
Newsgroups: comp.lang.prolog
Subject: Speed of LP languages - Naive Reverse
Date: 7 Apr 92 16:14:14 GMT
Organization: Sun Microsystems, Mt. View, Ca.
NNTP-Posting-Host: burgess

Look, I know - naive reverse is not a good benchmark - please
don't flame me. Still, I am interested in seeing numbers on the
speed of this program on various Prolog implementations. Also
interesting would be some numbers for implementations of
concurrent languages such as FGHC, Parlog, Strand, PCN, FCP,
Janus, etc.

If you have relevant information, please email me, to the
internet address jyl@eng.sun.com.  Please include a description
of the configuration used to obtain the numbers, e.g.  that it
was run on a Sparc Station 2 with 32 MBytes of memory, a local
disk and SunOS 4.1. Finally, if you have it, please include the
source of the program.

Many thanks. If there's sufficient interest I will summarize the
results. I also have some numbers to contribute for Janus, I'll
post these here after I receive your input.

--JYL
From: rolando@aifh.ed.ac.uk (Rolando Carrera-Sanchez)
Newsgroups: comp.lang.prolog
Subject: Where can I get a Type Inference system for prolog?
Date: 8 Apr 92 17:22:51 GMT
Reply-To: rolando@aifh.ed.ac.uk (Rolando Carrera-Sanchez)
Organization: Dept of AI, University of Edinburgh, Scotland

I'm interested in using a type inference system for prolog. 

Does anybody knows where could I get one or
Is there someone that has one of such systems and 
could let me have a copy?

If you have any  relevant information, please email me, to my
e-mail address rolando@aisb.ed.ac.uk

I will appreciate very much any help. If there's sufficient interest
I will summarize the results.


-- 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
*   Rolando S Carrera, (room E17)  | e-mail: rolando@aisb.ed.ac.uk          *
*   DAI, Edinburgh University,     |                                        *
*   80 South Bridge,               |                                        *
*   Edinburgh EH1 1HN, U. K.       |                                        *
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
Newsgroups: comp.lang.prolog
From: luky@ihss15.wsr.ac.at (Lukanowicz Martin)
Subject: was Finding min/max no. from a list
Organization: Wirtschaftsuniversitaet Wien
Date: Fri, 10 Apr 1992 08:44:01 GMT

/*****************************************************************************/
/* finding the minimum and the maximum from a list of numbers */
/* call list_min_max(+ListofNumbers,-TheMinimum,-TheMaximum)  */

list_min_max([Number|RL],Min,Max):-           /* if look at the first      */
     find_min_max(RL,Number,Number,Min,Max).  /* number, it is min and max */

/* (1a) if the list is empty you have the solutions */
find_min_max([],Min,Max,Min,Max).

/* (1b) you must search each number in the list (loop) */
find_min_max([Number|RL],OldMin,OldMax,Min,Max):-
     is_min_or_max(Number,OldMin,OldMax,NewMin,NewMax), /* decision */
     find_min_max(RL,NewMin,NewMax,Min,Max).

/* (2) decision */
/* is the number a new minimum or new maximum? */
is_min_or_max(Number,Min,Max,Number,Max):- Number < Min, !. /* number is min */
is_min_or_max(Number,Min,Max,Min,Number):- Number > Max, !. /* number is max */
is_min_or_max(Number,Min,Max,Min,Max).                      /* nothing       */

/*****************************************************************************/
Benefits of this implementation:

 .) declarative approach
 .) same structure as member/2  (ease to understand)
 .) tailrecursive
 .) 'search-time' increases linear with length of list O(N)
 .) runs in all Prolog implementations as fast as possible with
    as few space (memory) as needed

Martin
From: chik@icot.or.jp (Takashi Chikayama)
Newsgroups: comp.lang.prolog
Subject: Re: PARLOG??
Date: 7 Apr 92 02:44:39 GMT
	<1992Apr1.234053.16571@cs.sfu.ca> <1992Apr5.175911.22506@dcs.qmw.ac.uk>
Reply-To: chikayama@icot.or.jp
Organization: Institute for New Generation Computer Technology, Tokyo, Japan.

In article <1992Apr5.175911.22506@dcs.qmw.ac.uk>
	mmh@cs.qmw.ac.uk (Matthew Huntbach) writes:

> Clearly it would be impossible for any language to be
> completely parallel in your sense. Since you cannot have an
> infinite number of processors, you will always be able to find
> a problem where the number of branches in the search tree
> needing to be searched exceeds the number of processors.
> 
> Unfortunately, Parlog and the other concurrent logic
> programming languages don't specify what to do when this
> situation is reached. Depth-first, breadth-first or anything in
> between as the default would fit into the languages'
> specification. The case you mention above is simply how one
> particular implementor of Parlog has chosen to resolve the
> problem.
> 
> I have addressed this problem and suggested a solution which
> gives the user more control in a paper recently published,
> "Speculative Computation and Priorities in Concurrent Logic
> Languages" by Matthew Huntbach.
> In proceeedings of 3rd UK Annual Conference on Logiv
> Programming, published by Springer-Verlag, editors
> G.A.Wiggins, C.Mellish. T.Duncan.

To solve the problem, we also introduced the notion of priority in the
design of a language called KL1, which is based on GHC.  The following
articles briefly describe the feature.

@inproceedings{PIMOS,
	author={Takashi Chikayama and Hiroyuki Sato and Toshihiko Miyazaki},
	title={Overview of the Parallel Inference Machine Operating 
		System ({P}{I}{M}{O}{S})},
	booktitle={Proceedings of FGCS'88},
	institution={ICOT},
	address={Tokyo, Japan},
	pages={230--251},
	year=1988}

@article{KL-Design,
	author={Kazunori Ueda and Takashi Chikayama},
	title={Design of the Kernel Language for the Parallel
		Inference Machine},
	journal={The Computer Journal},
	month={December},
	year={1990}}

Many computation mapping techniques are developed based upon this
mechanism and actually tried out on physically parallel machines.  One
of them is reported in the following.

@inproceedings{Multi-Level-Balancer,
	author={Masakazu Furuichi, Kazuo Taki, and Nobuyuki Ichiyoshi},
	title={A Multi-Level Load Balancing Scheme for OR-Parallel
		Exhaustive Search Programs on the Multi-{P}{S}{I}},
	booktitle={Proceedings of the Second ACM SIGPLAN Symposium on
		Principles and Practice of Parallel Programming},
	pages={50--59},
	year={1990},	
	month={March}}

Takashi Chikayama
Institute for New Generation Computer Technology
From: torkel@sics.se (Torkel Franzen)
Newsgroups: comp.lang.prolog
Subject: Re: Purpose of Prolog Semantics
Date: 15 Apr 92 08:23:58 GMT
Organization: Swedish Institute of Computer Science, Kista

In article <6155@geocub.UUCP> billaud@geocub.UUCP (Michel BILLAUD) writes:

   >Predicate calculus is totally inadequate as a tool to think
   >about Prolog programs (even pure Prolog) !

  Inadequate, yes, totally inadequate, no. It depends on the kind of
thinking you do. What predicate logic does for Prolog is to provide
a useful concept of partial correctness.
From: csa09@seq1.keele.ac.uk (P. Singleton)
Newsgroups: comp.lang.prolog
Subject: term-encoding sets so that unify = intersect
Date: 12 Apr 92 17:02:51 GMT
Organization: University of Keele, England

I need to represent sets of constants (from some small, known domain)
as terms in such a way that unification of two such terms yields the
intersection of their corresponding sets.

Chris Mellish told me of a trick attributed, in Prolog folklore, to
Colmerauer, whereby a subset of N values is denoted by a list of N+1
variables, each adjacent pair corresponding to one possible element.
Iff a pair share, that element is not in the subset.

It is necessary to maintain a mapping between domain values and list
positions, but the whole affair can/should be packaged as an abstract
data type.  Further folklore: if you bind the first variable to 0,
and the last to 1; then disjoint subsets will fail to unify.

No doubt this is in "The Craft of Prolog", which I _still_ haven't
bought, or even read much of, but can anyone cite an original or early
appearance of this trick?

I have generalised it to domains which may grow after some
subsets have already been denoted: one way is to leave each list
somewhat unbound at its tail, and a more ambitious variation uses
sparse binary trees which should be more efficient for small subsets
of large domains.  Dare I claim originality for these in my thesis?

Sorry if this description is only intelligible to those who already
know what I am writing about.  If there is interest, I will post some
code (unless someone else gets in first :-).
----
  __   __    Paul Singleton (Mr)           JANET: paul@uk.ac.keele.cs
 |__) (__    Computer Science Dept.        other: paul@cs.keele.ac.uk
 |  .  __).  Keele University, Newcastle,    tel: +44 (0)782 621111 x7355
             Staffs ST5 5BG, ENGLAND         fax: +44 (0)782 713082
Newsgroups: comp.lang.prolog
From: kusalik@skorpio.usask.ca (Tony Kusalik)
Subject: acceptance of Prolog
Organization: University of Saskatchewan, Saskatoon, Canada
Date: Thu, 16 Apr 1992 23:04:20 GMT

We sometimes wonder why we have so much trouble getting
people to consider using Prolog (and logic programming languages
in general) for "real" applications.  Well, part of it could
be due to the material they are taught.  The following is a quote
from "Software Engineering", 4th ed, by Ian Sommerville.  It is
a popular text for university software engineering courses.
On page 18 he states:
	"Exploratory programming is not suited to the development
	of most large, long-lifetime software systems because it
	is likely to result in systems which are expensive to
	maintain."
On page 19 he says:
	" ... If you are familiar with LISP, Prolog or some other
	exploratory programming language ..."

With "authorities" like this, no wonder we have trouble getting
people to believe us that we can program "real" applications in Prolog!
-- 
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=		Tony Kusalik
 kusalik@cs.usask.ca		Department of Computational Science
 kusalik@skribe.usask.ca	University of Saskatchewan
 kusalik@sask.usask.ca		Saskatoon, Saskatchewan
From: bayram@cis.uab.edu (Zeki Bayram)
Newsgroups: comp.lang.prolog,comp.lang.functional
Subject: database applications of functional/logic languages
Date: 16 Apr 92 08:15:48 GMT
Organization: University of Alabama at Birmingham
Originator: bayram@orion


 
I am investigating database applications of functional/logic programming languages.
I will appreciate any references to published papers, technical reports and
the like on this subject. Functional database languages are also of relevance.
Please send me e-mail. I will post the collection of references on the newsnet.

Thanks in advance,
Zeki Bayram
UAB