Who Killed Prolog? (2010)

Prolog is useful everywhere proofs are useful. Now, a proof isn't what you may think of as a proof in the general sense.

One example of a proof that Prolog is good at is solving games, such as solving a particular instance of tic tac toe, or 4-in-a-row. Beyond these toy examples, you can see a good fit in any application which needs to follow a procession of rules. These rules may be in a feeding/bleeding relationship — this is essentially constraint logic programming. The problem goes: given these constraints, does this statement fulfil the constraints? How can I make the statement fit the constraints? Which is the set of statements that fit these constraints?

I know of an industry application in German luxury cars, where the customer can order a car with a lot (a lot a lot) of different features, but some are mutually exclusive. If you have this particular leather seat, you can't have that particular heating unit or whatever. Now tell me if the customer selected a valid configuration, and if not, tell me what the valid configurations "next to" the desired one are.

Another application are DCGs (Definite Clause Grammar), which have the expressive power of regular expressions (EDIT: see below for a correction, it appears they're at least context-sensitive.) If you've done Monadic parsing, DCGs feel kinda similar. They're super-close to Phrase Structure Grammar rules, and used to be part of my linguistics curriculum (I hear it's all ML nowadays. Pity.)

Yes, Prolog fits niche domains. But if you find a domain, such as regular languages or a problem that can be solved by CLP, the elegance of logic programming can hardly be beat. It's really a joy to work with in the right domain. It's absolutely awful as a general purpose programming language, though — mostly because the debugging is so complex, it almost feels nondeterministic (it isn't, but there were many moments at 2 in the morning where I could've sworn it is.)

In principle, Prolog is great for searching for solutions of a formally posed problem. Think of it as a logic search engine. If your problem can be stated in logic, and the logic problem can be evaluated in a finite time, Prolog's your friend.

If not, you'll blow the stack.

> ... is the way it is is that that way is ...

Not at all on topic, but this is the first time I've seen double repetition like that in the wild. Makes me wonder about examples of non-contrived buffalo sentences.

> For AI in particular - the way the world is developing, it seems logic is a weak foundation for intelligence. At this point, given that we know humans do not use logic for their intelligence, it would be a little surprising if logic is the best way to approach that particular problem.

Whoa, "humans do not use logic for their intelligence"? Hold on there. How do we know that?

I suspect the line of reasoning is something like: if machine learning is massively successfully without a great deal of logic or deductive rules, then the human mind works similarly.

Which stems in turn from thinking the brain is just like a computer, and vice-versa, which is arguable (let alone lamentable).

> what field is Prolog especially suited for?

Graphs?

SWI-Prolog even comes with an RDF triple store: http://www.swi-prolog.org/pldoc/man?section=semweb-rdfapi

Why aren't people using Prologs instead of graph databases like neo4j?

> it seems logic is a weak foundation for intelligence

What an offensive statement.

Over two thousand years of fighting intuition-based judgements, and now that DL can merely tell a gorilla from a mouse (with 712 hours of training on 91 GPUs), it is best form of "intelligence" but Logic - a fundamental part of mathematics that helped us u.n.d.e.r.s.t.a.n.d the universe better - is a "weak foundation for intelligence?

Prolog has a great programming model, but atrocious efficiency. Programming anything beyond 8-queens quickly becomes an exponential combinatoric minefield.

I almost finished implementing a Prolog-like system to determine what operating system is installed in a guest image (replacing a huge chunk of C code which had accreted lots of rules and special cases). Described in a bit of detail here: https://rwmj.wordpress.com/2015/12/06/inspection-now-with-ad...

This never went upstream for a couple of practical reasons:

(1) It wasn't much simpler than the C code. In fact once you've gone and explained to people how Prolog works they might as well have digested the C code.

(2) There wasn't a good, embeddable, widely-available Prolog "engine" we could use. As a result I wrote my own engine which only did the simplest sort of forward inference and so wasn't at all efficient.

> Sometimes new paradigms rear up - eg, Clojure with its set-and-forget approach to values.

why is that "new" paradigm associated with clojure?

core.logic hasn't really seen any updates in such a long time. I don't think it's maintained any more.

As I was seeing another post, it seems like Prolog's advantage would be as an embedded DSL. So you can write the logic parts in Prolog, then switch to C++ or Java or whatever for the GUI.

You can run Prolog inside Common Lisp:

https://www.cliki.net/prolog

I don't know how good those implementations are compared to dedicated Prolog environments, though.

Maybe ML hype will kill python in 20 years?

PicoLisp has a built-in Prolog engine.

I haven't tried it yet. I'd like to build some project in it.

“Poaching” implies theft.

Are you saying researchers belong to their university? Or are you saying once someone is a researcher they are no longer allowed to move to industry?

Also in my experience a lot of researchers are grad students, who move to industry on completion of their degree - does getting a job after graduating mean you were “poached”?

    choose x y = x
    choose x y = y

:-) That's mind bending if you don't know logic programming. So how can the above statement even make sense? You have to understand that a logic program will try all possible statements until it finds a match, or simply all possible statements if its job is to do an exhaustive search of the problem space.

So in the choose function above, the execution algorithm (the runtime, as it were) would try to choose x first, and see if that yields a result that matches the query. It then chooses y. This may yield no, one, or many results, depending on the exact constraints of the search space.

If you posed the problem as choose 'a' 'b' then the answer would be 'a' if you're content with any solution (it gives you the first it finds), or ['a','b'] if you wanted all solutions.

Man, now I wanna go do some Prolog… pity there's nobody who's gonna pay me to do it, and I have to do PHP and JS.

> Am I wrong in thinking that Coq for example can be considered a replacement of Prolog?

I don't know if you're right or wrong about that. But Coq is about as "dead" as Prolog is. That is, it isn't used very much for real-world programming. It doesn't look like it's going to become more alive very soon, either.

Even if Coq and Prolog can be considered as "in the same style/family", maybe the problem is that for most problems, most people just don't want to program that way?

Both Coq and Prolog have something to do with logic, but that is where the similarities end. Other than this, they are apples and oranges.

Prolog is a programming language whose execution is based on certain logical principles.

Coq is a functional programming language, and and extra logic layer to prove things about programs written in its programming language.

If you will, Prolog uses logic at "run time", while Coq uses logic at "compile time". Different things (and very different logics).

Languages like Prolog and Haskell represent different views on the relation between logic and computation. Prolog models computation as proof search, whereas Haskell models it as proof normalization. In the former case your program basically consists of a bunch of formulas that are used as assumptions in an attempt to answer a query at runtime. With Haskell, your program consists of terms, which correspond directly to proofs under the Curry-Howard isomorphism. From the type theory perspective, with functional programming languages like Haskell the programmer writes terms (proofs) of some given type (formula), whereas with logic programming it's the runtime that tries to answer whether a given type is inhabited (i.e., if a proof exists). I'm being a bit sloppy here in that I'm disregarding the differences between classical and intuitionistic logics, although the former as well have been studied in type theory via their double negation translations.

I think Girard's ludics, among other goals, tried to unify these two views, although I know too little about it.

Finally, note Coq, like Haskell, models computation as proof normalization, although it's design goals are very different from Haskell.

Even easier: there’s a “past” link embedded at the top of each discussion. (I just discovered this after being here for several years.)

That tutorial is fast, but it's a pretty bad tutorial that will teach you terrible habits and a very incomplete understanding of Prolog. Unfortunately there are no good free ones.

Many people seem to like https://www.metalevel.at/prolog (featured here several times). Although I don't think it's very good from a didactic point of view, many disagree, and at least the author really knows what they are talking about.

I have a PDF of the fifth edition of "Programming in Prolog" by Clocksin and Mellish lying around here. I could swear it was available for free as open access for a while, though a very quick web search doesn't confirm this.

Beside syntax, those languages are nothing like Prolog. Notably lacking are backtracking and logic variables.