Swish: SWI Prolog Notebook
swish.swi-prolog.org
swish.swi-prolog.org
[1] https://www.metalevel.at/prolog
[2] https://book.simply-logical.space/
[3] https://github.com/klaussinani/awesome-prolog
"Production Prolog" by Michael Hendricks
I had always heard of Prolog as being obscure and overly academic. It's popped up a little bit recently however - the last place I heard of it in use is in the recently launched TerminusDB https://github.com/terminusdb?language=prolog
Both Haskell and Prolog seem to run on a school-year cycle where search interest peaks a little before the end of the semester. Prolog's cycle is significantly more pronounced, suggesting the interest is indeed purely academic. Whereas Rust has been growing steadily and shows little seasonality.
I'd say it's random chance, given X million programmers and Y million articles there's always somebody who will see a lot of Z topic.
Terminus in particular seems to be an extension of work Gavin did during his postdoc, in particular the Dacura stuff mentioned here: http://aligned-project.eu/open-source-tools/. He deleted the DQS repository for some reason but there's a mirror here: https://github.com/bozicb/dacura-1.
By inflating the search results they'll encourage the competition to spend inordinate amounts of time learning cat theory and trying to get the compiler to understand their code. In the mean time they'll hack it together in Perl.
Sorry for the inappropriate about at humour, I couldn't resist.
That's not to say that Haskell isn't used in China; there is a visualization group in Didi (Chinese Uber) that uses it, Haskell/FP user groups, university classes, etc. But there's no obvious reason that Haskell would have massively shot up in the past 3 days.
http://wadler.blogspot.com/2015/04/prime-minister-of-singapo...
He is already quite good with C++
https://arstechnica.com/information-technology/2015/05/prime...
Other than that, a lot of it is just automating chores — booking my office hour appointments, maintaining sayit.pdis.nat.gov.tw (part of the radical transparency protocol visit.pdis.tw), etc.
Non-work-related projects such as moedict.tw and Hackage/CPAN modules are mostly in maintenance mode, with occasional releases based on pull requests from the community.
foo(X, Y) :-
some_condition(X),
!,
bar(Y, X).
foo(X, Y) :-
baz(X, Y).
foo(X, Y) :-
( some_condition(X)
-> bar(Y, X)
; baz(X, Y) ).
There are really very few actually useful uses of the cut in modern Prolog code. But we have no good, free, current teaching materials, so people get stuck learning the old ugly and convoluted ways.
Unfortunately since it's almost impossible to model ideas without stuff like the arrow, cut, or \+ (not) operators, writing actual pure logical Prolog programs that actually do interesting things is supremely difficult.
For example, both versions of foo/2 that are shown above suffer from the same core deficiency: If some_condition/1 has multiple solutions, then they are cut away and not generated at all. Therefore, for the most general query,
?- foo(X, Y).
This is problematic because if any concrete solution S is cut off due to this deficiency, we can still force the Prolog system to yield it with:
?- X = S, foo(X, Y).
To write good declarative Prolog code that is also efficient, we first need to find and implement the mechanisms that let us express predicates like foo/2 in such a way that they are efficient while retaining their generality as logical relations.
One important building block pertaining to this concrete example was recently found with the new language construct if_/3, described in Indexing dif/2 by Ulrich Neumerkel and Stefan Kral:
https://arxiv.org/abs/1607.01590
With if_/3, we can write foo/2 as:
foo(X, Y) :-
if_(some_condition(X),
bar(Y, X)
baz(X, Y)).
Some predicates are already reified in the library, so we can write for example:
?- X = a, if_(X = a, Y = b, Y = c).
X = a,
Y = b.
?- if_(X = a, Y = b, Y = c).
X = a,
Y = b ;
Y = c,
dif(X, a).
To benefit from the true power of Prolog, such constructs must become available in Prolog implementations. For example, currently, the only Prolog system that ships with if_/3 as a built-in feature is Mark Thom's Scryer Prolog, where if_/3 and related predicates are available in library(reif):
https://github.com/mthom/scryer-prolog
https://github.com/mthom/scryer-prolog/blob/master/src/prolo...
Other features that are necessary to make Prolog programs more declarative include CLP(ℤ) constraints, pure I/O, efficient implementation of partial strings as lists of characters etc., all of which are currently work in progress and as of yet only partially available in some Prolog systems. Over time, such features will become more widely available, and then they can be more easily taught and used to obtain Prolog programs that are pure and efficient.
I always felt that the language was more incomplete for having (needing) such an imperative construct in an otherwise entirely declarative design.
The ability to mix in impure features where needed is what makes Prolog practical.
However: I do miss DCGs in every other language I've used. They're so useful that I've come to hate using regexes or even worse: manually parsing lists and strings.
That's a very general statement. The non-logical behavior can be well-contained and unobservable from the outside. For example, the nice and pure if_/3 internally uses both of the non-logical predicates (->)/2 and (==)/2. Yet viewed from the outside it doesn't taint anything.
> And at that point you step back and ask why you're even using prolog.
As I wrote above, because I think even used imperatively it's a very convenient language for expressing matching and transformation of trees. And DCGs are great as well, I agree.
'Logical' is a misnomer, Prolog is really a database query language. Unlike SQL it's not relational and not based on joins, it has tree walking semantics.
That said, without a decent storage/indexing system under the hood it is indeed quite pointless. Nobody wants a 'small data' tiny DB engine in 2019.
I prototyped (but did not fully implement, no management support) test case generation using Prolog.
In our case, it was (grossly simplified) a messaging system with a well-defined protocol running in an embedded device. When some message was sent, we anticipated a response back within some time window with some content based on what was initially sent (NB: This is only one of many potential scenarios). Let's say that some complex computation is happening on the remote end, based on the series of messages transmitted you eventually expect a response that will be the result of computation on those inputs.
You could manually calculate what that response should be, which fundamentally limits how many test cases you can generate and potentially leads to biased tests (assumptions of system behavior or design by the testers), or you can do it automatically. In our case, Prolog (or something like it) could be used to model the system and generate arbitrary test cases for us. It acts as the oracle (if you're familiar with property-based testing, this is where I was heading with my effort). You can now use Prolog to generate arbitrary input sequences with a known output (depending on the fidelity of your model to the spec) and generate test sequences for your system and compare the output.
And if your Prolog model is sufficiently developed, it can also be used for other development/testing efforts. If you get some response, what series of inputs may have produced it (this may be computationally infeasible, but maybe you know or can assume some of the inputs to constrain the search space). Or if your manual testing (throwing bodies at the problem) results in unexpected behavior, you can check what the model produces using the recorded inputs. Perhaps your system performs correctly, but the tester or user's mental model was incorrect. Or perhaps they found an actual implementation error.
A nice thing about using Prolog, vice using a second "reference" implementation in a more traditional language like C++, is that the Prolog model is often much simpler than the full system being developed, whereas (for us) a reference implementation would've been of comparable size. In our case, it could be the difference between 10k lines of code versus 100k lines of code.
The downside of this Prolog approach is performance, a C++ reference implementation may be able to run in real-time (or close enough) and could be directly substituted for the unit under test to verify other aspects of the test rig or system. Or, in a multi-system test, a reference implementation could be used in place of "real" remote systems (due to cost or other constraints).
To get the idea (which I barely knew of at the time), look into property-based testing. I really liked this book: https://pragprog.com/book/fhproper/property-based-testing-wi...
It does a lot of the things I was thinking about but doesn’t build the whole system model like I wanted (and was tractable for our problem domain, it isn’t for all).
int main() { printf(“No\n”); return 0; }
I used to use SWI Prolog a lot in the early days of the semantic web because I liked the SWI Prolog semantic web library.
coolproject(X)
yes
This rule means that everything is a cool project.